[PYTHON] Vorhersage des Nikkei-Durchschnitts mit Pytorch

Ich bin ein Doktorand, der kürzlich Pytorch studiert.

Ich begann neuronale Netze zu studieren und träumte von Aktienkurs- und Pferderennprognosen.

Schließlich hat es Gestalt angenommen, also werde ich es als Memorandum schreiben. Ich hoffe, es wird für Anfänger wie mich hilfreich sein.

Referenzen, zitierte Artikel und Bücher

Übersicht über das LSTM-Netzwerk Dies ist ein Artikel über die Netzwerkstruktur und den Mechanismus von LSTM.

Ich möchte mit LSTM mit Pytorch anfangen ... willst du nicht? Hier geht es hauptsächlich um die Implementierung von LSTM.

FX-Vorhersage: Vorhersage von Zeitreihendaten mit PyTorchs LSTM Es war sehr hilfreich, weil ich ausführlich geschrieben habe, wie man Daten sammelt, formt, Backtesting durchführt und tatsächlich lernt.

Deep Learning-Aktienkursprognosemodell _1 mit einer Genauigkeit von 67% Dies ist kein FX, ich habe den Aktienkurs vorhergesagt und er stimmte mit der Prognose des nächsten Tages überein, den ich wollte, also habe ich mich darauf bezogen. Dies ist in Keras implementiert, aber ich werde dies in Pytorch implementieren.

