【机器学习实战中阶】比特币价格预测

比特币价格预测项目介绍

比特币价格预测项目是一个非常有实用价值的机器学习项目。随着区块链技术的快速发展，越来越多的数字货币如雨后春笋般涌现，尤其是比特币作为最早的加密货币，其价格波动备受全球投资者和研究者的关注。本项目的目标是通过分析比特币的历史数据，建立一个能够预测未来比特币价格的机器学习模型，帮助用户更好地理解和应对市场的波动。

项目背景

比特币（Bitcoin）是一种去中心化的数字货币，由中本聪（Satoshi Nakamoto）在2008年提出，并于2009年正式发布。与传统的法定货币不同，比特币不依赖于任何中央银行或金融机构，而是基于区块链技术，通过分布式账本记录所有的交易。比特币的总量被限制在2100万枚，这使得它具备了稀缺性，也为其价格波动提供了基础。

近年来，随着加密货币市场的迅速扩展，比特币的价格经历了多次剧烈波动。投资者、金融机构以及普通用户都对比特币的未来价格走势充满好奇。然而，由于比特币市场的高度不确定性，预测其价格变化并非易事。因此，通过机器学习技术来分析历史数据，进而预测比特币的价格走势，成为一个极具吸引力的项目。

项目目标

本项目的主要目标是通过机器学习模型来预测比特币的未来价格，具体目标包括以下几个方面：

1. 数据收集与预处理：首先，项目需要收集大量的历史数据，包括比特币的每日价格（开盘价、收盘价、最高价、最低价）、交易量、市场情绪指数、宏观经济指标等。数据来源可以包括加密货币交易平台、新闻媒体、社交媒体等。收集到的数据需要进行清洗、标准化和特征提取，以确保输入模型的数据质量。

2. 特征工程：在数据预处理的基础上，进行特征工程，提取对价格预测有帮助的特征。例如，时间序列特征（如移动平均线、波动率）、技术指标（如MACD、RSI）等。通过特征工程，可以更好地捕捉比特币价格变化的规律。

3. 模型选择与训练：选择合适的机器学习算法来构建预测模型。常用的算法包括线性回归、随机森林、支持向量机（SVM）、长短期记忆网络（LSTM）等。由于比特币价格的预测是一个时间序列问题，LSTM等深度学习算法可能具有更好的表现。通过交叉验证和超参数调优，确保模型的准确性和鲁棒性。

4. 模型评估与优化：使用历史数据对模型进行评估，通过均方误差（MSE）、平均绝对误差（MAE）等指标衡量模型的预测效果。同时，进行回测（Backtesting）来验证模型在不同时间段的表现，确保其在实际应用中的稳定性。

5. 预测与应用：训练好的模型可以用于预测未来的比特币价格。通过可视化工具，用户可以直观地查看预测结果。此外，该模型还可以集成到加密货币交易系统中，帮助投资者制定交易策略。在实际应用中，用户可以根据模型的预测结果调整投资组合，降低市场风险。

项目意义

比特币价格预测项目不仅具有学术研究价值，还具备广泛的实际应用前景。对于投资者而言，准确的比特币价格预测可以帮助他们更好地把握市场机会，降低投资风险。对于金融机构和研究机构而言，该项目可以为加密货币市场的研究和监管提供重要的参考依据。

此外，随着区块链技术的不断发展，数字货币市场的规模和影响力也在不断扩大。比特币作为加密货币市场的风向标，其价格波动对整个市场都有着重大影响。通过该项目的研究，可以帮助我们更好地理解加密货币市场的运行规律，推动区块链技术的进一步发展。

技术难点与挑战

尽管比特币价格预测项目具有很大的潜力，但在实际操作中也面临着一些技术难点和挑战：

1. 数据质量问题：比特币市场的数据来源复杂，数据质量参差不齐，可能包含缺失值、异常值等问题。如何有效地清洗和处理这些数据是一个重要的挑战。

2. 市场的不确定性：比特币市场受到多种因素的影响，包括政策法规、市场情绪、技术进步等。这些因素的复杂性和不确定性使得价格预测变得异常困难。

3. 模型的泛化能力：由于比特币价格的高波动性，模型需要在不同的市场环境下保持较好的预测能力。如何提高模型的泛化能力是一个重要的研究方向。

4. 实时性要求：在实际应用中，模型需要能够实时处理和预测，这对计算能力和系统响应速度提出了较高的要求。

