[PYTHON] Ich habe versucht, die Höhen und Tiefen des Schlusskurses des Aktienkurses von Guru Navi mit TensorFlow vorherzusagen (Fortschritt)

Einführung

• Letztes Mal bin ich wieder zurück. Ich bin verrückt, aber ich habe es ziemlich oft neu gemacht. ――Ich habe keine Grundkenntnisse in Deep Learning. Bitte beachten Sie, dass ich es nur mit dem Wunsch gemacht habe, es zu bewegen. ――Die Entwicklungszeit beträgt ca. eine Woche.
• Python Ich weiß es nicht. Dies ist mein erstes Mal mit TensorFlow. Das ist das Level.
• Ich habe keine Kenntnis von Aktien. ――Die Genauigkeit ist überhaupt nicht hoch. »Vor der Genauigkeit habe ich nicht verstanden, wie man den Inhalt erstellt, und ich habe ihn immer wieder neu gemacht, und als ich erschöpft war, ging ich nur zum Lernen.
• Guru Navi. ――Da es sich mitten im Prozess befindet, wird es möglicherweise nicht vollständig verstanden (falsch). ――Nachdem Sie es richtig gemacht haben, können Sie die Seiten organisieren.

Pakuri Original

• TensorFlow sagt voraus, ob der Schlusskurs des Nikkei-Durchschnitts gegenüber dem Vortag steigen oder fallen wird (1)
• Machine Learning with Financial Time Series Data on Google Cloud Platform
• [Aktienkursprognose mit TensorFlow] 0 - Versuchen Sie, den Google-Beispielcode auszuführen

Erläuterung

Sagen Sie voraus, ob der Schlusskurs des Aktienkurses von Guru Navi gegenüber dem Vortag gestiegen oder gefallen ist.

Umgebung

Verwenden Sie die von Letztes Mal.

Zusätzlich ist matplotlib enthalten, um das Diagramm anzuzeigen (es hat nichts mit der tatsächlichen Vorhersage zu tun).

pip install matplotlib

Datensammlung

Die Quelle der Aktienkursdaten wurde aus dem Folgenden erhalten. Aktieninvestitionsnotiz / Aktiendatenbank

Zusätzlich haben wir die Dateien für jede Marke in 3 Dateien unterteilt und die für jedes Jahr aufgeteilten Dateien kombiniert. Schließlich habe ich die Kopfzeile angepasst.

Es scheint, dass die Datei nicht veröffentlicht werden kann, daher ist das Folgende ein Beispiel.

Beispiel) Gurunavi.csv

Ergebnis

Quellcode

stock_price_prediction.py

#!/usr/local/bin/python
#! -*- coding: utf-8 -*-

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf

flags = tf.app.flags
FLAGS = flags.FLAGS

#Ordner, in dem CSV-Daten abgelegt werden
flags.DEFINE_string('csv_dir', '{Verzeichnispfad}', 'Directory to put the csv data.')
#Ordner, in dem die Trainingsdaten abgelegt werden
flags.DEFINE_string('train_dir', '{Verzeichnispfad}', 'Directory to put the training data.')
#Name der schließenden Spalte
flags.DEFINE_string('close_column', 'Close', 'Close column name.')

#Lernmodell Teil der KI(neurales Netzwerk)Erschaffen
def inference(num_predictors, num_classes, stock_placeholder):

    #Gewichtsstandardabweichung 0.Initialisieren Sie mit einer Normalverteilung von 1
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.0001)

        return tf.Variable(initial)

    #Vorspannung zur Standardabweichung 0.Initialisieren Sie mit einer Normalverteilung von 1
    def bias_variable(shape):
        initial = tf.ones(shape)

        return tf.Variable(initial)

    with tf.name_scope('fc1') as scope:
        weights = weight_variable([num_predictors, num_classes])
        biases = bias_variable([num_classes])

    #Normalisierung durch Softmax-Funktion
    #Konvertieren Sie die bisherige Ausgabe des neuronalen Netzwerks in die Wahrscheinlichkeit jedes Labels
    with tf.name_scope('softmax') as scope:
        model = tf.nn.softmax(tf.matmul(stock_placeholder, weights) + biases)

    #Wahrscheinlichkeit jedes Etiketts(Etwas wie?)Gib es zurück
    return model

