当前位置： 首页 > news >正文

烟台做网站排名/网站排名查询站长之家

news 文章来源：https://blog.csdn.net/FHY26828/article/details/144138145 2025/3/9 9:31:17
烟台做网站排名,网站排名查询站长之家,网站一般做哪些测试,ui设计周末培训学校1.循环神经网络 1.1 什么是循环神经网络（RNN）？ 循环神经网络（Recurrent Neural Network, RNN） 是一种用于处理序列数据的神经网络类型，它的主要特点是拥有循环连接，使得网络可以对序列中的每个…

1.循环神经网络

1.1 什么是循环神经网络（RNN）？

循环神经网络（Recurrent Neural Network, RNN） 是一种用于处理序列数据的神经网络类型，它的主要特点是拥有循环连接，使得网络可以对序列中的每个时间步（timestep）进行处理，并将前一个时间步的信息传递到当前时间步，从而捕捉序列数据中的时序依赖关系。

1.2 RNN的基本结构和工作原理

RNN 的核心思想是：通过每个时间步的“隐藏状态”（hidden state）来记录过去的信息，并将这些信息传递给下一个时间步。这个隐藏状态不仅依赖于当前的输入，还依赖于上一个时间步的隐藏状态。

（1）输入：在每个时间步 ttt，RNN 接收一个输入 xtx_txt​，这个输入可以是序列数据的一个元素，如单词、音频信号的一个采样点等。

（2）隐藏状态：每个时间步都会更新一个隐藏状态 hth_tht​，它不仅受到当前输入的影响，还受到上一个时间步的隐藏状态的影响。隐藏状态捕捉了当前时刻和过去时刻的上下文信息。

隐藏状态的更新公式：

其中：

  • ht：当前时间步的隐藏状态。
  • ht−1​：上一个时间步的隐藏状态。
  • xt​：当前时间步的输入。
  • Wh：权重矩阵，分别控制隐藏状态和输入的影响。
  • b：偏置项。
  • f：激活函数，通常是非线性函数（如 tanh 或 ReLU）。

（3）输出：经过多个时间步后，RNN 会输出序列的预测结果。这个输出可以是每个时间步的预测（如时间序列预测），也可以是序列整体的预测（如文本分类）。

1.3 RNN的优缺点

优点：

  • 序列数据处理能力：RNN 可以自然地处理序列数据（如文本、语音、时间序列等），并且能够捕捉到时间步之间的依赖关系。
  • 共享权重：RNN 在每个时间步使用相同的权重，因此参数量相对较少，训练更加高效。

缺点：

  • 梯度消失/爆炸问题：在长序列的训练过程中，RNN 的梯度可能变得非常小（梯度消失）或者非常大（梯度爆炸），导致网络难以学习长时间依赖关系。
  • 长期依赖问题：标准 RNN 难以记住长期的依赖关系，因为每个时间步的隐藏状态只通过一个单一的矩阵乘法进行更新，导致远距离的信息丢失。

1.4 RNN的变种

为了解决 RNN 的缺点，出现了许多改进的变种：

  1. 长短期记忆网络（LSTM）：LSTM 是 RNN 的一种改进，它通过引入三个门（输入门、遗忘门和输出门）来控制信息的流动，能有效缓解梯度消失和长期依赖问题。
  2. 门控循环单元（GRU）：GRU 是另一种改进的 RNN 变种，与 LSTM 类似，但结构更简单，计算量较小，同样能够捕捉长期依赖。

1.5 RNN的应用

RNN 被广泛应用于需要处理时序数据的任务，以下是一些典型的应用场景：

自然语言处理（NLP）：

  • 机器翻译：RNN 能够处理句子的顺序信息，因此它在机器翻译任务中非常有效。
  • 情感分析：分析文本中情感的倾向。
  • 文本生成：生成连贯的文本内容。

语音识别：将语音信号转换为文本，RNN 能够捕捉音频信号的时序特性。

时间序列预测：用于股市预测、天气预报等领域，RNN 可以基于历史数据预测未来的趋势。

视频分析：在视频流中，RNN 可以用来捕捉帧与帧之间的时序关系，用于视频分类、动作识别等任务。

1.6 总结

        RNN 是一种非常适合处理序列数据的神经网络架构，通过循环连接的方式，能够捕捉时序数据中的上下文信息。尽管它在处理短期依赖上表现良好，但由于梯度消失和长期依赖问题，RNN 在实际应用中往往被 LSTM 和 GRU 等变种所取代。这些变种改进了 RNN 的性能，能够更好地处理长序列数据中的长期依赖关系。

2.小实验

2.1 数字填充

2.1.1 代码与结果

如何使用 TensorFlow 的 pad_sequences 函数对一个不等长的序列进行填充

import tensorflow as tf  # 导入所需库s = [[1], [2, 3], [4, 5, 6]]  # 初始化填充前序列 s
print("填充前序列为\n", s)  # 显示填充前序列 s# 填充序列并赋值给 a
a = tf.keras.preprocessing.sequence.pad_sequences(s, padding='post')
print("填充后序列为\n", a)  # 显示填充后序列 a

填充前序列为
 [[1], [2, 3], [4, 5, 6]]
填充后序列为
 [[1 0 0]
 [2 3 0]
 [4 5 6]]

2.1.2 关键代码解释

# 填充序列并赋值给 a
a = tf.keras.preprocessing.sequence.pad_sequences(s, padding='post')

这里的 pad_sequences 是 TensorFlow 中的一个函数，属于 tf.keras.preprocessing.sequence 模块，用于对不同长度的序列进行填充，使它们的长度一致。具体来说，pad_sequences 会自动将每个子序列（列表）填充为相同的长度。

（1）参数详解

s: 这是输入的原始序列，可以是一个嵌套的列表（或数组），每个子列表的长度可以不同。例如，在你的代码中，s = [[1], [2, 3], [4, 5, 6]] 是一个 3×3 的嵌套列表，不同的子序列有不同的长度：第一个子序列只有一个元素，第二个有两个，第三个有三个。

padding='post': 这个参数指定了填充的位置。

  • 'post': 表示在序列的 末尾 添加填充值（默认是 0）。
  • 'pre': 表示在序列的 前面 添加填充值。
    你在代码中选择了 'post'，所以会在每个子序列的末尾填充零。

（2）填充的方式

在这个例子中，原始序列的最大长度是 3，因为第三个子序列（[4, 5, 6]）有三个元素。所以 pad_sequences 会将其他长度较短的子序列填充到 3 的长度。

  • [1] 会被填充成 [1, 0, 0]，填充了两个零。
  • [2, 3] 会被填充成 [2, 3, 0]，填充了一个零。
  • [4, 5, 6] 不需要填充，因为它的长度已经是 3。

（3）填充后的序列

假设 s = [[1], [2, 3], [4, 5, 6]]，填充后的结果 a 会是：

a = [[1, 0, 0], [2, 3, 0], [4, 5, 6]]

这样，所有的子序列就被填充成了相同的长度 3，方便后续的操作（例如，在神经网络中进行批处理时，通常需要所有输入数据的形状一致）。

（4）默认填充值

默认情况下，pad_sequences 会使用 0 进行填充，如果需要填充其他值，可以通过 value 参数来指定填充值。例如，如果你想用 -1 填充，可以这样写：

a = tf.keras.preprocessing.sequence.pad_sequences(s, padding='post', value=-1)

2.2 序列剪裁

2.2.1 代码与结果

