[PYTHON] Versuchen Sie, FX mit LSTM mithilfe von Keras + Tensorflow Teil 3 vorherzusagen (versuchen Sie, alle Parameter zu treffen).

Einführung

Versuchen Sie, FX mit LSTM mithilfe von Keras + Tensorflow Teil 2 vorherzusagen (mit GPU berechnen) Schreiben Sie, dass der Start endgültig beendet ist Ich tat. Der Grund dafür ist, dass es zwar viele Parameter gibt, die für Deep Learning und FX verwendet werden, es jedoch eine beträchtliche Zeit in Anspruch nimmt, wichtige oder korrekte Werte unter ihnen zu finden.

Das ist richtig, Sie können es nicht finden, ohne GPU zu verwenden.

Dieses Mal kann ich also eine GPU verwenden, also werde ich versuchen, einen guten Wert zu finden, indem ich verschiedene Parameter aufrunde, nach denen ich mich gesehnt habe.

Quelle

Die Quelle finden Sie unter https://github.com/rakichiki/keras_fx. Oder mach einen Git-Klon.

git clone https://github.com/rakichiki/keras_fx.git 

Die Quelle ist diesmal keras_fx_gpu_multi.ipynb. Holen Sie sich dies und laden Sie es auf jupyter hoch.

Lassen Sie mich ein wenig erklären.

Parameter Round-Robin

Zuerst habe ich mich für die Parameter entschieden, die ich ändern möchte. Es ist wie folgt. (Wenn Sie genau hinschauen, ist es nicht alles ...)

• Tage, um zurückzublicken
• Anzahl der Tage vom Kauf und Verkauf bis zum Urteil
• Prozentsatz der Zunahme / Abnahme, um den Kauf / Verkauf zu bestimmen
• Art der aktiven Funktion
• Art der Zielfunktion
• Arten der Optimierung
• Prozentsatz der Trainingsdaten in den Zugdaten
• Währungspaar

Round-Robin

l_of_s_list                  = [20,25]
n_next_list                  = [5,7]
check_treshhold_list         = [0.50,0.60]
#activation_list              = ['sigmoid','tanh','linear']
activation_list              = ['tanh']
#loss_func_list               = ['mean_squared_error','mean_absolute_error','mean_squared_logarithmic_error']
loss_func_list               = ['mean_squared_error','mean_absolute_error']
#optimizer_func_list          = ['sgd','adadelta','adam','adamax']
optimizer_func_list          = ['adadelta','adam','adamax']
#validation_split_number_list = [0.1,0.05]
validation_split_number_list = [0.05]

currency_pair_list   = ['usdjpy']

#Speicherung der Ergebnisdatei
if os.path.exists('result') == False:
    os.mkdir('result')
if os.path.exists('png') == False:
    os.mkdir('png')

save_file_name = 'result/result_' + dt.today().strftime("%Y%m%d%H%M%S") + '.txt'
save_file_name = dt.today().strftime("%Y%m%d%H%M%S")

#fx Datenerfassung
start_day     = "20010101"
end_day       =  dt.today().strftime("%Y%m%d")

for currency_pair in currency_pair_list:
    (train_start_count, train_end_count,test_start_count, test_end_count,data) = \
        get_date(start_day, end_day, currency_pair)
    file_name = currency_pair + '_d.csv'

    for l_of_s in l_of_s_list:
        for n_next in n_next_list:
            for check_treshhold in check_treshhold_list:
                #
                (chane_data,average_value,diff_value, up_down,check_percent) = \
                    get_data(l_of_s, n_next,check_treshhold, file_name,train_start_count,\
                             train_end_count,test_start_count, test_end_count,data)
                
                #
                for activation in activation_list:
                    for loss_func in loss_func_list:
                        for optimizer_func in optimizer_func_list:
                            for validation_split_number in validation_split_number_list:
                                print('--------------------------')
                                fit_starttime = time.time()
                                fit(l_of_s, n_next,check_treshhold,file_name,save_file_name,activation,loss_func,optimizer_func,\
                                    validation_split_number,train_start_count, train_end_count,test_start_count, test_end_count,\
                                    chane_data,average_value,diff_value,up_down,check_percent)
                                print(str(math.floor(time.time() - fit_starttime)) + "s")
                                print('')

Ich möchte sagen, dass ich den Bereich der Erwartungen abrunden möchte, aber da die Zeit exponentiell ansteigen wird, ist es besser, etwas einzugrenzen und nach und nach zu untersuchen. Nun, selbst wenn Sie eine GPU verwenden können, wenn die Geschwindigkeit 10-mal schneller und der Berechnungsbetrag 1000-mal schneller ist, wird es das Original von Kiami sein. (Es liegt jedoch nicht mehr innerhalb des Bereichs, der von der CPU berechnet werden kann.)

