网站换空间多少钱,哪个免费自助建站系统最好用,asp做网站 的pdf教程,广州市南沙住房和建设局网站tip:本项目用到的数据和代码在https://pan.baidu.com/s/1Cw6OSSWJevSv7T1ouk4B6Q?pwdz6w2
1. RNN : 预测股价
任务#xff1a;基于zgpa_train.csv数据,建立RNN模型,预测股价
1.完成数据预处理#xff0c;将序列数据转化为可用于RNN输入的数据
2.对新数据zgpa_test.csv进…tip:本项目用到的数据和代码在https://pan.baidu.com/s/1Cw6OSSWJevSv7T1ouk4B6Q?pwdz6w2
1. RNN : 预测股价
任务基于zgpa_train.csv数据,建立RNN模型,预测股价
1.完成数据预处理将序列数据转化为可用于RNN输入的数据
2.对新数据zgpa_test.csv进行预测可视化结果
3.存储预测结果并观察局部预测结果
备注模型结构单层RNN输出有5个神经元每次使用前8个数据预测第9个数据
1.1 数据准备
下面是一个预测股票的一个项目实战。
任务基于zgpa_train.csv数据,建立RNN模型,预测股价
1.完成数据预处理将序列数据转化为可用于RNN输入的数据
2.对新数据zgpa_test.csv进行预测可视化结果
3.存储预测结果并观察局部预测结果
备注模型结构单层RNN输出有5个神经元每次使用前8个数据预测第9个数据。
数据内容大致如下 开始项目代码如下
import pandas as pd
import numpy as np
data pd.read_csv(zgpa_train.csv)
data.head()# 加载收盘价
price data.loc[:, close]
price.head()# 归一化处理
price_norm price/max(price)
print(price_norm)# 归一化之前的数据可视化
%matplotlib inline
from matplotlib import pyplot as plt
fig1 plt.figure(figsize(8,5))
plt.plot(price)
plt.title(close_price) # 归一化之前的数据
plt.xlabel(time)
plt.ylabel(price)
plt.show()
%matplotlib inline的作用
%matplotlib inline 是一个 IPython 魔法命令用于在 Jupyter Notebook 中将 matplotlib 绘图直接嵌入到输出单元中。这样可以使绘图在 Notebook 中显示而无需调用 plt.show() 方法。此外它可以确保每次执行绘图代码时图形都能在相应的输出单元显示而不是在外部窗口中弹出。
inline表示图像“在线”显示意思是在 Jupyter Notebook 的输出单元中直接显示图像而不是在单独的窗口中弹出。
# 对 X 与 y 进行赋值
# 定义方法去提取 X 与 y
def extract_data(data, time_step):X [] # listy [] # list# 例如10个样本time_step8# 第一组样本0,1,2,...7# 第二组样本1,2,3,...8# 第三组样本2,3,4,...9# 共有2组样本可供观测for i in range(len(data)-time_step):X.append([a for a in data[i:itime_step]])y.append(data[itime_step])X np.array(X)X X.reshape(X.shape[0], X.shape[1], 1)return X, y
上面是设计数组X、y的函数即X是因y是果用X的一个数组得到y的一个对应值这里把X处理成了最后一个维度只有一个元素的维度即X.shape *,*,...,1)。
# 定义 X 与 y
time_step 8
X, y extract_data(price_norm, time_step)
print(X.shape) # 723个样本每个样本有8个数据每个样本对应1个单独数值723,8,1
print(X[0, :, :]) # 第一个样本数据
这里使用刚才的函数提供data和time_step创建出Xy。
jupyter里可以不需要用那么多print直接在单元格输入X.shapeX[0]就能得到相应的结果。
---------------------------------------------------------------------------------------------------------------------------
1.2 模型建立
下面是建立模型的主要代码这段代码使用 Keras 构建了一个简单的 循环神经网络RNN模型它适合用于 回归任务。以下是代码中各个步骤的解释
from keras.models import Sequential
from keras.layers import Dense, SimpleRNN # 引入层相关,输出层与 RNN 层model Sequential() # 创建实例
model.add(SimpleRNN(units5, input_shape(time_step, 1), activationrelu)) # RNN 层
model.add(Dense(units1, activationlinear)) # 输出层回归任务直接使用 linear 激活函数
model.compile(optimizeradam, lossmean_squared_error) # 回归使用mse评测
model.summary()
逐步解析代码
1. 导入模块
from keras.models import Sequential
from keras.layers import Dense, SimpleRNNSequential用于构建 Keras 的顺序模型可以按顺序堆叠各层。Dense 和 SimpleRNN分别代表全连接层和简单循环神经网络RNN层。
2. 创建模型实例
model Sequential()使用 Sequential() 创建一个顺序模型实例 model可以层层堆叠神经网络层。
3. 添加 SimpleRNN 层
model.add(SimpleRNN(units5, input_shape(time_step, 1), activationrelu))SimpleRNN一种简单的循环神经网络层。units5表示 RNN 层有 5 个隐藏单元Hidden Units。input_shape(time_step, 1)输入的形状。假设时间步为 time_step每步有一个特征。activationrelu使用 ReLU 激活函数。
1. 这一步就对应理论部分的由x到h这里 units5 表示 RNN 层有 5 个隐藏单元h每个单元可以理解为负责捕捉某一方面的特征这些单元共同作用从输入数据中提取序列信息并将提取到的特征传递到下一层或输出层。在这个RNN 模型中每个时间步都会产生 5 个隐藏单元的输出。
隐藏单元越多模型能够捕捉的特征就越多模型也会更复杂适合处理高维和复杂数据。
2. input_shape(time_step, 1)说明输入序列的长度和每个时间步的特征数量用来告诉模型输入数据的形状。这里的特征指的是描述了每个时间步的输入信息量比如传感器数据流中每个时间步可能有多个传感器特征例如温度、湿度、压力等。这个模型只用到了一个特征即close收盘价对应之前数据准备只取了那一列。
3. activationrelu指定了隐藏状态计算中的激活函数即计算由x到h的激活函数。
4. 添加 Dense 输出层
model.add(Dense(units1, activationlinear))是在给模型添加一个 全连接层Dense 层该层有如下配置 units1表示该层包含一个神经元输出为一个值。对于回归任务例如预测一个连续值输出层通常只需一个神经元因为只需输出一个预测结果。 activationlinear激活函数设置为 linear即线性激活函数。线性激活函数的作用是直接输出该层计算的值不做任何非线性变换这非常适合回归任务因为回归问题中预测的目标值是连续的需要直接输出真实值的估计。
即上面的隐藏状态h到这里的y一个时间步对应只有一个y的输出具体来说就是一个时间步里刚才得到的5个隐藏状态h到输出的y用到的激活函数是 linear。
5. 编译模型
model.compile(optimizeradam, lossmean_squared_error)optimizeradam使用 Adam 优化器适合多种神经网络优化。lossmean_squared_error使用均方误差MSE作为损失函数MSE 常用于回归问题评估模型预测的误差。
Adam 是一种自适应优化算法具有以下特点
自适应学习率Adam 会为每个参数动态调整学习率使得每个参数都能有合适的更新步长。结合动量和 RMSProp 的优势Adam 使用动量Momentum来平滑梯度的更新同时利用 RMSProp 的方法来控制梯度的变化幅度从而加速收敛。 6. 模型结构总结
model.summary()输出模型的层次结构、参数数量等信息便于了解模型的总体结构和参数情况。 总结
该模型是一个用于回归任务的简单 RNN 模型包含一个 RNN 层和一个全连接输出层。使用 ReLU 激活函数在隐藏层线性激活函数在输出层以适应回归任务。
--------------------------------------------------------------------------------------------------------------------------------
1.3 模型层数介绍
在深度学习模型中层数概念指的是网络结构中的不同计算层它们共同完成数据的逐步抽象和特征提取。一般来说一个模型的层可以分为 输入层、隐藏层 和 输出层。这些层共同构成了模型的数据流动路径和特征提取结构。
(1). 输入层
作用接收输入数据并将其传递给模型的第一层。输入层本身不进行任何计算操作仅定义输入数据的形状。表示方式在 Keras 中输入层是通过指定第一层的 input_shape 参数来隐式定义的不会单独显示在 model.summary() 中。例子在你的模型中input_shape(time_step, 1) 就定义了输入层表示输入数据是一个具有 time_step 个时间步且每个时间步有 1 个特征的序列。
(2). 隐藏层
作用模型中真正进行特征提取、模式识别和学习的层。隐藏层可以是各种类型的神经网络层例如全连接层Dense、卷积层Conv2D、循环层SimpleRNN、LSTM等。数量和类型一个模型可以有多个隐藏层这些层负责将输入数据逐步转换为更高层次的特征。例子在你的模型中SimpleRNN 层就是一个隐藏层。它接受输入数据的时间序列并通过 5 个隐藏单元来提取时序特征。
(3). 输出层
作用生成最终的模型输出。输出层的形状和激活函数通常根据具体任务如分类或回归进行设置。设置输出层通常是一个全连接层Dense其单元数量和激活函数会根据任务调整。例如分类任务会使用 softmax 激活函数而回归任务则使用 linear 激活函数。例子在你的模型中Dense(units1, activationlinear) 是输出层用于回归任务输出一个连续值。 在深度学习模型中层数包括输入层逻辑上存在、隐藏层特征提取层和输出层生成预测结果。在大多数框架中输入层是隐式的所以模型的“层数”通常只统计显式的隐藏层和输出层。
Dense 层可以同时作为 隐藏层 和 输出层它的角色取决于其在模型中的位置和任务。 作为隐藏层如果 Dense 层在模型的中间部分用于进一步处理和转换特征那么它就是隐藏层。例如在一个深层神经网络中前几层 Dense 层可以作为隐藏层以提取输入数据的特征。 作为输出层如果 Dense 层是模型的最后一层用于生成最终的输出如分类概率或回归值那么它就是输出层。例如在分类任务中最后一个 Dense 层通常会使用 softmax 激活函数作为输出层在回归任务中通常使用 linear 激活函数作为输出层。
上面提到的模型有 2 个显式的计算层SimpleRNN 和 Dense
输入层隐式指定输入的形状 (time_step, 1)传入 SimpleRNN 层。SimpleRNN 层接收输入数据并生成 5 个隐藏状态的输出作为时序特征。Dense 输出层接收 5 维的隐藏状态将它转化为一个数值输出用于回归任务。
--------------------------------------------------------------------------------------------------------------------------
1.4 训练模型
# 训练模型
model.fit(X, np.array(y), batch_size 30, epochs 200)这一步使用 fit() 方法来训练模型参数说明如下
X训练数据的输入特征。y训练数据的标签目标值这里先转换为 NumPy 数组 np.array(y)。batch_size30批量大小每次更新模型权重时使用 30 个样本的数据这样可以加快训练速度。epochs200训练的轮数将整个数据集训练 200 次模型会在每个 epoch 后更新权重以逐步优化性能。
在训练过程中模型会通过前向传播计算预测结果通过反向传播调整权重逐步减小预测值与真实值之间的误差。
在训练模型时使用批量大小batch_size30而不是全部样本进行权重更新主要是为了在效率和性能上做出平衡。选择 batch_size30可以加快训练速度、减少内存占用同时还可以引入一定的随机性使得训练过程更稳定减少陷入局部最优的风险。
------------------------------------------------------------------------------------------------------------------------------
1.5 基于训练数据做预测 # 基于训练数据做预测
y_train_predict model.predict(X)*max(price) # 预测结果去除归一化
y_train [i * max(price) for i in y] # 训练数据真实结果
这部分代码进行基于训练数据的预测并将预测结果“去归一化”即将预测值和真实值还原到原始价格范围。详细说明如下 y_train_predict使用 model.predict(X) 基于训练数据 X 进行预测得到归一化状态下的预测结果。之后通过 * max(price) 将预测结果恢复到原始数据范围因为在数据预处理时可能将 price 归一化过所以这里乘以 max(price) 还原到真实价格范围。 y_train真实的训练数据 y 也被还原到原始数据范围。代码 [i * max(price) for i in y] 中将归一化状态下的 y 乘以 max(price)以得到真实的训练数据价格。
tipmodel.predict(X) 的详细过程 前向传播predict() 方法会将输入数据 X 逐层传递通过网络结构中的每一层如 RNN 层、Dense 层并应用层中的权重和激活函数计算输出。 生成预测值经过前向传播后predict() 会输出每个输入样本的预测结果。这些结果的形状取决于模型的输出层结构。在你的模型中输出层是一个 Dense 层有一个神经元所以 predict() 将返回每个输入样本的单一预测值。
--------------------------------------------------------------------------------------------------------------------------------
1.6 展示真实值和预测值
fig2 plt.figure(figsize(8, 5))
plt.plot(y_train, labelreal price)
plt.plot(y_train_predict, labelpredict price)
plt.title(close_price) # 归一化之前的数据
plt.xlabel(time)
plt.ylabel(price)
plt.legend()
plt.show()
1.7 对测试数据进行预测
最后把测试数据放到刚才训练的模型得到相应的预测值。
现预处理数据
# 对测试数据进行预测
data_test pd.read_csv(zgpa_test.csv)
data_test.head()
price_test data_test.loc[:, close]
price_test.head()# extract X_test and y_test
price_test_norm price_test/max(price)
X_test_norm, y_test_norm extract_data(price_test_norm, time_step)
print(X_test_norm.shape, len(y_test_norm))
拿训练好的模型做预测并画图做对比比较预测值和真实值
# make prediction based on the test data
y_test_predict model.predict(X_test_norm)*max(price)
y_test [i*max(price) for i in y_test_norm]fig3 plt.figure(figsize(8, 5))
plt.plot(y_test, labelreal price_test)
plt.plot(y_test_predict, labelpredict price_test)
plt.title(close_price) # 归一化之前的数据
plt.xlabel(time)
plt.ylabel(price)
plt.legend() # 展示图例
plt.show()
把预测的数据存储起来
# 存储数据
result_y_test np.array(y_test).reshape(-1, 1) # 若干行1列
result_y_test_predict y_test_predict
print(result_y_test.shape, result_y_test_predict.shape)
result np.concatenate((result_y_test, result_y_test_predict), axis1)
print(result.shape)
result pd.DataFrame(result, columns[real_price_test, predict_price_test])
result.to_csv(zgpa_predict_test.csv)
--------------------------------------------------------------------------------------------------------------------------------
1.8 pandas的一点知识点
(1) -1在reshape的应用
这里提到了reshape(-1)那就讲一下其作用。在 reshape 中只能有一个 -1。如果有多个 -1NumPy 无法确定数组的形状。当使用 -1 作为 reshape() 参数中的某个维度时NumPy 会根据数组的总元素数量和指定的其他维度自动计算 -1 所在维度的大小。举几个例子
单独一个-1将数组展平为一维数组。不论原数组的形状是什么reshape(-1) 会将其拉平成一个一维向量。
arr np.array([[1, 2, 3], [4, 5, 6]])
arr_reshaped arr.reshape(-1)
print(arr_reshaped)[1 2 3 4 5 6]下面将数组转换为二维数组其中有多行具体行数由原数组长度决定每行只有 1 列。-1 表示行数由系统自动计算而 1 则指定了列数为 1。
arr np.array([1, 2, 3, 4, 5, 6])
arr_reshaped arr.reshape(-1, 1)
print(arr_reshaped)[[1][2][3][4][5][6]]reshape(3, -1) 告诉 NumPy 重新将数组的形状调整为 3 行而列数-1则由 NumPy 自动计算为 4以确保元素总数3x412不变。
arr np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])arr_reshaped arr.reshape(3, -1)
print(arr_reshaped)[[ 1 2 3 4][ 5 6 7 8][ 9 10 11 12]](2) numpy中concatenate的应用
把两个长度为n的一维array合并成一个二维shape为(n,2)的array可以用以下两个方法
1. 先把一维array用方法reshape(-1,1)转化成[[1][2][3][4][5][6]]这种格式然后指定axis1在里面那层进行合并。
# 将一维数组转换为二维数组每个数组为一列
# a np.array([1,2,3,4,5])a1 a.reshape(-1, 1)
b1 b.reshape(-1, 1)# 按列方向axis1合并成一个二维数组
result np.concatenate((a1, b1), axis1)2. 或者直接使用np.column_stack()。
result2 np.column_stack((a,b))1.9 总结
这个股票预测rnn模型的局限性预测结果比实际结果趋势变化较慢。 如上图所示实际数据已经开始上升了而预测的数据还在下降并在下一个时间点上才开始上升。
2. LSTM预测序列文字
任务基于 flare 文本数据建立 LSTM 模型预测序列文字
1.完成数据预处理将文字序列数据转化为可用于LSTM输入的数据
2.查看文字数据预处理后的数据结构并进行数据分离操作
3.针对字符串输入 flare is a teacher in ai industry. He obtained his phd in Australia.预测其对应的后续字符
备注模型结构单层LSTM输出有20个神经元每次使用前20个字符预测第21个字符
2.1 数据预处理
加载文本数据把换行符和制表符替换成空格。
# load the data
data open(flare).read()
data data.replace(\n,).replace(\r, ) # 替换换行符
print(data)
用set函数对字符数据进行处理得到去重后的字符。
# 字符去重处理
letters list(set(data))
print(letters)
num_letters len(letters)
print(num_letters) # 进行独热数值编码23行1列的数组#[A, o, c, h, l, m, p, ., s, S, , t, n, H, e, b, d, a, u, f, y, r, i]
23
利用for循环加上enumerate函数配合得到由序号、字符组成的字典。
# 建立字典
# int to char
int_to_char {a:b for a,b in enumerate(letters)}
print(int_to_char)
# char to int
char_to_int {b:a for a,b in enumerate(letters)}
print(char_to_int){0: A, 1: o, 2: c, 3: h, 4: l, 5: m, 6: p, 7: ., 8: s, 9: S, 10: , 11: t, 12: n, 13: H, 14: e, 15: b, 16: d, 17: a, 18: u, 19: f, 20: y, 21: r, 22: i}
{A: 0, o: 1, c: 2, h: 3, l: 4, m: 5, p: 6, .: 7, s: 8, S: 9, : 10, t: 11, n: 12, H: 13, e: 14, b: 15, d: 16, a: 17, u: 18, f: 19, y: 20, r: 21, i: 22}
设置time_step 20即用连续的20个字符预测第21个字符。
2.1.1 构建数据处理函数
然后构建能得到训练数据X、y的函数。
# time_step
time_step 20# 数据预处理
import numpy as np
from tensorflow.keras.utils import to_categorical # 库发生了迁移# 滑动窗口提取数据
def extract_data(data, slide):x []y []for i in range(len(data) - slide):x.append([a for a in data[i : i slide]])y.append(data[islide])return x,y# 字符到数字的批量转化
def char_to_int_Data(x, y, chat_to_int):x_to_int []y_to_int []for i in range(len(x)):x_to_int.append([char_to_int[char] for char in x[i]])y_to_int.append([char_to_int[char] for char in y[i]]) return x_to_int, y_to_int# 实现输入字符文章的批量处理输入整个字符滑动窗口大小转化字典
def data_preprocessing(data, slide, num_letters, char_to_int):char_Data extract_data(data, slide) int_Data char_to_int_Data(char_Data[0], char_Data[1], char_to_int) Input int_Data[0]Output list(np.array(int_Data[1]).flatten())Input_RESHAPED np.array(Input).reshape(len(Input), slide)new np.random.randint(0, 10, size[Input_RESHAPED.shape[0], Input_RESHAPED.shape[1], num_letters]) for i in range(Input_RESHAPED.shape[0]):for j in range(Input_RESHAPED.shape[1]):new[i, j, :] to_categorical(Input_RESHAPED[i, j], num_classes num_letters) return new, Output
这里的函数比较复杂最终data_preprocessing函数嵌套了之前构建的函数最后要求传入文本数据time_step(用多少个字符预测下一个), num_letters(文本数据中不重复字符个数), char_to_int(文本-序号字典)。
2.1.2 One-hot 编码
这里从tensorflow.keras.utils 模块中导入 to_categorical 函数。to_categorical 是一个工具函数主要用于将整数编码的类别标签转换为 One-hot 编码 格式。
One-hot 编码是一种常用的编码方式主要用于将类别数据转换为数值数据使其可以用于机器学习或深度学习模型中。它的核心思想是使用一个向量表示每一个类别其中只有一个位置是 1其余位置是 0。这个唯一的 1 表示该类别的位置。
假设我们有 4 个类别苹果、香蕉、橘子 和 葡萄。我们可以为这 4 个类别进行 One-hot 编码
类别One-hot 编码苹果[1, 0, 0, 0]香蕉[0, 1, 0, 0]橘子[0, 0, 1, 0]葡萄[0, 0, 0, 1]
--------------------------------------------------------------------------------------------------------------------------------
2.1.3 得到训练集、测试集
下面传入相应的参数得到转化成数字的数据Xy。
X、y都只能是数字其中X转化成了One-hot 编码y转化成了字符-数字字典里字符对应的数字。
# extract X and y from text data
X, y data_preprocessing(data, time_step, num_letters, char_to_int) # X 已经被独热编码y 稍后处理
试着了解下得到的数据是什么样的。
print(X) # 独热格式
print(X.shape) # 23 个映射[[[0 0 0 ... 0 0 0][0 0 0 ... 0 0 0][0 0 0 ... 0 0 0]...[0 0 0 ... 0 1 0][0 0 0 ... 0 0 0][0 0 0 ... 0 0 1]][[0 0 0 ... 0 0 0][0 0 0 ... 0 0 0][0 0 0 ... 0 1 0]...(44962, 20, 23)print(len(y))44962
首先看shape这个文本有4496220个字符得到44962个组后面对应的y是一个有44962个元素的列表和X相对应。后面的2023表示用20个字符来预测下一个字符这20个字符每一个字符都是用的One-hot 编码来表示的。
大概是这个意思X[0]得到的20*23二维矩阵根据One-hot 编码中23个字符对应的位置得到对应的字符再用20个字符预测得到y[0]即y的第一个数字对应的字符。图里的字符只是举个例子。 把刚才处理得到的44962组转化成数字类型数据根据0.1的比例分90%的数据给训练集10%的数据给测试集。
# split the data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.1, random_state10)
print(X_train.shape, len(y_train)) (40465, 20, 23) 40465
把刚才的y也转化成One-hot 编码。
y_train_category to_categorical(y_train, num_letters)
print(y_train_category)
tip刚才rnn也分了训练集和测试集只不过lstm这个项目用一个文件按比例91拆成训练集和测试集而rnn模型则是分别用两个文件当成训练集和测试集。
2.2 构造模型
和之前构建rnn模型类似相似的内容不再赘述。
# set up the model
from keras.models import Sequential
from keras.layers import Dense, LSTMmodel Sequential()
model.add(LSTM(units20, input_shape(X_train.shape[1], X_train.shape[2]), activationrelu))
model.add(Dense(unitsnum_letters, activationsoftmax))
model.compile(optimizeradam, losscategorical_crossentropy, metrics[accuracy])
model.summary()
这里指定的损失函数为categorical_crossentropy这是多分类任务中常用的损失函数用于 One-hot 编码格式的标签。
metrics指定评估指标评估指标用于在训练和评估时衡量模型的表现。accuracy准确率是最常用的分类评估指标之一表示模型预测正确的样本占总样本的比例。在训练和验证过程中模型会输出 accuracy 指标值以便观察模型的分类性能。
2.3 训练模型
# train the model
model.fit(X_train, y_train_category, batch_size 1000, epochs 10)
模型在每次迭代时会从训练数据中随机抽取 1000 个样本进行训练暂时先训练轮数为10。
2.4 利用模型进行预测训练值
# make prediction based on the training data
predict_x model.predict(X_train) # 笔者可能与视频使用的keras不是一个版本故而有所更改
y_train_predict np.argmax(predict_x, axis1)
print(y_train_predict) 这里得到的predict_x是二维数组 根据argmax函数配合axis1找出第二层每个中括号中最大值的索引从0开始。 得到一维数组y_train_predict40465 把数字数组根据之前的字典转化回字符
# transform the int to letters
y_train_predict_char [int_to_char[i] for i in y_train_predict]
print(y_train_predict_char)
计算下训练集的真实值和预测值的准确度
from sklearn.metrics import accuracy_score
accuracy_train accuracy_score(y_train, y_train_predict)
print(accuracy_train)
2.5 测试集的预测
方法和上面差不多最后得到测试集的真实值和预测值的准确度。
predict_x model.predict(X_test) # 笔者可能与视频使用的keras不是一个版本故而有所更改
y_test_predict np.argmax(predict_x, axis1)
accuracy_test accuracy_score(y_test, y_test_predict)
print(accuracy_test)
print(y_test_predict)
print(y_test)
2.6 用模型预测一段其他文本
拿一段另外的文本用前二十个字符预测第21个字符这段文本得保证里面的字符都包括在一开始得到的字符集合里。
# 预测样例
new_letters flare is a teacher in ai industry. He obtained his phd in Australia.
X_new, y_new data_preprocessing(new_letters, time_step, num_letters, char_to_int)
predict_x model.predict(X_new) # 笔者可能与视频使用的keras不是一个版本故而有所更改
y_new_predict np.argmax(predict_x, axis1)
print(y_new_predict)# transform the int to letters
y_new_predict_char [int_to_char[i] for i in y_new_predict]
print(y_new_predict_char)
还是像之前的操作用数据处理函数先得到X_new三维数组用模型预测得到二位数组predict_x然后用argmax配合axis1得到一维数组y_new_predict最后把用序号-字符字典把数组转化成字符组得到预测值。 可以配合下面代码返回的内容使得预测可视化更加合理
for i in range(0, X_new.shape[0]-20):print(new_letters[i:i20], --predict next letter is--, y_new_predict_char[i])
得到结果如下
如图可以看到预测的结果不是很理想。可以再次训练模型然后重复刚才2.6的操作
# train the model
model.fit(X_train, y_train_category, batch_size 1000, epochs 10)# 预测样例
new_letters flare is a teacher in ai industry. He obtained his phd in Australia.
X_new, y_new data_preprocessing(new_letters, time_step, num_letters, char_to_int)
predict_x model.predict(X_new) # 笔者可能与视频使用的keras不是一个版本故而有所更改
y_new_predict np.argmax(predict_x, axis1)
print(y_new_predict)# transform the int to letters
y_new_predict_char [int_to_char[i] for i in y_new_predict]
print(y_new_predict_char)for i in range(0, X_new.shape[0]-20):print(new_letters[i:i20], --predict next letter is--, y_new_predict_char[i])
这次得到的结果就更加满意了 2.7 总结
总结一下rnn和lstm两个项目中训练和预测用到的数据
rnn用一个文件做训练集对模型进行训练用另外一个文件直接拿来做预测。
lstm将一个文件按91分成训练集和测试集用另外一个文本拿来做预测。