import tensorflow as tf  # 导入所需库
s = [[1, 2, 3, 9], [4, 5, 6], [7, 8]]  # 初始化剪裁前序列 s
print("剪裁前序列为\n", s)  # 显示剪裁前序列 s# 剪裁序列并赋值给 a，
# maxlen=2: 通过设置 maxlen 参数，将序列的长度裁剪为2。如果序列的长度超过2，则保留最后的两个元素
a = tf.keras.preprocessing.sequence.pad_sequences(s, maxlen=2)
print("剪裁后序列为\n", a)  # 显示剪裁后序列 a

剪裁前序列为
 [[1, 2, 3, 9], [4, 5, 6], [7, 8]]
剪裁后序列为
 [[3 9]
 [5 6]
 [7 8]]

2.2.2 关键代码解释

a = tf.keras.preprocessing.sequence.pad_sequences(s, maxlen=2)

（1）tf.keras.preprocessing.sequence.pad_sequences 作用

pad_sequences 是 TensorFlow 中用于处理变长序列的工具，它能够将一组不等长的序列填充或裁剪到相同的长度。这对于处理文本、时间序列或其他形式的序列数据尤其重要，因为在许多机器学习模型中（尤其是神经网络），输入的形状必须一致。

（2）maxlen 参数的作用

  • maxlen=2: 这是控制输出序列最大长度的参数。

    • maxlen 指定了每个序列的目标长度。如果一个子序列的长度超过了 maxlen，则会裁剪它（即从前端或后端去掉多余的元素）。如果一个子序列的长度小于 maxlen，则会根据 padding 参数填充元素（默认为 0）。

    • 在你的代码中，maxlen=2 表示每个序列都会被裁剪或填充到 2 的长度。如果子序列的长度大于 2，它会裁剪；如果子序列的长度小于 2，它会用默认的填充值（0）填充。

（3）默认的裁剪方式

  • 裁剪方式（truncating）: 默认情况下，pad_sequences 会从 序列的前面（pre） 裁剪多余的元素。如果你不指定 truncating 参数，它会假设为 'pre'，也就是裁剪掉超过 maxlen 的前面的部分，保留后面的部分。

  • 如果你希望从序列的末尾（post）裁剪，可以通过设置 truncating='post' 来改变默认行为。

（4）填充方式

  • 填充方式（padding）: 默认情况下，pad_sequences 会在序列的末尾（post）添加零填充，如果你希望填充的内容是其他值，可以通过 value 参数指定填充值。

  • 默认填充位置是 post，即在序列的末尾进行填充。

（5）具体操作

考虑到 s = [[1, 2, 3, 9], [4, 5, 6], [7, 8]]，每个子序列的长度不一致：

  • 第一子序列 [1, 2, 3, 9] 长度为 4。
  • 第二子序列 [4, 5, 6] 长度为 3。
  • 第三子序列 [7, 8] 长度为 2。

当 maxlen=2 时，pad_sequences 会裁剪这些子序列的长度，使其都为 2。

  • 第一子序列 [1, 2, 3, 9] 长度超过 2，所以会被裁剪，裁剪后的结果是 [3, 9]（默认从前面裁剪）。
  • 第二子序列 [4, 5, 6] 长度为 3，所以它的前一个元素会被裁剪，裁剪后的结果是 [5, 6]。
  • 第三子序列 [7, 8] 已经是 2 个元素，因此它不需要裁剪或填充，保持不变。

2.3 keras 搭建模型

2.3.1 代码和结果

这段代码展示了如何使用 TensorFlow 和 Keras 创建一个简单的神经网络模型，并使用嵌入层（Embedding）来处理文本数据。

# 3.最常见的 100 个单词
import tensorflow as tf  # 导入 TensorFlow 库
import numpy as np       # 导入 NumPy 库# 构建空的网络模型 model
model = tf.keras.Sequential()# 创建嵌入层
embedding = tf.keras.layers.Embedding(output_dim=32, input_dim=100, input_length=400)
model.add(embedding)  # 添加到网络模型 model 中model.summary()  # 显示网络模型的参数信息# 显示 embedding 矩阵的值
print("embeddings矩阵=\n", embedding.get_weights())# 定义输入文本
text = "Deep learning is an important concept raised by the current sciences."# 定义分词器对象
token = tf.keras.preprocessing.text.Tokenizer(num_words=100)
token.fit_on_texts([text])  # 分词
input = token.texts_to_sequences([text])  # 输出向量序列# 序列填充
test_seq = tf.keras.preprocessing.sequence.pad_sequences(input, padding='post', maxlen=400, truncating='post'
)# 使用向量序列应用网络模型
output_array = model.predict(test_seq)# 输出矩阵的形状
print("输出矩阵的形状=", output_array.shape)

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 400, 32)           3200      
                                                                 
=================================================================
Total params: 3,200
Trainable params: 3,200
Non-trainable params: 0
_________________________________________________________________
embeddings矩阵=
 [array([[-0.02878962, -0.03292129,  0.04554972, ..., -0.0058917 ,
         0.01143857,  0.0233766 ],
       [ 0.01397041, -0.01258515,  0.00929421, ..., -0.04004631,
         0.0135694 ,  0.0277424 ],
       [ 0.04916861, -0.04198183, -0.04687737, ..., -0.03828448,
         0.02139128,  0.02899126],
       ...,
       [-0.0321876 ,  0.0293329 ,  0.02029986, ..., -0.00899869,
        -0.00628114, -0.02092808],
       [-0.0257414 ,  0.03492158, -0.00921569, ..., -0.0181116 ,
        -0.03592857,  0.02451548],
       [ 0.04689746,  0.02985245, -0.04975928, ..., -0.02757919,
        -0.01401014, -0.03509605]], dtype=float32)]
1/1 [==============================] - 0s 75ms/step
输出矩阵的形状= (1, 400, 32)

2.3.2 代码解释

（1）导入必要的库

import tensorflow as tf  # 导入 TensorFlow 库
import numpy as np       # 导入 NumPy 库
  • tensorflow 用于构建神经网络模型及其相关操作。
  • numpy 用于数组操作，尽管在这个代码片段中未直接使用，但它通常用于处理数值数据和矩阵。

（2）构建空的神经网络模型

model = tf.keras.Sequential()

  • 这里使用 tf.keras.Sequential 创建了一个空的顺序模型 model。这是一个简单的线性堆叠模型，用于顺序地添加层（例如 Embedding 层）。

（3）创建嵌入层（Embedding Layer）

embedding = tf.keras.layers.Embedding(output_dim=32, input_dim=100, input_length=400)
model.add(embedding)  # 添加到网络模型 model 中

  • Embedding 层用于将输入的整数序列映射为稠密的向量表示。这里的 output_dim=32 表示嵌入空间的维度为 32，也就是说每个词会被映射为一个 32 维的向量。
  • input_dim=100 表示输入的词汇表大小是 100，即模型将处理的词汇表最多包含 100 个不同的词。
  • input_length=400 表示每个输入序列的长度为 400。也就是说，输入的每个文本序列将被填充或截断到 400 个词。

这个嵌入层将每个整数（词汇的索引）转换为一个 32 维的向量。

（4）打印模型结构

model.summary()  # 显示网络模型的参数信息

  • model.summary() 会打印出当前模型的结构、各层的类型、每一层的参数量、输出形状等信息，帮助你理解模型的结构。

（5）获取并显示嵌入矩阵的值

print("embeddings矩阵=\n", embedding.get_weights())

  • embedding.get_weights() 会返回嵌入层的权重矩阵。这个权重矩阵是一个二维数组，其形状是 (input_dim, output_dim)，即 (100, 32)，表示每个词汇对应的 32 维向量表示。

