Прогнозирование цены биткойна с помощью TensorFlow и Keras

Эта статья была изначально создана "AI Frontline", оригинальная ссылка:Прогнозирование цены биткойна с помощью TensorFlow и Keras
Автор｜Huang Gongxiang Steeve Huang
Переводчик｜Эрика Йи
Редактор | Эмили

Руководство по передовой ИИ:"Криптовалюты, особенно Биткойн, в последнее время стали одной из горячих точек в социальных сетях и поисковых системах. Из-за высокой волатильности криптовалют на них можно получить огромную прибыль с помощью разумной и рациональной инвестиционной стратегии. Внезапно кажется, что все люди в мире говорят о криптовалютах.Но по сравнению с традиционными финансовыми инструментами цены на криптовалюты относительно непредсказуемы из-за отсутствия соответствующих индикаторов.Эта статья нацелена на использование биткойна в качестве примера, чтобы научить вас использовать глубину. прогнозировать цены на эти криптовалюты, чтобы получить представление о будущих тенденциях биткойнов».

Криптовалюты, особенно Биткойн, в наши дни стали одной из самых популярных тем в социальных сетях и поисковых системах. Из-за высокой волатильности криптовалют люди могут получать от них огромную прибыль с помощью разумной и рациональной инвестиционной стратегии. Внезапно кажется, что все люди в мире говорят о криптовалютах. Но по сравнению с традиционными финансовыми инструментами цены относительно непредсказуемы из-за отсутствия соответствующих индикаторов для криптовалют. Цель этой статьи — использовать биткойн в качестве примера, чтобы научить вас, как использовать глубокое обучение для прогнозирования цен на эти криптовалюты, чтобы получить представление о будущих тенденциях в биткойнах.

Готов к работе

Чтобы следующий код работал гладко, убедитесь, что вы установили следующие среды и библиотеки:

Python 2.7
Tensorflow=1.2.0
Keras=2.1.1
Pandas=0.20.3
Numpy=1.13.3
h5py=2.7.0
sklearn=0.19.1

Сбор данных

Данные для составления прогнозов можно получить с Kaggle или Poloniex. Чтобы обеспечить согласованность, имена столбцов, загруженных из Poloniex, будут изменены, чтобы соответствовать именам в Kaggle.

import json
import numpy as np
import os
import pandas as pd
import urllib2
# connect to poloniex's API
url = 'https://poloniex.com/public?command=returnChartData&currencyPair=USDT_BTC&start=1356998100&end=9999999999&period=300'
# parse json returned from the API to Pandas DF
openUrl = urllib2.urlopen(url)
r = openUrl.read()
openUrl.close()
d = json.loads(r.decode())
df = pd.DataFrame(d)
original_columns=[u'close', u'date', u'high', u'low', u'open']
new_columns = ['Close','Timestamp','High','Low','Open']
df = df.loc[:,original_columns]
df.columns = new_columns
df.to_csv('data/bitcoin2015to2017.csv',index=None)

(Исходный код можно найти на GitHub)

Подготовить данные

Прежде чем собранные данные можно будет использовать для прогнозирования модели, данные необходимо проанализировать. Класс PastSampler ссылается на этот блог и разбивает указанные данные на список данных и список меток. Размер ввода (N) равен 256, а размер вывода (K) равен 16. Примечательно, что Poloniex собирает данные каждые пять минут. То есть входные данные охватывают 1280 минут, а выходные — более 80 минут.

import numpy as np
import pandas as pd
class PastSampler:
    '''
    Forms training samples for predicting future values from past value
    '''
    def __init__(self, N, K, sliding_window = True):
        '''
        Predict K future sample using N previous samples
        '''
        self.K = K
        self.N = N
        self.sliding_window = sliding_window
    def transform(self, A):
        M = self.N + self.K     #Number of samples per row (sample + target)
        #indexes
        if self.sliding_window:
            I = np.arange(M) + np.arange(A.shape[0] - M + 1).reshape(-1, 1)
        else:
            if A.shape[0]%M == 0:
                I = np.arange(M)+np.arange(0,A.shape[0],M).reshape(-1,1)
            else:
                I = np.arange(M)+np.arange(0,A.shape[0] -M,M).reshape(-1,1)
        B = A[I].reshape(-1, M * A.shape[1], A.shape[2])
        ci = self.N * A.shape[1]    #Number of features per sample
        return B[:, :ci], B[:, ci:] #Sample matrix, Target matrix
