Prévision du cours des actions à l'aide du Deep Learning (TensorFlow) - Partie 2

Suite de Dernière fois. C'est une histoire que nous allons prédire le cours de l'action à l'aide de TensorFlow, qui est un cadre d'apprentissage en profondeur. Au fait, la dernière fois, c'était un échec complet. Dernière fois a commenté de tawago ["Google fait la même chose"]( J'ai reçu les informations https://cloud.google.com/solutions/machine-learning-with-financial-time-series-data), j'ai donc copié cela et essayé de l'inspirer.

Différences par rapport à la dernière fois

La dernière fois, c'était «en utilisant la moyenne Nikkei pendant plusieurs jours pour prédire si la moyenne Nikkei du lendemain augmentera, diminuera ou ne changera pas (3 choix)». Dans la démo de Google, "Nous utilisons plusieurs jours d'indices boursiers mondiaux (Dow, Nikkei Average, FTSE100, DAX, etc.) pour prédire si le S&P augmentera ou diminuera le jour suivant (2 choix)." C'était le contenu. Voici donc les principaux changements par rapport à la dernière fois. ――Deux choix de «monter» et «descendre»

Pour plus d'informations sur la démo de Google, allez sur cette vidéo. (Anglais)

environnement

TensorFlow 0.7 Ubuntu 14.04 Python 2.7 AWS EC2 micro instance

la mise en oeuvre

Préparation

Il semble que les données puissent être téléchargées depuis le site Quandl. Cependant, il y avait un problème en raison du fait que les données publiées étaient trop volumineuses pour savoir laquelle télécharger, donc cette fois je n'en utiliserai que quatre, Nikkei, Dow, Hong Kong Hansen et l'Allemagne. J'en ai utilisé environ 8 dans la démo de Google.

Les données déposées sont rassemblées dans une table et enregistrées au format CSV. Il n'y a pas de script particulier. Je l'ai fait manuellement en utilisant la fonction RECHERCHEV d'Excel. Si vous le pouvez, vous pouvez le mettre dans la base de données et bien le gérer ...

étiquette

Cette fois, il y a deux choix, "haut" ou "bas", donc le drapeau correct est le suivant.

if array_base[idx][3] > array_base[idx+1][3]:
  y_flg_array.append([1., 0.])
  up += 1
else:
  y_flg_array.append([0., 1.])
  down += 1

Comme un échantillon complet Augmentation: 50,6% En baisse: 49,4% est devenu.

Création de graphes

Le graphique imite presque le code de Google. Le nombre de couches cachées et le nombre d'unités sont toujours dans le code Google. Il n'y a peut-être pas eu de décrochage.

NUM_HIDDEN1 = 50
NUM_HIDDEN2 = 25
def inference(x_ph, keep_prob):

  with tf.name_scope('hidden1'):
    weights = tf.Variable(tf.truncated_normal([data_num * price_num, NUM_HIDDEN1], stddev=stddev), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN1]), name='biases')
    hidden1 = tf.nn.relu(tf.matmul(x_ph, weights) + biases)
  
  with tf.name_scope('hidden2'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN1, NUM_HIDDEN2], stddev=stddev), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN2]), name='biases')
    hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
  
  #DropOut
  dropout = tf.nn.dropout(hidden2, keep_prob)
  
  with tf.name_scope('softmax'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN2, 2], stddev=stddev), name='weights')
    biases = tf.Variable(tf.zeros([2]), name='biases')
    y = tf.nn.softmax(tf.matmul(dropout, weights) + biases)
  
  return y

perte

La perte que j'ai oublié d'écrire la dernière fois est définie comme suit. C'est la même chose que la dernière fois, mais c'est la même chose que Google.

def loss(y, target):
  return -tf.reduce_sum(target * tf.log(y))

optimisation

L'optimisation est la même que la dernière fois.

def optimize(loss):
  optimizer = tf.train.AdamOptimizer(learning_rate)
  train_step = optimizer.minimize(loss)
  return train_step

Entraînement

