在 Python 中使用 RNN 和 LSTM 预测比特币价格

在本文中，我们将讨论与比特币价格预测相关的程序。

我们还将讨论此处用于图形表示的库。

涵盖的主题：

1.什么是比特币
2.如何使用比特币
3.使用深度学习预测比特币价格

什么是比特币？

比特币是所有加密爱好者常用的加密货币之一。尽管有以太坊、瑞波币、莱特币等几种加密货币，但比特币却位居榜首。

加密货币通常用作我们货币的加密形式，广泛用于购物、交易、投资等。

它使用点对点技术。这项技术背后的原因是没有驱动力或任何第三方来干扰网络内完成的交易。此外，比特币是“开源”的，任何人都可以使用。

一些特点是：

1.快速的点对点交易
2.全球支付
3.低手续费

使用的原则 - 密码学：

加密货币（比特币）背后的工作原理是“加密”。他们使用这一原则来保护和验证谈判，并控制加密货币新组件的建立。

如何使用比特币？

使用深度学习预测比特币价格：

本项目使用的步骤是：

1.数据收集：

导入 CSV 文件数据集。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

现在，使用 pandas 和 numpy 导入数据集。 python中numpy主要用于科学计算

coindata = pd.read_csv(‘Dataset.csv’)
googledata = pd.read_csv(‘DS2.csv’)

现在打印加载的原始数据集