#data file path
dfp = 'data/bitcoin2015to2017.csv'
#Columns of price data to use
columns = ['Close']
df = pd.read_csv(dfp)
time_stamps = df['Timestamp']
df = df.loc[:,columns]
original_df = pd.read_csv(dfp).loc[:,columns]

(Исходный код можно найти на GitHub)

После создания класса Pastsampler я применяю его к собранным данным. Поскольку необработанные данные варьируются от 0 до более чем 10 000, требуется некоторое масштабирование данных, чтобы упростить понимание нейронной сетью собранных данных.

file_name='bitcoin2015to2017_close.h5'
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# normalization
for c in columns:
    df[c] = scaler.fit_transform(df[c].values.reshape(-1,1))
#Features are input sample dimensions(channels)
A = np.array(df)[:,None,:]
original_A = np.array(original_df)[:,None,:]
time_stamps = np.array(time_stamps)[:,None,None]
#Make samples of temporal sequences of pricing data (channel)
NPS, NFS = 256, 16         #Number of past and future samples
ps = PastSampler(NPS, NFS, sliding_window=False)
B, Y = ps.transform(A)
input_times, output_times = ps.transform(time_stamps)
original_B, original_Y = ps.transform(original_A)
import h5py
with h5py.File(file_name, 'w') as f:
    f.create_dataset("inputs", data = B)
    f.create_dataset('outputs', data = Y)
    f.create_dataset("input_times", data = input_times)
    f.create_dataset('output_times', data = output_times)
    f.create_dataset("original_datas", data=np.array(original_df))
    f.create_dataset('original_inputs',data=original_B)
    f.create_dataset('original_outputs',data=original_Y)

Моделирование

CNN

Ожидается, что одномерная сверточная нейронная сеть (1D C) хорошо фиксирует локальность данных, при этом ядро скользит по входным данным. Как показано ниже.

(Примечание на CNN (от:На данный момент 231 you.GitHub.IO/convolution…)

import pandas as pd
import numpy as numpy
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv1D, MaxPooling1D, LeakyReLU, PReLU
from keras.utils import np_utils
from keras.callbacks import CSVLogger, ModelCheckpoint
import h5py
import os
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
# Make the program use only one GPU
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
with h5py.File(''.join(['bitcoin2015to2017_close.h5']), 'r') as hf:
    datas = hf['inputs'].value
    labels = hf['outputs'].value
output_file_name='bitcoin2015to2017_close_CNN_2_relu'
step_size = datas.shape[1]
batch_size= 8
nb_features = datas.shape[2]
epochs = 100
#split training validation
training_size = int(0.8* datas.shape[0])
training_datas = datas[:training_size,:]
training_labels = labels[:training_size,:]
validation_datas = datas[training_size:,:]
validation_labels = labels[training_size:,:]
#build model
# 2 layers
model = Sequential()
model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=3, filters=8, kernel_size=20))
model.add(Dropout(0.5))
model.add(Conv1D( strides=4, filters=nb_features, kernel_size=16))
'''
# 3 Layers
model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=3, filters=8, kernel_size=8))
#model.add(LeakyReLU())
model.add(Dropout(0.5))
model.add(Conv1D(activation='relu', strides=2, filters=8, kernel_size=8))
#model.add(LeakyReLU())
model.add(Dropout(0.5))
model.add(Conv1D( strides=2, filters=nb_features, kernel_size=8))
# 4 layers
model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=2, filters=8, kernel_size=2))
#model.add(LeakyReLU())
model.add(Dropout(0.5))
model.add(Conv1D(activation='relu', strides=2, filters=8, kernel_size=2))
#model.add(LeakyReLU())
model.add(Dropout(0.5))
model.add(Conv1D(activation='relu', strides=2, filters=8, kernel_size=2))
#model.add(LeakyReLU())
model.add(Dropout(0.5))
model.add(Conv1D( strides=2, filters=nb_features, kernel_size=2))
'''
model.compile(loss='mse', optimizer='adam')
model.fit(training_datas, training_labels,verbose=1, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint('weights/'+output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])