总结

比特币价格预测项目是一个结合了金融、数据科学和机器学习的综合性项目。通过分析历史数据并结合机器学习算法，项目旨在开发出一个准确、稳定的比特币价格预测模型。该模型不仅可以为个人投资者提供决策支持，还可以为金融机构和研究者提供有价值的市场分析工具。希望该项目能够为加密货币市场的进一步发展提供新的思路和方法。

接下来就开启我们的旅程吧！

序列模型介绍

序列模型是指那些处理数据序列的机器学习模型。序列数据包括文本流、音频片段、视频片段、时间序列数据等。递归神经网络（Recurrent Neural Networks, RNN）是序列模型中最受欢迎的算法之一。

以下代码导入了多个用于处理序列数据和绘图的模块，并设置了绘图库的基础配置。这段代码的主要目的是准备所需的库，以便后续处理数据和生成可视化图表。

from math import sqrt  # 从 math 模块中导入 sqrt 函数，用于计算平方根
from numpy import concatenate  # 从 NumPy 模块中导入 concatenate 函数，用于合并多个数组
from matplotlib import pyplot  # 导入 Matplotlib 的 Pyplot 模块，用于绘制数据图形
import pandas as pd  # 导入 Pandas 模块，用于数据处理和分析
from datetime import datetime  # 从 datetime 模块中导入 datetime 类，用于处理日期和时间
from sklearn.preprocessing import MinMaxScaler  # 从 sklearn.preprocessing 模块中导入 MinMaxScaler 类，用于数据归一化
from sklearn.preprocessing import LabelEncoder  # 从 sklearn.preprocessing 模块中导入 LabelEncoder 类，用于标签编码
from sklearn.metrics import mean_squared_error  # 从 sklearn.metrics 模块中导入 mean_squared_error 函数，用于计算均方误差

# 以下代码导入了 Keras 库中的模型和层，用于构建递归神经网络（RNN）
from keras.models import Sequential  # 从 Keras 模块中导入 Sequential 类，用于构建顺序模型
'''Dense Layer 是一个简单的神经元层，其中每个神经元都从上一层的所有神经元接收输入，因此称为全连接层。Dense Layer 通常用于根据卷积层的输出对图像进行分类。'''
from keras.layers import Dense  # 从 Keras.layers 模块中导入 Dense 类，用于添加全连接层
from keras.layers import LSTM  # 从 Keras.layers 模块中导入 LSTM 类，用于添加长短时记忆层

# 以下代码导入了 Plotly 库中的离线绘图模块，用于在 Jupyter Notebook 中离线绘制图表
'''使用 plotly.offline.iplot() 在离线状态下在 Jupyter Notebook 中显示图表。
注意 − 需要 Plotly 版本 1.9.4+ 才能进行离线绘图。
更改脚本中的 plot() 函数语句并运行。
将在本地创建一个名为 temp-plot.html 的 HTML 文件，并在浏览器中打开。'''
import plotly.offline as py  # 导入 Plotly 的离线模块，用于离线绘图

'''The plotly. graph_objects 模块（通常导入为 go）包含一个自动生成的 Python 类层次结构，这些类代表了此图形模式中的非叶节点。
术语 "graph objects" 指的是这些类的实例。plotly 中定义的主要类。'''
import plotly.graph_objs as go  # 导入 Plotly 的 graph_objects 模块，用于创建绘图对象

import numpy as np  # 导入 NumPy 模块，用于数值计算
import seaborn as sns  # 导入 Seaborn 模块，用于绘制统计图形

# py.init_notebook_mode(connected=True)  # 这行代码允许我们在离线版本的 Plotly 中工作
# %matplotlib inline  # %matplotlib inline 命令告诉 IPython 环境在当前单元格之后立即绘制图表

代码总结

这段代码的主要目的是导入处理序列数据和生成可视化图表所需的库。具体来说：