（6）定义输入文本并进行分词处理

text = "Deep learning is an important concept raised by the current sciences."

  • 这是输入的文本数据，用于展示如何将文本转换为模型可以处理的数值格式。
token = tf.keras.preprocessing.text.Tokenizer(num_words=100)
token.fit_on_texts([text])  # 分词
input = token.texts_to_sequences([text])  # 输出向量序列

  • Tokenizer 是 Keras 提供的文本处理工具，用于将文本转换为整数序列（每个单词对应一个唯一的整数）。
  • num_words=100 表示词汇表的大小限制为前 100 个最常见的词。
  • token.fit_on_texts([text]) 对输入文本进行分词，构建词汇表。
  • input = token.texts_to_sequences([text]) 将文本转换为整数序列（将文本中的每个单词替换为它在词汇表中的索引）。

假设词汇表中的单词被编码为整数，转换后的 input 可能是类似于 [1, 2, 3, 4, 5, 6, 7, ...] 的形式。

（7）序列填充

test_seq = tf.keras.preprocessing.sequence.pad_sequences(input, padding='post', maxlen=400, truncating='post'
)

  • pad_sequences 用于将不同长度的输入序列填充或截断到相同的长度。这里，maxlen=400 表示每个输入序列的最大长度为 400，超过这个长度的部分会被截断，长度不够的部分会被填充。
  • padding='post' 表示填充将在序列的末尾进行（默认填充的值是 0）。
  • truncating='post' 表示如果序列超过 maxlen，会从序列的末尾裁剪超出部分。

（8）使用模型进行预测

output_array = model.predict(test_seq)

  • 通过调用 model.predict() 方法，将填充后的文本序列 test_seq 输入到模型中，进行预测。此时，嵌入层会将每个单词（以索引表示）映射到对应的嵌入向量，输出一个矩阵。

（9） 输出矩阵的形状

print("输出矩阵的形状=", output_array.shape)

  • 输出 output_array 的形状。由于模型只有一个 Embedding 层，输出的形状应该是 (batch_size, input_length, output_dim)。具体来说，batch_size 是输入文本的批次大小（这里只有一个文本，批次大小为 1），input_length=400 是序列的长度，output_dim=32 是每个词的嵌入维度。因此，输出的形状应该是 (1, 400, 32)。

2.3.3 结果分析

（1）模型结构（model.summary() 的输出）

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 400, 32)           3200      
                                                                 
=================================================================
Total params: 3,200
Trainable params: 3,200
Non-trainable params: 0
_________________________________________________________________

  • 模型类型：模型是一个 Sequential 类型的神经网络，它包含一系列按顺序排列的层。
  • 嵌入层（Embedding）：
    • 输出形状：(None, 400, 32)，表示输入的每个序列都将转换为 400 个词的向量表示，每个词的嵌入向量是 32 维的。
    • 参数数量：3200。这个值表示嵌入层的权重矩阵的参数数量。嵌入层的权重矩阵大小为 input_dim * output_dim = 100 * 32 = 3200，即 100 个词汇（词表大小）每个词用一个 32 维的向量表示。

（2）嵌入矩阵的权重（embedding.get_weights() 的输出）

embeddings矩阵=
 [array([[-0.02878962, -0.03292129,  0.04554972, ..., -0.0058917 ,
         0.01143857,  0.0233766 ],
       [ 0.01397041, -0.01258515,  0.00929421, ..., -0.04004631,
         0.0135694 ,  0.0277424 ],
       [ 0.04916861, -0.04198183, -0.04687737, ..., -0.03828448,
         0.02139128,  0.02899126],
       ...,
       [-0.0321876 ,  0.0293329 ,  0.02029986, ..., -0.00899869,
        -0.00628114, -0.02092808],
       [-0.0257414 ,  0.03492158, -0.00921569, ..., -0.0181116 ,
        -0.03592857,  0.02451548],
       [ 0.04689746,  0.02985245, -0.04975928, ..., -0.02757919,
        -0.01401014, -0.03509605]], dtype=float32)]

  • 这是嵌入层的权重矩阵。这个矩阵的维度是 (input_dim, output_dim)，即 (100, 32)，表示词汇表中每个词都被映射为一个 32 维的向量。
  • embedding.get_weights() 返回的是一个列表，其中包含嵌入层的权重矩阵。每个词的向量在该矩阵中都有一个对应的行。
  • 这些向量的数值是经过训练优化得到的。你可以看到，这些向量的值是浮动的，表示模型学到的词嵌入。

（3）模型的预测输出（model.predict() 的输出）

1/1 [==============================] - 0s 75ms/step

输出矩阵的形状= (1, 400, 32)

  • model.predict(test_seq) 返回的是模型对输入序列的预测输出。这里，模型的输出是每个输入单词的嵌入表示（通过 Embedding 层）。
  • 输出矩阵的形状：(1, 400, 32)，说明：
    • 1 是批次大小，表示输入数据只有一个样本（即只有一个文本输入）。
    • 400 是输入序列的最大长度，每个序列被填充到 400 个词。
    • 32 是每个单词的嵌入维度，每个单词被映射为一个 32 维的向量。

这表明，对于每个输入序列中的每个词，模型输出一个 32 维的嵌入向量，总共有 400 个词，每个词由 32 维向量表示。

（4）总结

  • 模型架构：你的模型只有一个嵌入层，负责将输入的词序列转换为对应的 32 维向量表示。
  • 嵌入矩阵的权重：这个权重矩阵大小为 (100, 32)，表示你定义了一个包含 100 个词汇的词表，每个词的向量表示有 32 个维度。
  • 预测输出：模型根据输入文本，将每个词映射为一个 32 维的向量，输出的形状是 (1, 400, 32)，即每个输入文本（长度为 400）的每个词（总共 400 个词）都有一个 32 维的嵌入表示。

这个过程展示了如何使用 Keras 创建一个基本的嵌入层，并通过 Tokenizer 将文本转换为适合嵌入层处理的格式。 

2.4 RNN网络模型

2.4.1 代码和结果

# 构建 RNN 网络模型
import tensorflow as tf  # 导入所需库# 创建空的网络模型 model
model = tf.keras.Sequential()# 创建嵌入层并添加到 model 中
model.add(tf.keras.layers.Embedding(10, 5, input_length=6))# 创建简单循环层并添加到 model 中
model.add(tf.keras.layers.SimpleRNN(128))# 创建全连接层作为输出层，并添加到 model 中
model.add(tf.keras.layers.Dense(5, activation='softmax'))# 显示网络模型的参数信息
model.summary()

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding_1 (Embedding)     (None, 6, 5)              50        
                                                                 
 simple_rnn (SimpleRNN)      (None, 128)               17152     
                                                                 
 dense (Dense)               (None, 5)                 645       
                                                                 
=================================================================
Total params: 17,847
Trainable params: 17,847
Non-trainable params: 0
_________________________________________________________________

2.4.2 代码解释

（1）导入 TensorFlow 库

import tensorflow as tf # 导入所需库
  • 导入 TensorFlow 库，这是使用 Keras 构建和训练模型的核心库。

（2）创建空的网络模型

model = tf.keras.Sequential()
  • 使用 Sequential 创建一个空的顺序模型（model）。在 Sequential 模型中，层是按顺序堆叠的，每一层的输入是前一层的输出。

（3）添加嵌入层（Embedding Layer）

model.add(tf.keras.layers.Embedding(10, 5, input_length=6))