(см. исходный код на GitHub)

Первой моделью, которую я построил, была CNN. Следующий код устанавливает номер графического процессора равным «1» (поскольку у меня 4, вы можете установить его на любой понравившийся графический процессор). Поскольку Tensorflow, похоже, плохо работает на нескольких графических процессорах, разумно ограничить его только одним графическим процессором. Если у вас нет графического процессора, не волнуйтесь, просто проигнорируйте этот абзац.

os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' 
os.environ['CUDA_VISIBLE_DEVICES'] ='1' 
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

Код для построения модели CNN прост. Используйте слой Dropout, чтобы предотвратить переоснащение. Функция потерь определяется как среднеквадратическая ошибка (Mean Squared Error, сокращенно MSE), а оптимизатор использует самый продвинутый Адам.

model = Sequential() 
model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=3, filters=8, kernel_size=20)) 
model.add(Dropout(0.5)) 
model.add(Conv1D( strides=4, filters=nb_features, kernel_size=16)) 
model.compile(loss='mse', optimizer='adam')

Единственное, о чем вам нужно беспокоиться, это размерность ввода и вывода между слоями. Формула, используемая для расчета определенного сверточного слоя:

Output time step = (Input time step — Kernel size) / Strides + 1

В конце файла я добавил две функции обратного вызова CSVLogger и ModelCheckpoint. Первый помогает мне отслеживать весь процесс обучения и проверки, а второй позволяет мне хранить веса модели для каждой эпохи.

model.fit(training_datas, training_labels,verbose=1, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint('weights/'+output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')]

LSTM

Сеть с долговременной кратковременной памятью (LSTM) представляет собой вариант временной рекуррентной нейронной сети (Recurrent Neural Network, сокращенно RNN). Он был создан для решения проблемы ванильного градиента, вызванной ванильными RNN. Говорят, что LSTM способны запоминать входные данные с более длинными временными шагами.

(Описание LSTM взято из:столбец ah.GitHub.IO/posts/2015-…)

import pandas as pd
import numpy as numpy
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten,Reshape
from keras.layers import Conv1D, MaxPooling1D
from keras.utils import np_utils
from keras.layers import LSTM, LeakyReLU
from keras.callbacks import CSVLogger, ModelCheckpoint
import h5py
import os
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
with h5py.File(''.join(['bitcoin2015to2017_close.h5']), 'r') as hf:
    datas = hf['inputs'].value
    labels = hf['outputs'].value
step_size = datas.shape[1]
units= 50
second_units = 30
batch_size = 8
nb_features = datas.shape[2]
epochs = 100
output_size=16
output_file_name='bitcoin2015to2017_close_LSTM_1_tanh_leaky_'
#split training validation
training_size = int(0.8* datas.shape[0])
training_datas = datas[:training_size,:]
training_labels = labels[:training_size,:,0]
validation_datas = datas[training_size:,:]
validation_labels = labels[training_size:,:,0]
#build model
model = Sequential()
model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))
model.add(Dropout(0.8))
model.add(Dense(output_size))
model.add(LeakyReLU())
model.compile(loss='mse', optimizer='adam')
model.fit(training_datas, training_labels, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint('weights/'+output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])

(см. исходный код на GitHub)

LSTM легче реализовать, чем CNN, потому что вам даже не нужно заботиться о размере ядра, шаге, соотношении между размером ввода и размером вывода. Просто убедитесь, что размеры входа и выхода правильно определены в сети.

model = Sequential() 
model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False)) 
model.add(Dropout(0.8)) 
model.add(Dense(output_size)) 
model.add(LeakyReLU()) 
model.compile(loss='mse', optimizer='adam')

GRU

GRU (Gated Recurrent Units) — еще один вариант RNN. Его сетевая структура не такая сложная, как LSTM, только с одним шлюзом сброса и забвения, но без блока памяти. Говорят, что GRU работают наравне с LSTM, но более эффективны. (Также и в этом блоге, поскольку LSTM занимает около 45 секунд/эпоху, а GRU менее 40 секунд/эпоху).

(Примечание о ГРУ, взято из:Ууууу. Барабанные перепонки Джека должны быть.net/bright wire/…)

