Zuvor (1, 2, [3](http: // qiita). Eine Fortsetzung von com / yai / items / 1b7f8ef69f8f2343e3e9)). Es macht keinen Spaß, nur zu klassifizieren, deshalb möchte ich das Regressionsproblem ausprobieren. Dieses Mal werden wir also das Framework für maschinelles Lernen TensorFlow und scicit-learn verwenden, um den Aktienkurs direkt vorherzusagen. Früher wurde der Aktienkurs des nächsten Tages als "hoch oder runter" klassifiziert, aber dieses Mal werden wir direkt vorhersagen, "wie viele Yen". Die für die Eingabe verwendeten Daten werden wiederverwendet. Sumimasen jedes Mal.
"Prognose des durchschnittlichen Nikkei-Aktienkurses am nächsten Tag unter Verwendung globaler Aktienindizes im Wert von mehreren Tagen (Dow, Nikkei-Durchschnitt, DAX usw.)" (Rendite)
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
Laden Sie die Aktienindizes von Nikkei, Dow, Hong Kong Hansen und German von der Website Quandl herunter. Kombinieren Sie sie als Textdaten zu einer. (Handarbeit)
Verwenden Sie den Schlusskurs des nächsten Tages als korrekte Antwortdaten. (Prognostizieren Sie den Schlusskurs des nächsten Tages) Als ich jedoch versuchte, den Aktienkurs direkt als Etikett zu verwenden, war das Ergebnis immer unterschiedlich, also habe ich es mir ausgedacht. Wir werden das Prognoseziel zu einem indirekten Ziel machen, z. B. "Welcher Prozentsatz des Schlusskurses des nächsten Tages höher oder niedriger als der vorherige Tag sein wird", und dann neu berechnen, um den Schlusskurs zu ermitteln. Da für die später beschriebene Eingabe dieselbe Änderungsrate verwendet wird, ist dies sinnvoll ... (・ ・;)
# JUDGE_DAY = 1,Zweiter Index[3]Enthält den Schlusskurs des Nikkei-Durchschnitts.
y_array.append([(array_base[i][3] - array_base[i+JUDGE_DAY][3]) / array_base[i][3] * 100])
Anstatt den Aktienkurs so zu setzen, wie er ist, geben wir eine Liste an, "wie viel (%) er im Vergleich zum Vortag gestiegen oder gefallen ist". (Weil es überhaupt nicht funktioniert hat, auch wenn ich den Aktienkurs so gesetzt habe, wie er ist)
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 hat zwei versteckte Ebenen und die Anzahl der Einheiten beträgt 50 bzw. 25.
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
Verwenden Sie l2_loss (), um den Verlust zu berechnen. Ich frage mich, ob das gut ist, weil der Unterschied zwischen den Zahlen ein Verlust ist, aber ich bin mir nicht sicher, ob es richtig ist. Diejenigen, die "Nein" sagen, sind herzlich eingeladen, Kommentare abzugeben.
def loss(y, target):
return tf.reduce_mean(tf.nn.l2_loss((y - target)))
Gibt es nichts Besonderes zu erwähnen?
def optimize(loss):
optimizer = tf.train.AdamOptimizer(learning_rate)
train_step = optimizer.minimize(loss)
return train_step
Gibt es hier auch nichts Besonderes zu erwähnen?
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)
Für die Genauigkeit wird die Differenz zwischen der berechneten Schwankungsrate des Aktienkurses und der tatsächlichen Schwankungsrate berechnet und der Durchschnitt der absoluten Werte ausgegeben. Mit anderen Worten, es gibt nur den durchschnittlichen Fehler.
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}))
Es gibt verschiedene Algorithmen, aber ... ich bin mir nicht sicher, welcher der beste ist, also nehme ich ungefähr drei und verwende sie ohne Argumente.
# 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)
Das Training führt nur fit () aus. Als ich score () ausführte, wurde die Bewertung teilweise negativ und ich war mir nicht sicher, wie ich sie beurteilen sollte (bitte sagen Sie mir, wenn Sie es wissen), so wie bei TensorFlow die vorhergesagte Änderungsrate des Aktienkurses Wird herausgenommen, um den Durchschnitt der absoluten Werte der Differenz in der tatsächlichen Aktienkursänderungsrate (kurz der durchschnittliche Fehler) zu nehmen.
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
Daher betrug der Fehler etwa 1%. Ein 1% iger Fehler in der Aktienkursprognose ... kann überhaupt nicht verwendet werden ... Gefun Gefun.
Da es eine große Sache ist, lassen Sie uns tatsächlich den vorhergesagten Wert erhalten. Da die vorliegenden Daten bis zum 24. März 2016 vorliegen, prognostizieren wir den Schlusskurs des durchschnittlichen Nikkei-Aktienkurses am 25. März 2016. scikit-learn verwendet 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
Der tatsächliche Aktienkurs am 25.03. Ist also ... 17.002,75. ** ... Nun, das stimmt. ** ** **
―― Es scheint, dass maschinelles Lernen nicht bedeutet, dass "warum trainierst du damit, die Maschine wird ihr Bestes geben und die beste wird herauskommen". Es scheint, dass die menschliche Seite auch darüber nachdenken muss, was getan werden sollte, damit die Maschine leichter zu denken und zu beantworten ist.
Recommended Posts