1. 数学运算：导入了 sqrt 函数，用于计算平方根。
2. 数组操作：导入了 concatenate 函数，用于合并多个数组。
3. 绘图：导入了 Matplotlib 的 pyplot 模块，用于绘制数据图形；导入了 Plotly 的 offline 模块，用于在 Jupyter Notebook 中离线绘制图表；导入了 Seaborn 模块，用于绘制统计图形。
4. 数据处理：导入了 Pandas 模块，用于数据处理和分析；导入了 datetime 类，用于处理日期和时间。
5. 数据预处理：导入了 MinMaxScaler 类，用于数据归一化；导入了 LabelEncoder 类，用于标签编码。
6. 模型评估：导入了 mean_squared_error 函数，用于计算均方误差。
7. 深度学习模型：导入了 Keras 库中的 Sequential 类，用于构建顺序模型；导入了 Dense 类，用于添加全连接层；导入了 LSTM 类，用于添加长短时记忆层。

读取数据集并进行可视化

以下代码读取数据集并进行基本的信息查看，然后绘制基于加权价格的折线图。接着，代码将加权价格中的 0 值替换为 NaN，并使用前向填充方法填充这些值，最后再次绘制折线图以显示填充后的数据。

# 读取数据集并进行基本的信息查看
data = pd.read_csv(filepath_or_buffer="../input/btcusdkraken/BTCUSDKRAKEN", index_col="Date")  # 从指定路径读取 CSV 文件，并将 "Date" 列设置为索引
data.info()  # 打印数据集的基本信息，包括每列的数据类型和非空值数量


data.head()  # 显示数据集的前 5 行
data.tail()  # 显示数据集的最后 5 行

# 绘制基于加权价格的折线图
btc_trace = go.Scatter(x=data.index, y=data['Weighted Price'], name='Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为加权价格，图例名称为 "Price"
py.iplot([btc_trace])  # 在 Jupyter Notebook 中显示折线图

# 将加权价格中的 0 值替换为 NaN，然后使用前向填充方法填充这些值
data['Weighted Price'].replace(0, np.nan, inplace=True)  # 将加权价格列中的 0 值替换为 NaN
data['Weighted Price'].fillna(method='ffill', inplace=True)  # 使用前向填充方法（ffill）填充 NaN 值

# 再次绘制基于加权价格的折线图，显示填充后的数据
btc_trace = go.Scatter(x=data.index, y=data['Weighted Price'], name='Price')  # 创建一个新的折线图数据对象，x 轴为日期，y 轴为加权价格，图例名称为 "Price"
py.iplot([btc_trace])  # 在 Jupyter Notebook 中显示新的折线图

使用加权价格作为特征训练 LSTM 模型

使用加权价格作为特征来训练 LSTM 模型。使用 MinMaxScaler 将加权价格归一化到 0 到 1 的范围内。然后将数据集的 70% 用于训练，30% 用于测试。接下来，创建一个函数来生成具有回溯窗口的数据集，并生成训练和测试数据集。为了训练模型，将 X 重塑为适合 LSTM 输入的形状。运行 LSTM 模型 300 个周期，并绘制损失曲线。使用测试数据进行预测，并绘制预测值与真实值的折线图。最后，将预测值和真实值反归一化为原始值，并计算 RMSE。再次绘制预测值与真实值的折线图，这次以美元为单位。将 X 转换为日期，并将预测值和真实值重塑为适合 Plotly 绘图的形状。最后，使用 Plotly 绘制预测值和真实值的折线图，其中 X 轴为日期，Y 轴为美元价格。

代码翻译及详细注释

读取数据集并进行归一化

代码总结：
这段代码的主要目的是读取数据集中的加权价格，并使用 MinMaxScaler 将其归一化到 0 到 1 的范围内。

from sklearn.preprocessing import MinMaxScaler  # 从 sklearn.preprocessing 模块中导入 MinMaxScaler 类，用于数据归一化

values = data['Weighted Price'].values.reshape(-1, 1)  # 从数据集中提取 "Weighted Price" 列的值，并将其重塑为列向量
values = values.astype('float32')  # 将提取的值转换为浮点数类型
scaler = MinMaxScaler(feature_range=(0, 1))  # 创建一个 MinMaxScaler 对象，将数据归一化到 0 到 1 的范围内
scaled = scaler.fit_transform(values)  # 使用 MinMaxScaler 对数据进行归一化处理

划分训练集和测试集

代码总结：
这段代码的主要目的是将归一化后的数据集划分为训练集和测试集，其中 70% 的数据用于训练，30% 的数据用于测试。

train_size = int(len(scaled) * 0.7)  # 计算训练集的大小，占数据集的 70%
test_size = len(scaled) - train_size  # 计算测试集的大小，占数据集的 30%
train, test = scaled[0:train_size, :], scaled[train_size:len(scaled), :]  # 将数据集划分为训练集和测试集
print(len(train), len(test))  # 打印训练集和测试集的长度

创建具有回溯窗口的数据集

代码总结：
这段代码的主要目的是创建一个函数 create_dataset，该函数生成具有指定回溯窗口的数据集，并将其用于生成训练和测试数据集。

def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []  # 初始化数据集的输入和输出列表
    for i in range(len(dataset) - look_back):
        a = dataset[i:(i + look_back), 0]  # 获取回溯窗口内的数据
        dataX.append(a)  # 将回溯窗口内的数据添加到输入列表
        dataY.append(dataset[i + look_back, 0])  # 将下一个时间点的数据添加到输出列表
    print(len(dataY))  # 打印输出数据集的长度
    return np.array(dataX), np.array(dataY)  # 返回输入和输出数据集，转换为 NumPy 数组

look_back = 1  # 设置回溯窗口的大小为 1
trainX, trainY = create_dataset(train, look_back)  # 使用训练集生成带有回溯窗口的训练数据集
testX, testY = create_dataset(test, look_back)  # 使用测试集生成带有回溯窗口的测试数据集

重塑 X 以适应模型训练

代码总结：
这段代码的主要目的是将训练和测试数据集中的输入数据 trainX 和 testX 重塑为适合 LSTM 模型输入的形状。

trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))  # 将 trainX 重塑为 [样本数, 时间步数, 特征数] 的形状
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))  # 将 testX 重塑为 [样本数, 时间步数, 特征数] 的形状