[Minna no python 4. Ausgabe](https://www.amazon.co.jp/%E3%81%BF%E3%82%93%E3%81%AA%E3%81%AEPython-%E7%AC% AC4% E7% 89% 88-% E6% 9F% B4% E7% 94% B0-% E6% B7% B3 / dp / 479738946X / ref = sr_1_1? __Mk_ja_JP =% E3% 82% AB% E3% 82% BF % E3% 82% AB% E3% 83% 8A & Schlüsselwörter =% E3% 81% BF% E3% 82% 93% E3% 81% AA% E3% 81% AEpython & qid = 1580280858 & sr = 8-1) Dies ist das Buch, in dem ich die grundlegende Verwendung von Python herausgefunden habe.

Datensammlung

Die Daten wurden mit HYPER SBI gesammelt, das von SBI Securities heruntergeladen werden kann. In Deep Learning Stock Price Prediction Model_1 mit 67% Genauigkeit haben wir 20 Jahre lang die Aktienkurse von 423 börsennotierten Unternehmen gelernt. Also habe ich zuerst gelernt, ob ich am nächsten Tag nur mit dem Nikkei-Durchschnitt steigen soll. Die Daten sind für 20 Jahre.

Überblick

Wir haben 20 Jahre lang Daten gesammelt und diese separat für Zug und Test trainiert. Die Genauigkeit für den ~~ Test betrug 62,5%. Es gibt jedoch Probleme, da der Verlust nicht konvergiert und der aus der gemischten Matrix berechnete Wert von f1 während des Trainings 0 wird. ~~

Schließlich lag die Genauigkeit bei 60,5%.

Definition der Konstante

main.py

import glob
import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
import torch.nn.functional as F
import torch.optim as optim

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
torch.manual_seed(1)

future_num = 1 #Wie viele Tage vor uns
feature_num = 7 #'Offener Preis', 'Hoher Preis','Niedriger Preis','Schlusskurs','5-Tage-Durchschnitt','25-Tage-Durchschnitt','75-Tage-Durchschnitt'7 Artikel
batch_size = 128

time_steps = 30 #lstm Zeitschritte
moving_average_num = 30 #Anzahl der Tage für einen gleitenden Durchschnitt
n_epocs = 50

lstm_hidden_dim = 16
target_dim = 1

Daten lesen

Informationen zum Sammeln von Daten finden Sie unter Offizielle Website von SBI: Häufig gestellte Fragen und Antworten. Ich habe hier den Index ausgewählt und die Nikkei-Durchschnittsdaten für 20 Jahre heruntergeladen.

main.py

path = "./data/nikkei_heikin.csv"

model_name = "./models/nikkei.mdl"

#data load
flist = glob.glob(path)
for file in flist:
    df = pd.read_csv(file, header=0, encoding='cp932')
    dt = pd.read_csv(file, header=0, encoding='cp932')


#Zugdaten,Index zum Teilen in Test
val_idx_from = 3500
test_idx_from = 4000

future_price = df.iloc[future_num:]['Schlusskurs'].values
curr_price = df.iloc[:-future_num]['Schlusskurs'].values

#future_Behandeln Sie den Preis im Vergleich zu Anzahl Tage später als das richtige Etikett
y_data_tmp = future_price / curr_price
#Bereiten Sie eine Liste für das richtige Antwortetikett vor
y_data = np.zeros_like(y_data_tmp)

#Zukunft vorherzusagen_Richtige Antwort, wenn num Tage später mehr als der vorherige Tag ist

for i in range(len(y_data_tmp)):
    if y_data_tmp[i] > 1.0:
        y_data[i] = 1

#Bewegen, wenn der Preis normalisiert ist_average_Da für wenige Minuten leere Daten erstellt werden, wird dieser Teil gelöscht.
y_data = y_data[moving_average_num:]

#Preisnormalisierung
#Spaltennamen abrufen
cols = ['Offener Preis', 'Hoher Preis','Niedriger Preis','Schlusskurs','5-Tage-Durchschnitt','25-Tage-Durchschnitt','75-Tage-Durchschnitt']
#Ich habe es herausgezogen, weil die Volumendaten beschädigt waren.

for col in cols:
    dt[col] = df[col].rolling(window=25, min_periods=25).mean()
    df[col] = df[col] / dt[col] - 1
    

X_data = df.iloc[moving_average_num:-future_num][cols].values

#Datenaufteilung, konvertiert in Fackeltensor
#Trainingsdaten
X_train = torch.tensor(X_data[:val_idx_from], dtype=torch.float, device=device)
y_train = torch.tensor(y_data[:val_idx_from], dtype=torch.float, device=device)
#Bewertungsdaten
X_val   = torch.tensor(X_data[val_idx_from:test_idx_from], dtype=torch.float, device=device)
y_val   = y_data[val_idx_from:test_idx_from]
#Testdaten
X_test  = torch.tensor(X_data[test_idx_from:], dtype=torch.float, device=device)
y_test  = y_data[test_idx_from:]

Die ursprüngliche Anzahl der Daten betrug ca. 4500. Die Anzahl der Trainingsdaten beträgt 3500, die Validierung beträgt 500 und der Rest sind Testdaten.

Modelldefinition

main.py

class LSTMClassifier(nn.Module):
    def __init__(self, lstm_input_dim, lstm_hidden_dim, target_dim):
        super(LSTMClassifier, self).__init__()
        self.input_dim = lstm_input_dim
        self.hidden_dim = lstm_hidden_dim
        self.lstm = nn.LSTM(input_size=lstm_input_dim, 
                            hidden_size=lstm_hidden_dim,
                            num_layers=1, #default
                            #dropout=0.2,
                            batch_first=True
                            )
        self.dense = nn.Linear(lstm_hidden_dim, target_dim)

    def forward(self, X_input):
        _, lstm_out = self.lstm(X_input)
        #Verwenden Sie nur die endgültige Ausgabe von LSTM.
        linear_out = self.dense(lstm_out[0].view(X_input.size(0), -1))
        return torch.sigmoid(linear_out)

Die Definition des Modells. Ich habe LSTM aus Pytorchs Bibliothek gezogen.

main.py

def prepare_data(batch_idx, time_steps, X_data, feature_num, device):
    feats = torch.zeros((len(batch_idx), time_steps, feature_num), dtype=torch.float, device=device)
    for b_i, b_idx in enumerate(batch_idx):
        #Speichern Sie die letzten 30 Tage als Zeitschrittdaten.
        b_slc = slice(b_idx + 1 - time_steps ,b_idx + 1)
        feats[b_i, :, :] = X_data[b_slc, :]

    return feats

Die Funktion prepare_data spielt eine Rolle beim Sammeln der Daten, die jeweils 30 Tage lang in LSTM eingegeben werden sollen.

Lernen und Bewerten

main.py

#Lernen
model = LSTMClassifier(feature_num, lstm_hidden_dim, target_dim).to(device)
loss_function = nn.BCELoss()
optimizer= optim.Adam(model.parameters(), lr=1e-4)


train_size = X_train.size(0)
best_acc_score = 0

for epoch in range(n_epocs):
    #Ersetzen Sie den Index der Zugdaten nach dem Zufallsprinzip. Erstes Mal_Verwenden Sie keine Schritte.
    perm_idx = np.random.permutation(np.arange(time_steps, train_size))
    for t_i in range(0, len(perm_idx), batch_size):
        batch_idx = perm_idx[t_i:(t_i + batch_size)]
        #Vorbereitung von Zeitreihendaten für die LSTM-Eingabe
        feats = prepare_data(batch_idx, time_steps, X_train, feature_num, device)
        y_target = y_train[batch_idx]
        model.zero_grad()
        train_scores = model(feats) # batch size x time steps x feature_num
        loss = loss_function(train_scores, y_target.view(-1, 1))
        loss.backward()
        optimizer.step()

    #Auswertung von Validierungsdaten
    print('EPOCH: ', str(epoch), ' loss :', loss.item())
    with torch.no_grad():
        feats_val = prepare_data(np.arange(time_steps, X_val.size(0)), time_steps, X_val, feature_num, device)
        val_scores = model(feats_val)
        tmp_scores = val_scores.view(-1).to('cpu').numpy()
        bi_scores = np.round(tmp_scores)
        acc_score = accuracy_score(y_val[time_steps:], bi_scores)
        roc_score = roc_auc_score(y_val[time_steps:], tmp_scores)
        f1_scores = f1_score(y_val[time_steps:], bi_scores)
        print('Val ACC Score :', acc_score, ' ROC AUC Score :', roc_score, 'f1 Score :', f1_scores)

    #Modell speichern, wenn die Validierung gut ist
    if acc_score > best_acc_score:
        best_acc_score = acc_score
        torch.save(model.state_dict(),model_name)
        print('best score updated, Pytorch model was saved!!', )

#Mit dem besten Modell vorhersagen.
model.load_state_dict(torch.load(model_name))

with torch.no_grad():
    feats_test = prepare_data(np.arange(time_steps, X_test.size(0)), time_steps, X_test, feature_num, device)
    val_scores = model(feats_test)
    tmp_scores = val_scores.view(-1).to('cpu').numpy()   
    bi_scores = np.round(tmp_scores)
    acc_score = accuracy_score(y_test[time_steps:], bi_scores)
    roc_score = roc_auc_score(y_test[time_steps:], tmp_scores)
    f1_scores = f1_score(y_test[time_steps:], bi_scores)
    print('Test ACC Score :', acc_score, ' ROC AUC Score :', roc_score, 'f1 Score :', f1_scores)

Beim Lernen werden Genauigkeit, ROC-Score und f1-Score ausgegeben. Gewichte werden gespeichert, wenn die höchste Genauigkeit aktualisiert wird.

Ergebnis

EPOCH:  0  loss : 0.7389694452285767
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5448111497752646 f1 Score : 0.653295128939828
best score updated, Pytorch model was saved!!
EPOCH:  1  loss : 0.6844338178634644
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5550601710888793 f1 Score : 0.653295128939828
EPOCH:  2  loss : 0.7206816673278809
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5678012179208352 f1 Score : 0.653295128939828
EPOCH:  3  loss : 0.7066923975944519
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5815934464259822 f1 Score : 0.653295128939828
EPOCH:  4  loss : 0.7148252129554749
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.6025717703349283 f1 Score : 0.653295128939828
EPOCH:  5  loss : 0.6946689486503601
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.6224264172828766 f1 Score : 0.653295128939828
EPOCH:  6  loss : 0.7018400430679321
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.639100333478324 f1 Score : 0.653295128939828
EPOCH:  7  loss : 0.7006129026412964
.
.
.
.
EPOCH:  43  loss : 0.7038401961326599
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6018921270117442 f1 Score : 0.0
EPOCH:  44  loss : 0.6951379179954529
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6018921270117443 f1 Score : 0.0
EPOCH:  45  loss : 0.6788191795349121
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6018921270117443 f1 Score : 0.0
EPOCH:  46  loss : 0.6547065377235413
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6018558793678411 f1 Score : 0.0
EPOCH:  47  loss : 0.6936472654342651
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6016746411483254 f1 Score : 0.0
EPOCH:  48  loss : 0.719009280204773
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6016202696824707 f1 Score : 0.0
EPOCH:  49  loss : 0.6854437589645386
Val ACC Score : 0.5148936170212766  ROC AUC Score : 0.6014934029288096 f1 Score : 0.0
Test ACC Score : 0.6252100840336134  ROC AUC Score : 0.6860275646683414 f1 Score : 0.6915629322268327

Nachtrag

Wenn Sie die Anzahl der Epochen von 50 auf 500 ändern, ist der Verlust eine anständige Zahl, also werde ich ihn veröffentlichen.

EPOCH:  0  loss : 0.7389694452285767
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5448111497752646 f1 Score : 0.653295128939828
best score updated, Pytorch model was saved!!
EPOCH:  1  loss : 0.6844338178634644
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5550601710888793 f1 Score : 0.653295128939828
EPOCH:  2  loss : 0.7206816673278809
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5678012179208352 f1 Score : 0.653295128939828
EPOCH:  3  loss : 0.7066923975944519
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.5815934464259822 f1 Score : 0.653295128939828
EPOCH:  4  loss : 0.7148252129554749
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.6025717703349283 f1 Score : 0.653295128939828
EPOCH:  5  loss : 0.6946689486503601
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.6224264172828766 f1 Score : 0.653295128939828
EPOCH:  6  loss : 0.7018400430679321
Val ACC Score : 0.4851063829787234  ROC AUC Score : 0.639100333478324 f1 Score : 0.653295128939828
EPOCH:  7  loss : 0.7006129026412964
.
.
.
.
EPOCH:  493  loss : 0.694491982460022
Val ACC Score : 0.6042553191489362  ROC AUC Score : 0.638157894736842 f1 Score : 0.5079365079365079
EPOCH:  494  loss : 0.6935185194015503
Val ACC Score : 0.6063829787234043  ROC AUC Score : 0.638157894736842 f1 Score : 0.5144356955380578
EPOCH:  495  loss : 0.6262539029121399
Val ACC Score : 0.5957446808510638  ROC AUC Score : 0.6370704654197477 f1 Score : 0.48087431693989063
EPOCH:  496  loss : 0.5570085644721985
Val ACC Score : 0.6085106382978723  ROC AUC Score : 0.6387559808612441 f1 Score : 0.5422885572139303
EPOCH:  497  loss : 0.6102970838546753
Val ACC Score : 0.6  ROC AUC Score : 0.6374691895026823 f1 Score : 0.4973262032085562
EPOCH:  498  loss : 0.6443783640861511
Val ACC Score : 0.6042553191489362  ROC AUC Score : 0.6395534290271132 f1 Score : 0.5633802816901409
EPOCH:  499  loss : 0.663628876209259
Val ACC Score : 0.6085106382978723  ROC AUC Score : 0.6380310279831811 f1 Score : 0.518324607329843
Test ACC Score : 0.6050420168067226  ROC AUC Score : 0.644737139882771 f1 Score : 0.660894660894661

Berücksichtigung der Ergebnisse

~~ Wenn Sie sich die Mitte des Lernens ansehen, wird die Genauigkeit häufig nicht aktualisiert. Und f1 Score ist 0. Es scheint, dass es viele Probleme gibt, wie zum Beispiel, dass der Verlust nicht konvergiert. Bei Betrachtung der Ergebnisse der Testdaten haben wir jedoch eine Genauigkeit von 62,5% festgestellt. ~~

Durch Erhöhen der Anzahl der Epochen sind der ROC-Score und der f1-Score anständig. Die Genauigkeit selbst beträgt jedoch 60,5%.

Ich möchte die Genauigkeit verbessern, indem ich die Anzahl der Daten und die Anzahl der Funktionen erhöhe und LSTM selbst implementiere.

Beim nächsten Mal werden wir Aktien prognostizieren, die um 3% steigen werden, wie dies in Deep Learning Stock Price Forecast Model_1 mit 67% Genauigkeit geschehen ist.