Embedding(10, 5, input_length=6)：嵌入层将输入的整数（每个词的索引）转换为一个 5 维的稠密向量。它的输出形状将是 (batch_size, input_length, output_dim)，在这个例子中，输出形状是 (batch_size, 6, 5)。

  • input_dim=10：词汇表的大小为 10，即输入数据中的单词索引最多为 9。
  • output_dim=5：每个单词将被嵌入为一个 5 维的向量。
  • input_length=6：每个输入序列的长度为 6，即每个输入将包含 6 个单词（或词汇索引）。

（4）添加循环层（SimpleRNN）

model.add(tf.keras.layers.SimpleRNN(128))

SimpleRNN(128)：创建一个简单的循环神经网络（RNN）层，包含 128 个隐藏单元。

  • 这个循环层将接收前一层（Embedding 层）输出的向量序列，并使用 RNN 单元（128 个）处理这个序列数据，生成最终的一个输出向量。
  • 输出的形状是 (batch_size, 128)，即将输入的长度为 6 的序列压缩成一个 128 维的向量。

（5）添加全连接层（Dense Layer）

model.add(tf.keras.layers.Dense(5, activation='softmax'))

Dense(5, activation='softmax')：这是一个全连接层，用于最终输出分类结果。

该层的输出形状是 (batch_size, 5)，表示每个样本将有 5 个类别的概率输出，且这些概率的和为 1。

  • 5：表示输出的类别数（即输出层有 5 个神经元）。
  • activation='softmax'：使用 softmax 激活函数，将输出值转换为概率分布，适用于多分类任务。

（6）显示网络模型的参数信息

model.summary()  # 显示网络模型的参数信息
  • model.summary() 会打印出模型的各层结构，包括每一层的输出形状、参数数量等信息。这有助于了解网络的整体架构。

（7）模型结构和参数分析

假设批量大小（batch_size）为 32，输入序列的长度为 6。通过 model.summary() 可以看到模型的详细参数信息。下面是每一层的详细解释：

  • 嵌入层（Embedding）：

    • 输入：词汇表大小为 10，输出：每个单词是 5 维的向量。
    • 参数数量：input_dim * output_dim = 10 * 5 = 50，即嵌入层有 50 个可训练参数。
    • 输出形状：(batch_size, 6, 5)，即每个输入序列（长度 6）都会被转换为 6 个 5 维的向量。

  • 简单循环层（SimpleRNN）：

    • 输入：每个单词被表示为 5 维向量（来自嵌入层），序列长度为 6。
    • 输出：128 维的向量表示整个序列的特征（最终的 RNN 输出）。
    • 参数数量：(input_dim * units) + (units * units) + units = (5 * 128) + (128 * 128) + 128 = 640 + 16384 + 128 = 17052，即该层有 17,052 个可训练参数。
    • 输出形状：(batch_size, 128)，即每个输入序列通过 RNN 处理后输出一个 128 维的向量。

  • 全连接层（Dense）：

    • 输入：128 维的向量（来自 RNN 层）。
    • 输出：5 维的概率分布（来自 softmax 激活）。
    • 参数数量：(input_dim * output_dim) + output_dim = (128 * 5) + 5 = 640 + 5 = 645，即该层有 645 个可训练参数。
    • 输出形状：(batch_size, 5)，即每个输入样本会有 5 个类别的概率输出。

2.4.3 结果分析

 embedding_1 (Embedding)     (None, 6, 5)              50        
                                                                 
 simple_rnn (SimpleRNN)      (None, 128)               17152     
                                                                 
 dense (Dense)               (None, 5)                 645       
                                                                 
=================================================================
Total params: 17,847
Trainable params: 17,847
Non-trainable params: 0

第一层：embedding_1 (Embedding Layer)

  • 输出形状：(None, 6, 5)，表示每个输入序列（长度为 6）会被映射为 6 个 5 维的向量。
  • 参数数量：50。这个值由 input_dim * output_dim 计算得出，即 10 * 5 = 50。input_dim=10 表示词汇表的大小，output_dim=5 表示每个词将被映射为一个 5 维的向量。

第二层：simple_rnn (SimpleRNN Layer)

  • 输出形状：(None, 128)，表示该层将输入的序列压缩成一个 128 维的向量。RNN 会处理输入序列，并将每个时间步的输出与前一时间步的状态结合，最终生成一个固定大小的输出向量。

  • 参数数量：17,152。这个参数数量是由以下公式计算的：

    参数数量=(input_dim×units)+(units×units)+units\text{参数数量} = (input\_dim \times units) + (units \times units) + units参数数量=(input_dim×units)+(units×units)+units
    • input_dim = 5（来自嵌入层的每个词的向量维度）
    • units = 128（SimpleRNN 中的隐藏单元数量）

    所以参数数量是：(5×128)+(128×128)+128=640+16,384+128=17,152

第三层：dense (Dense Layer)

  • 输出形状：(None, 5)，表示该层将产生一个 5 维的向量，用于分类任务的 5 个类别的概率。

  • 参数数量：645。这个值是由以下公式计算得出的：

    参数数量=(input_dim×output_dim)+output_dim\text{参数数量} = (input\_dim \times output\_dim) + output\_dim参数数量=(input_dim×output_dim)+output_dim
    • input_dim = 128（来自 RNN 层的输出维度）
    • output_dim = 5（输出层的神经元数量）

    所以参数数量是：(128×5)+5=640+5=645

总参数数量

  • 总参数数量：17,847，是所有层的参数总和，计算公式如下：

    50(嵌入层)+17,152(RNN层)+645(全连接层)=17,84750

总结

  • 嵌入层（Embedding）：输入的整数序列（最大长度 6，每个单词映射到 5 维的向量），共有 50 个参数。
  • RNN 层（SimpleRNN）：接收嵌入层的输出，处理整个序列，输出一个 128 维的向量，包含 17,152 个可训练参数。
  • 全连接层（Dense）：将 RNN 输出的 128 维向量映射为 5 类的概率分布，包含 645 个参数。

这个网络模型是一个简单的序列分类模型，首先通过嵌入层将词汇序列转化为向量，再通过 RNN 层学习序列的时序特征，最后通过全连接层进行分类。

2.5 构建LSTM网络     

创建了一个包含 LSTM（长短期记忆） 层的神经网络模型。与普通的 RNN 层不同，LSTM 层能够捕捉更长范围的时序依赖关系，因为它包含了门控机制（如遗忘门、输入门、输出门）

2.5.1 代码和结果

import tensorflow as tf  # 导入所需库# 创建空的网络模型 model
model = tf.keras.Sequential()# 创建嵌入层并添加到 model 中
model.add(tf.keras.layers.Embedding(10, 5, input_length=6))# 创建长短期记忆层（LSTM）并添加到 model 中
model.add(tf.keras.layers.LSTM(128))# 创建全连接层作为输出层，并添加到 model 中
model.add(tf.keras.layers.Dense(5, activation='softmax'))# 显示网络模型的参数信息
model.summary()

Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding_2 (Embedding)     (None, 6, 5)              50        
                                                                 
 lstm (LSTM)                 (None, 128)               68608     
                                                                 
 dense_1 (Dense)             (None, 5)                 645       
                                                                 
=================================================================
Total params: 69,303
Trainable params: 69,303
Non-trainable params: 0
_________________________________________________________________

2.5.2 代码解释                  

（1）导入 TensorFlow 库

import tensorflow as tf # 导入所需库
  • 这里导入了 tensorflow 库，它包含了构建和训练深度学习模型所需的工具。