运行 LSTM 模型

代码总结：
这段代码的主要目的是构建并训练一个 LSTM 模型，使用训练数据集进行 300 个周期的训练，并在测试数据集上进行验证。

model = Sequential()  # 创建一个顺序模型
model.add(LSTM(100, input_shape=(trainX.shape[1], trainX.shape[2])))  # 添加一个 LSTM 层，设置 100 个神经元，输入形状为 [时间步数, 特征数]
model.add(Dense(1))  # 添加一个全连接层，输出维度为 1
model.compile(loss='mae', optimizer='adam')  # 编译模型，使用均绝对误差（MAE）作为损失函数，Adam 优化器
history = model.fit(trainX, trainY, epochs=300, batch_size=100, validation_data=(testX, testY), verbose=0, shuffle=False)  # 训练模型，训练 300 个周期，每批 100 个样本，使用测试数据集进行验证

绘制训练和验证损失曲线

代码总结：
这段代码的主要目的是绘制训练和验证过程中的损失曲线，以便观察模型的训练效果。

pyplot.plot(history.history['loss'], label='train')  # 绘制训练损失曲线，并添加标签 "train"
pyplot.plot(history.history['val_loss'], label='test')  # 绘制验证损失曲线，并添加标签 "test"
pyplot.legend()  # 添加图例
pyplot.show()  # 显示图表

使用测试数据进行预测并绘制折线图

代码总结：
这段代码的主要目的是使用训练好的 LSTM 模型对测试数据进行预测，并绘制预测值与真实值的折线图。

yhat = model.predict(testX)  # 使用训练好的模型对测试数据进行预测
pyplot.plot(yhat, label='predict')  # 绘制预测值折线图，并添加标签 "predict"
pyplot.plot(testY, label='true')  # 绘制真实值折线图，并添加标签 "true"
pyplot.legend()  # 添加图例
pyplot.show()  # 显示图表

将预测值和真实值反归一化为原始值

代码总结：
这段代码的主要目的是将预测值和真实值从归一化范围反归一化为原始值，并计算 RMSE。

yhat_inverse = scaler.inverse_transform(yhat.reshape(-1, 1))  # 将预测值反归一化为原始值
testY_inverse = scaler.inverse_transform(testY.reshape(-1, 1))  # 将真实值反归一化为原始值

rmse = sqrt(mean_squared_error(testY_inverse, yhat_inverse))  # 计算预测值和真实值之间的均方根误差（RMSE）
print('Test RMSE: %.3f' % rmse)  # 打印测试 RMSE

绘制以美元为单位的折线图

代码总结：
这段代码的主要目的是绘制预测值和真实值的折线图，Y 轴以美元为单位。

pyplot.plot(yhat_inverse, label='predict')  # 绘制预测值折线图，并添加标签 "predict"
pyplot.plot(testY_inverse, label='actual', alpha=0.5)  # 绘制真实值折线图，并添加标签 "actual"，透明度为 0.5
pyplot.legend()  # 添加图例
pyplot.show()  # 显示图表

