Pythonda makine öğrenimi (keras – sklearn ve LSTM)ile hisse senedi ve kripto fiyatları üzerinde tahminde bulunma

Bildiğiniz gibi python, makine öğrenimi için yaygın olarak tercih edilen bir programlama dilidir ve pek çok açık kaynaklı ve popüler makine öğrenimi kütüphanesi bulunmaktadır. Makine öğrenimi, bilgisayar sistemlerinin verilerden öğrenerek belirli görevleri gerçekleştirebilmelerini sağlayan bir yapay zeka alanıdır. Python dilini kullanarak makine öğrenimi uygulamak için genel adımlar şunlardır:

1. Veri Toplama ve Hazırlama: İlk adım, modelinizi eğitmek ve değerlendirmek için kullanacağınız verileri toplamak ve düzenlemektir. Veriler, genellikle bir CSV dosyası, veritabanı, API çağrıları veya diğer kaynaklardan elde edilebilir. Verileri düzenlemek ve ön işleme yapmak, makine öğrenimi algoritmalarının daha iyi performans göstermesine yardımcı olabilir.
2. Veri Görselleştirme: Verilerinizi daha iyi anlamak ve özellikleri incelemek için veri görselleştirmesi yapabilirsiniz. Python’un popüler veri görselleştirme kütüphaneleri olan Matplotlib ve Seaborn gibi araçlarla grafikler ve görseller oluşturabilirsiniz.
3. Veri Bölümleme: Verilerinizi eğitim ve test kümeleri olarak ayırmak, modelinizi eğitirken doğrulama yapmanızı ve aşırı uyuma (overfitting) gibi problemleri engellemenize yardımcı olur.
4. Makine Öğrenimi Algoritmalarını Seçme: Amacınıza ve veri tipinize uygun bir makine öğrenimi algoritması seçmelisiniz. Python’un popüler makine öğrenimi kütüphaneleri arasında Scikit-learn, TensorFlow, Keras ve PyTorch gibi kütüphaneler, çeşitli algoritma ve modeller sunar.
5. Model Oluşturma ve Eğitme: Seçtiğiniz makine öğrenimi modelini Python kullanarak oluşturun ve verilerinizi kullanarak modeli eğitin. Eğitim sırasında modelin hiperparametrelerini ayarlayabilir ve modelin performansını optimize edebilirsiniz.
6. Model Değerlendirme: Eğitilen modelin performansını değerlendirmek için test veri kümesini kullanın. Modelin doğruluğu, hatası ve diğer performans metriklerini değerlendirin. Eğer sonuçlar yeterli değilse, modeli geliştirmek için hiperparametreleri ve veri ön işleme adımlarını ayarlayabilirsiniz.
7. Model Kullanımı: Eğitilen ve değerlendirilen modeli gerçek dünyada kullanmak için yeni verileri modele besleyerek tahminler yapabilirsiniz.

Python’un popüler makine öğrenimi kütüphaneleri sayesinde bu adımları kolaylıkla uygulayabilirsiniz. Python ekosistemi, veri bilimi ve makine öğrenimi için zengin bir araç kümesi sunar ve kullanıcı dostu olması nedeniyle bu alanda tercih edilen bir dil haline gelmiştir.

Bu yazımızda da hisse senedi ve kripto getirilerini tahmin etmekten bahsedeceğiz. Kodumuz biraz komplike olduğu için bu projeyi iki bölüme ayıracağız:

İlk olarak, LSTM sinir ağını kullanarak hisse senedi fiyatını nasıl tahmin edeceğimizi öğreneceğiz. Ardından hisse senedi ve kripto analizi için Plotly dash kullanarak bir pano oluşturacağız.

App.py dosyamız şu şekilde olacak:

import os

from dash import Dash, Patch, callback, dcc, html
from dash.dependencies import Input, Output
from keras.models import load_model
import plotly.graph_objs as go
from sklearn.preprocessing import MinMaxScaler

from prediction import *


def predict(name):
    dataset = prepare_dataset(name, '1d', '1m')
    train_data, valid_data = split_dataset(dataset)

    model_filename = build_model_filename(name)
    scaler = MinMaxScaler(feature_range=(0, 1))

    if os.path.isfile(model_filename):
        # önceden oluşturulmuş model
        scaler.fit(train_data.values)
        model = load_model(model_filename)
    else:
        # veri kümesini normalleştiriyoruz ve lstm modelini eğitiyoruz
        train_dataset = prepare_dataset(name, '7d', '15m')
        x_train_data, y_train_data = normalize_dataset(train_dataset, scaler)
        model = train_lstm_model(x_train_data, y_train_data)
        model.save(model_filename)

    # kapanış fiyatını tahmin et
    inputs = get_sample_dataset(dataset, scaler)
    closing_price = predict_close_price(model, scaler, inputs)

    valid_data['Predictions'] = closing_price
    return valid_data


debug = os.environ.get("DASH_DEBUG_MODE", "True") == "True"
app = Dash()
server = app.server

app.layout = html.Div(
    [
        html.H1('Kripto Fiyat Tahmin Panosu', style={'textAlign': 'center'}),
        html.Div(
            [
                dcc.Dropdown(
                    id='crypto-dropdown',
                    options=[
                        {'label': 'Bitcoin', 'value': 'BTC'},
                        {'label': 'Ethereum', 'value': 'ETH'},
                        {'label': 'Cardano', 'value': 'ADA'},
                    ],
                    value='BTC',
                    clearable=False,
                ),
                dcc.Loading(
                    id='loading-graphs',
                    type='circle',
                    children=[
                        html.H2('Actual closing price', style={'textAlign': 'center'}),
                        dcc.Graph(
                            id='actual-closing-price-chart',
                            figure={
                                'data': [go.Scatter(mode='markers')],
                            },
                        ),
                        html.H2('LSTM Predicted closing price', style={'textAlign': 'center'}),
                        dcc.Graph(
                            id='predicted-closing-price-chart',
                            figure={
                                'data': [go.Scatter(mode='markers')],
                            },
                        ),
                    ],
                ),
            ]
        ),
    ],
)