Lassen Sie uns auch nach und nach gehen, anstatt uns aufgrund des später beschriebenen Problems von Anfang an umzudrehen (ich bin derjenige, der versagt hat, indem er sich am Anfang viel umgedreht hat).

Einführung des frühen Stopps

Der Rechenaufwand ist aufgrund der Rundung der Parameter explodiert, aber die Verbesserung der Einführung der GPU reicht nicht aus. Daher werden wir Early Stopping einführen, um unnötige Schleifen durch Epochen zu vermeiden.

EarlyStopping

early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=1)
～～
high_history = high_model.fit(X_high_train, y_high_train, batch_size=100, epochs=300, \
                   validation_split=validation_split_number, callbacks=[early_stopping])

Ich denke, Keras ist hier einfach. Es ist jedoch unklar, ob dies die Voraussetzung für ein vorzeitiges Anhalten ist.

Ich möchte die Lernkurve sehen

Natürlich können Sie nicht feststellen, ob die Parameter korrekt sind, ohne die Lernkurve zu betrachten. Die Einführung ist nicht allzu schwierig.

Behalten Sie einfach den Rückgabewert von fit bei und zeichnen Sie ihn grafisch auf.

Lernkurve

    #Lernen
    high_history = high_model.fit(X_high_train, y_high_train, batch_size=100, epochs=300, \
                   validation_split=validation_split_number, callbacks=[early_stopping])

    ～～～～

    # high
    val_loss = high_history.history['val_loss']
    plt.rc('font',family='serif')
    fig = plt.figure()
    plt.plot(range(len(high_history.history['val_loss'])), val_loss, label='val_loss', color='black')
    plt.xlabel('epochs')
    plt.savefig('png/' + save_file_name + '_high_' + \
                str(l_of_s) + '_' + str(n_next) + \
                '_' + str(check_treshhold) + '_' + file_name + \
                '_' + activation + '_' + loss_func + \
                '_' + optimizer_func + '_' + str(validation_split_number) + \
                '.png')
    plt.show()

Wenn Sie ein Diagramm hinterlassen möchten, führen Sie als Einschränkung plt.show () nach plt.savefig aus. Der Grund ist unbekannt, aber wenn es umgekehrt ist, wird es nicht bleiben (ich habe irgendwo auf die Antwort in der Fragenecke verwiesen).

Wenn es gut ist, wird das Diagramm mit dem Übergang von val_loss wie unten gezeigt angezeigt.

Nun, es ist eine andere Frage, ob die Trefferquote gut ist, nur weil dies schön ist. In diesem Diagramm können Sie jedoch sehen, ob Lernen möglich ist oder nicht.

Speichern Sie das Ergebnis als Datei

Es wird erwartet, dass es sehr lange dauern wird, aber der PC kann unterwegs heruntergefahren werden. ich Ich bin nicht der Typ, der einen PC ohne ECC-Speicher über 10 Stunden arbeiten lassen und weiter beten möchte, dass er nicht auf den Weg fällt.

Speichern Sie also das Analyseergebnis in einer Datei und ergreifen Sie Maßnahmen, auch wenn der PC in der Mitte ausfällt (obwohl ich im Falle eines Speicherfehlers aufgeben werde).

Dateiausgabe

    f = open(save_file_name, 'a')
    f.write('l_of_s: ' + str(l_of_s) + ' n_next: ' + str(n_next) + \
            ' check_treshhold:' + str(check_treshhold) + ' file_name:' + file_name + \
            ' activation:' + activation + ' loss_func:' + loss_func + \
            ' optimizer_func:' + optimizer_func + ' validation_split_number:' + str(validation_split_number) + \
            '\n')
    f.write('UP: ' + str(up_ok_count) + ' - ' + str(up_ng_count) + ' - ' + str(up_ev_count) + '\n')
    f.write('DN: ' + str(down_ok_count) + ' - ' + str(down_ng_count) + ' - ' + str(down_ev_count) + '\n')
    f.close()

War das CSV-Format besser? Nein, war es besser, das JSON-Format zu verwenden (ich mag das JSON-Format)? Ich werde den Fortschritt jedoch vorerst ausgeben. Ah, das JSON-Format ist nutzlos, wenn man bedenkt, dass es unterwegs fehlschlagen wird.

Wie oben erwähnt, möchten Sie möglicherweise auch das Diagramm speichern.

Ergebnis (nicht gut ...)

Ich habe es vorerst viel gedreht. Aus dem später beschriebenen Grund ist es jedoch ein wenig sanft (sagen Sie nicht, dass es nur ein Muster wie die Aktivierungsfunktion gibt).