将 X 转换为日期

代码总结：
这段代码的主要目的是将测试数据集的索引转换为日期。

predictDates = data.tail(len(testX)).index  # 获取测试数据集对应的日期索引

重塑测试数据和预测数据以适应 Plotly 绘图

代码总结：
这段代码的主要目的是将反归一化后的测试数据和预测数据重塑为适合 Plotly 绘图的形状。

testY_reshape = testY_inverse.reshape(len(testY_inverse))  # 将真实值重塑为一维数组
yhat_reshape = yhat_inverse.reshape(len(yhat_inverse))  # 将预测值重塑为一维数组

使用 Plotly 绘制预测值和真实值的折线图

代码总结：
这段代码的主要目的是使用 Plotly 绘制预测值和真实值的折线图，X 轴为日期，Y 轴为美元价格。

actual_chart = go.Scatter(x=predictDates, y=testY_reshape, name='Actual Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为真实值，图例名称为 "Actual Price"
predict_chart = go.Scatter(x=predictDates, y=yhat_reshape, name='Predict Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为预测值，图例名称为 "Predict Price"
py.iplot([predict_chart, actual_chart])  # 在 Jupyter Notebook 中显示折线图

使用额外特征进行模型训练

使用加权价格以及其他特征来训练 LSTM 模型。首先，找到特征与加权价格之间的相关性。通过绘制热力图，可以观察到交易量（Volume）与加权价格之间存在相关性，而开盘价（Open）、最高价（High）、最低价（Low）和收盘价（Close）则直接与加权价格相关。然后，创建一个函数 series_to_supervised 将数据序列转换为监督学习问题。接下来，提取所有相关特征的值，并将其归一化到 0 到 1 的范围内。将数据集转换为监督学习问题，并删除不必要的列。将数据集划分为 70% 的训练集和 30% 的测试集。训练 LSTM 模型 300 个周期，并绘制每个周期的损失曲线。使用测试数据进行预测，并绘制预测值与真实值的折线图。最后，将预测值和真实值反归一化为原始值，并计算 RMSE。绘制包含真实价格、单特征预测价格和多特征预测价格的折线图。结果显示，使用多特征的 LSTM 模型比使用单特征的 LSTM 模型更加准确。

找到特征与加权价格之间的相关性

代码总结：
这段代码的主要目的是绘制数据集特征之间的相关性热力图，观察特征与加权价格之间的相关性。

import seaborn as sns  # 导入 seaborn 模块，用于绘制热力图

# 绘制数据集特征之间的相关性热力图
sns.heatmap(data.corr(), annot=True, cmap='RdYlGn', linewidths=0.1, vmin=0)  # 使用 data.corr() 计算特征之间的相关性矩阵，并绘制热力图
# annot=True 表示在格子中显示相关性数值
# cmap='RdYlGn' 设置颜色主题
# linewidths=0.1 设置格子间的线条宽度
# vmin=0 设置热力图的最小值为 0

# 观察：交易量（Volume）与加权价格（Weighted Price）之间存在相关性
# 开盘价（Open）、最高价（High）、最低价（Low）和收盘价（Close）直接与加权价格相关

函数 series_to_supervised 用于将数据序列转换为监督学习问题

代码总结：
这段代码的主要目的是定义一个函数 series_to_supervised，将时间序列数据转换为监督学习问题，以便用于 LSTM 模型的训练。

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 = pd.DataFrame(data)  # 将数据转换为 DataFrame
    cols, names = list(), list()  # 初始化列和列名列表
    
    # 输入序列（t-n, ..., t-1）
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))  # 将数据向后移 i 个时间步
        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]  # 生成列名
        
    # 预测序列（t, t+1, ..., t+n）
    for i in range(0, n_out):
        cols.append(df.shift(-i))  # 将数据向前移 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 = pd.concat(cols, axis=1)  # 按列合并所有数据
    agg.columns = names  # 设置列名
    
    # 删除包含 NaN 值的行
    if dropnan:
        agg.dropna(inplace=True)  # 删除包含 NaN 值的行
    
    return agg  # 返回转换后的数据集

获取所有相关特征的值

代码总结：
这段代码的主要目的是从数据集中提取加权价格、交易量（BTC）和交易量（货币单位）的值，并将其转换为浮点数类型。