（2）创建空的网络模型

model = tf.keras.Sequential()
  • 使用 Sequential 模型来创建一个线性堆叠的网络模型，意味着每一层的输出都是下一层的输入。

（3）添加嵌入层（Embedding Layer）

model.add(tf.keras.layers.Embedding(10, 5, input_length=6))

Embedding(10, 5, input_length=6)：

该层的输出形状是 (batch_size, 6, 5)，表示每个输入序列（长度为 6）将被转换为 6 个 5 维的词向量。

  • input_dim=10：词汇表的大小为 10（输入的数据中的每个词汇的索引不超过 9）。
  • output_dim=5：每个词将被表示为一个 5 维的向量。
  • input_length=6：每个输入序列的长度为 6，即每个输入样本由 6 个词组成。

（4）添加 LSTM 层（LSTM）

model.add(tf.keras.layers.LSTM(128))

LSTM(128)：这是一个 LSTM 层，包含 128 个隐藏单元。

  • LSTM 层能够学习输入数据的时序特征，捕捉长时间跨度的依赖关系。
  • 该层的输出形状是 (batch_size, 128)，即每个输入序列经过 LSTM 处理后将被压缩成一个 128 维的向量。LSTM 层会为输入序列生成一个固定长度的输出。

（5）添加全连接层（Dense）

model.add(tf.keras.layers.Dense(5, activation='softmax'))

Dense(5, activation='softmax')：这是一个全连接层，用于生成分类任务的输出。

该层的输出形状是 (batch_size, 5)，即每个输入样本会生成一个 5 维的概率分布，表示其属于每个类别的概率。

  • 5：表示输出的类别数，即 5 个分类。
  • activation='softmax'：使用 softmax 激活函数，将输出的 5 个值转换为一个概率分布。softmax 会将输出值转换为 0 到 1 之间的概率，且所有输出的概率和为 1。

（6）显示网络模型的参数信息

model.summary() # 显示网络模型的参数信息
  • model.summary() 会打印出模型的层结构、每一层的输出形状以及可训练的参数数量，帮助我们了解模型的详细结构。

2.5.3 结果分析

 Layer (type)                Output Shape              Param #   
=================================================================
 embedding_2 (Embedding)     (None, 6, 5)              50        
                                                                 
 lstm (LSTM)                 (None, 128)               68608     
                                                                 
 dense_1 (Dense)             (None, 5)                 645       
                                                                 
=================================================================
Total params: 69,303
Trainable params: 69,303
Non-trainable params: 0

（1）嵌入层（embedding_2）

  • 输出形状：(None, 6, 5)，表示输入的每个序列（长度为 6）会被映射为 6 个 5 维的向量。
  • 参数数量：50，这个是由 input_dim * output_dim 计算得出的，即 10 * 5 = 50。
    • input_dim=10：词汇表的大小（输入数据的词汇数量，即最大单词索引为 9）。
    • output_dim=5：每个词的词向量维度。

（2）LSTM 层（lstm）

  • 输出形状：(None, 128)，表示 LSTM 层会将每个输入序列压缩成一个 128 维的向量。

  • 参数数量：68,608，这是由以下公式计算的：

    参数数量=4×(input_dim×units+units×units+units)\text{参数数量} = 4 \times (input\_dim \times units + units \times units + units)参数数量=4×(input_dim×units+units×units+units)

    其中：

    • input_dim = 5（来自嵌入层的词向量维度）。
    • units = 128（LSTM 层的隐藏单元数）。

    所以，LSTM 层的参数数量为：

    4×((5×128)+(128×128)+128)=4×(640+16,384+128)=68,6084

（3）全连接层（dense_1）：

  • 输出形状：(None, 5)，表示该层输出 5 个类别的概率值。

  • 参数数量：645，这是由以下公式计算的：

    参数数量=(input_dim×output_dim)+output_dim

    其中：

    • input_dim = 128（来自 LSTM 层的输出维度）。
    • output_dim = 5（全连接层的输出维度，即 5 个类别）。

    所以，全连接层的参数数量为：(128×5)+5=640+5=645

（4）总参数数量

  • 总参数数量：69,303，是所有层的参数总和，即：

    50(嵌入层)+68,608(LSTM 层)+645(全连接层)=69,30350 (\text{嵌入层}) + 68,608 (\text{LSTM 层}) + 645 (\text{全连接层}) = 69,30350(嵌入层)+68,608(LSTM 层)+645(全连接层)=69,303

    所有这些参数都是 可训练的，因此 Trainable params 为 69,303，Non-trainable params 为 0。

（5）总结

这个模型是一个简单的文本分类模型，包含：

  • 嵌入层：将词汇索引转换为 5 维的词向量。
  • LSTM 层：捕捉输入序列的时序特征，并输出一个 128 维的向量表示。
  • 全连接层：输出 5 个类别的概率分布，用于多分类任务。

3.基于 GRU 、LSTM的情感分析模型

3.1 构建 GRU 神经网络模型

实现了一个基于 GRU（门控循环单元）的情感分类任务，目标是利用 IMDb 数据集预测影评是正面（1）还是负面（0）。这段代码实现了一个基于 GRU 的情感分析模型，处理 IMDb 数据集中的电影评论情感分类任务。模型通过训练数据来学习并进行预测，并在每一轮训练时绘制损失和准确率图，以帮助评估模型的训练过程。最终，模型在测试集上的表现通过损失和准确率输出。

3.1.1 代码和结果