Das einzige Währungspaar ist usdjpy. Das Ergebnis ist wie folgt (über die Anzahl der Tage des Kauf- und Verkaufsurteils ist nicht in der Trefferquote enthalten).

Bestenfalls 60% und schlimmstenfalls 50% lag der Durchschnitt bei 55%, was etwas besser war als in den vorangegangenen Tagen. Die Berechnung von 48 Mustern (mit Geforce GTX 1070) dauerte übrigens ca. 2 Stunden. Es wird auch erwartet, dass das Erhöhen der Parameter exponentiell Zeit in Anspruch nimmt. Aus diesem Grund müssen Maßnahmen ergriffen werden, um irgendwo schneller zu werden, und da die Trefferquote schlecht ist, müssen Maßnahmen ergriffen werden, aber zuvor wurde ein großes Problem festgestellt.

ein Problem ist aufgetreten

Ich konnte die gewünschten Parameter bis zu einem gewissen Grad finden, fand aber ein enttäuschendes Problem.

Es ist ein speicherintensives Problem. Anfangs suchte ich nach ungefähr 1000 Mustern, aber ein Ereignis, das sehr langsam wurde, trat in der Mitte auf. Nach dem Ergreifen der Gegenmaßnahmen ist der Zustand des PCs als Ergebnis von weniger als 48 Mustern wie folgt.

Der Speicher des PCs selbst verbraucht 12 GB und die GPU 2 GB. Obwohl es nicht veröffentlicht wird, wenn ein Muster ausgeführt wird, hat die GPU weniger als 1 GB und der Hauptteil weniger als 4 GB verbraucht.

Einfach gesagt, es gibt ein Speicherleck. Anfangs hatte dieser PC nur 8 GB Speicher, aber in Eile ersetzte ich den Speicher (das Gehäuse ist Mini-ITX und es gibt nur zwei Speichersteckplätze) und erhöhte ihn auf 32 GB (ich denke, 16 GB waren hier gut). Es gibt Meinungen, aber eine halbfertige Investition bringt keine guten Ergebnisse, also habe ich sie auf einmal auf 32 GB gebracht.

Ich weiß nicht, warum es nicht so viel Speicher verbraucht (oder freigibt), aber wenn Sie mehr mit diesem Skript tun möchten, sollten Sie die Speichermenge sowie das Muster und die Ausführungszeit berücksichtigen. .. Ich habe bisher keine Problemumgehung gefunden.

Schließlich

Diese Serie war eigentlich bisher geplant. In Zukunft werde ich mein Bestes tun, um die Ergebnisse im Bereich des Fehlers zu verbessern, aber es gibt keine Garantie dafür, dass die Ergebnisse bisher erzielt werden.

Aus diesem Grund weiß ich nicht, wie weit ich gehen kann, aber ich denke, ich kann viele Dinge tun. Folgendes gehe ich an dieser Stelle aus:

• Fortsetzung der Reise, um die richtigen Parameter zu finden
• Hinzufügung von Bedingungen, nicht zu kaufen oder zu verkaufen (Beispiel: Ausschließen, wenn es einen Unterschied zwischen dem Schließen am aktuellen Tag und dem Öffnen am nächsten Tag gibt)
• Einführung einer Methode, um eine Kauf- und Verkaufsentscheidung durch mehrmaliges Ausführen zu treffen (sie ist nicht jedes Mal dieselbe, da es ein zufälliges Element gibt).
• Einführung einer Methode zur umfassenden Bewertung des Umsatzes durch Implementierung mehrerer Parameter (da es abhängig von den Parametern anscheinend Stärken und Schwächen gibt)
• Erhöhen Sie die zu ändernden Parameter (erwartete versteckte Anzahl usw.)
• Ich habe es mit eindimensionalen Daten von nur hoch und nur niedrig erwartet, aber die Dimension erhöhen (Hinzufügen von hihg-niedrig oder Verwenden von Öffnen / Schließen)
• Einführung von Hochgeschwindigkeit (GRU etc.)

Ich denke, ich kann eine Menge solcher Dinge tun, aber um klar zu sein, es ist ein Level, das 1 GPU wahrscheinlich nicht kann. In diesem Fall kann es erforderlich sein, mehrere GPUs zu installieren oder AWS zu mieten. Ich habe vor, über die nächsten Maßnahmen nachzudenken, während ich ein wenig über diesen Bereich nachdenke.

Verknüpfung

• Versuchen Sie, FX mit LSTM mithilfe von Keras + Tensorflow vorherzusagen
• FX mit LSTM mithilfe von Keras + Tensorflow Teil 2 vorhersagen (mit GPU berechnen)