使用Python预测比特币价格

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

涉及的主题：

1.什么是比特币

2.如何使用比特币

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

什么是比特币？

比特币是所有加密爱好者普遍使用的加密货币之一。即使有几种突出的加密货币，如以太坊，Ripple，Litecoin等，比特币也位居榜首。

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

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

功能：

快速的点对点交易

全球支付

手续费低

使用的原理-密码学：

加密货币（比特币）背后的工作原理是“加密”，他们使用此原理来保护和认证协商，并控制加密货币新组件的建立。

如何使用比特币？

保护钱包：应该更安全地保护比特币钱包，以便轻松顺利地进行交易

比特币价格易变：比特币价格可能会波动。价格可以根据通货膨胀率，数量等几个因素而增加或减少。

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

1. 数据收集：

导入CSV文件数据集。

import pandas as pdimport numpy as npimport matplotlib.pyplot as plt

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

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)

2.一维RNN：

现在将两个数据集串联后，将导出最终数据集。

import pandas as pdimport matplotlib.pyplot as pltimport numpy as npimport mathfrom sklearn.preprocessing import MinMaxScalerfrom sklearn.metrics import mean_squared_errorfrom keras.models import Sequentialfrom keras.layers import Dense, Activation, Dropoutfrom 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 datascaler = 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)

将纪元数定义为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

将转换后的train数据集用于绘图，

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.多变量的RNN：

import pandas as pdfrom pandas import DataFramefrom pandas import concatfrom math import sqrtfrom numpy import concatenateimport matplotlib.pyplot as pyplotimport numpy as npfrom sklearn.metrics import mean_squared_errorfrom sklearn.preprocessing import MinMaxScalerfrom keras import Sequentialfrom 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.valuestrain_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]

训练和测试数据集以3D尺寸重塑以用于LSTM，

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]))

训练数据集反转缩放比例以进行训练，

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

测试数据集反转缩放以进行预测，

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用于train和测试预测来计算性能指标，

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.Closeactual = actual.valuesactual = 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()

目前为止，我们使用历史比特币价格数据集开发价格预测模型，通过使用Python中的RNN和LSTM算法来找到价格预测。