Aucune formation n'est la même que la dernière fois.

def training(sess, train_step, loss, x_train_array, y_flg_train_array):
  
  summary_op = tf.merge_all_summaries()
  init = tf.initialize_all_variables()
  sess.run(init)
  
  summary_writer = tf.train.SummaryWriter(LOG_DIR, graph_def=sess.graph_def)
  
  for i in range(int(len(x_train_array) / bach_size)):
    batch_xs = getBachArray(x_train_array, i * bach_size, bach_size)
    batch_ys = getBachArray(y_flg_train_array, i * bach_size, bach_size)
    sess.run(train_step, feed_dict={x_ph: batch_xs, y_ph: batch_ys, keep_prob: 0.8})
    ce = sess.run(loss, feed_dict={x_ph: batch_xs, y_ph: batch_ys, keep_prob: 1.0})

    summary_str = sess.run(summary_op, feed_dict={x_ph: batch_xs, y_ph: batch_ys, keep_prob: 1.0})
    summary_writer.add_summary(summary_str, i)

Évaluation

L'évaluation est la même que la dernière fois.

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_ph, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

print(sess.run(accuracy, feed_dict={x_ph: x_test_array, y_ph: y_flg_test_array, keep_prob: 1.0}))

Résultat-Partie 1-

En raison de ce qui précède, la précision est

0.50295

** · · · Non. ** **

Réparer

En entrée, j'ai utilisé l'indice boursier de chaque pays tel quel, mais je l'ai corrigé un peu. J'ai décidé de saisir "combien l'indice boursier a fluctué par rapport à la veille". (Je ne suis pas sûr, mais Google a semblé le faire dans la vidéo) Le code ressemble à ceci. (Cela peut être difficile à comprendre)

tmp_array = []
for j in xrange(idx+1, idx + data_num + 1):
  for row, sprice in enumerate(array_base[j]):
    tmp_array.append(sprice)

x_array.append(tmp_array)

Modifié ce qui précède comme ci-dessous.

tmp_array = []
for j in xrange(idx+1, idx + data_num + 1):
  for k in range(price_num):
    tmp_array.append(((array_base[j][k]) - (array_base[j+1][k])) / array_base[j][k] * 100)

x_array.append(tmp_array)

Résultat-Partie 2-

0.63185

Il semble que d'une manière ou d'une autre, c'est devenu un nombre significatif. À 63%, nous pouvons prédire s'il augmentera ou diminuera, alors on peut dire que nous obtenons de meilleurs résultats que de deviner. C'est pourquoi c'est un succès (^ _ ^;) Je pense que la précision était d'environ 72% dans la démo de Google, mais je pense que c'est parce que le nombre d'indices boursiers utilisés ici est petit.

Considération

«Il peut être préférable de saisir« un groupe de nombres qui sont significatifs dans leur ensemble »plutôt que« un groupe de nombres indépendants ». ―― La spécification stddev de tf.truncated_normal (), dont je me demandais si cela n'avait pas d'importance la dernière fois, est relativement importante. Si vous conservez la valeur par défaut, elle divergera facilement, donc 0.001 est spécifié. S'il semble diverger, il semble que ce soit un meilleur paramètre à ajuster. ―― Le nombre d'unités de calques cachés spécifié par Google semble tout à fait approprié. Cette fois, c'est 50 et 25, mais devrais-je regarder le nombre initial d'unités environ deux fois l'entrée? (Je ne comprends pas vraiment) ――Comme avec la démo de Google, si vous incluez davantage d'indices boursiers ou de données telles que les taux de change, la précision peut augmenter.

Impressions

«Je suis content que ça ressemble à ça pour le moment! ――TensorFlow comporte de nombreuses parties qui n'ont pas besoin d'être modifiées, telles que des parties de formation, même si les données changent un peu, donc une fois que vous créez quelque chose comme un modèle, le codage est facile. Si quoi que ce soit, le traitement des données d'entrée est plus gênant. ――Pour les raisons ci-dessus, il est plus facile de garder les nombres constants autant que possible.