#Berechnen Sie, wie viel "Fehler" zwischen dem Vorhersageergebnis und der richtigen Antwort lag
def loss(logits, labels):

    #Berechnung der gekreuzten Entropie
    cross_entropy = -tf.reduce_sum(labels*tf.log(logits))

    #Geben Sie an, dass in TensorBoard angezeigt werden soll
    tf.summary.scalar("cross_entropy", cross_entropy)

    #Wert der Fehlerrate(cross_entropy)Gib es zurück
    return cross_entropy

#Error(loss)Trainieren Sie ein Lernmodell, das mit Hilfe der Fehler-Backpropagation basierend auf entwickelt wurde
def training(labels_placeholder, model):

    #Wie diese Funktion macht das alles
    cost = -tf.reduce_sum(labels_placeholder*tf.log(model))
    training_step = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(cost)

    return training_step

#Berechnen Sie die korrekte Antwortrate des Vorhersageergebnisses, das das Lernmodell bei Inferenz angibt
def accuracy(model, labels_placeholder):

    #Holen Sie sich ein Array, wenn der vorhergesagte (Modell) und der tatsächliche Wert (Ist) übereinstimmen (gleich)
    #Beispiel Ergebnis: [1,1,0,1,0]1 ist die richtige Antwort
    correct_prediction = tf.equal(
        tf.argmax(model, 1),
        tf.argmax(labels_placeholder, 1)
    )

    #Ergebnis (zB)[1,1,0,1,0]1 ist richtig) zum Schweben gegossen
    #Alle Durchschnittswerte (reduzieren)_erhalten)
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    #Auf TensorBoard anzeigen lassen
    tf.summary.scalar("accuracy", accuracy)

    return accuracy

