J'ai essayé de prédire les hauts et les bas du cours de clôture du cours de l'action de Guru Navi en utilisant TensorFlow (progression)

introduction

―― Après Dernière fois, je suis de retour. Je suis fou, mais je suis en train de le refaire. «Je n'ai aucune connaissance de base de l'apprentissage profond. Veuillez noter que je l'ai fait uniquement avec l'envie de le déplacer. ―― La période de développement est d'environ une semaine.

• Python je ne sais pas. C'est ma première fois avec TensorFlow. Tel est le niveau.
• Je n'ai aucune connaissance des stocks. ――La précision n'est pas du tout élevée. «Avant l'exactitude, je ne comprenais pas comment faire le contenu, et je l'ai refait encore et encore et me suis épuisé, donc je suis seulement allé étudier.
• Guru Navi. ―― Puisqu'il est au milieu du processus, il peut ne pas être entièrement compris (faux). ――Une fois que vous l'avez fait correctement, vous pouvez organiser les pages.

Pakuri original

• TensorFlow prédit si le cours de clôture de la moyenne Nikkei augmentera ou baissera par rapport à la veille (1)
• Machine Learning with Financial Time Series Data on Google Cloud Platform
• [Prévision du cours de l'action avec TensorFlow] 0 --Essayez d'exécuter l'exemple de code Google

La description

Prédisez si le cours de clôture du cours de l'action de Guru Navi a augmenté ou baissé par rapport à la veille.

Environnement

Utilisez celui de Dernière fois.

En plus de cela, matplotlib est inclus pour afficher le graphique (cela n'a rien à voir avec la prédiction réelle).

pip install matplotlib

Collecte de données

La source des données sur le prix des actions a été obtenue à partir des éléments suivants. Mémo d'investissement / base de données d'actions

De plus, nous avons divisé les fichiers en 3 fichiers pour chaque marque et combiné les fichiers répartis pour chaque année. Enfin, j'ai ajusté la colonne d'en-tête.

Il semble que le fichier ne puisse pas être publié, voici donc un exemple.

Exemple) Gurunavi.csv

résultat

Code source

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

#Dossier dans lequel les données CSV sont placées
flags.DEFINE_string('csv_dir', '{Chemin du répertoire}', 'Directory to put the csv data.')
#Dossier dans lequel les données d'entraînement sont placées
flags.DEFINE_string('train_dir', '{Chemin du répertoire}', 'Directory to put the training data.')
#Nom de la colonne de fermeture
flags.DEFINE_string('close_column', 'Close', 'Close column name.')

#Modèle d'apprentissage faisant partie de l'IA(réseau neuronal)Créer
def inference(num_predictors, num_classes, stock_placeholder):

    #Écart type de poids 0.Initialiser avec une distribution normale de 1
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.0001)

        return tf.Variable(initial)

    #Biais par rapport à l'écart type 0.Initialiser avec une distribution normale de 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])

    #Normalisation par fonction softmax
    #Convertir la sortie du réseau neuronal jusqu'à présent en probabilité de chaque étiquette
    with tf.name_scope('softmax') as scope:
        model = tf.nn.softmax(tf.matmul(stock_placeholder, weights) + biases)

    #Probabilité de chaque étiquette(Quelque chose comme?)rends le
    return model

#Calculez le taux d '"erreur" entre le résultat de la prédiction et la bonne réponse
def loss(logits, labels):

    #Calcul de l'entropie croisée
    cross_entropy = -tf.reduce_sum(labels*tf.log(logits))

    #Spécifier pour afficher dans TensorBoard
    tf.summary.scalar("cross_entropy", cross_entropy)

    #Valeur du taux d'erreur(cross_entropy)rends le
    return cross_entropy

#Erreur(loss)Former un modèle d'apprentissage conçu à l'aide d'une rétropropagation d'erreur basée sur
def training(labels_placeholder, model):

    #Comme cette fonction fait tout ça
    cost = -tf.reduce_sum(labels_placeholder*tf.log(model))
    training_step = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(cost)

    return training_step

