03RNN小项目（pytorch）（RNN概念理解为主）

RNN理论讲解视频推荐

昨天睡前在bilibili上找了一个up主AI研习图书馆的讲解视频https://www.bilibili.com/video/BV1dZ4y1g7DE，非常简短，二倍速的话能够很快学会其概念（含公式推理过程），自己也是从第一个视频看到了跟RNN有关的最后一个视频，进行了全面的复习。
借用上面视频中的两张视频中的图片：

使用RNN做项目

随着时代发展，pytroch越来越流行，所以专栏以pytorch为主（我的版本是1.6.0+cpu——官网下载whl（选择需要的版本，很快就下好了）：https://download.pytorch.org/whl/torch/），如果遇到了tensorflow的现成的项目，那就像tensorflow低头（我的tensorflow版本是1.13.1——https://github.com/tensorflow/tensorflow/releases/tag/v1.13.1下载压缩包，然后自行解压（记得好像有点慢，可以用迅雷下载，快得多，同样的，其他版本也是一样可以下载的），当然如何多个版本呢？这就需要看我以前总结的一篇关于virtualenv的文章。

项目A代码

附录1：

中文版：
Docstring:tensor（数据，dtype=None，device=None，requires\u grad=False，pin\u memory=False）->tensor
使用：attr:data构造张量。
… 警告：：
：func:torch.tensor始终复制：attr:data。如果你有张量数据若要避免复制，请使用：func:torch.Tensor.requires\u grad_
或者：func:torch.Tensor.detach。
如果您有一个NumPyndarray并希望避免复制，请使用
：func:torch.as_tensor。
… 警告：：
当数据是张量’x’，：func:‘torch.tensor’从传递的数据中读出’data’，
并构造一个叶变量。因此torch.tensor（x）相当于x.clone（）.detach（）
“torch.tensor（x，requires_grad=True）”相当于“x.clone（）.detach（）.requires_grad（True）”。
建议使用clone（）和detach（）进行等效。
Args:data（类似数组）：张量的初始数据。可以是列表、元组、NumPy ndarray、标量和其他类型。dtype（：class:torch.dtype，可选）：返回的张量的所需数据类型。默认值：如果没有，则根据：attr:data推断数据类型。设备（：class:torch.device，可选）：返回张量的所需设备。默认值：如果没有，则使用当前设备作为默认张量类型（请参阅：func:torch.set\u Default\u tensor\u type）：属性：设备将是CPU张量类型的CPU，而CUDA张量类型的当前CUDA设备。requires_grad（bool，可选）：If autograd应在返回的张量上记录操作。
默认值：False。pin_内存（bool，可选）：如果设置，返回的张量将分配到pined内存中。仅适用于CPU张量。
默认值：False.Docstring:tensor（数据，dtype=None，device=None，requires\u grad=False，pin\u memory=False）->tensor
使用：attr:data构造张量。
… 警告：：
：func:torch.tensor始终复制：attr:data。如果你有张量数据若要避免复制，请使用：func:torch.Tensor.requires\u grad_
或者：func:torch.Tensor.detach。
如果您有一个NumPyndarray并希望避免复制，请使用
：func:torch.as_tensor。
… 警告：：
当数据是张量’x’，：func:‘torch.tensor’从传递的数据中读出’data’，
并构造一个叶变量。因此torch.tensor（x）相当于x.clone（）.detach（）
“torch.tensor（x，requires_grad=True）”相当于“x.clone（）.detach（）.requires_grad（True）”。
建议使用clone（）和detach（）进行等效。
Args:data（类似数组）：张量的初始数据。可以是列表、元组、NumPy ndarray、标量和其他类型。dtype（：class:torch.dtype，可选）：返回的张量的所需数据类型。默认值：如果没有，则根据：attr:data推断数据类型。设备（：class:torch.device，可选）：返回张量的所需设备。默认值：如果没有，则使用当前设备作为默认张量类型（请参阅：func:torch.set\u Default\u tensor\u type）：属性：设备将是CPU张量类型的CPU，而CUDA张量类型的当前CUDA设备。requires_grad（bool，可选）：If autograd应在返回的张量上记录操作。
默认值：False。pin_内存（bool，可选）：如果设置，返回的张量将分配到pined内存中。仅适用于CPU张量。默认值：False。

官方案例：
Example::

>>> torch.tensor([[0.1, 1.2], [2.2, 3.1], [4.9, 5.2]])
tensor([[ 0.1000,  1.2000],
        [ 2.2000,  3.1000],
        [ 4.9000,  5.2000]])

>>> torch.tensor([0, 1])  # Type inference on data
tensor([ 0,  1])

>>> torch.tensor([[0.11111, 0.222222, 0.3333333]],
                 dtype=torch.float64,
                 device=torch.device('cuda:0'))  # creates a torch.cuda.DoubleTensor
tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64, device='cuda:0')

>>> torch.tensor(3.14159)  # Create a scalar (zero-dimensional tensor)
tensor(3.1416)

>>> torch.tensor([])  # Create an empty tensor (of size (0,))
tensor([])

Type: builtin_function_or_method

附录2

参数列表：
Init signature: torch.nn.Embedding(num_embeddings: int, embedding_dim: int, padding_idx: Union[int, NoneType] = None, max_norm: Union[float, NoneType] = None, norm_type: float = 2.0, scale_grad_by_freq: bool = False, sparse: bool = False, _weight: Union[torch.Tensor, NoneType] = None) -> None