if __name__ == '__main__':
    stocks = [
        'Gurunavi',
        'Recruit',
        'Kakakucom',
    ]

    closing_data = pd.DataFrame()

    for stock in stocks:
        #Laden Sie CSV in Pandas Dataframe.
        data = pd.read_csv(FLAGS.csv_dir + stock + '.csv', index_col='Date').sort_index()

        #Normalisieren Sie den Schlusskurs, indem Sie das logarithmische Verhältnis von vor einem Tag verwenden.
        #Wenn es höher als am Vortag ist, ist es positiv und wenn es niedriger ist, ist es negativ.
        closing_data[stock] = np.log(data[FLAGS.close_column] / data[FLAGS.close_column].shift())

    #Schließen Sie die fehlende Wertezeile aus.
    closing_data = closing_data.dropna()

    #Konvertiert eine logarithmische Rückkehr in ein Flag.
    #Wenn positiv
    closing_data["Gurunavi_Positive"] = 0
    closing_data.ix[closing_data["Gurunavi"] >= 0, "Gurunavi_Positive"] = 1
    #Wenn negativ
    closing_data["Gurunavi_Negative"] = 0
    closing_data.ix[closing_data["Gurunavi"] < 0, "Gurunavi_Negative"] = 1

    training_data = pd.DataFrame(
        # column name is "<index>_<day>".
        columns= ["Gurunavi_Positive", "Gurunavi_Negative"] + [s + "_1" for s in stocks[1:]]
    )

    for i in range(7, len(closing_data)):
        data = {}

        # We will use today's data for positive/negative labels
        data["Gurunavi_Positive"] = closing_data["Gurunavi_Positive"].ix[i]
        data["Gurunavi_Negative"] = closing_data["Gurunavi_Negative"].ix[i]

        # Use yesterday's data for world market data
        for col in stocks[1:]:
            data[col + "_1"] = closing_data[col].ix[i - 1]

        training_data = training_data.append(data, ignore_index=True)

    #Daten, die zur Vorhersage verwendet werden
    # Gurunavi_Positive, Gurunavi_Negative
    predictors_tf = training_data[training_data.columns[2:]]
    #Richtige Antwortdaten
    classes_tf = training_data[training_data.columns[:2]]

    #Geteilte Trainings- und Testdaten.
    training_set_size = int(len(training_data) * 0.8)
    test_set_size = len(training_data) - training_set_size

    training_predictors_tf = predictors_tf[:training_set_size]
    training_classes_tf = classes_tf[:training_set_size]
    test_predictors_tf = predictors_tf[training_set_size:]
    test_classes_tf = classes_tf[training_set_size:]

    #Definiert die Anzahl der Prädiktoren und die Anzahl der Klassenvariablen, um die magische Zahl aus Ihrem Code zu entfernen.
    num_predictors = len(training_predictors_tf.columns)
    num_classes = len(training_classes_tf.columns)

    #Geben Sie den Bereich an, der in das TensorBoard-Diagramm ausgegeben werden soll
    with tf.Graph().as_default():
        #
        stock_placeholder = tf.placeholder("float", [None, num_predictors])
        #
        labels_placeholder = tf.placeholder("float", [None, num_classes])

        # inference()Ein Modell machen
        model = inference(num_predictors, num_classes, stock_placeholder)
        # loss()Den Verlust berechnen
        loss_value = loss(model, labels_placeholder)
        # training()Trainieren und Anpassen der Parameter des Lernmodells
        training_step = training(labels_placeholder, model)
        #Berechnung der Genauigkeit
        accuracy = accuracy(model, labels_placeholder)

        #Bereit zum Speichern
        saver = tf.train.Saver()
        #Sitzung erstellen(TensorFlow-Berechnungen müssen in einer absoluten Sitzung durchgeführt werden)
        sess = tf.Session()
        #Variable Initialisierung(Nach dem Starten der Sitzung initialisieren)
        sess.run(tf.global_variables_initializer())
        #TensorBoard-Anzeigeeinstellungen(Tensor Board deklarativ?)
        summary_op = tf.summary.merge_all()
        # train_Geben Sie den Pfad für die Ausgabe des TensorBoard-Protokolls mit dir an
        summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)

        for step in range(1, 10000):
            sess.run(
                training_step,
                feed_dict={
                    stock_placeholder: training_predictors_tf.values,
                    labels_placeholder: training_classes_tf.values.reshape(len(training_classes_tf.values), 2)
                }
            )

            if step % 100 == 0:

                train_accuracy = sess.run(
                    accuracy,
                    feed_dict={
                        stock_placeholder: training_predictors_tf.values,
                        labels_placeholder: training_classes_tf.values.reshape(len(training_classes_tf.values), 2)
                    }
                )

                print "step %d, training accuracy %g"%(step, train_accuracy)

                #Fügen Sie nach jedem Schritt einen Wert hinzu, der auf dem TensorBoard angezeigt werden soll
                summary_str = sess.run(
                    summary_op,
                    feed_dict={
                        stock_placeholder: training_predictors_tf.values,
                        labels_placeholder: training_classes_tf.values.reshape(len(training_classes_tf.values), 2)
                    }
                )
                summary_writer.add_summary(summary_str, step)

        #Anzeigegenauigkeit für Testdaten nach dem Training
        print "test accuracy %g"%sess.run(
            accuracy,
            feed_dict={
                stock_placeholder: test_predictors_tf.values,
                labels_placeholder: test_classes_tf.values.reshape(len(test_classes_tf.values), 2)
            }
        )

Ausführungsergebnis