import pandas as pd
import numpy as numpy
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten,Reshape
from keras.layers import Conv1D, MaxPooling1D, LeakyReLU
from keras.utils import np_utils
from keras.layers import GRU,CuDNNGRU
from keras.callbacks import CSVLogger, ModelCheckpoint
import h5py
import os
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
with h5py.File(''.join(['bitcoin2015to2017_close.h5']), 'r') as hf:
    datas = hf['inputs'].value
    labels = hf['outputs'].value
output_file_name='bitcoin2015to2017_close_GRU_1_tanh_relu_'
step_size = datas.shape[1]
units= 50
batch_size = 8
nb_features = datas.shape[2]
epochs = 100
output_size=16
#split training validation
training_size = int(0.8* datas.shape[0])
training_datas = datas[:training_size,:]
training_labels = labels[:training_size,:,0]
validation_datas = datas[training_size:,:]
validation_labels = labels[training_size:,:,0]
#build model
model = Sequential()
model.add(GRU(units=units, input_shape=(step_size,nb_features),return_sequences=False))
model.add(Activation('tanh'))
model.add(Dropout(0.2))
model.add(Dense(output_size))
model.add(Activation('relu'))
model.compile(loss='mse', optimizer='adam')
model.fit(training_datas, training_labels, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint('weights/'+output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])

(см. исходный код на GitHub)

Просто измените вторую строку кода модели LSTM, которую вы создаете,

model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))

Заменить:

model.add(GRU(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))

построение результатов

Поскольку результаты трех моделей схожи по графикам, я привожу здесь только графики версии CNN. Во-первых, нам нужно перестроить модель и загрузить в модель тренировочные веса.

from keras import applications
from keras.models import Sequential
from keras.models import Model
from keras.layers import Dropout, Flatten, Dense, Activation
from keras.callbacks import CSVLogger
import tensorflow as tf
from scipy.ndimage import imread
import numpy as np
import random
from keras.layers import LSTM
from keras.layers import Conv1D, MaxPooling1D, LeakyReLU
from keras import backend as K
import keras
from keras.callbacks import CSVLogger, ModelCheckpoint
from keras.backend.tensorflow_backend import set_session
from keras import optimizers
import h5py
from sklearn.preprocessing import MinMaxScaler
import os
import pandas as pd
# import matplotlib
import matplotlib.pyplot as plt
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
with h5py.File(''.join(['bitcoin2015to2017_close.h5']), 'r') as hf:
    datas = hf['inputs'].value
    labels = hf['outputs'].value
    input_times = hf['input_times'].value
    output_times = hf['output_times'].value
    original_inputs = hf['original_inputs'].value
    original_outputs = hf['original_outputs'].value
    original_datas = hf['original_datas'].value
scaler=MinMaxScaler()
#split training validation
training_size = int(0.8* datas.shape[0])
training_datas = datas[:training_size,:,:]
training_labels = labels[:training_size,:,:]
validation_datas = datas[training_size:,:,:]
validation_labels = labels[training_size:,:,:]
validation_original_outputs = original_outputs[training_size:,:,:]
validation_original_inputs = original_inputs[training_size:,:,:]
validation_input_times = input_times[training_size:,:,:]
validation_output_times = output_times[training_size:,:,:]
ground_true = np.append(validation_original_inputs,validation_original_outputs, axis=1)
ground_true_times = np.append(validation_input_times,validation_output_times, axis=1)
step_size = datas.shape[1]
batch_size= 8
nb_features = datas.shape[2]
model = Sequential()
# 2 layers
model.add(Conv1D(activation='relu', input_shape=(step_size, nb_features), strides=3, filters=8, kernel_size=20))
# model.add(LeakyReLU())
model.add(Dropout(0.25))
model.add(Conv1D( strides=4, filters=nb_features, kernel_size=16))
model.load_weights('weights/bitcoin2015to2017_close_CNN_2_relu-44-0.00030.hdf5')
model.compile(loss='mse', optimizer='adam')

(См. GitHub для исходного кода)

Во-вторых, нам нужно обратно масштабировать прогнозируемые данные, поскольку MinMaxScaler использовался ранее, поэтому диапазон прогнозируемых данных равен [0,1].