values = data[['Weighted Price'] + ['Volume (BTC)'] + ['Volume (Currency)']].values  # 从数据集中提取 "Weighted Price"、"Volume (BTC)" 和 "Volume (Currency)" 列的值
values = values.astype('float32')  # 将提取的值转换为浮点数类型

归一化特征值

代码总结：
这段代码的主要目的是使用 MinMaxScaler 将提取的特征值归一化到 0 到 1 的范围内。

scaler = MinMaxScaler(feature_range=(0, 1))  # 创建一个 MinMaxScaler 对象，将数据归一化到 0 到 1 的范围内
scaled = scaler.fit_transform(values)  # 使用 MinMaxScaler 对数据进行归一化处理

将数据转换为监督学习问题

代码总结：
这段代码的主要目的是将归一化后的数据转换为监督学习问题，并删除不必要的列。

reframed = series_to_supervised(scaled, 1, 1)  # 将归一化后的数据转换为监督学习问题，回溯窗口为 1，预测窗口为 1
reframed.head()  # 显示转换后的数据集的前 5 行

# 删除不必要的列
reframed.drop(reframed.columns[[4, 5]], axis=1, inplace=True)  # 删除第 4 和第 5 列
print(reframed.head())  # 打印删除列后的数据集前 5 行

划分训练集和测试集

代码总结：
这段代码的主要目的是将数据集划分为 70% 的训练集和 30% 的测试集，并将输入和输出数据分开。

values = reframed.values  # 获取转换后的数据集的值
n_train_hours = int(len(values) * 0.7)  # 计算训练集的大小，占数据集的 70%
train = values[:n_train_hours, :]  # 划分训练集
test = values[n_train_hours:, :]  # 划分测试集

# 将训练集和测试集的数据分为输入和输出
train_X, train_y = train[:, :-1], train[:, -1]  # 训练集的输入和输出
test_X, test_y = test[:, :-1], test[:, -1]  # 测试集的输入和输出

# 重塑输入数据，使其适应 LSTM 模型的输入形状 [样本数, 时间步数, 特征数]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))  # 重塑训练集的输入数据
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))  # 重塑测试集的输入数据

print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)  # 打印训练集和测试集的形状

训练 LSTM 模型

代码总结：
这段代码的主要目的是构建并训练一个 LSTM 模型，使用训练数据集进行 300 个周期的训练，并在测试数据集上进行验证。

from keras.models import Sequential  # 从 keras.models 模块中导入 Sequential 类
from keras.layers import LSTM, Dense  # 从 keras.layers 模块中导入 LSTM 和 Dense 层

multi_model = Sequential()  # 创建一个顺序模型
multi_model.add(LSTM(100, input_shape=(train_X.shape[1], train_X.shape[2])))  # 添加一个 LSTM 层，设置 100 个神经元，输入形状为 [时间步数, 特征数]
multi_model.add(Dense(1))  # 添加一个全连接层，输出维度为 1
multi_model.compile(loss='mae', optimizer='adam')  # 编译模型，使用均绝对误差（MAE）作为损失函数，Adam 优化器

# 训练模型
multi_history = multi_model.fit(train_X, train_y, epochs=300, batch_size=100, validation_data=(test_X, test_y), verbose=0, shuffle=False)  # 训练模型 300 个周期，每批 100 个样本，使用测试数据集进行验证

绘制训练和验证损失曲线

代码总结：
这段代码的主要目的是绘制训练和验证过程中的损失曲线，以便观察模型的训练效果。

import matplotlib.pyplot as pyplot  # 导入 matplotlib.pyplot 模块，用于绘制图表

pyplot.plot(multi_history.history['loss'], label='multi_train')  # 绘制训练损失曲线，并添加标签 "multi_train"
pyplot.plot(multi_history.history['val_loss'], label='multi_test')  # 绘制验证损失曲线，并添加标签 "multi_test"
pyplot.legend()  # 添加图例
pyplot.show()  # 显示图表

使用测试数据进行预测并绘制折线图

代码总结：
这段代码的主要目的是使用训练好的 LSTM 模型对测试数据进行预测，并绘制预测值与真实值的折线图。

