收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人
都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
+ 梯度消失或爆炸的危害:
- 如果在训练过程中发生了梯度消失，权重无法被更新，最终导致训练失败; 梯度爆炸所带来的梯度过大，大幅度更新网络参数，在极端情况下，结果会溢出（NaN值）.
1.3 LSTM模型
-
学习目标:
- 了解LSTM内部结构及计算公式.
- 掌握Pytorch中LSTM工具的使用.
- 了解LSTM的优势与缺点.
-
LSTM（Long Short-Term Memory）也称长短时记忆结构, 它是传统RNN的变体, 与经典RNN相比能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时LSTM的结构更复杂, 它的核心结构可以分为四个部分去解析:
- 遗忘门
- 输入门
- 细胞状态
- 输出门
-
LSTM的内部结构图:
- 结构解释图:
- 遗忘门部分结构图与计算公式:
- 遗忘门结构分析:
- 与传统RNN的内部结构计算非常相似, 首先将当前时间步输入x(t)与上一个时间步隐含状态h(t-1)拼接, 得到[x(t), h(t-1)], 然后通过一个全连接层做变换, 最后通过sigmoid函数进行激活得到f(t), 我们可以将f(t)看作是门值, 好比一扇门开合的大小程度, 门值都将作用在通过该扇门的张量, 遗忘门门值将作用的上一层的细胞状态上, 代表遗忘过去的多少信息, 又因为遗忘门门值是由x(t), h(t-1)计算得来的, 因此整个公式意味着根据当前时间步输入和上一个时间步隐含状态h(t-1)来决定遗忘多少上一层的细胞状态所携带的过往信息.
- 遗忘门内部结构过程演示:
- 激活函数sigmiod的作用:
- 用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间.
- 输入门部分结构图与计算公式:
- 输入门结构分析:
- 我们看到输入门的计算公式有两个, 第一个就是产生输入门门值的公式, 它和遗忘门公式几乎相同, 区别只是在于它们之后要作用的目标上. 这个公式意味着输入信息有多少需要进行过滤. 输入门的第二个公式是与传统RNN的内部结构计算相同. 对于LSTM来讲, 它得到的是当前的细胞状态, 而不是像经典RNN一样得到的是隐含状态.
- 输入门内部结构过程演示:
- 细胞状态更新图与计算公式:
- 细胞状态更新分析:
- 细胞更新的结构与计算公式非常容易理解, 这里没有全连接层, 只是将刚刚得到的遗忘门门值与上一个时间步得到的C(t-1)相乘, 再加上输入门门值与当前时间步得到的未更新C(t)相乘的结果. 最终得到更新后的C(t)作为下一个时间步输入的一部分. 整个细胞状态更新过程就是对遗忘门和输入门的应用.
- 细胞状态更新过程演示:
- 输出门部分结构图与计算公式:
- 输出门结构分析:
- 输出门部分的公式也是两个, 第一个即是计算输出门的门值, 它和遗忘门，输入门计算方式相同. 第二个即是使用这个门值产生隐含状态h(t), 他将作用在更新后的细胞状态C(t)上, 并做tanh激活, 最终得到h(t)作为下一时间步输入的一部分. 整个输出门的过程, 就是为了产生隐含状态h(t).
- 输出门内部结构过程演示:
- 什么是Bi-LSTM ?
- Bi-LSTM即双向LSTM, 它没有改变LSTM本身任何的内部结构, 只是将LSTM应用两次且方向不同, 再将两次得到的LSTM结果进行拼接作为最终输出.
-
Bi-LSTM结构分析:
- 我们看到图中对"我爱中国"这句话或者叫这个输入序列, 进行了从左到右和从右到左两次LSTM处理, 将得到的结果张量进行了拼接作为最终输出. 这种结构能够捕捉语言语法中一些特定的前置或后置特征, 增强语义关联,但是模型参数和计算复杂度也随之增加了一倍, 一般需要对语料和计算资源进行评估后决定是否使用该结构.
-
Pytorch中LSTM工具的使用:
- 位置: 在torch.nn工具包之中, 通过torch.nn.LSTM可调用.
-
nn.LSTM类初始化主要参数解释:
- input_size: 输入张量x中特征维度的大小.
- hidden_size: 隐层张量h中特征维度的大小.
- num_layers: 隐含层的数量.
- nonlinearity: 激活函数的选择, 默认是tanh.
- bidirectional: 是否选择使用双向LSTM, 如果为True, 则使用; 默认不使用.
-
nn.LSTM类实例化对象主要参数解释:
- input: 输入张量x.
- h0: 初始化的隐层张量h.
- c0: 初始化的细胞状态张量c.
-
nn.LSTM使用示例:
>>> import torch.nn as nn
>>> import torch
>>> rnn = nn.LSTM(5, 6, 2)
>>> input = torch.randn(1, 3, 5)
>>> h0 = torch.randn(2, 3, 6)
>>> c0 = torch.randn(2, 3, 6)
>>> output, (hn, cn) = rnn(input, (h0, c0))
>>> output
tensor([[[ 0.0447, -0.0335, 0.1454, 0.0438, 0.0865, 0.0416],
[ 0.0105, 0.1923, 0.5507, -0.1742, 0.1569, -0.0548],
[-0.1186, 0.1835, -0.0022, -0.1388, -0.0877, -0.4007]]],
grad_fn=<StackBackward>)
>>> hn
tensor([[[ 0.4647, -0.2364, 0.0645, -0.3996, -0.0500, -0.0152],
[ 0.3852, 0.0704, 0.2103, -0.2524, 0.0243, 0.0477],
[ 0.2571, 0.0608, 0.2322, 0.1815, -0.0513, -0.0291]],
[[ 0.0447, -0.0335, 0.1454, 0.0438, 0.0865, 0.0416],
[ 0.0105, 0.1923, 0.5507, -0.1742, 0.1569, -0.0548],
[-0.1186, 0.1835, -0.0022, -0.1388, -0.0877, -0.4007]]],
grad_fn=<StackBackward>)
>>> cn
tensor([[[ 0.8083, -0.5500, 0.1009, -0.5806, -0.0668, -0.1161],
[ 0.7438, 0.0957, 0.5509, -0.7725, 0.0824, 0.0626],
[ 0.3131, 0.0920, 0.8359, 0.9187, -0.4826, -0.0717]],
[[ 0.1240, -0.0526, 0.3035, 0.1099, 0.5915, 0.0828],
[ 0.0203, 0.8367, 0.9832, -0.4454, 0.3917, -0.1983],
[-0.2976, 0.7764, -0.0074, -0.1965, -0.1343, -0.6683]]],
grad_fn=<StackBackward>)
-
LSTM优势:
- LSTM的门结构能够有效减缓长序列问题中可能出现的梯度消失或爆炸, 虽然并不能杜绝这种现象, 但在更长的序列问题上表现优于传统RNN.
-
LSTM缺点:
- 由于内部结构相对较复杂, 因此训练效率在同等算力下较传统RNN低很多.
-
小节总结:
- LSTM（Long Short-Term Memory）也称长短时记忆结构, 它是传统RNN的变体, 与经典RNN相比能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时LSTM的结构更复杂, 它的核心结构可以分为四个部分去解析:
- 遗忘门
- 输入门
- 细胞状态
- 输出门
- LSTM（Long Short-Term Memory）也称长短时记忆结构, 它是传统RNN的变体, 与经典RNN相比能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时LSTM的结构更复杂, 它的核心结构可以分为四个部分去解析:
+ 遗忘门结构分析:
- 与传统RNN的内部结构计算非常相似, 首先将当前时间步输入x(t)与上一个时间步隐含状态h(t-1)拼接, 得到[x(t), h(t-1)], 然后通过一个全连接层做变换, 最后通过sigmoid函数进行激活得到f(t), 我们可以将f(t)看作是门值, 好比一扇门开合的大小程度, 门值都将作用在通过该扇门的张量, 遗忘门门值将作用的上一层的细胞状态上, 代表遗忘过去的多少信息, 又因为遗忘门门值是由x(t), h(t-1)计算得来的, 因此整个公式意味着根据当前时间步输入和上一个时间步隐含状态h(t-1)来决定遗忘多少上一层的细胞状态所携带的过往信息.
+ 输入门结构分析:
- 我们看到输入门的计算公式有两个, 第一个就是产生输入门门值的公式, 它和遗忘门公式几乎相同, 区别只是在于它们之后要作用的目标上. 这个公式意味着输入信息有多少需要进行过滤. 输入门的第二个公式是与传统RNN的内部结构计算相同. 对于LSTM来讲, 它得到的是当前的细胞状态, 而不是像经典RNN一样得到的是隐含状态.
+ 细胞状态更新分析:
- 细胞更新的结构与计算公式非常容易理解, 这里没有全连接层, 只是将刚刚得到的遗忘门门值与上一个时间步得到的C(t-1)相乘, 再加上输入门门值与当前时间步得到的未更新C(t)相乘的结果. 最终得到更新后的C(t)作为下一个时间步输入的一部分. 整个细胞状态更新过程就是对遗忘门和输入门的应用.
+ 输出门结构分析:
- 输出门部分的公式也是两个, 第一个即是计算输出门的门值, 它和遗忘门，输入门计算方式相同. 第二个即是使用这个门值产生隐含状态h(t), 他将作用在更新后的细胞状态C(t)上, 并做tanh激活, 最终得到h(t)作为下一时间步输入的一部分. 整个输出门的过程, 就是为了产生隐含状态h(t).
+ 什么是Bi-LSTM ?
- Bi-LSTM即双向LSTM, 它没有改变LSTM本身任何的内部结构, 只是将LSTM应用两次且方向不同, 再将两次得到的LSTM结果进行拼接作为最终输出.
+ Pytorch中LSTM工具的使用:
- 位置: 在torch.nn工具包之中, 通过torch.nn.LSTM可调用.
+ LSTM优势:
- LSTM的门结构能够有效减缓长序列问题中可能出现的梯度消失或爆炸, 虽然并不能杜绝这种现象, 但在更长的序列问题上表现优于传统RNN.
+ LSTM缺点:
- 由于内部结构相对较复杂, 因此训练效率在同等算力下较传统RNN低很多.
1.4 GRU模型
-
学习目标:
- 了解GRU内部结构及计算公式.
- 掌握Pytorch中GRU工具的使用.
- 了解GRU的优势与缺点.
-
GRU（Gated Recurrent Unit）也称门控循环单元结构, 它也是传统RNN的变体, 同LSTM一样能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时它的结构和计算要比LSTM更简单, 它的核心结构可以分为两个部分去解析:
- 更新门
- 重置门
-
GRU的内部结构图和计算公式:
- 结构解释图:
- GRU的更新门和重置门结构图:
-
内部结构分析:
- 和之前分析过的LSTM中的门控一样, 首先计算更新门和重置门的门值, 分别是z(t)和r(t), 计算方法就是使用X(t)与h(t-1)拼接进行线性变换, 再经过sigmoid激活. 之后重置门门值作用在了h(t-1)上, 代表控制上一时间步传来的信息有多少可以被利用. 接着就是使用这个重置后的h(t-1)进行基本的RNN计算, 即与x(t)拼接进行线性变化, 经过tanh激活, 得到新的h(t). 最后更新门的门值会作用在新的h(t)，而1-门值会作用在h(t-1)上, 随后将两者的结果相加, 得到最终的隐含状态输出h(t), 这个过程意味着更新门有能力保留之前的结果, 当门值趋于1时, 输出就是新的h(t), 而当门值趋于0时, 输出就是上一时间步的h(t-1).
-
Bi-GRU与Bi-LSTM的逻辑相同, 都是不改变其内部结构, 而是将模型应用两次且方向不同, 再将两次得到的LSTM结果进行拼接作为最终输出. 具体参见上小节中的Bi-LSTM.
-
Pytorch中GRU工具的使用:
- 位置: 在torch.nn工具包之中, 通过torch.nn.GRU可调用.
-
nn.GRU类初始化主要参数解释:
- input_size: 输入张量x中特征维度的大小.
- hidden_size: 隐层张量h中特征维度的大小.
- num_layers: 隐含层的数量.
- nonlinearity: 激活函数的选择, 默认是tanh.
- bidirectional: 是否选择使用双向LSTM, 如果为True, 则使用; 默认不使用.
-
nn.GRU类实例化对象主要参数解释:
- input: 输入张量x.
- h0: 初始化的隐层张量h.
-
nn.GRU使用示例:
>>> import torch
>>> import torch.nn as nn
>>> rnn = nn.GRU(5, 6, 2)
>>> input = torch.randn(1, 3, 5)
>>> h0 = torch.randn(2, 3, 6)
>>> output, hn = rnn(input, h0)
>>> output
tensor([[[-0.2097, -2.2225, 0.6204, -0.1745, -0.1749, -0.0460],
[-0.3820, 0.0465, -0.4798, 0.6837, -0.7894, 0.5173],
[-0.0184, -0.2758, 1.2482, 0.5514, -0.9165, -0.6667]]],
grad_fn=<StackBackward>)
>>> hn
tensor([[[ 0.6578, -0.4226, -0.2129, -0.3785, 0.5070, 0.4338],
[-0.5072, 0.5948, 0.8083, 0.4618, 0.1629, -0.1591],
[ 0.2430, -0.4981, 0.3846, -0.4252, 0.7191, 0.5420]],
[[-0.2097, -2.2225, 0.6204, -0.1745, -0.1749, -0.0460],
[-0.3820, 0.0465, -0.4798, 0.6837, -0.7894, 0.5173],
[-0.0184, -0.2758, 1.2482, 0.5514, -0.9165, -0.6667]]],
grad_fn=<StackBackward>)
-
GRU的优势:
- GRU和LSTM作用相同, 在捕捉长序列语义关联时, 能有效抑制梯度消失或爆炸, 效果都优于传统RNN且计算复杂度相比LSTM要小.
-
GRU的缺点:
- GRU仍然不能完全解决梯度消失问题, 同时其作用RNN的变体, 有着RNN结构本身的一大弊端, 即不可并行计算, 这在数据量和模型体量逐步增大的未来, 是RNN发展的关键瓶颈.
-
小节总结:
- GRU（Gated Recurrent Unit）也称门控循环单元结构, 它也是传统RNN的变体, 同LSTM一样能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时它的结构和计算要比LSTM更简单, 它的核心结构可以分为两个部分去解析:
- 更新门
- 重置门
- GRU（Gated Recurrent Unit）也称门控循环单元结构, 它也是传统RNN的变体, 同LSTM一样能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时它的结构和计算要比LSTM更简单, 它的核心结构可以分为两个部分去解析:
+ 内部结构分析:
- 和之前分析过的LSTM中的门控一样, 首先计算更新门和重置门的门值, 分别是z(t)和r(t), 计算方法就是使用X(t)与h(t-1)拼接进行线性变换, 再经过sigmoid激活. 之后重置门门值作用在了h(t-1)上, 代表控制上一时间步传来的信息有多少可以被利用. 接着就是使用这个重置后的h(t-1)进行基本的RNN计算, 即与x(t)拼接进行线性变化, 经过tanh激活, 得到新的h(t). 最后更新门的门值会作用在新的h(t)，而1-门值会作用在h(t-1)上, 随后将两者的结果相加, 得到最终的隐含状态输出h(t), 这个过程意味着更新门有能力保留之前的结果, 当门值趋于1时, 输出就是新的h(t), 而当门值趋于0时, 输出就是上一时间步的h(t-1).
+ Bi-GRU与Bi-LSTM的逻辑相同, 都是不改变其内部结构, 而是将模型应用两次且方向不同, 再将两次得到的LSTM结果进行拼接作为最终输出. 具体参见上小节中的Bi-LSTM.
+ Pytorch中GRU工具的使用:
- 位置: 在torch.nn工具包之中, 通过torch.nn.GRU可调用.
+ GRU的优势:
- GRU和LSTM作用相同, 在捕捉长序列语义关联时, 能有效抑制梯度消失或爆炸, 效果都优于传统RNN且计算复杂度相比LSTM要小.
+ GRU的缺点:
- GRU仍然不能完全解决梯度消失问题, 同时其作用RNN的变体, 有着RNN结构本身的一大弊端, 即不可并行计算, 这在数据量和模型体量逐步增大的未来, 是RNN发展的关键瓶颈.
weight_ih_l[k]
第k层的可学习输入隐藏权重的形状 (hidden_size, input_size)
对于“k=0”。否则，形状是 (hidden_size, num_directions * hidden_size)
weight_ih:
可学习输入隐藏权重的形状(hidden_size, input_size)
每个单词 的嵌入维度的 向量 作为 一个时间步 输入到 一个 RNN 节点，
然后 会和 神经元数量维度的 向量 构成一个 可学习输入隐藏权重 这样的 形状 (hidden_size, input_size)，
就是 (神经元数量, 单词嵌入维度)。
def __init__(self, mode, input_size, hidden_size,
num_layers=1, bias=True, batch_first=False, dropout=0.,
bidirectional=False):
#默认值bidirectional=False：那么“2 if False else 1”返回1，“2 if True else 1”返回2。
#如果RNN是双向的，num_directions应该是2，否则应该是1。
num_directions = 2 if bidirectional else 1
========================================================================
# nn.RNN(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
rnn = nn.RNN(5, 6, 2)
rnn = nn.GRU(5, 6, 2)
rnn = nn.LSTM(5, 6, 2)
# input of shape (seq_len, batch, input_size)：(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)
# input输入数据，torch.randn(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度)
input = torch.randn(4, 3, 5)
# h_0 of shape (num_layers * num_directions, batch, hidden_size)：
# RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)
# RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
# hn隐藏层数据，torch.randn(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)
h0 = torch.randn(2, 3, 6)
# c_0 of shape (num_layers * num_directions, batch, hidden_size)
# RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)
# RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
c0 = torch.randn(2, 3, 6)
output, hn = rnn(input, h0)
output, (hn, cn) = rnn(input, (h0, c0))
# output of shape (seq_len, batch, num_directions * hidden_size):
# RNN是单向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 1)
# RNN是双向：(当前批次的样本个数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量 * 2)
output.shape #torch.Size([4, 3, 6])
# h_n of shape (num_layers * num_directions, batch, hidden_size)
# RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)
# RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
hn.shape #torch.Size([2, 3, 6])
# c_n of shape (num_layers * num_directions, batch, hidden_size)
# RNN是单向：(隐藏层层数 * 1, 一个句子单词个数, 隐藏层中神经元数量)
# RNN是双向：(隐藏层层数 * 2, 一个句子单词个数, 隐藏层中神经元数量)
hn.shape #torch.Size([2, 3, 6])
========================================================================
Examples::
#nn.LSTM(输入数据的词嵌入维度 10, 隐藏层中神经元数量 20, 隐藏层层数 2)
>>> rnn = nn.LSTM(10, 20, 2)
#input输入数据，torch.randn(当前批次的样本个数 5, 当前样本的序列长度(单词个数) 3, 词嵌入维度 10)
>>> input = torch.randn(5, 3, 10)
#h0/hn隐藏层数据，torch.randn(隐藏层层数 2, 当前样本的序列长度(单词个数) 3, 隐藏层中神经元数量 20)
>>> h0 = torch.randn(2, 3, 20)
#c0/cn细胞状态数据，torch.randn(隐藏层层数 2, 当前样本的序列长度(单词个数) 3, 隐藏层中神经元数量 20)
>>> c0 = torch.randn(2, 3, 20)
>>> output, (hn, cn) = rnn(input, (h0, c0))
RNN
weight_ih:
可学习输入隐藏权重的形状(hidden_size, input_size)
每个单词 的嵌入维度的 向量 作为 一个时间步 输入到 一个 RNN 节点，
然后 会和 神经元数量维度的 向量 构成一个 可学习输入隐藏权重 这样的 形状 (hidden_size, input_size)，
就是 (神经元数量, 单词嵌入维度)。
nn.RNN(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
Xt：输入数据，shape为(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度影)，比如[1,3,5]。
h0：隐藏层数据，shape为(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)，比如[1,3,6]。
[Xt,ht-1]：通过concat(Xt,ht-1)把[1,3,5]和[1,3,6]进行列维度(最后一个维度)的拼接变成[1,3,11]。
Wt[Xt,ht-1]：concat拼接后的[1,3,11]乘以Wt的[11,6]变成[1,3,6]。
output是hn隐藏层中的最后一层输出，比如：
当隐藏层只有一层时，rnn的输出output和隐藏层数据hn 两者完全相同，shape均为[1,3,6]。
当隐藏层有多层时，rnn的输出output为隐藏层数据hn中的最后一个二维矩阵，比如hn为[2,3,6]，output的数据实际为hn中最后一个二维矩阵[1,3,6]。
LSTM
1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处的遗忘门中的通过sigmiod输出的ft便是一个0和1之间的小数值，ft用作在“细胞状态更新公式”中的ft*Ct-1，
因为ft本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ft*Ct-1表示使用ft这个百分值保留多少Ct-1的值。
1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处输入门中的通过sigmiod输出的it便是一个0和1之间的小数值，it用作在“细胞状态更新公式”中的it*Ct~，
因为it本身就是一个0和1之间的小数值(相当于一个百分比值)，那么it*Ct~表示使用it这个百分值保留多少Ct~的值。
1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如输入门中的通过sigmiod输出的it便是一个0和1之间的小数值，it用作在“细胞状态更新公式”中的it*Ct~，
因为it本身就是一个0和1之间的小数值(相当于一个百分比值)，那么it*Ct~表示使用it这个百分值保留多少Ct~的值。
3.比如遗忘门中的通过sigmiod输出的ft便是一个0和1之间的小数值，ft用作在“细胞状态更新公式”中的ft*Ct-1，
因为ft本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ft*Ct-1表示使用ft这个百分值保留多少Ct-1的值。
1.激活函数sigmiod的作用：用于帮助调节流经网络的值, sigmoid函数将值压缩在0和1之间的小数值(相当于一个百分比值)。
只要是sigmiod输出的百分比值(比如ft/it/ot) 都可作为控制阈值(保留信息比例值)，用于控制流经的数据保留多少。
2.比如此处输出门中的通过sigmiod输出的ot便是一个0和1之间的小数值，ot用作在“输出门更新公式”中的ot*tanh(Ct)，
因为ot本身就是一个0和1之间的小数值(相当于一个百分比值)，那么ot*tanh(Ct)表示使用ot这个百分值保留多少tanh(Ct)的值。
GRU
RNN和GRU.py
import torch
import torch.nn as nn
#nn.RNN(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
# rnn = nn.RNN(5, 6, 2)
rnn = nn.GRU(5, 6, 2)
#input输入数据，torch.randn(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度影)
input = torch.randn(4, 3, 5)
#hn隐藏层数据，torch.randn(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)
h0 = torch.randn(2, 3, 6)
"""
nn.GRU 和 nn.LSTM 和 nn.RNN中，output是hn隐藏层中的最后一层输出，有如下情况：
1.当前批量数据只有一个样本的情况：
1.当隐藏层只有一层时，rnn的输出output和隐藏层数据hn 两者完全相同，shape均为[1,3,6]。
比如output的shape均为[1,3,6]，[1,3,6]中的1表示一个样本，3表示样本的序列长度(单词个数)，6表示隐藏层中神经元数量。
2.当隐藏层有多层时，rnn的输出output实际为多层隐藏层数据hn中的最后一层数据。
比如隐藏层有4层，那么hn为[4,3,6]，output为[1,3,6]，hn的[4,3,6]中的4表示4层的隐藏层数据，
output的[1,3,6]实际为4层隐藏层中最后一层隐藏层的数据，即output的[1,3,6]中的[3,6]实际和hn中最后一个二维矩阵数据相同。
2.当前批量数据有多个样本的情况：
1.当隐藏层只有一层，批量数据有4个样本时，比如output.shape为[4, 3, 6]，hn.shape为[1, 3, 6]，
output的[4, 3, 6]中的4表示4个样本的输出数据，hn的[1, 3, 6]实际是批量数据样本中最后一个样本的输出数据，
即hn的[1, 3, 6]中的[3,6]实际和output中最后一个二维矩阵数据相同。
2.当隐藏层有多层时，比如有2层隐藏层，批量数据有4个样本时，output.shape为[4, 3, 6]，hn.shape为[2, 3, 6]。
output的[4, 3, 6]中的4表示4个样本的输出数据，hn的[2, 3, 6]中的2表示2层隐藏层数据，
只有output中的最后一个二维矩阵和hn中的最后一个二维矩阵相同，因为output是hn隐藏层中的最后一层输出的关系，
那么批量样本输出数据output中最后一个样本的输出数据和hn隐藏层中的最后一层的隐藏层数据相同。
"""
output, hn = rnn(input, h0)
print("output.shape",output.shape)
print("hn.shape",hn.shape)
print("output",output)
print("hn",hn)
LSTM.py
import torch.nn as nn
import torch
#nn.LSTM(输入数据的词嵌入维度, 隐藏层中神经元数量, 隐藏层层数)
rnn = nn.LSTM(5, 6, 2)
#input输入数据，torch.randn(当前批次的样本个数, 当前样本的序列长度(单词个数), 词嵌入维度影)
input = torch.randn(4, 3, 5)
#hn隐藏层数据，torch.randn(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)
h0 = torch.randn(2, 3, 6)
#cn细胞状态数据，torch.randn(隐藏层层数, 当前样本的序列长度(单词个数), 隐藏层中神经元数量)
c0 = torch.randn(2, 3, 6)
"""
nn.GRU 和 nn.LSTM 和 nn.RNN中，output是hn隐藏层中的最后一层输出，有如下情况：
1.当前批量数据只有一个样本的情况：
1.当隐藏层只有一层时，rnn的输出output和隐藏层数据hn 两者完全相同，shape均为[1,3,6]。
比如output的shape均为[1,3,6]，[1,3,6]中的1表示一个样本，3表示样本的序列长度(单词个数)，6表示隐藏层中神经元数量。
2.当隐藏层有多层时，rnn的输出output实际为多层隐藏层数据hn中的最后一层数据。
比如隐藏层有4层，那么hn为[4,3,6]，output为[1,3,6]，hn的[4,3,6]中的4表示4层的隐藏层数据，
output的[1,3,6]实际为4层隐藏层中最后一层隐藏层的数据，即output的[1,3,6]中的[3,6]实际和hn中最后一个二维矩阵数据相同。
2.当前批量数据有多个样本的情况：
1.当隐藏层只有一层，批量数据有4个样本时，比如output.shape为[4, 3, 6]，hn.shape为[1, 3, 6]，
output的[4, 3, 6]中的4表示4个样本的输出数据，hn的[1, 3, 6]实际是批量数据样本中最后一个样本的输出数据，
即hn的[1, 3, 6]中的[3,6]实际和output中最后一个二维矩阵数据相同。
2.当隐藏层有多层时，比如有2层隐藏层，批量数据有4个样本时，output.shape为[4, 3, 6]，hn.shape为[2, 3, 6]。
output的[4, 3, 6]中的4表示4个样本的输出数据，hn的[2, 3, 6]中的2表示2层隐藏层数据，
只有output中的最后一个二维矩阵和hn中的最后一个二维矩阵相同，因为output是hn隐藏层中的最后一层输出的关系，
那么批量样本输出数据output中最后一个样本的输出数据和hn隐藏层中的最后一层的隐藏层数据相同。
"""
output, (hn, cn) = rnn(input, (h0, c0))
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**
**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**
**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**
隐藏层有多层时，比如有2层隐藏层，批量数据有4个样本时，output.shape为[4, 3, 6]，hn.shape为[2, 3, 6]。
output的[4, 3, 6]中的4表示4个样本的输出数据，hn的[2, 3, 6]中的2表示2层隐藏层数据，
只有output中的最后一个二维矩阵和hn中的最后一个二维矩阵相同，因为output是hn隐藏层中的最后一层输出的关系，
那么批量样本输出数据output中最后一个样本的输出数据和hn隐藏层中的最后一层的隐藏层数据相同。
"""
output, (hn, cn) = rnn(input, (h0, c0))
[外链图片转存中...(img-aZMmKnKo-1715895268184)]
[外链图片转存中...(img-Qovz71DS-1715895268184)]
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**
**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**
**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**
5868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