#Calculer le taux de réponse correct du résultat de prédiction donné par le modèle d'apprentissage à l'inférence
def accuracy(model, labels_placeholder):

    #Obtenir un tableau lorsque la valeur prédite (modèle) et la valeur réelle (réelle) correspondent (égales)
    #Exemple de résultat: [1,1,0,1,0]1 est la bonne réponse
    correct_prediction = tf.equal(
        tf.argmax(model, 1),
        tf.argmax(labels_placeholder, 1)
    )

    #Résultat (par exemple)[1,1,0,1,0]1 est correct) jeté pour flotter
    #Toutes les moyennes (réduire)_avoir)
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    #Configurer pour afficher sur TensorBoard
    tf.summary.scalar("accuracy", accuracy)

    return accuracy

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

    closing_data = pd.DataFrame()

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

        #Normaliser le cours de clôture en prenant le ratio logarithmique d'il y a un jour.
        #S'il est plus élevé que la veille, il sera positif, et s'il est inférieur, il sera négatif.
        closing_data[stock] = np.log(data[FLAGS.close_column] / data[FLAGS.close_column].shift())

    #Excluez la ligne de valeur manquante.
    closing_data = closing_data.dropna()

    #Convertit un retour logarithmique en indicateur.
    #Si positif
    closing_data["Gurunavi_Positive"] = 0
    closing_data.ix[closing_data["Gurunavi"] >= 0, "Gurunavi_Positive"] = 1
    #Si négatif
    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)

    #Données utilisées pour faire des prédictions
    # Gurunavi_Positive, Gurunavi_Negative
    predictors_tf = training_data[training_data.columns[2:]]
    #Corriger les données de réponse
    classes_tf = training_data[training_data.columns[:2]]

    #Divisez les données d'entraînement et de test.
    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:]

    #Définit le nombre de prédicteurs et le nombre de variables de classes pour supprimer le nombre magique de votre code.
    num_predictors = len(training_predictors_tf.columns)
    num_classes = len(training_classes_tf.columns)

    #Spécifiez la portée à afficher dans le graphique TensorBoard
    with tf.Graph().as_default():
        #
        stock_placeholder = tf.placeholder("float", [None, num_predictors])
        #
        labels_placeholder = tf.placeholder("float", [None, num_classes])

        # inference()Faire un modèle
        model = inference(num_predictors, num_classes, stock_placeholder)
        # loss()Pour calculer la perte
        loss_value = loss(model, labels_placeholder)
        # training()Pour former et ajuster les paramètres du modèle d'apprentissage
        training_step = training(labels_placeholder, model)
        #Calcul de la précision
        accuracy = accuracy(model, labels_placeholder)

        #Prêt à économiser
        saver = tf.train.Saver()
        #Créer une session(Les calculs TensorFlow doivent être effectués dans une session absolue)
        sess = tf.Session()
        #Initialisation variable(Initialiser après le démarrage de la session)
        sess.run(tf.global_variables_initializer())
        #Paramètres d'affichage du TensorBoard(Déclaratif du Tensor Board?)
        summary_op = tf.summary.merge_all()
        # train_Spécifiez le chemin pour sortir le journal TensorBoard avec dir
        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)

                #Ajouter une valeur à afficher sur le TensorBoard après chaque étape
                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)

        #Afficher la précision des données de test après l'entraînement
        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)
            }
        )

Résultat d'exécution

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

Je voulais l'éteindre, mais je ne peux pas le mettre en place car il ne semble pas être dans un état normal.

Supplément

• La précision 0.464567 signifie que c'est environ 40% que ça monte ou descend, donc c'est complètement peu fiable (?) «Avant d'arriver à ce point, l'apprentissage était un nombre fixe, mais il a finalement changé. ――Pour améliorer la précision, il y a peu de données, un ajustement est nécessaire, il y a peu d'éléments d'apprentissage ou la compréhension est erronée.

Lorsque vous souhaitez créer un graphique

# pd.DataFrame()Faites un graphique de ligne de pliage.
data.plot(figsize = (10, 5), linewidth = 0.5)
#Dessinez un graphique
plt.show()