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

Pour une raison quelconque, je ne vois pas les gens en faire autant, alors je vais essayer de prédire le cours de l'action en utilisant le deep learning. L'apprentissage en profondeur et Python sont tous deux des débutants. On sait peu de choses sur les bibliothèques, les méthodes d'implémentation, les théories, etc. Nous attendons Tsukkomi etc.

Cible

―― En utilisant les données boursières pendant plusieurs jours, vous pouvez prédire si le cours moyen de l'action Nikkei pour le jour suivant «montera», «baissera» ou «changera». (Catégorie)

Aperçu

―― Le cours de clôture du lendemain est utilisé pour juger s'il était «à la hausse», «à la baisse» ou «inchangé».

Pour les données d'entrée, utilisez "prix ouvert", "prix élevé", "prix bas" et "prix de clôture" d'il y a quelques jours jusqu'à la veille. --Il y a quatre couches cachées. ――En tant qu'entrée, entraînez-vous simplement avec les cours des actions des derniers jours ci-dessus.

environnement

TensorFlow 0.7 Ubuntu 14.04 Python 2.7 AWS EC2 micro instance

Contenu

Préparation

Préparez autant de données moyennes Nikkei que possible. Cette fois, j'ai utilisé les données de Yahoo Finance.

la mise en oeuvre

La moyenne Nikkei est un texte. (Parce que c'est gênant d'aller le chercher à chaque fois) Cette fois, je vais regarder les données pendant 10 jours et prédire le cours de l'action pour le lendemain. De plus, si le cours de clôture du jour suivant est de 0,5% ou plus par rapport au cours de clôture de la veille, il est «à la hausse», s'il est de 0,5% ou moins, il est «à la baisse», sinon il est «inchangé». La raison de ce nombre est que ces trois sont à peu près 33%.

if array_base[idx][3] > (array_base[idx+1][3] * (1.0+flg_range)):
  y_flg_array.append([1., 0., 0.])
  up += 1
elif array_base[idx][3] < (array_base[idx+1][3] * (1.0-flg_range)):
  y_flg_array.append([0., 0., 1.])
  down += 1
else:
  y_flg_array.append([0., 1., 0.])
  keep += 1

Le rapport des données dans leur ensemble est le suivant. Augmentation: 33,9% Diminution: 32,7% Aucun changement: 33,4%

Création de graphes

Le code ressemble à ceci. C'est un petit spaghetti avec une copie, mais c'est facile à voir. (Excuse)

def inference(x_ph, keep_prob):

  with tf.name_scope('hidden1'):
    weights = tf.Variable(tf.truncated_normal([data_num * 4, NUM_HIDDEN1]), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN1]), name='biases')
    hidden1 = tf.nn.sigmoid(tf.matmul(x_ph, weights) + biases)
  
  with tf.name_scope('hidden2'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN1, NUM_HIDDEN2]), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN2]), name='biases')
    hidden2 = tf.nn.sigmoid(tf.matmul(hidden1, weights) + biases)
  
  with tf.name_scope('hidden3'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN2, NUM_HIDDEN3]), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN3]), name='biases')
    hidden3 = tf.nn.sigmoid(tf.matmul(hidden2, weights) + biases)
  
  with tf.name_scope('hidden4'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN3, NUM_HIDDEN4]), name='weights')
    biases = tf.Variable(tf.zeros([NUM_HIDDEN4]), name='biases')
    hidden4 = tf.nn.sigmoid(tf.matmul(hidden3, weights) + biases)
  
  #DropOut
  dropout = tf.nn.dropout(hidden4, keep_prob)
  
  with tf.name_scope('softmax'):
    weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN4, 3]), name='weights')
    biases = tf.Variable(tf.zeros([3]), name='biases')
    y = tf.nn.softmax(tf.matmul(dropout, weights) + biases)
  
  return y

Un espace réservé où x_ph contient les données sur le cours de l'action jusqu'à la veille. Les données sont incluses en tant que [cours de clôture il y a 1 jour, cours d'ouverture il y a 1 jour, prix haut il y a 1 jour, prix bas il y a 1 jour, cours de clôture il y a 2 jours, ...]. Le nombre d'unités de calque masquées est de 100, 50, 30, 10. Autrement dit, il est défini ci-dessous.

# DEFINITION
NUM_HIDDEN1 = 100
NUM_HIDDEN2 = 50
NUM_HIDDEN3 = 30
NUM_HIDDEN4 = 10

À propos, le nombre d'unités et le nombre de couches sont appropriés. N'est-il pas préférable d'en avoir plus? J'ai décidé avec l'intention. Je vous serais reconnaissant si vous pouviez me dire des directives pour déterminer ces nombres m (_ _) m

optimisation

L'optimisation utilise ADAM. Je ne connais pas les détails, mais d'après mon expérience, il est plus difficile de diverger que le GradientDescentOptimizer.

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

Entraînement

La formation ressemble à ce qui suit. La taille du lot est de 100. S'il est trop gros, ce sera de la mousse. (Mémoire insuffisante. Ce n'est pas grave si vous ne restez pas bloqué)

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})

    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

Après la formation, évaluez comme suit. Il s'agit essentiellement d'une copie du didacticiel.

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

En regardant le TensorBoard, il semble qu'il a convergé comme suit.

Cependant, en regardant le pourcentage de bonnes réponses,

0.3375

Une terrible défaite. : crier: Comme mentionné ci-dessus, la probabilité de chaque catégorie (haut, bas, inchangé) est d'environ 33%, le résultat est donc le même que celui de deviner. (Lol)

Considération

Concernant la cause de cette panne, les causes possibles sont les suivantes.

Construction de modèles insuffisante? (Veuillez me donner quelques conseils) ――En premier lieu, le cours de l'action jusqu'au jour précédent affecte-t-il le cours de l'action le jour suivant? ――La moyenne Nikkei étant la moyenne des cours des actions, n'y a-t-il pas de facteur technique en premier lieu?

J'ai essayé diverses choses en changeant le nombre de jours utilisés pour la saisie, le nombre de couches cachées, le nombre d'unités, la fonction d'activation, etc., mais il n'y a pas eu de changement particulier dans les résultats. : sanglot:

Impressions

Je ne suis pas très familier avec le calcul matriciel ou le deep learning, mais si je peux comprendre les grandes lignes, il semble que je puisse faire quelque chose comme ça avec TensorFlow! : satisfait:

Sites référencés, pages, littérature

Tutoriel officiel Jouez pour prédire la valeur et le type de race à partir du nom de Pokemon avec TensorFlow [Deep learning (série professionnelle d'apprentissage automatique)](http://www.amazon.co.jp/%E6%B7%B1%E5%B1%A4%E5%AD%A6%E7%BF%92-%E6 % A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 83% 97% E3% 83% AD% E3% 83% 95% E3% 82% A7% E3% 83 % 83% E3% 82% B7% E3% 83% A7% E3% 83% 8A% E3% 83% AB% E3% 82% B7% E3% 83% AA% E3% 83% BC% E3% 82% BA -% E5% B2% A1% E8% B0% B7-% E8% B2% B4% E4% B9% 8B / dp / 4061529021)