@callback(
    Output('actual-closing-price-chart', 'figure'),
    Output('predicted-closing-price-chart', 'figure'),
    Input('crypto-dropdown', 'value'),
)
def update_graph(selected_crypto):
    valid_data = predict(selected_crypto)

    patched_actual_figure = Patch()
    patched_actual_figure['data'][0]['x'] = valid_data.index
    patched_actual_figure['data'][0]['y'] = valid_data.Close

    patched_predicted_figure = Patch()
    patched_predicted_figure['data'][0]['x'] = valid_data.index
    patched_predicted_figure['data'][0]['y'] = valid_data.Predictions

    return [patched_actual_figure, patched_predicted_figure]


if __name__ == '__main__':
    app.run(debug=debug)

LSTM model öğreticimiz:

from sklearn.preprocessing import MinMaxScaler

from prediction import *


def build_dataset_filename(crypto_name: str, path: str = DEFAULT_MODEL_DATASET_PATH) -> str:
    prefix = path if path.endswith('/') else path + '/'
    return f'{prefix}{crypto_name}_dataset.csv'


def train_model(dataset: DataFrame) -> Sequential:
    scaler = MinMaxScaler(feature_range=(0, 1))
    x_train_data, y_train_data = normalize_dataset(dataset, scaler)
    model = train_lstm_model(x_train_data, y_train_data)
    return model


if __name__ == '__main__':
    for crypto_name in ['BTC', 'ETH', 'ADA']:
        print(f'>>> Cryptocurrency: {crypto_name}')

        # prepare dataset
        print(f'>>> preparing dataset...')
        dataset = prepare_dataset(crypto_name, '7d', '15m')
        dataset.to_csv(build_dataset_filename(crypto_name))
        print(f'>>> prepared dataset successfully')

        print()

        # öğrenme modeli
        print(f'>>> training LSTM model...')
        model = train_model(dataset)
        model.save(build_model_filename(crypto_name))
        print(f'>>> trained LSTM model successfully')

        print()

Son olarak prediction.py dosyamız:

from keras.layers import Dense, LSTM
from keras.models import Sequential
import numpy as np
from pandas import DataFrame, RangeIndex, to_datetime
import yfinance as yf


TRAIN_SIZE = 0.8
DEFAULT_MODEL_DATASET_PATH = '../model_dataset/'


def build_model_filename(crypto_name: str, path=DEFAULT_MODEL_DATASET_PATH) -> str:
    prefix = path if path.endswith('/') else path + '/'
    return f'{prefix}{crypto_name}_lstm_model.keras'


def load_live_cryptocurrency_data(name: str, currency: str, period: str, interval: str) -> DataFrame:
    data = yf.download(tickers=f"{name}-{currency}", period=period, interval=interval)
    data.insert(0, "Date", data.index)
    data.index = RangeIndex(0, len(data), 1)
    return data


def split_dataset(dataset, train_size=TRAIN_SIZE):
    index = int(len(dataset) * train_size)
    return dataset[:index], dataset[index:]


def prepare_dataset(crypto_name: str, period: str, interval: str) -> DataFrame:
    dataset = load_live_cryptocurrency_data(crypto_name, 'USD', period, interval)
    dataset['Date'] = to_datetime(dataset.Date, format='%Y-%m-%d')
    sorted_dataset = dataset.sort_values(by='Date', ascending=True, axis=0)
    filtered_dataset = DataFrame(data=sorted_dataset.Close.to_numpy(), index=sorted_dataset.Date, columns=['Close'])
    return filtered_dataset


# return type: tuple(ndarray, ndarray)
def normalize_dataset(dataset: DataFrame, scaler):
    final_dataset = dataset.values
    train_data, _ = split_dataset(final_dataset)

    scaled_data = scaler.fit_transform(final_dataset)

    x_train_data, y_train_data = [], []
    for i in range(60, len(train_data)):
        x_train_data.append(scaled_data[i - 60 : i, 0])
        y_train_data.append(scaled_data[i, 0])

    x_train_data, y_train_data = np.array(x_train_data), np.array(y_train_data)
    x_train_data = np.reshape(x_train_data, (x_train_data.shape[0], x_train_data.shape[1], 1))

    return x_train_data, y_train_data


# return type: Sequential
def train_lstm_model(x_train_data, y_train_data):
    lstm_model = Sequential()
    lstm_model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train_data.shape[1], 1)))
    lstm_model.add(LSTM(units=50))
    lstm_model.add(Dense(1))

    lstm_model.compile(loss="mean_squared_error", optimizer="adam")
    lstm_model.fit(x_train_data, y_train_data, epochs=1, batch_size=1, verbose="2")

    return lstm_model


def get_sample_dataset(dataset: DataFrame, scaler):
    _, valid_data = split_dataset(dataset.values)
    inputs = dataset[len(dataset) - len(valid_data) - 60 :].values
    inputs = inputs.reshape(-1, 1)
    return scaler.transform(inputs)


def predict_close_price(model, scaler, inputs):
    X_test = []
    for i in range(60, inputs.shape[0]):
        X_test.append(inputs[i - 60 : i, 0])
    X_test = np.array(X_test)

    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
    closing_price = model.predict(X_test)
    closing_price = scaler.inverse_transform(closing_price)

    return closing_price