predicted = model.predict(validation_datas)
predicted_inverted = []
for i in range(original_datas.shape[1]):
    scaler.fit(original_datas[:,i].reshape(-1,1))
    predicted_inverted.append(scaler.inverse_transform(predicted[:,:,i]))
print np.array(predicted_inverted).shape
#get only the close data
ground_true = ground_true[:,:,0].reshape(-1)
ground_true_times = ground_true_times.reshape(-1)
ground_true_times = pd.to_datetime(ground_true_times, unit='s')
# since we are appending in the first dimension
predicted_inverted = np.array(predicted_inverted)[0,:,:].reshape(-1)
print np.array(predicted_inverted).shape
validation_output_times = pd.to_datetime(validation_output_times.reshape(-1), unit='s')

(См. GitHub для исходного кода)

Создайте два фрейма данных для фактической и прогнозируемой рыночной цены биткойна. В целях визуализации цифры на графике показывают данные только с августа 2017 года.

ground_true_df = pd.DataFrame()
ground_true_df['times'] = ground_true_times
ground_true_df['value'] = ground_true
prediction_df = pd.DataFrame()
prediction_df['times'] = validation_output_times
prediction_df['value'] = predicted_inverted
prediction_df = prediction_df.loc[(prediction_df["times"].dt.year == 2017 )&(prediction_df["times"].dt.month > 7 ),: ]
ground_true_df = ground_true_df.loc[(ground_true_df["times"].dt.year == 2017 )&(ground_true_df["times"].dt.month > 7 ),:]

(См. GitHub для исходного кода)

Используйте pyplot для рисования графиков. Поскольку прогноз цены основан на каждые 16 минут, распределение точек облегчит нам просмотр результатов. Поэтому прогнозируемые здесь данные отображаются красными точками, обозначенными буквой «ro» в третьей строке. Синяя линия на графике ниже представляет реальную ситуацию (фактические данные) на рынке, а красные точки представляют прогнозируемую цену биткойна.

plt.figure(figsize=(20,10))
plt.plot(ground_true_df.times,ground_true_df.value, label = 'Actual')
plt.plot(prediction_df.times,prediction_df.value,'ro', label='Predicted')
plt.legend(loc='upper left')
plt.show()

(см. исходный код на GitHub)

(Построено с лучшими результатами для прогнозирования цены биткойна с помощью двухслойной CNN)

Как видно из графика выше, прогнозируемая цена очень похожа на фактическую цену Биткойна. Чтобы выбрать лучшую модель, я решил протестировать несколько различных конфигураций сети, что дало мне таблицу ниже.

(прогнозируемые результаты различных моделей)

Каждая строка в приведенной выше таблице представляет собой модель с наилучшей потерей при проверке, полученную в общей сложности из 100 эпох обучения. Как видно из приведенных выше результатов, LeakyReLU всегда дает лучшие потери, чем обычный ReLU. Однако 4-слойная CNN с Leaky ReLU в качестве функции активации влечет за собой большие потери при проверке. Это может быть связано с неправильным развертыванием модели, что может потребовать повторной проверки. Модели CNN можно обучать очень быстро (с графическим процессором, 2 секунды в эпоху) и они работают немного хуже, чем LSTM и GRU. Лучшим режимом, по-видимому, является LSTM tanh и Leaky ReLU в качестве функции активации, хотя трехслойная CNN, по-видимому, лучше фиксирует локальные временные зависимости данных.

(с функцией tanh и LSTM с Leaky ReLu в качестве функции активации)

(3-слойная CNN с Leaky ReLu в качестве функции активации)

Пока прогнозы выглядят довольно хорошо, есть проблемы с переоснащением, о которых нужно знать. Существует разрыв между потерями при обучении и проверке (5.97E-06 по сравнению с 3.92E-05), и следует использовать регуляризацию, чтобы свести к минимуму разницу при обучении LSTM с LeakyReLU.

Регуляризация

Чтобы найти наилучшую стратегию регуляризации, я провел несколько экспериментов с несколькими разными значениями L1 и L2. Во-первых, необходимо определить новую функцию, которая поможет нам подогнать данные к LSTM. Здесь я буду использовать регуляризатор смещения для регуляризации вектора смещения в качестве примера.

