Précédemment (1, 2, [3](http: // qiita. Une suite de com / yai / items / 1b7f8ef69f8f2343e3e9)). Ce n'est pas amusant de simplement classer, alors j'aimerais essayer le problème de régression. Donc, cette fois, nous utiliserons le framework d'apprentissage automatique TensorFlow et scikit-learn pour prédire directement le cours de l'action. Auparavant, le cours de l'action du lendemain était classé comme «à la hausse ou à la baisse», mais cette fois, nous prédirons directement «combien de yens». Les données utilisées pour l'entrée sont réutilisées. Sumimasen à chaque fois.
"Prévoyez le cours moyen de l'action Nikkei du lendemain en utilisant plusieurs jours d'indices boursiers mondiaux (Dow, Nikkei average, DAX, etc.)" (retour)
scikit-learn scikit-learn 0.17.1 Python 2.7 Windows 7 TensorFlow TensorFlow 0.7 Ubuntu 14.04 Python 2.7 AWS EC2 micro instance
Téléchargez les indices boursiers Nikkei, Dow, Hong Kong Hansen et allemand sur le site Quandl. Combinez-les en un seul sous forme de données textuelles. (Travail manuel)
Utilisez le cours de clôture du jour suivant comme donnée de réponse correcte. (Prédisez le cours de clôture du lendemain) Cependant, lorsque j'ai essayé d'utiliser le cours de l'action directement comme étiquette, le résultat était divergent et divergent. Nous allons faire de la cible de prédiction une cible indirecte, comme "quel pourcentage du cours de clôture du jour suivant sera supérieur ou inférieur à celui de la veille", puis recalculer pour trouver le cours de clôture. Étant donné que le même taux de changement est utilisé pour l'entrée décrite plus loin, il est logique ... (・ ・;)
# JUDGE_DAY = 1,Deuxième indice[3]Contient le cours de clôture de la moyenne Nikkei.
y_array.append([(array_base[i][3] - array_base[i+JUDGE_DAY][3]) / array_base[i][3] * 100])
Au lieu de mettre le cours de l'action tel qu'il est, nous donnons une liste de "combien (%) il a augmenté ou diminué par rapport à la veille". (Parce que ça n'a pas du tout fonctionné même si je mets le cours de l'action tel quel)
tmp_array = []
for j in xrange(i+1, i + data_num + 1):
for k in range(16):
tmp_array.append((array_base[j][k] - array_base[j+1][k]) / array_base[j][k] * 100)
x_array.append(tmp_array)
TensorFlow a deux couches cachées et le nombre d'unités est de 50 et 25, respectivement.
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('regression'):
weights = tf.Variable(tf.truncated_normal([NUM_HIDDEN2, 1], stddev=stddev), name='weights')
biases = tf.Variable(tf.zeros([1]), name='biases')
y = tf.matmul(dropout, weights) + biases
return y
Utilisez l2_loss () pour calculer la perte. Je me demande si c'est bien parce que la différence entre les chiffres est une perte, mais je ne suis pas sûr que ce soit correct. Ceux qui disent «non» sont invités à commenter.
def loss(y, target):
return tf.reduce_mean(tf.nn.l2_loss((y - target)))
N'y a-t-il rien de spécial à mentionner?
def optimize(loss):
optimizer = tf.train.AdamOptimizer(learning_rate)
train_step = optimizer.minimize(loss)
return train_step
N'y a-t-il rien de spécial à mentionner ici également?
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)
Pour plus de précision, la différence entre le taux de fluctuation calculé du cours de l'action et le taux de fluctuation réel est calculée et la moyenne des valeurs absolues est sortie. En d'autres termes, cela donne simplement l'erreur moyenne.
accuracy = tf.reduce_mean(tf.abs(y - y_ph))
print "accuracy"
print(sess.run(accuracy, feed_dict={x_ph: test_batch_xs, y_ph: test_batch_ys, keep_prob: 1.0}))
Il existe différents algorithmes, mais ... Je ne sais pas lequel est le meilleur, alors je vais en prendre environ trois et les utiliser sans arguments.
# SGDRegressor
clf = linear_model.SGDRegressor()
testClf(clf, x_train_array, y_train_array, x_test_array, y_test_array)
# DecisionTreeRegressor
clf = tree.DecisionTreeRegressor()
testClf(clf, x_train_array, y_train_array, x_test_array, y_test_array)
# SVM
clf = svm.SVR()
testClf(clf, x_train_array, y_train_array, x_test_array, y_test_array)
La formation n'exécute que fit (). Lorsque j'ai exécuté score (), l'évaluation est devenue partiellement négative et je ne savais pas trop comment la juger (veuillez me dire si vous le connaissez), comme avec TensorFlow, le taux de variation du cours de l'action prévu Est pris pour prendre la moyenne des valeurs absolues de la différence du taux de variation réel du cours de l'action (en bref, l'erreur moyenne).
def testClf(clf, x_train_array, y_flg_train_array, x_test_array, y_flg_test_array):
print clf
clf.fit(x_train_array, y_flg_train_array)
result = clf.predict(x_test_array)
print clf.score(x_test_array, y_flg_test_array)
print np.mean(np.abs(np.array(result) - np.array(y_flg_test_array)))
TensorFlow
1.00044
scikit-learn
SGDRegressor: 0.943171296872
DecisionTreeRegressor: 1.3551351662
SVM: 0.945361479916
Par conséquent, l'erreur était d'environ 1%. Une erreur de 1% dans la prévision du cours de l'action ... ne peut pas du tout être utilisée ... Gefun Gefun.
Puisque c'est un gros problème, obtenons en fait la valeur prévue. Étant donné que les données disponibles sont jusqu'au 24 mars 2016, nous prévoyons le cours de clôture du cours moyen de l'action Nikkei le 25 mars 2016. scikit-learn utilise SVM.
TensorFlow
p = sess.run(y, feed_dict={x_ph: data, keep_prob: 1.0})
price = ((p[0][0] / 100.) + 1.) * 16892.33
print price
scikit-learn
p = clf.predict(data)
price = ((p[0] / 100.) + 1.) * 16892.33
print price
TensorFlow
16804.3398821
scikit-learn
16822.6013292
Ainsi, le cours réel de l'action le 25/03 est de ... 17 002,75. ** ... Eh bien, c'est vrai. ** **
«Il semble que l'apprentissage automatique ne signifie pas que« pourquoi vous entraînez-vous avec lui, la machine fera de son mieux et le meilleur sortira ». Il semble que le côté humain doit également réfléchir à ce qui devrait être fait pour rendre la machine plus facile à penser et à répondre.
Recommended Posts