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.
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)
TensorFlow 0.7 Ubuntu 14.04 Python 2.7 AWS EC2 micro instance
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 ...
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.
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
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))
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
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)
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}))
En raison de ce qui précède, la précision est
0.50295
** · · · Non. ** **
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)
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.
«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.
«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.
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