def fit_lstm(reg):
    global training_datas, training_labels, batch_size, epochs,step_size,nb_features, units
    model = Sequential()
    model.add(CuDNNLSTM(units=units, bias_regularizer=reg, input_shape=(step_size,nb_features),return_sequences=False))
    model.add(Activation('tanh'))
    model.add(Dropout(0.2))
    model.add(Dense(output_size))
    model.add(LeakyReLU())
    model.compile(loss='mse', optimizer='adam')
    model.fit(training_datas, training_labels, batch_size=batch_size, epochs = epochs, verbose=0)
    return model

(см. исходный код на GitHub)

Обучите модель 30 раз, повторяя ее с 30 эпохами для каждого испытания.

def experiment(validation_datas,validation_labels,original_datas,ground_true,ground_true_times,validation_original_outputs, validation_output_times, nb_repeat, reg):
    error_scores = list()
    #get only the close data
    ground_true = ground_true[:,:,0].reshape(-1)
    ground_true_times = ground_true_times.reshape(-1)
    ground_true_times = pd.to_datetime(ground_true_times, unit='s')
    validation_output_times = pd.to_datetime(validation_output_times.reshape(-1), unit='s')
    for i in range(nb_repeat):
        model = fit_lstm(reg)
        predicted = model.predict(validation_datas)
        predicted_inverted = []
        scaler.fit(original_datas[:,0].reshape(-1,1))
        predicted_inverted.append(scaler.inverse_transform(predicted))
        # since we are appending in the first dimension
        predicted_inverted = np.array(predicted_inverted)[0,:,:].reshape(-1)
        error_scores.append(mean_squared_error(validation_original_outputs[:,:,0].reshape(-1),predicted_inverted))
    return error_scores
regs = [regularizers.l1(0),regularizers.l1(0.1), regularizers.l1(0.01), regularizers.l1(0.001), regularizers.l1(0.0001),regularizers.l2(0.1), regularizers.l2(0.01), regularizers.l2(0.001), regularizers.l2(0.0001)]
nb_repeat = 30
results = pd.DataFrame()
for reg in regs:
    name = ('l1 %.4f,l2 %.4f' % (reg.l1, reg.l2))
    print "Training "+ str(name)
    results[name] = experiment(validation_datas,validation_labels,original_datas,ground_true,ground_true_times,validation_original_outputs, validation_output_times, nb_repeat,reg)
results.describe().to_csv('result/lstm_bias_reg.csv')
results.describe()

(см. исходный код на GitHub)

Если вы используете блокнот Jupyter, вы можете просмотреть приведенную ниже таблицу непосредственно из выходных данных.

(рабочий результат регуляризатора смещения)

Чтобы визуализировать результаты сравнения, мы можем использовать boxplot:

results.describe().boxplot()
plt.show()

(см. исходный код на GitHub)

Для сравнения, регуляризаторы L2 с коэффициентом 0,01 для вектора смещения, похоже, дают наилучшие результаты.

Чтобы найти наилучшую комбинацию всех регуляризаторов, включая активации, смещения, ядра, циркулянтные матрицы, необходимо протестировать эти регуляризаторы один за другим, что невозможно с аппаратной конфигурацией, которую я сейчас использую. Так что я оставлю это для будущей работы.

в заключении

Из этой статьи вы узнали:

Как собирать биткойн-данные в реальном времени.
Как подготовить данные для обучения и тестирования.
Как использовать глубокое обучение для прогнозирования цены биткойна.
Как визуализировать результаты прогноза.
Как применить регуляризацию к модели.

В будущем перед этим блогом будет поставлена задача найти лучшие гиперпараметры для лучшей модели и, возможно, использовать социальные сети, чтобы сделать прогнозы более точными. Я впервые публикую статью в Medium. Если есть какие-либо ошибки или вопросы, пожалуйста, не стесняйтесь оставлять свои комментарии ниже.

Смотрите мой github для получения дополнительной информации.

Оригинальная ссылка:

blog.good Audience.com/predicting-…

Для большего содержания сухих товаров вы можете обратить внимание на AI Frontline, ID:ai-front, фоновый ответ "AI", "TF", "Большие данные«Вы можете получить серию мини-книг в формате PDF и карт навыков «AI Frontline».