import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dropout, GRU, Dense
from tensorflow.keras.optimizers import RMSprop
import matplotlib.pyplot as plt# (1) 准备数据
# 导入 IMDb 数据集
vocab_size = 4000  # 词汇表大小
maxlen = 400       # 输入序列的最大长度# 加载数据集（仅保留 vocab_size 个最常用的单词）
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)# 对训练集和测试集的特征值进行序列填充
x_train = pad_sequences(x_train, maxlen=maxlen, padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=maxlen, padding='post', truncating='post')# (2) 构建 GRU 神经网络模型
model = Sequential()
# 嵌入层
model.add(Embedding(input_dim=vocab_size, output_dim=32, input_length=maxlen))
# Dropout 层
model.add(Dropout(0.3))
# GRU 层
model.add(GRU(64))
# Dropout 层
model.add(Dropout(0.3))
# 输出层
model.add(Dense(1, activation='sigmoid'))# 显示模型的参数信息
model.summary()# (3) 编译、训练和评估 GRU 神经网络模型
# 编译模型
model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])# 训练模型
history = model.fit(x_train, y_train,batch_size=64,epochs=50,validation_split=0.2,verbose=2
)# 评估模型
test_loss, test_accuracy = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
print(f"Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")# (4) 绘制损失和准确率图
# 获取历史数据
train_loss = history.history['loss']
val_loss = history.history['val_loss']
train_accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']# 创建子图
plt.figure(figsize=(12, 6))# 子图 1：损失函数值折线图
plt.subplot(1, 2, 1)
plt.plot(train_loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Loss Function')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()# 子图 2：准确率折线图
plt.subplot(1, 2, 2)
plt.plot(train_accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()# 显示图形
plt.tight_layout()
plt.show()

3.1.2 代码解释

这段代码实现了一个基于 GRU（门控循环单元） 的情感分析模型，使用 IMDb 数据集来进行电影评论的情感分类任务。下面逐部分分析代码：

（1）准备数据

from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequencesvocab_size = 4000  # 词汇表大小
maxlen = 400       # 输入序列的最大长度# 加载数据集（仅保留 vocab_size 个最常用的单词）
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)# 对训练集和测试集的特征值进行序列填充
x_train = pad_sequences(x_train, maxlen=maxlen, padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=maxlen, padding='post', truncating='post')

  • imdb.load_data()：加载 IMDb 数据集，num_words=vocab_size 参数限制了使用数据集中前 4000 个最常见的单词。返回的数据 (x_train, y_train) 和 (x_test, y_test) 分别是训练集和测试集的数据和标签。
    • x_train 和 x_test 是电影评论的单词索引序列。
    • y_train 和 y_test 是对应的情感标签，0 代表负面评论，1 代表正面评论。
  • pad_sequences()：对输入序列进行填充或截断。maxlen=400 限制了每个评论的最大长度为 400，padding='post' 表示在序列的末尾进行填充，truncating='post' 表示截断序列时，从末尾开始截取。

（2）构建 GRU 神经网络模型

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dropout, GRU, Densemodel = Sequential()
# 嵌入层
model.add(Embedding(input_dim=vocab_size, output_dim=32, input_length=maxlen))
# Dropout 层
model.add(Dropout(0.3))
# GRU 层
model.add(GRU(64))
# Dropout 层
model.add(Dropout(0.3))
# 输出层
model.add(Dense(1, activation='sigmoid'))

  • Sequential()：创建一个顺序模型，即每一层的输出都作为下一层的输入。
  • Embedding(input_dim=vocab_size, output_dim=32, input_length=maxlen)：嵌入层将每个单词的索引转换为固定长度的稠密向量。input_dim=vocab_size 表示词汇表的大小为 4000，output_dim=32 表示嵌入向量的维度是 32，input_length=maxlen 表示每个输入序列的长度是 400。
  • Dropout(0.3)：在训练过程中随机丢弃 30% 的神经元，以防止过拟合。
  • GRU(64)：GRU 层包含 64 个单元。GRU 是一种循环神经网络（RNN）变体，能够捕捉序列数据的长期依赖关系。相比于 LSTM，GRU 结构更简洁，但通常在很多任务中表现相似。
  • Dense(1, activation='sigmoid')：输出层，使用 sigmoid 激活函数来输出一个 0 到 1 之间的值，表示电影评论的情感分类（正面或负面）。

（3）编译、训练和评估 GRU 神经网络模型

from tensorflow.keras.optimizers import RMSprop# 编译模型
model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])# 训练模型
history = model.fit(x_train, y_train,batch_size=64,epochs=50,validation_split=0.2,verbose=2
)# 评估模型
test_loss, test_accuracy = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
print(f"Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")

  • model.compile()：编译模型，指定优化器 RMSprop()、损失函数 binary_crossentropy（用于二分类任务），并设置评估指标为准确率（accuracy）。
  • model.fit()：训练模型，使用训练数据 x_train 和标签 y_train，batch_size=64 表示每次训练时使用 64 个样本，epochs=50 表示训练 50 轮，validation_split=0.2 表示将 20% 的训练数据用于验证，verbose=2 会打印出每轮的训练进度。
  • model.evaluate()：评估模型，计算测试集的损失和准确率，batch_size=64 表示每次评估时使用 64 个样本。

（4）绘制损失和准确率图

import matplotlib.pyplot as plt# 获取历史数据
train_loss = history.history['loss']
val_loss = history.history['val_loss']
train_accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']# 创建子图
plt.figure(figsize=(12, 6))# 子图 1：损失函数值折线图
plt.subplot(1, 2, 1)
plt.plot(train_loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Loss Function')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()# 子图 2：准确率折线图
plt.subplot(1, 2, 2)
plt.plot(train_accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()# 显示图形
plt.tight_layout()
plt.show()

  • history.history：包含训练过程中每一轮的损失值和准确率，以及在验证集上的损失和准确率。
  • plt.subplot()：创建一个 1 行 2 列的子图，第一个子图用于显示损失函数的变化，第二个子图用于显示准确率的变化。
  • plt.plot()：绘制折线图，分别显示训练集和验证集的损失值和准确率。
  • plt.legend()：添加图例，标注训练集和验证集。
  • plt.tight_layout()：调整子图布局，确保图形不会重叠。

3.2 构建LSTM神经网络模型

3.2.1 代码和结果

这段代码实现了一个简单的 LSTM 模型，处理 IMDb 数据集中的电影评论情感分类任务，包含数据预处理、模型构建、训练、评估和可视化步骤。通过训练 50 轮后，模型可以对测试集进行评估，并通过图形展示训练过程中的损失和准确率变化情况。

import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dropout, LSTM, Dense
from tensorflow.keras.optimizers import RMSprop
import matplotlib.pyplot as plt# (1) 准备数据
# 导入 IMDb 数据集
vocab_size = 4000  # 词汇表大小
maxlen = 400       # 输入序列的最大长度# 加载数据集（仅保留 vocab_size 个最常用的单词）
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)# 对训练集和测试集的特征值进行序列填充
x_train = pad_sequences(x_train, maxlen=maxlen, padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=maxlen, padding='post', truncating='post')# (2) 构建 LSTM 神经网络模型
model = Sequential()
# 嵌入层
model.add(Embedding(input_dim=vocab_size, output_dim=32, input_length=maxlen))
# Dropout 层
model.add(Dropout(0.3))
# LSTM 层
model.add(LSTM(64))
# Dropout 层
model.add(Dropout(0.3))
# 输出层
model.add(Dense(1, activation='sigmoid'))# 显示模型的参数信息
model.summary()# (3) 编译、训练和评估 LSTM 神经网络模型
# 编译模型
model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])# 训练模型
history = model.fit(x_train, y_train,batch_size=64,epochs=50,validation_split=0.2,verbose=2
)# 评估模型
test_loss, test_accuracy = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
print(f"Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")# (4) 绘制损失和准确率图
# 获取历史数据
train_loss = history.history['loss']
val_loss = history.history['val_loss']
train_accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']# 创建子图
plt.figure(figsize=(12, 6))# 子图 1：损失函数值折线图
plt.subplot(1, 2, 1)
plt.plot(train_loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('LSTM - Loss Function')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()# 子图 2：准确率折线图
plt.subplot(1, 2, 2)
plt.plot(train_accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.title('LSTM - Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()# 显示图形
plt.tight_layout()
plt.show()

3.2.2 代码解释

（1）准备数据

from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequencesvocab_size = 4000  # 词汇表大小
maxlen = 400       # 输入序列的最大长度# 加载数据集（仅保留 vocab_size 个最常用的单词）
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)# 对训练集和测试集的特征值进行序列填充
x_train = pad_sequences(x_train, maxlen=maxlen, padding='post', truncating='post')
x_test = pad_sequences(x_test, maxlen=maxlen, padding='post', truncating='post')
  • imdb.load_data()：加载 IMDb 数据集，num_words=vocab_size 参数指定仅使用数据集中最常见的 4000 个单词进行处理。返回的 (x_train, y_train) 和 (x_test, y_test) 是训练和测试数据，x_train 和 x_test 是评论的单词索引列表，y_train 和 y_test 是对应的标签（0 或 1，表示负面或正面评论）。
  • pad_sequences()：对评论序列进行填充或截断，以确保所有输入序列的长度为 400。padding='post' 表示如果评论短于 400，则在后面填充 0；truncating='post' 表示如果评论超过 400，则截断评论后面的部分。

（2）构建 LSTM 神经网络模型

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dropout, LSTM, Densemodel = Sequential()
# 嵌入层
model.add(Embedding(input_dim=vocab_size, output_dim=32, input_length=maxlen))
# Dropout 层
model.add(Dropout(0.3))
# LSTM 层
model.add(LSTM(64))
# Dropout 层
model.add(Dropout(0.3))
# 输出层
model.add(Dense(1, activation='sigmoid'))

  • Sequential()：创建一个顺序模型，即每一层的输出连接到下一层。
  • Embedding()：嵌入层将每个单词的索引转换为一个固定长度的稠密向量（这里是 32 维）。input_dim=vocab_size 表示词汇表大小为 4000，output_dim=32 表示嵌入向量的维度为 32，input_length=maxlen 表示每个输入序列的长度为 400。
  • Dropout(0.3)：在训练过程中随机丢弃 30% 的神经元，防止过拟合。
  • LSTM(64)：LSTM 层包含 64 个单元，主要用于处理序列数据，捕捉时间序列中的长期依赖关系。
  • Dense(1, activation='sigmoid')：输出层，使用 sigmoid 激活函数输出一个 0 到 1 之间的值，表示正面（1）或负面（0）的概率。

（3）编译、训练和评估模型

from tensorflow.keras.optimizers import RMSprop# 编译模型
model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])# 训练模型
history = model.fit(x_train, y_train,batch_size=64,epochs=50,validation_split=0.2,verbose=2
)# 评估模型
test_loss, test_accuracy = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
print(f"Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")

  • model.compile()：编译模型，指定优化器 RMSprop()、损失函数 binary_crossentropy（二分类问题使用的常见损失函数），并设置评估指标为准确率（accuracy）。
  • model.fit()：训练模型，使用训练数据 x_train 和标签 y_train，batch_size=64 表示每次训练时处理 64 个样本，epochs=50 表示训练 50 轮，validation_split=0.2 表示将 20% 的训练数据用于验证，verbose=2 会打印出每轮的训练进度。
  • model.evaluate()：在测试集上评估模型的性能，返回损失和准确率。