yhat = multi_model.predict(test_X)  # 使用训练好的模型对测试数据进行预测
pyplot.plot(yhat, label='predict')  # 绘制预测值折线图，并添加标签 "predict"
pyplot.plot(test_y, label='true')  # 绘制真实值折线图，并添加标签 "true"
pyplot.legend()  # 添加图例
pyplot.show()  # 显示图表

将预测值和真实值反归一化为原始值

代码总结：
这段代码的主要目的是将预测值和真实值从归一化范围反归一化为原始值，并计算 RMSE。

test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))  # 重塑测试集的输入数据，使其恢复为二维数组

# 反归一化预测值
inv_yhat = np.concatenate((yhat, test_X[:, 1:]), axis=1)  # 将预测值与测试集的其他特征值拼接
inv_yhat = scaler.inverse_transform(inv_yhat)  # 反归一化拼接后的数据
inv_yhat = inv_yhat[:, 0]  # 提取反归一化后的预测值

# 反归一化真实值
test_y = test_y.reshape((len(test_y), 1))  # 将真实值重塑为二维数组
inv_y = np.concatenate((test_y, test_X[:, 1:]), axis=1)  # 将真实值与测试集的其他特征值拼接
inv_y = scaler.inverse_transform(inv_y)  # 反归一化拼接后的数据
inv_y = inv_y[:, 0]  # 提取反归一化后的真实值

rmse = sqrt(mean_squared_error(inv_y, inv_yhat))  # 计算预测值和真实值之间的均方根误差（RMSE）
print('Test RMSE: %.3f' % rmse)  # 打印测试 RMSE

绘制包含真实价格、单特征预测价格和多特征预测价格的折线图

代码总结：
这段代码的主要目的是绘制包含真实价格、单特征预测价格和多特征预测价格的折线图，X 轴为日期，Y 轴为美元价格。

import plotly.graph_objs as go  # 从 plotly.graph_objs 模块中导入 Scatter 类

actual_chart = go.Scatter(x=predictDates, y=inv_y, name='Actual Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为真实值，图例名称为 "Actual Price"
multi_predict_chart = go.Scatter(x=predictDates, y=inv_yhat, name='Multi Predict Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为多特征预测值，图例名称为 "Multi Predict Price"
predict_chart = go.Scatter(x=predictDates, y=yhat_reshape, name='Predict Price')  # 创建一个折线图数据对象，x 轴为日期，y 轴为单特征预测值，图例名称为 "Predict Price"

py.iplot([predict_chart, multi_predict_chart, actual_chart])  # 在 Jupyter Notebook 中显示折线图

结论

• LSTM 仅使用加权价格特征的 RMSE 为 159.194
• LSTM 使用交易量（BTC）、交易量（货币单位）和加权价格特征的 RMSE 为 96.184
• 多特征的 LSTM 模型显示了更准确的结果，如上图所示

整体代码总结

链接: 【机器学习实战中阶】比特币价格预测器 源代码与数据集

这段代码的目的是读取一个包含比特币价格的数据集，并对其进行基本的信息查看。然后，基于数据集中的加权价格绘制折线图，以便直观地查看价格趋势。接下来，代码将加权价格中的 0 值替换为 NaN，并使用前向填充方法（ffill）来填充这些 NaN 值，以避免数据中的 0 值对模型训练产生影响。最后，再次绘制折线图，显示填充后的数据，确保数据处理的效果。

1. 读取数据集：

   • 使用 pd.read_csv 函数读取 CSV 文件，并将 “Date” 列设置为索引。
   • 使用 data.info() 查看数据集的基本信息。
   • 使用 data.head() 和 data.tail() 分别显示数据集的前 5 行和最后 5 行。

2. 绘制初始折线图：

   • 使用 Plotly 的 go.Scatter 创建一个折线图数据对象，x 轴为日期，y 轴为加权价格。
   • 使用 py.iplot 在 Jupyter Notebook 中显示折线图。

3. 数据处理：

   • 使用 replace 方法将加权价格中的 0 值替换为 NaN。
   • 使用 fillna 方法的 ffill 参数（前向填充）来填充 NaN 值。

4. 绘制处理后的折线图：

   • 再次使用 go.Scatter 创建一个折线图数据对象，x 轴为日期，y 轴为处理后的加权价格。
   • 使用 py.iplot 在 Jupyter Notebook 中显示处理后的折线图。

比特币价格预测（轻量级CSV）关于数据集
致谢
这些数据来自CoinMarketCap，并且可以免费使用该数据。
https://coinmarketcap.com/