python stock_price_prediction.py                                                                        
2017-06-06 15:26:17.251792: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-06 15:26:17.251816: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-06 15:26:17.251824: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations.
2017-06-06 15:26:17.251831: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-06 15:26:17.251838: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.
step 100, training accuracy 0.504931
step 200, training accuracy 0.504931
step 300, training accuracy 0.504931
step 400, training accuracy 0.504931
step 500, training accuracy 0.504931
step 600, training accuracy 0.504931
step 700, training accuracy 0.502959
step 800, training accuracy 0.504931
step 900, training accuracy 0.510848
step 1000, training accuracy 0.510848
step 1100, training accuracy 0.510848
step 1200, training accuracy 0.512821
step 1300, training accuracy 0.510848
step 1400, training accuracy 0.508876
step 1500, training accuracy 0.510848
step 1600, training accuracy 0.510848
step 1700, training accuracy 0.510848
step 1800, training accuracy 0.512821
step 1900, training accuracy 0.510848
step 2000, training accuracy 0.508876
step 2100, training accuracy 0.502959
step 2200, training accuracy 0.499014
step 2300, training accuracy 0.500986
step 2400, training accuracy 0.502959
step 2500, training accuracy 0.504931
step 2600, training accuracy 0.506903
step 2700, training accuracy 0.506903
step 2800, training accuracy 0.514793
step 2900, training accuracy 0.512821
step 3000, training accuracy 0.508876
step 3100, training accuracy 0.504931
step 3200, training accuracy 0.508876
step 3300, training accuracy 0.506903
step 3400, training accuracy 0.510848
step 3500, training accuracy 0.510848
step 3600, training accuracy 0.512821
step 3700, training accuracy 0.512821
step 3800, training accuracy 0.508876
step 3900, training accuracy 0.510848
step 4000, training accuracy 0.512821
step 4100, training accuracy 0.510848
step 4200, training accuracy 0.510848
step 4300, training accuracy 0.512821
step 4400, training accuracy 0.512821
step 4500, training accuracy 0.512821
step 4600, training accuracy 0.512821
step 4700, training accuracy 0.514793
step 4800, training accuracy 0.512821
step 4900, training accuracy 0.512821
step 5000, training accuracy 0.514793
step 5100, training accuracy 0.514793
step 5200, training accuracy 0.514793
step 5300, training accuracy 0.512821
step 5400, training accuracy 0.514793
step 5500, training accuracy 0.514793
step 5600, training accuracy 0.518738
step 5700, training accuracy 0.516765
step 5800, training accuracy 0.518738
step 5900, training accuracy 0.518738
step 6000, training accuracy 0.516765
step 6100, training accuracy 0.514793
step 6200, training accuracy 0.518738
step 6300, training accuracy 0.52071
step 6400, training accuracy 0.518738
step 6500, training accuracy 0.52071
step 6600, training accuracy 0.522682
step 6700, training accuracy 0.522682
step 6800, training accuracy 0.522682
step 6900, training accuracy 0.52071
step 7000, training accuracy 0.52071
step 7100, training accuracy 0.518738
step 7200, training accuracy 0.514793
step 7300, training accuracy 0.516765
step 7400, training accuracy 0.516765
step 7500, training accuracy 0.514793
step 7600, training accuracy 0.512821
step 7700, training accuracy 0.512821
step 7800, training accuracy 0.514793
step 7900, training accuracy 0.514793
step 8000, training accuracy 0.518738
step 8100, training accuracy 0.516765
step 8200, training accuracy 0.516765
step 8300, training accuracy 0.514793
step 8400, training accuracy 0.516765
step 8500, training accuracy 0.518738
step 8600, training accuracy 0.516765
step 8700, training accuracy 0.516765
step 8800, training accuracy 0.516765
step 8900, training accuracy 0.516765
step 9000, training accuracy 0.516765
step 9100, training accuracy 0.516765
step 9200, training accuracy 0.516765
step 9300, training accuracy 0.516765
step 9400, training accuracy 0.516765
step 9500, training accuracy 0.514793
step 9600, training accuracy 0.512821
step 9700, training accuracy 0.512821
step 9800, training accuracy 0.512821
step 9900, training accuracy 0.512821
test accuracy 0.464567

TensorBoard

Ich wollte es löschen, aber ich kann es nicht löschen, weil es nicht in einem normalen Zustand zu sein scheint.

Ergänzung

• Genauigkeit 0,464567 bedeutet, dass es ungefähr 40% ist, dass es nach oben oder unten geht, also ist es völlig unzuverlässig (?) ――Vor diesem Punkt war das Lernen eine feste Zahl, aber es hat sich endlich geändert. ――Um die Genauigkeit zu verbessern, sind nur wenige Daten vorhanden, Anpassungen sind erforderlich, es gibt nur wenige Lernelemente oder das Verständnis ist falsch.

Wenn Sie ein Diagramm löschen möchten

# pd.DataFrame()Erstellen Sie ein Faltliniendiagramm.
data.plot(figsize = (10, 5), linewidth = 0.5)
#Zeichnen Sie ein Diagramm
plt.show()