（4）绘制损失和准确率图

import matplotlib.pyplot as plt# 获取历史数据
train_loss = history.history['loss']
val_loss = history.history['val_loss']
train_accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']# 创建子图
plt.figure(figsize=(12, 6))# 子图 1：损失函数值折线图
plt.subplot(1, 2, 1)
plt.plot(train_loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('LSTM - Loss Function')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()# 子图 2：准确率折线图
plt.subplot(1, 2, 2)
plt.plot(train_accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.title('LSTM - Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()# 显示图形
plt.tight_layout()
plt.show()

  • history.history：包含训练过程中每一轮的损失值（loss）和准确率（accuracy）以及验证集上的损失值和准确率。
  • plt.subplot()：创建一个 1 行 2 列的子图，分别用于显示损失函数值和准确率的变化。
  • plt.plot()：绘制折线图，分别显示训练集和验证集的损失和准确率。
  • plt.legend()：添加图例，区分训练和验证数据。
  • plt.tight_layout()：调整子图布局，确保不重叠。 

相关文章：

【机器学习】任务十二：循环神经网络

1.循环神经网络 1.1 什么是循环神经网络（RNN）？ 循环神经网络（Recurrent Neural Network, RNN） 是一种用于处理序列数据的神经网络类型，它的主要特点是拥有循环连接，使得网络可以对序列中的每个…...

编程日记 2024/12/9 13:12:57

【返璞归真】-切比雪夫不等式（Chebyshev‘s Inequality）

切比雪夫不等式（Chebyshev’s Inequality） 切比雪夫不等式是概率论中的一个基本不等式，用于估计随机变量偏离其期望值一定范围的概率。它对于任何具有有限期望和有限方差的随机变量都成立。 公式表达 切比雪夫不等式的基本形式如下&#xf…...

编程日记 2024/12/9 13:11:56

【Django】在view中调用channel来主动进行websocket通信

前提：consumer中已经写好了建立连接的代码，并且能够成功把连接加入到通道层的组内 可以参考我的另一个博客： LuckySheet协同编辑后端示例(DjangoChannel,Websocket通信)_lucksheet 协同编辑-CSDN博客 我是懒得去折腾luckysheet的源码&…...

编程日记 2024/12/9 13:10:55

18.[极客大挑战 2019]BabySQL1

进入靶场 随便输输 再输输 可以判断是单引号闭合 再随便输输 查询字段数量 得，过滤了 关键字也过滤了 只能双写了 根据回显，这样可以，只是需要改改 1,2不行 1,2,3行 1,2,3,4不行 可以尝试得到库名，表名了 库名 database(…...

编程日记 2024/12/9 13:09:53

Python快速入门二：Python3 基础语法

一、编码 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码： # -*- coding: cp-1252 -*-上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适…...

编程日记 2024/12/9 13:08:52

1-1 C语言链表

目录 目录 1.0 定义 2.0 为什么使用链表 3.0 链表原理 4.0 创建链表节点 5.0 链表原理续 6.0 链表实现 6.0.1 创建节点 6.0.2 初始化链表 6.0.3 添加链表节点 6.0.4 循环遍历 6.0.5 插入节点 6.0.6 插入头结点main函数 7.0 完整代码 8.0 节点添加方案二 8.0.1 …...

编程日记 2024/12/9 13:05:49

[0629].第29节：配置中心业务规则与动态刷新

我的后端学习大纲 SpringCloud学习大纲 1、编码实现3377服务： 1.1.建module: 1.2.改pom: 1.3.写YML： 1.Nacos同Consul一样，在项目初始化时，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正…...

编程日记 2024/12/9 13:02:46

mac: docker : Command not found解决

描述: 安装docker但是docker命令显示Command not found 分析: mac没有配置对应的环境变量 解决方案: 打开配置文件: vim ~/.zshrc写docker环境变量: export PATH"/Applications/Docker.app/Contents/Resources/bin:$PATH"保存退出: esc,输入wq,按enter 配置文…...

编程日记 2024/12/9 13:00:44

Django drf基于APIView 快速使用

1. 注册 # settings.pyINSTALLED_APPS [,rest_framework, ]2. 路由 from django.urls import pathurlpatterns [path(task/, views.TaskAPIView.as_view()) ]3. 视图 from rest_framework.views import APIView from rest_framework.response import Responseclass TaskAPIV…...

编程日记 2024/12/9 12:57:39

【MarsCode】每日一题数组 之 数字分组求偶数和

数字分组求偶数和 1.问题描述 问题描述 小M面对一组从 1 到 9 的数字，这些数字被分成多个小组，并从每个小组中选择一个数字组成一个新的数。目标是使得这个新数的各位数字之和为偶数。任务是计算出有多少种不同的分组和选择方法可以达到这一目标。 n…...

编程日记 2024/12/9 12:56:37

解决：error: subprocess-exited-with-error 的问题

系统和配置： ubuntu20.04 python3.10 torch2.5.1 pip install时报错如下 （实际指令是：pip3 install -r drl_grasping/python_requirements.txt） Collecting python-xlib>0.17 (from pynput1.7.6->-r drl_grasping/python_…...

编程日记 2024/12/9 12:54:34

使用腾讯混元(HunYuanVideo)视频模型FP8量化版本来生成绅士动画,模型体积30G,8G甜品卡可玩,2秒视频需要15分钟

腾讯混元(HunYuanVideo)视频模型发布以来，视频效果有口皆碑，但由于推理门槛比较高，消费级显卡用户望而却步，最近大神Kijai发布了FP8量化版本模型，使得甜品卡用户也有了一餐秀色的可能。 本次我们利用HunYuanVideo量化…...

编程日记 2024/12/9 12:53:32

使用Ancona安装node，安装vue

搜索Conda仓库中可用的Node.js版本 conda search nodejs 通过Conda安装Node.js conda install nodejs 检查已安装的Node.js版本 node -v 安装中国npm镜像（cnpm） conda install cnpm 使用cnpm全局安装Vue CLI cnpm install -g vue/cli...

编程日记 2024/12/9 12:47:27

如何“安装Android SDK“？

一、下载 https://android-sdk.en.softonic.com/ 二、解压（不能有中文） 三、配置环境变量 1、ANDROID_HOME：D:\android-sdk 2、在Path添加文件路径 四、验证 adb version...

编程日记 2024/12/9 12:45:25

天童教育：提升孩子的语言表达能力

语言表达能力如同阳光、空气和水，无处不在，无时不用。然而，很多人并没有意识到，想要让孩子能够良好适应社会生活，提升他们的语言表达能力是至关重要的。大连天童教育认为，我们务必重视孩子的语言表达能力&a…...

编程日记 2024/12/9 12:39:17

Node.js中JWT的token完整生命周期管理：从生成到销毁

Node.js中JWT的token完整生命周期管理：从生成到销毁 在Node.js中使用JWT（JSON Web Token）进行身份验证和授权是一种常见的实践。下面详细介绍JWT从生成到销毁的过程。 JWT生成 安装jsonwebtoken库： 要生成JWT，首先…...

编程日记 2024/12/9 12:38:16

Kotlin报错：lateinit property xxx has not been initialized

Kotlin报错：lateinit property xxx has not been initialized 发生在定义了一个名为xxx的lateinit变量。 解决，在调用前，可以先判断一层该xxx变量是否已经初始化： if (this::xxx.isInitialized) {//正常使用该变量} kotlin.Unini…...

编程日记 2024/12/9 12:35:07

debian编译失败

A、缘由和分析 debian的代码在删除该路径下的2个包后， 重新全编，编译不过的问题。 至于我为什么删除这2个包，这是因为在sdk第一次编译时一些文件已经打包进去了，我现在的修改无法更新进img中，而现在我的项目中不需要…...

编程日记 2024/12/9 12:31:02

flink-connector-mysql-cdc：03 mysql-cdc常见问题汇总

flink-connector-mysql-cdc： 01 mysql-cdc基础配置代码演示02 mysql-cdc高级扩展03 mysql-cdc常见问题汇总04 mysql-cdc-kafka生产级代码分享05 flink-kafka-doris生产级代码分享06 flink-kafka-hudi生产级代码分享flink-cdc版本：3.2.0 flink版本：flink-1.18.0 mysql版本：…...

编程日记 2024/12/9 12:30:00

JSP技术发展现状

多年前，Java入门时学习的JSP可谓时风光无限，J2EE如日中天，短短数年，技术迭代更新光速般发展，有些技术慢慢就退出历史舞台。 JSP（Java Server Pages） 技术在早期 Java Web 开发中曾是构建动态网…...

编程日记 2024/12/9 12:22:46

浏览器同源策略、跨域、跨域请求，服务器处理没、跨域解决方案

目录 什么是同源策略什么是跨域发生跨域时，服务器有没有接到请求并处理响应：（两种情况） 如何解决跨域 什么是同源策略 概念： 同源策略是浏览器的一种安全机制，用于防止恶意网站对用户的敏感数据进行未经授…...

编程日记 2024/12/9 12:20:39

flink-connector-mysql-cdc：02 mysql-cdc高级扩展

flink-connector-mysql-cdc：01 mysql-cdc基础配置代码演示02 mysql-cdc高级扩展03 mysql-cdc常见问题汇总04 mysql-cdc-kafka生产级代码分享05 flink-kafka-doris生产级代码分享06 flink-kafka-hudi生产级代码分享 flink-cdc版本：3.2.0flink版本&#xf…...

编程日记 2024/12/9 12:19:39

Couchbase 简介

Couchbase 是一款分布式 NoSQL 数据库，主要用于现代应用程序中高性能、高可扩展性和灵活的数据存储需求。它结合了文档存储和键值存储的特性，为开发者提供了一种高效的数据库解决方案。 Couchbase 的特点 高性能： 支持内存优先的架构&#x…...

编程日记 2024/12/9 12:16:32

我们来学mysql -- 事务并发之幻读(原理篇)

事务并发之幻读 题记幻读系列文章 题记 在《事务之概念》提到事务对应现实世界的状态转换，这个过程要满足4个特性这世界，真理只在大炮射程之类，通往和平的道路，非“常人”可以驾驭一个人生活按部就班，人多起来&#x…...

编程日记 2024/12/9 12:15:31

Ubuntu Linux 图形界面工具管理磁盘分区和文件系统(八)

本文为Ubuntu Linux操作系统- 第八弹~~ 今天接着上文的内容，讲Linux磁盘分区存储的相关知识~ 上期回顾：命令行-管理磁盘分区和文件系统 今天看酷酷的雪獒铠甲！！雪獒铠甲合体~ 文章目录 磁盘管理器GNOME Disks主要功能安装命令 磁盘…...

编程日记 2024/12/9 12:08:12

Eclipse IDE 各个版本的用途和区别

Eclipse官方下载地址：https://www.eclipse.org/downloads/packages/ 会出现很多个Eclipse版本，初学者可能会感觉到很迷惑，不知道下载哪个版本。 Eclipse IDE for Enterprise Java and Web Developers (544 MB) 专为 Java 和 Web 应用开发者设计 包含 Java IDE、JavaScript、…...

编程日记 2024/12/9 12:07:10

国产GPU中，VLLM0.5.0发布Qwen2.5-14B-Instruct-GPTQ-Int8模型，请求返回结果乱码

概述 国产GPU: DCU Z100 推理框架： vllm0.5.0 docker容器化部署 运行如下代码： python -m vllm.entrypoints.openai.api_server --model /app/models/Qwen2.5-14B-Instruct-GPTQ-Int8 --served-model-name qwen-gptq --trust-remote-code --enforce…...

编程日记 2024/12/9 12:06:09

在 Vue 3 中实现点击按钮后禁止浏览器前进或后退

在 Vue 3 中实现点击按钮后禁止浏览器前进或后退&#xff0c;我们可以通过 ref 和 watch 来管理状态&#xff0c;同时使用 onBeforeUnmount 来清理事件监听。 使用 Vue 3 实现&#xff1a; <template><div><button click"disableNavigation">点击…...

编程日记 2024/12/9 12:04:05

Linux：软硬链接

目录 一、概念 软链接 硬链接 二、原理 硬链接 软链接 三、使用场景 硬链接 软链接 一、概念 软链接 在当前目录下&#xff0c;有一个普通文件a.txt。 ln -s a.txt a_soft.link结论&#xff1a; 软链接是一个文件。 观察inode_id&#xff0c;发现软链接有着独立…...

编程日记 2024/12/9 12:03:04

Delphi XE 安卓Web开发 错误：net::ERR_CLEARTEXT_NOT_PERMITTED

解决方法&#xff1a; 1、确保已经申明权限&#xff08;AndroidManifest.xml 文件&#xff09; 1 <uses-permission android:name"android.permission.INTERNET" /> 2、开启 usesCleartextTraffic 1 2 <application android:usesCleartextTraffic&qu…...

编程日记 2024/12/9 12:01:00