coindata = coindata.drop([‘#’], axis=1)
coindata.columns = [‘Date’,’Open’,’High’,’Low’,’Close’,’Volume’]
googledata = googledata.drop([‘Date’,’#’], axis=1)

未使用的列将放置在此处。在这里，我们从硬币数据和 Google 数据集中删除了两列比特币涨跌预测软件，因为它们是未使用的列。

现在，从数据集中删除未使用的列后，将为两个数据集打印最终结果。

last = pd.concat([coindata,googledata], axis=1)

现在，连接两个数据集并使用函数打印它们

last.to_csv(‘Bitcoin3D.csv’, index=False)

p>

现在，连接两个数据集后，将导出最终的数据集。

1.一维循环神经网络：

import pandas as pd
import matplotlib.pyplot as plt
import numpy as npimport mathfrom sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_errorfrom keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.layers import LSTM

在这里，我们使用 Keras 库。 Keras 只需几行代码即可使用高效的计算库训练神经网络模型。 MinMaxScaler 通过将每个特征映射到给定范围来转换特征。 sklearn 包将提供该程序所需的一些实用功能。

致密层会做以下事情并返回输出。

output = activation(dot(input, kernel) + bias)def new_dataset(dataset, step_size):
    data_X, data_Y = [], []
    for i in range(len(dataset)-step_size-1):
        a = dataset[i:(i+step_size), 0]
        data_X.append(a)
        data_Y.append(dataset[i + step_size, 0])
    return np.array(data_X), np.array(data_Y)

这里，我们将数据预处理阶段采集的一维数据分解为时序数据

df = pd.read_csv(“Bitcoin1D.csv”)
df[‘Date’] = pd.to_datetime(df[‘Date’])
df = df.reindex(index= df.index[::-1])

@ >

数据集已加载。该函数从 Bitcoin1D.csv 文件中读取。此外，我们将“日期”列转换为“日期时间”。按“日期”列重新索引所有数据集。

zaman = np.arange(1, len(df) + 1, 1)
OHCL_avg = df.mean(axis=1)

这里，我们直接分配一个新的索引数组。

OHCL_avg = np.reshape(OHCL_avg.values, (len(OHCL_avg),1)) #7288 data
scaler = MinMaxScaler(feature_range=(0,1))
OHCL_avg = scaler.fit_transform(OHCL_avg)

分配缩放器后对数据集进行规范化

#print(OHCL_avg)train_OHLC = int(len(OHCL_avg)*0.56)
test_OHLC = len(OHCL_avg) — train_OHLCtrain_OHLC, test_OHLC = OHCL_avg[0:train_OHLC,:], OHCL_avg[train_OHLC:len(OHCL_avg),:]#Train the datasets and test ittrainX, trainY = new_dataset(train_OHLC,1)
testX, testY = new_dataset(test_OHLC,1)

我们从平均开始在OHLC（高开低开）中创建一维数据集

trainX = np.reshape(trainX, (trainX.shape[0],1,trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0],1,testX.shape[1]))step_size = 1

现在，在 3D 维度上重塑 LSTM 数据集。将 step_size 赋值为 1。

model = Sequential()
model.add(LSTM(128, input_shape=(1, step_size)))
model.add(Dropout(0.1))
model.add(Dense(1))
model.add(Activation(‘linear’))

在这里，创建 LSTM 模型

model.compile(loss=’mean_squared_error’, optimizer=’adam’)
model.fit(trainX, trainY, epochs=10, batch_size=25, verbose=2)

我们定义epoch数为10，batch_size为25

trainPredict = model.predict(trainX)
testPredict = model.predict(testX)trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)testY = scaler.inverse_transform([testY])

现在，为绘图完成了标准化

trainScore = math.sqrt(mean_squared_error(trainY[0], 
                       trainPredict[:,0]))testScore = math.sqrt(mean_squared_error(testY[0], 
                       testPredict[:,0]))

根据预测的测试数据集计算性能度量 RMSE

trainPredictPlot = np.empty_like（OHCL_avg）trainPredictPlot [：，：] = np.nantrainPredictPlot [step_size：len（trainPredict）+ step_size ,:] = 
                                                  trainPredict

现在，使用转换后的训练数据集进行绘图

testPredictPlot = np.empty_like（OHCL_avg）testPredictPlot [：，：] = np.nantestPredictPlot [len（trainPredict）+（step_size * 2）+1：len（OHCL_avg）-1 ,:] 
                    = testPredict

现在，使用转换后的预测测试数据集进行绘图

预测值的最终可视化

OHCL_avg = scaler.inverse_transform(OHCL_avg)plt.plot(OHCL_avg, ‘g’, label=’Orginal Dataset’)
plt.plot(trainPredictPlot, ‘r’, label=’Training Set’)
plt.plot(testPredictPlot, ‘b’, label=’Predicted price/test set’)
plt.title(“ Bitcoin Predicted Prices”)
plt.xlabel(‘ Time’, fontsize=12)
plt.ylabel(‘Close Price’, fontsize=12)
plt.legend(loc=’upper right’)
plt.show()

3.多元循环神经网络：

import pandas as pd
from pandas import DataFrame
from pandas import concatfrom math import sqrt
from numpy import concatenateimport matplotlib.pyplot as pyplot
import numpy as npfrom sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScalerfrom keras import Sequential
from keras.layers import LSTM, Dense, Dropout, Activationfrom pandas import read_csv

在这里，我们使用 Keras 库。 Keras 只需几行代码就可以使用高效的计算库来训练神经网络模型。 sklearn 包将提供该程序所需的一些实用功能。密集层将执行以下操作并返回输出。

dataset = read_csv(‘Bitcoin3D.csv’, header=0, index_col=0)
print(dataset.head())values = dataset.values

使用 Pandas 库加载数据集。可视化列在此处准备。

groups = [0, 1, 2, 3, 5, 6,7,8,9]
i = 1

将序列转换为监督学习

def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
    n_vars = 1 if type(data) is list else data.shape[1]
    df = DataFrame(data)
    cols, names = list(), list()
    # Here is created input columns which are (t-n, … t-1)
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))
        names += [(‘var%d(t-%d)’ % (j+1, i)) for j in range(n_vars)]#Here, we had created output/forecast column which are (t, t+1, … t+n)
    for i in range(0, n_out):
        cols.append(df.shift(-i))
        if i == 0:
            names += [(‘var%d(t)’ % (j+1)) for j in range(n_vars)]
        else:
            names += [(‘var%d(t+%d)’ % (j+1, i)) for j in
                                             range(n_vars)]    agg = concat(cols, axis=1)
    agg.columns = names
    # drop rows with NaN values 
    if dropnan:
        agg.dropna(inplace=True)
    return agg

