Введение
Прогнозирование цены акций — очень блефовая штука, но если оно основано только на исторических данных, то оно, очевидно, совершенно ненадежно.
Цены на акции представляют собой типичные данные временных рядов (называемые данными временных рядов), на которые будет влиять множество сложных факторов, таких как экономическая среда, государственная политика и деятельность человека.
Не имеет очевидных временных и сезонных закономерностей, таких как данные о погоде, такие как изменение температуры в течение дня, года и т. д.
Тем не менее стоит взять цены акций в качестве примера, чтобы описать, как прогнозировать данные временных рядов.
Следующее использует TensorFlow и Keras, справаS&P 500Данные о ценах на акции для анализа и прогнозирования
данные
S&P 500Данные о ценах на акции сканируются из Google Finance API и обрабатываются на предмет отсутствующих значений.
Загрузка библиотеки, pandas в основном используется для очистки и сортировки данных
# -*- coding: utf-8 -*-
import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.preprocessing import MinMaxScaler
import time
Прочитайте файл csv как DataFrame с пандами и используйтеdescribe()Просмотр числового распределения функции
data = pd.read_csv('data_stocks.csv')
data.describe()
также можно использоватьinfo()Просмотр сводки функций
data.info()
Данные имеют в общей сложности 502 столбца, 41266 строк и 502 столбца:
-
DATE: Временная метка строки данных -
SP500: можно понимать как рыночный индекс - Другие: можно понимать как цену акций 500 отдельных акций.
Просмотр первых пяти строк данных
data.head()
Просмотр временного интервала
print(time.strftime('%Y-%m-%d', time.localtime(data['DATE'].max())),
time.strftime('%Y-%m-%d', time.localtime(data['DATE'].min())))
Нарисуйте линейный график тенденции рынка
plt.plot(data['SP500'])
УдалитьDATEОдин столбец, тренировочный набор, тестовый набор, разделенный
data.drop('DATE', axis=1, inplace=True)
data_train = data.iloc[:int(data.shape[0] * 0.8), :]
data_test = data.iloc[int(data.shape[0] * 0.8):, :]
print(data_train.shape, data_test.shape)
Нормализация данных может использоваться толькоdata_trainпровестиfit()
scaler = MinMaxScaler(feature_range=(-1, 1))
scaler.fit(data_train)
data_train = scaler.transform(data_train)
data_test = scaler.transform(data_test)
Одновременное предсказание
Синхронное прогнозирование означает, что цена акций 500 акций в текущий момент используется для прогнозирования рыночного индекса в текущий момент, то есть задача регрессии.Входные данные представляют собой в общей сложности 500-мерные признаки, а выходные данные одно- размерный, а именно[None, 500] => [None, 1]
Используйте TensorFlow для достижения синхронного прогнозирования, в основном с использованием многослойного персептрона (MLP) и функции потерь с использованием среднеквадратичной ошибки (MSE).
X_train = data_train[:, 1:]
y_train = data_train[:, 0]
X_test = data_test[:, 1:]
y_test = data_test[:, 0]
input_dim = X_train.shape[1]
hidden_1 = 1024
hidden_2 = 512
hidden_3 = 256
hidden_4 = 128
output_dim = 1
batch_size = 256
epochs = 10
tf.reset_default_graph()
X = tf.placeholder(shape=[None, input_dim], dtype=tf.float32)
Y = tf.placeholder(shape=[None], dtype=tf.float32)
W1 = tf.get_variable('W1', [input_dim, hidden_1], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b1 = tf.get_variable('b1', [hidden_1], initializer=tf.zeros_initializer())
W2 = tf.get_variable('W2', [hidden_1, hidden_2], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b2 = tf.get_variable('b2', [hidden_2], initializer=tf.zeros_initializer())
W3 = tf.get_variable('W3', [hidden_2, hidden_3], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b3 = tf.get_variable('b3', [hidden_3], initializer=tf.zeros_initializer())
W4 = tf.get_variable('W4', [hidden_3, hidden_4], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b4 = tf.get_variable('b4', [hidden_4], initializer=tf.zeros_initializer())
W5 = tf.get_variable('W5', [hidden_4, output_dim], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b5 = tf.get_variable('b5', [output_dim], initializer=tf.zeros_initializer())
h1 = tf.nn.relu(tf.add(tf.matmul(X, W1), b1))
h2 = tf.nn.relu(tf.add(tf.matmul(h1, W2), b2))
h3 = tf.nn.relu(tf.add(tf.matmul(h2, W3), b3))
h4 = tf.nn.relu(tf.add(tf.matmul(h3, W4), b4))
out = tf.transpose(tf.add(tf.matmul(h4, W5), b5))
cost = tf.reduce_mean(tf.squared_difference(out, Y))
optimizer = tf.train.AdamOptimizer().minimize(cost)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for e in range(epochs):
shuffle_indices = np.random.permutation(np.arange(y_train.shape[0]))
X_train = X_train[shuffle_indices]
y_train = y_train[shuffle_indices]
for i in range(y_train.shape[0] // batch_size):
start = i * batch_size
batch_x = X_train[start : start + batch_size]
batch_y = y_train[start : start + batch_size]
sess.run(optimizer, feed_dict={X: batch_x, Y: batch_y})
if i % 50 == 0:
print('MSE Train:', sess.run(cost, feed_dict={X: X_train, Y: y_train}))
print('MSE Test:', sess.run(cost, feed_dict={X: X_test, Y: y_test}))
y_pred = sess.run(out, feed_dict={X: X_test})
y_pred = np.squeeze(y_pred)
plt.plot(y_test, label='test')
plt.plot(y_pred, label='pred')
plt.title('Epoch ' + str(e) + ', Batch ' + str(i))
plt.legend()
plt.show()
Потеря окончательного тестового набора составляет около 0,005, а результаты прогнозирования следующие.
Используя Keras для достижения синхронного прогнозирования, объем кода будет намного меньше, но конкретные детали реализации не такие гибкие, как TensorFlow.
from keras.layers import Input, Dense
from keras.models import Model
X_train = data_train[:, 1:]
y_train = data_train[:, 0]
X_test = data_test[:, 1:]
y_test = data_test[:, 0]
input_dim = X_train.shape[1]
hidden_1 = 1024
hidden_2 = 512
hidden_3 = 256
hidden_4 = 128
output_dim = 1
batch_size = 256
epochs = 10
X = Input(shape=[input_dim,])
h = Dense(hidden_1, activation='relu')(X)
h = Dense(hidden_2, activation='relu')(h)
h = Dense(hidden_3, activation='relu')(h)
h = Dense(hidden_4, activation='relu')(h)
Y = Dense(output_dim, activation='sigmoid')(h)
model = Model(X, Y)
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, shuffle=False)
y_pred = model.predict(X_test)
print('MSE Train:', model.evaluate(X_train, y_train, batch_size=batch_size))
print('MSE Test:', model.evaluate(X_test, y_test, batch_size=batch_size))
plt.plot(y_test, label='test')
plt.plot(y_pred, label='pred')
plt.legend()
plt.show()
Потери окончательного тестового набора составляют около 0,007, а результаты прогнозирования следующие.
Асинхронное предсказание
Асинхронное прогнозирование относится к использованию рыночного индекса нескольких исторических моментов для прогнозирования рыночного индекса на текущий момент, чтобы больше соответствовать определению прогнозирования.
Например, при использовании первых пяти рыночных индексов для прогнозирования текущего рыночного индекса каждый набор входных данных включает 5 шагов, каждый шаг соответствует рыночному индексу в исторический момент, а выходные данные являются одномерными, а именно[None, 5, 1] => [None, 1]
Используйте Keras для достижения асинхронного прогнозирования, в основном с использованием LSTM (длинная кратковременная память) в RNN (рекуррентная нейронная сеть).
from keras.layers import Input, Dense, LSTM
from keras.models import Model
output_dim = 1
batch_size = 256
epochs = 10
seq_len = 5
hidden_size = 128
X_train = np.array([data_train[i : i + seq_len, 0] for i in range(data_train.shape[0] - seq_len)])[:, :, np.newaxis]
y_train = np.array([data_train[i + seq_len, 0] for i in range(data_train.shape[0] - seq_len)])
X_test = np.array([data_test[i : i + seq_len, 0] for i in range(data_test.shape[0] - seq_len)])[:, :, np.newaxis]
y_test = np.array([data_test[i + seq_len, 0] for i in range(data_test.shape[0] - seq_len)])
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)
X = Input(shape=[X_train.shape[1], X_train.shape[2],])
h = LSTM(hidden_size, activation='relu')(X)
Y = Dense(output_dim, activation='sigmoid')(h)
model = Model(X, Y)
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, shuffle=False)
y_pred = model.predict(X_test)
print('MSE Train:', model.evaluate(X_train, y_train, batch_size=batch_size))
print('MSE Test:', model.evaluate(X_test, y_test, batch_size=batch_size))
plt.plot(y_test, label='test')
plt.plot(y_pred, label='pred')
plt.legend()
plt.show()
Потеря окончательного тестового набора составляет около 0,0015.Результаты прогнозирования выглядят следующим образом.Влияние одного слоя LSTM намного лучше.
Конечно, возможна также попытка использовать цены 500 отдельных акций и рыночный индекс в несколько исторических моментов для прогнозирования текущего рыночного индекса, т. е.[None, 5, 501] => [None, 1]
from keras.layers import Input, Dense, LSTM
from keras.models import Model
output_dim = 1
batch_size = 256
epochs = 10
seq_len = 5
hidden_size = 128
X_train = np.array([data_train[i : i + seq_len, :] for i in range(data_train.shape[0] - seq_len)])
y_train = np.array([data_train[i + seq_len, 0] for i in range(data_train.shape[0] - seq_len)])
X_test = np.array([data_test[i : i + seq_len, :] for i in range(data_test.shape[0] - seq_len)])
y_test = np.array([data_test[i + seq_len, 0] for i in range(data_test.shape[0] - seq_len)])
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)
X = Input(shape=[X_train.shape[1], X_train.shape[2],])
h = LSTM(hidden_size, activation='relu')(X)
Y = Dense(output_dim, activation='sigmoid')(h)
model = Model(X, Y)
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, shuffle=False)
y_pred = model.predict(X_test)
print('MSE Train:', model.evaluate(X_train, y_train, batch_size=batch_size))
print('MSE Test:', model.evaluate(X_test, y_test, batch_size=batch_size))
plt.plot(y_test, label='test')
plt.plot(y_pred, label='pred')
plt.legend()
plt.show()
Окончательная потеря составляет около 0,004, но результат ухудшается.
Эффект предсказания 500 отдельных акций плюс индекс крупной капитализации не так хорош, как использование только индекса крупной капитализации.
Объясните, что чем больше функций, тем не лучше, иногда это приводит к лишнему шуму.
Поскольку не используются сложные CNN или RNN, скорость процессора в порядке.
Ссылаться на
- Простая модель глубокого обучения для прогнозирования цен на акции с использованием TensorFlow:medium.com/ml обзор/ah-…