au fait···

Si quelqu'un connaît un site où vous pouvez télécharger des données d'échange de 5, 15, 30 minutes, merci de me le faire savoir. m (__) m

Recommended Posts

Prévision du cours des actions à l'aide du Deep Learning (TensorFlow) - Partie 2
Prévision du cours des actions à l'aide du Deep Learning (TensorFlow)
Prévision du cours de l'action à l'aide du Deep Learning [acquisition de données]
Prévision du cours des actions à l'aide de l'apprentissage automatique (scikit-learn)
Prévision de stock avec TensorFlow (LSTM) ~ Prévision de stock Partie 1 ~
Prévision du cours des actions à l'aide de l'apprentissage automatique (édition de retour)
Prévision du cours de l'action avec tensorflow
Python: prévision du cours de l'action, partie 2
Python: prévision du cours de l'action partie 1
Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Prévision du cours de l'action 2 Chapitre 2
Prévision du cours de l'action par machine learning Numerai Signals
Mémo d'étude Python & Machine Learning ⑦: Prévision du cours de l'action
Prévision du cours de l'action 1 Chapitre 1
Essayez l'apprentissage en profondeur avec TensorFlow
Prévision du cours de l'action avec LSTM_1
[Partie 4] Utilisez le Deep Learning pour prévoir la météo à partir d'images météorologiques
[Partie 1] Utilisez le Deep Learning pour prévoir la météo à partir d'images météorologiques
[Partie 2] Utilisez le Deep Learning pour prévoir la météo à partir d'images météorologiques
Prévisions du cours des actions par apprentissage automatique Commençons Numerai
Prévisions de prix Bitcoin avec TensorFlow (LSTM)
[Python] Mes prévisions de cours de bourse [HFT]
J'ai essayé l'apprentissage en profondeur avec Theano
Prédire les variations du cours des actions à l'aide de l'étiquetage métallique et de l'apprentissage automatique en deux étapes
Les prévisions du cours des actions par apprentissage automatique sont si vraies Signaux Numerai
La gestion du tensorflow a soudainement cessé de fonctionner en utilisant le GPU dans l'apprentissage en profondeur
Modèle de reconnaissance d'image utilisant l'apprentissage profond en 2016
Essayez les prévisions de prix Bitcoin avec Deep Learning
Python: Identification du genre (développement de l'apprentissage profond) Partie 1
Python: Identification du genre (développement de l'apprentissage profond) Partie 2
Jusqu'à ce que l'environnement Deep Learning (TensorFlow) utilisant le GPU soit préparé pour Ubuntu 14.04
L'apprentissage en profondeur
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Une histoire sur l'apprentissage automatique simple avec TensorFlow
Un amateur a essayé le Deep Learning avec Caffe (Introduction)
Un amateur a essayé le Deep Learning en utilisant Caffe (Practice)
[Apprentissage automatique] Apprentissage supervisé utilisant l'estimation de la densité du noyau Partie 2
[Apprentissage automatique] Apprentissage supervisé utilisant l'estimation de la densité du noyau Partie 3
Interpolation d'images vidéo par apprentissage en profondeur, partie 1 [Python]
[Recherche causale / inférence causale] Effectuer une recherche causale (SAM) à l'aide du Deep Learning
Un amateur a essayé le Deep Learning avec Caffe (Vue d'ensemble)
Report_Apprentissage approfondi (partie 1)
Report_Apprentissage approfondi (partie 1)
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Report_Apprentissage approfondi (partie 2)
Apprentissage en profondeur Python
Apprentissage profond × Python
Réflexion sur les tactiques de croissance de type attaque de groupe en utilisant l'apprentissage en profondeur
Investissement en actions par apprentissage approfondi (méthode du gradient de politique) (1)
Apprendre en profondeur à partir des bases mathématiques Partie 2 (pendant la fréquentation)
Bibliothèque DNN (Deep Learning): Comparaison de chainer et TensorFlow (1)
Collecte et automatisation d'images érotiques à l'aide du deep learning