检查值是否为数字格式

values = values.astype(‘float32’)

使用MinMax方法对数据集值进行归一化

scaler = MinMaxScaler(feature_range=(0,1))
scaled = scaler.fit_transform(values)

将归一化的值转化为监督学习

reframed = series_to_supervised(scaled,1,1)#reframed.drop(reframed.columns[[9,10,11,12,13,14,15]], axis=1, inplace=True)

数据集分为两组比特币涨跌预测软件，训练集和测试集

values = reframed.values
train_size = int(len(values)*0.70)
train = values[:train_size,:]
test = values[train_size:,:]

拆分数据集拆分为trainX、trainY、testX和testY

trainX, trainY = train[:,:-1], train[:,13]
testX, testY = test[:,:-1], test[:,13]

训练和测试数据集被拆分为 LSTM 的 3D Resize

trainX = trainX.reshape((trainX.shape[0],1,trainX.shape[1]))
testX = testX.reshape((testX.shape[0],1,testX.shape[1]))

创建 LSTM 模型并调整神经元结构

model = Sequential()
model.add(LSTM(128, input_shape=(trainX.shape[1], trainX.shape[2])))
model.add(Dropout(0.05))
model.add(Dense(1))
model.add(Activation(‘linear’))
model.compile(loss=’mae’, optimizer=’adam’)

通过使用 trainX 和 trainY 训练数据集

history = model.fit(trainX, trainY, epochs=10, batch_size=25, validation_data=(testX, testY), verbose=2, shuffle=False)

计算每个训练时期的损失值并将其可视化

pyplot.plot(history.history[‘loss’], label=’train’)
pyplot.plot(history.history[‘val_loss’], label=’test’)
pyplot.title(“Test and Train set Loss Value Rate”)
pyplot.xlabel(‘Epochs Number’, fontsize=12)
pyplot.ylabel(‘Loss Value’, fontsize=12)
pyplot.legend()
pyplot.show()

在训练数据集上执行预测过程

trainPredict = model.predict(trainX)
trainX = trainX.reshape((trainX.shape[0], trainX.shape[2]))

在测试数据集上执行预测过程

testPredict = model.predict(testX)
testX = testX.reshape((testX.shape[0], testX.shape[2]))

在训练数据集上反转尺度进行训练

trainPredict = concatenate((trainPredict, trainX[:, -9:]), axis=1)
trainPredict = scaler.inverse_transform(trainPredict)
trainPredict = trainPredict[:,0]

用于预测的测试数据集逆缩放

testPredict = concatenate((testPredict, testX[:, -9:]), axis=1)
testPredict = scaler.inverse_transform(testPredict)
testPredict = testPredict[:,0]# invert scaling for actualtestY = testY.reshape((len(testY), 1))
inv_y = concatenate((testY, testX[:, -9:]), axis=1)
inv_y = scaler.inverse_transform(inv_y)
inv_y = inv_y[:,0]

使用 mean_squared_error 计算的性能指标进行训练和测试预测

rmse2 = sqrt(mean_squared_error(trainY, trainPredict))rmse = sqrt(mean_squared_error(inv_y, testPredict))

将训练和测试的预测集连接起来

final = np.append(trainPredict, testPredict)final = pd.DataFrame(data=final, columns=[‘Close’])
actual = dataset.Close
actual = actual.values
actual = pd.DataFrame(data=actual, columns=[‘Close’])

最后，可视化训练和预测结果

pyplot.plot(actual.Close, ‘b’, label=’Original Set’)
pyplot.plot(final.Close[0:16781], ‘r’ , label=’Training set’)pyplot.plot(final.Close[16781:len(final)], ‘g’,
            label=’Predicted/Test set’)pyplot.title(“ Bitcoin Predicted Prices”)
pyplot.xlabel(‘ Time’, fontsize=12)
pyplot.ylabel(‘Close Price’, fontsize=12)
pyplot.legend(loc=’best’)
pyplot.show()

结论：

在这里，我们使用历史比特币价格数据集来开发价格预测模型。我们使用 RNN 和 LSTM 算法来寻找价格预测