中文版：
一个简单的查找表，用于存储固定字典和大小的嵌入项。
此模块通常用于存储单词嵌入并使用索引检索它们。
模块的输入是一个索引列表，输出是相应的索引单词嵌入。
Args：
num_embeddings（int）：嵌入字典的大小
嵌入_dim（int）：每个嵌入向量的大小
padding_idx（int，可选）：如果给定，则使用以下位置的嵌入向量填充输出：attr:padding_idx（初始化为零）每当遇到索引时。
max_norm（float，可选）：如果给定，则范数大于：attr:max_norm的每个嵌入向量被重整为具有norm:attr:max\u norm。
norm_type（float，可选）：要为：attr:max_norm选项计算的p-范数的p。默认值为“2”。
按频率缩放梯度（布尔值，可选）：如果给定，将按频率的倒数缩放渐变小批量中的单词。默认值为False。
稀疏（bool，可选）：如果True，梯度w.r.t.：attr:weight矩阵将是稀疏张量。
有关稀疏渐变的详细信息，请参见注释。
属性：
权重（张量）：形状模块的可学习权重（num\u嵌入，嵌入\u dim）
初始化自：math:\mathcal{N}（0，1）
形状：
-输入：：数学：（*），任意形状的长传感器，包含要提取的索引
-输出：：math:（*，H），其中*是输入形状，而：math:H=\text{embedding\\u dim}
… 注：：
请记住，只有有限数量的优化器支持稀疏渐变：当前为：class:optim.SGD（CUDA和CPU），
：class:optim.SparseAdam（CUDA和CPU）和：class:optim.Adagrad（CPU）
… 注：：
使用：attr:padding_idxset，在
：attr:padding_idx已初始化为全零。但是，请注意之后可以修改向量，例如，使用定制的初始化方法，从而更改用于填充输出。此向量的梯度来自：类：~torch.nn.Embedding总是零。

官方案例：
Examples::

>>> rnn = nn.RNN(10, 20, 2)
>>> input = torch.randn(5, 3, 10)
>>> h0 = torch.randn(2, 3, 20)
>>> output, hn = rnn(input, h0)

项目B代码：

附录3：

中文版：
Args：
input_size：输入中预期的特征数x
隐藏大小：处于隐藏状态的要素数量’hnum_layers：重复出现的层数。例如，设置``num_layers=2`` 这意味着将两个RNN堆叠在一起形成“堆叠RNN”， 第二个RNN接收第一个RNN的输出，并且 计算最终结果。默认值：1 非线性：使用的非线性。可以是“tanh”或“relu”。默认值：“tanh”`` 偏差：如果“False”，则层不使用偏差权重“b_ih”和“b_hh”。 默认值：Truebatch_first：如果“True”，则提供输入和输出张量 作为`（批、序列、特征）`。默认值：`False
辍学：如果非零，则在每个输出上引入“辍学”层
RNN层（最后一层除外），退出概率等于
：attr:dropout。默认值：0
双向：如果“True”，则变为双向RNN。默认值：False`` 输入：输入，h_0 -**输入**形状（顺序、批次、输入大小）：包含特征的张量 输入序列的类型。输入也可以是压缩可变长度 序列请参阅：func:torch.nn.utils.rnn.pack\u padded\u序列或：func:torch.nn.utils.rnn.pack_序列详情请参阅。 -**h\u 0**（层数*方向数，批次，隐藏大小）：张量
包含批处理中每个元素的初始隐藏状态。
如果未提供，则默认为零。如果RNN是双向的，
num_方向应为2，否则应为1。
输出：输出，h_n
-**形状（序列长度、批次、数量方向*隐藏大小）的输出**：张量 包含RNN最后一层的输出特征（h\u t）， 对于每个“t”。如果a:class:torch.nn.utils.rnn.PackedSequence作为输入，输出也将是压缩序列。 对于未包装的箱子，方向可以分开 使用``output.view（seq\u len，batch，num\u directions，hidden\u size），
向前和向后分别为方向“0”和“1”。
同样，方向可以在包装箱中分开。
-h\u n形状（层数*层数方向、批次、隐藏大小）：张量
包含“t=seq_len”的隐藏状态。
与output一样，可以使用
``视图（层数、方向数、批量、隐藏大小）```。
形状：
-数学：（L，N，H{in}）包含输入特征的张量，其中
：math:H{in}=\text{input\\u size}和L表示序列长度。
-数学：（S，N，H{out}）张量
包含批处理中每个元素的初始隐藏状态。
：数学：H{out}=\text{hidden\\u size}
如果未提供，则默认为零。其中：math:S=\text{num\\u layers}*\text{num\\u directions}
如果RNN是双向的，num_directions应该是2，否则应该是1。
-Output1:：math:（L，N，H{all}）where:math:H{all}=\text{num\\u directions}*\text{hidden\\u size}
-Output2:：math:（S，N，H{out}）包含下一个隐藏状态的张量
对于批次中的每个元素
属性：
weight_ih_l[k]：第k层的可学习输入隐藏权重，
“k=0”的形状“（隐藏大小，输入大小）”。否则，形状是
（隐藏大小、数量方向*隐藏大小）
权重[k]：第k层的可学习隐藏权重，
形状（隐藏大小，隐藏大小）
bias_ih_l[k]：第k层的可学习输入隐藏偏差，
形状为“”（隐藏大小）bias_hh_l[k]：第k层的可学习隐藏偏差， 形状为“”（隐藏大小）
… 注：：
所有权重和偏差都从以下位置初始化：math:\mathcal{U}（-\sqrt{k}、\sqrt{k}）
其中：math:k=\frac{1}{\text{hidden\\u size}
… 包括：：…/cudnn\u persistent\u rnn.rst

官方案例：
Examples::

>>> rnn = nn.RNN(10, 20, 2)
>>> input = torch.randn(5, 3, 10)
>>> h0 = torch.randn(2, 3, 20)
>>> output, hn = rnn(input, h0)

Init docstring: Initializes internal Module state, shared by both nn.Module and ScriptModule.