第十一周：机器学习笔记

摘要

本周周报主要讲述了注意力机制中更加细节的内容，周报讲述了相关的复杂性如果通过多头注意力机制解决的方法，并讲述了注意力机制如果通过位置编码方式解决先后位置的问题。此外，本周周报在注意力机制的章节中，将self-attention与CNN和RNN进行了比较以及其在实际场景的应用。在RNN的章节中，本周报详细描述了RNN的概念、RNN的变形拓展、以及LSTM。然后，本周报在Pytorch的章节，讲述了优化器的概念以及原理，并在最后展示了优化器使用的代码。

Abstract

This week’s weekly report mainly discusses the more detailed content of attention mechanism. The report discusses the methods to solve the related complexity through multi-head attention mechanism, and discusses how attention mechanism can solve the problem of sequential positions through position encoding. In addition, the report compared self attention with CNN and RNN in the attention mechanism section and showed the self-attention’s application in practical scenarios. In addition, this report provides a detailed description of the concept of RNN, and shows its variant derivatives as well as LSTM. Then, the chapter on Pytorch explains the concept and principles of optimizers, and finally presents the code used by optimizers.

机器学习

1. 注意力机制（下）

在继续学习注意力机制之前，先做一个简短的复习：
上一周我们求了b1，这一周来求b2进行复习

b3、b4的求法同理。

我们可以从另外一个角度——矩阵的角度来学习。
我们将a₁、a₂、…拼接成一个矩阵I，将q₁、q₂、…拼接成一个矩阵Q。
于是便有了下图所示的关系：

接下来，我们对其进行矩阵化的应用：
将k¹、k²、…当成列、q₁、q₂、…当作是行，相乘得到α的矩阵。
再将这个矩阵经过soft-max函数，最终得到α’。

再将下图的做一个矩阵的运算，就得到了b¹、b²、…。

1.1 multi-head self-attention（多头注意力机制）

从标题中我们就可以看出，这是一个很多head的self-attention模型。

为什么我们会需要比较多的head呢？
我们在做self-attention的时候，我们是用q找相关的k
但是相关这件事情有很多种不同的形式，有很多种不同的定义。
所以也许我们不能只有一个q，我们应该要有多个q，不同的q负责不同的不同种类的相关性。

你会怎么操作呢？
1、先把a呢乘上一个矩阵得到q

2、接下来再把q乘上另外两个矩阵，分别得到q¹跟q²
同理k和v进行相同的操作，得到k¹、k²与v¹、v²
另外一个位置也是同理
总体情况如下图所示：

3、接下来就是对应位置相乘（即qⁱ ¹对应kⁱ ¹，求出来的结果又对应vⁱ ¹等到bⁱ ¹）

bⁱ ²的计算也是同理

3、接下来再将计算到的bⁱ ¹、bⁱ ²接起来 再与一个矩阵Wº相乘得到最终的bⁱ

1.2 Positional Encoding（位置编码）

到目前为止啊，这个layer它少了一个很重要的信息
这个信息是什么呢？
这个信息是位置的信息
其实我们仔细思考可以得出，对self-attention而言，那个位置1、位置2、位置3、位置4，其实完全没有任何差别，所有的位置之间的距离都是一样的，没有任何一个位置距离比较远，也没有任何位置距离比较近，也没有谁在整个sequence的最前面，也没有谁在整个sequence的最后面。
因为这四个位置的操作其实是一模一样的。

这样会出现一些问题：
我们在做这个**POS tagging（词性标记）**的时
动词比较不容易出现在句首，所以如果某一个词汇它是放在句首的，那它是动词的可能性可能就比较低。
可是在我们到目前为止的操作里面，它根本就没有位置的信息。所以我们要用到 Positional Encoding（位置编码）技术来把位置的信息加进去
这个技术的说明如下：

为每一个位置设定一个vector，叫做positional vector，这边用eⁱ 来表示，上标i代表的是位置，不同的位置都有一个它专属的vector。
如果他看到说aⁱ 好像有被加上eⁱ ，就知道现在出现的位置应该是在i这个位置。

那eⁱ长什么样子呢？
如下图：每一个color就代表一个e，第一个位置就是e¹，第二个位置就是e²，第三个位置就是e³，以此类推。

这样子的positional vector是人为设计的，那人设的这个vector有很多问题
假设现在定这个vector的时候只定到128，那我现在sequence的长度如果是129怎么办呢？
但是今天的论文的研究实验中就不存在这个问题了，这个vector是透过某一个规则所产生的（是通过sin、cos方程所产生的），但是不一定非要用这种方式产生hand-craft positional vector，只是提供一种方法
positional encoding 依然是一个尚待研究的问题，如下图中有些是把positional encoding里面的数值当做network参数的一部分，直接learn出来也可以（右上方的图示）。

1.3 truncated self attention（截断式注意力机制）

self-attention还可以应用在许多的问题上
比如在做语音的时候，也可以用self-attention，
不过在做语音的时候，用self attention你可能会希望对self-attention做一些小小的改动
因为要把一段声音信号表示成一排向量的话，这排向量可能会非常的长。

之前的学习中，在做语音辨识的时候，要把声音序号表示成一排向量，而每一个向量其实只代表了10 ms（毫秒）的长度而已，所以如果今天是1s的声音讯号，它就有100个向量了；5s的声音讯号就500个向量了。也就是说你随便讲一句话，都是上千个向量了。
所以要描述一段声音信号的时候，ector的sequence的长度是非常可观的。
因此在计算这个attention matrix的时候，它的complexity是长度（L）的平方
（因为attention matrix的计算其实就是每个a与其他的a相乘获得的（包括其自身））

那随便讲一句话所产生的这个attention matrix可能会太大，大到你根本就不容易处理。不容易训练，所以怎么办呢？
在做语音的时候有一招叫做truncated self attention

‌Truncated Self-Attention‌
是一种在处理长序列数据时，为了限制计算复杂度和提高计算效率而对Self-Attention机制进行的一种优化。
在标准的Self-Attention机制中，每个位置都需要计算与序列中所有其他位置的注意力分数，这在处理长序列时会导致计算量呈平方级增长，从而成为瓶颈。
为了解决这个问题，Truncated Self-Attention通过限制每个位置注意力的计算范围，即只考虑序列中的一部分位置，来减少必要的计算量。
这种优化特别适用于需要处理长序列数据的场景，如自然语言处理和计算机视觉任务，其中序列可能非常长，如长篇文章或视频帧序列。

truncated self attention做的事情就是我们今天在做self attention的时候，不要看一整句话，我们就只看一个小的范围就好。
那至于这个范围应该要多大？这个是人为设定的
我们并不需要看整句话，因为只要看这句话跟他前后一定范围之内的信息就可以做出判断。
所以如果在做语音辨识的时候，也许没有必要看过一整个句子。
这样就可以加快运算的速度。

self-attention还可以用在图像识别中
我们都说self-attention的使用的范围是输入是一排向量的时候输入或者说是一个vector set的时候，之前在学习CNN的时候我们也学习到了
一张图片我们把它看作是一个很长的向量。那其实换一个观点，把它看作是一个vector set。
例子如下：
这张图可以看作是一个tensor
这个tensor的大小是5×10×3（3代表rgb这3个channel）
可以把每一个位置的pixel（像素）看作是一个3维的向量（x1，x2，x3），那整张图片其实就是5×10个向量
所以我们其实可以换一个角度来看影像，图像其实也是一个vector set

具体要怎么在图片上使用self-attention呢？
例子如下：
可以看到，一个卷积后生成

1.4 CNN v.s. self-attention ＆ RNN v.s. self-attention

CNN v.s. self-attention
在之前的学习中，我们学习到了CNN是只考虑receptive filed（感受野）的信息，但是感受野的范围始终是图像的一部分
但是self-attention因为覆盖了全图
所以我们可以称CNN为简化版的self-attention，或者说self-attention是复杂化的CNN。
如下图所示：

对CNN而言，我们要人为的去设置receptive field，但对于Self-attention来说，似乎receptive field是自主学习的**
因为我们用self-attention去找出相关的pixel，就好像是自动被学出来的。**，network自己决定receptive field的形状，比如以上图这个pixel为中心去找哪些pixel是我们真正需要考虑的，哪些pixel。是相关的，所以receptive field的范围不再是人工划定，而是让机器自己学出来。

如下图：
在这篇paper里面会用数学的方式严谨的告诉我们其实CNN就是self-attention的特例，self -attention只要设定合适的参数，它可以做到跟CNN一模一样的事情
self-attention是flexible的CNN
CNN是有受限制的self-attention

那么我们可以延伸到我们之前学习的知识
我们之前按说过：
越复杂的模型越是需要更多数据的train才不会导致overfitting，如果你data不够就有可能overfitting。
而简单的模型则不需要太多的data也可以trian，它适合在data小的少的时候，它可能比较不会overfitting。

下面是google的paper，其实把一张图片拆成16×16个patch，然后他把每一个patch就想象成是一个word
横轴是训练的图像的量

paper会发现：随着资料量越来越多，self attention的结果就越来越好，最终在资料量最多的时候，self attention可以超过CNN，但在资料量少的时候CNN它是可以比self attention得到更好的结果
这也印证了我们之前的理论：
越复杂的model需要越多的数据才能更好，因为self-attention就是复杂化的CNN

那CNN与self-attention谁比较好呢？

RNN v.s. self-attention
什么是RNN？

‌循环神经网络（‌RNN）是一种深度学习架构，专门用于处理序列数据，如时间序列或顺序数据。‌
 RNN通过其内部状态来展示动态时序行为，利用记忆来处理任意时序的输入序列，从而能够捕捉序列中的时序信息和语义信息。
 这种网络结构使得模型能够利用过去的信息来提高处理当前和未来输入的性能，特别适合处理长度不同的顺序数据以及解决自然信号分类、语言处理和视频分析等问题。

如下如所示：
RNN与self-attention一样，都是要处理input是一个sequence/vector set的情况
假设有一个memory的vector和一个input vector然后你有一个RNN的block
RNN就和结合这两个vector然后output一个vector 再进行fully connected，再做prediction

如果sequence里面第二个vector作为input的时候
会把第二个vector当做input，也会把前一个时间点吐出来，当做下一个时间点的输入，再丢进RNN里面，然后再产生新的vector，再拿去给fully connecting network做你想要做的事情
以此类推。。。
这就是RNN

RNN其实也可以考虑全部vector，但是其要放在memory里面，一步一步传下去，不是平行的。
self-attention可以考虑全部vector，且是平行的，所以其效果会更好。
所以self-attention是由于RNN的

1.6 self-attention在garph中的应用（GNN）

self-attention也可以用在graph中，但不同上面的是graph中的edge以及提示了node与node之间的关联性（自带关联性），因此不需要我们使用self-attention再去计算attention score

所以当把self attention用在graph上面的时候，在做这个attention match计算的时候，只计算有edge相连的node就好了。
比如，在这个图上哦node 1跟node 8有相连，那我们只需要计算node 1跟node 8这两个向量之间的attention分数，以此类推。
那如果两个node之间没有相连，那其实就暗示我们这两个node之间没有关系，既然没有关系，我们就不需要再去计算它的attention score，直接把它设为零就好了。
就类似与我们学习数据结构时的graph时需要的二维图表来表示图中各节点的关系。
其实把self-attention按照我们这种限制用在graph上面的时候，其实就是一种graph neural never，也就是一种gnn

如下图：
self-attention的变形现在都叫做xx former
往右代表它运算的速度
这个纵轴代表是performer
所以有很多各式各样新的former，他们的速度会比原来的transformer快，但是快的速度带来的就是performer变差

2. Recurrent Neural Network（RNN，循环神经网络）

槽填充(Slot Filling)
什么是slot filling？
如下图所示
比如有一个智慧订票系统，顾客输入他的行程需求
智慧系统就要提取关键词，填入到slot（目的地、到达时间）

那这个问题要怎么实现呢？
我们可以用一个feedforward neural network（前馈神经网络）来完成。
input就是一个词汇

2.1 词汇vector的编码方式

1-of-N encoding
词汇肯定要变成vector来表示，那么我们有最经典的表达方式 1-of-N encoding
（即有多少个词汇就有多少个向量；向量的维度等同于词汇的数量）
每个词汇表达的方式，如下图所示：

又或者我们对1-of-N encoding的编码方式做出一些改进
改进方式1：Dimension for “other”
因为我们的词汇实在是太多了，更何况还有一些人名之类的。把所有词汇按照上述方式编排，vector的维度和数量是不敢想象的。
因此我们可以设置一个other来表示其他没有见过的词汇（通过拓展一个dimension来表示other）

改进方式2：word hashing（字串比对）
可以用某一个词汇的字母来表示它的vector
如果你用某一个词汇的字母的来表示那个vector的话呢，你就不会有某一个词汇不在词典中的问题。

word hashing（字串比对）
仅用于英文中。
具体以bool这个单词为例，分为三个步骤：
1.在bool两端添加临界符#bool#
2.采用n-gram的方式分成多个部分，如果是trigrams那么结果是[#bo, boo, ool, ol#]
3.最终bool将会用[#bo, boo, ool, ol#]的向量来表示
不难发现，hashing后的结果[#bo, boo, ool, ol#] 每个letter长度都是3个字母，因此成为tri-letter。
单词词表很大，很容易出现OOV，OOV(Out-Of-Vocabulary)是指在自然语言处理中遇到的未知单词。
但是word hashing后，词表不再是单词，而是每个letter，也就是词根，这样词表规模就会小很多。

无论我们用以上哪一种方式，我们都可以将词汇转化为vector作为feedforward neural network的input。
然后output是一个probability distribution（概率分布）
这个probability distribution代表是我们现在input的这个词汇属于每一个slot的几率。
这样就完成了slot filling的任务。
比如TaiBei属于destination的几率 或 属于time of departure的几率

但是如果单纯的使用feedforward neural network会出现一些问题，如下图所示：

这种有记忆的network叫做RNN（Recurrent Neural Network，循环神经网络）
在RNN中，hidden layer的输出不会被遗忘，而是会被记住。在下一次输出的时候，会连同input与这些hidden layer 的 output一同考虑，最后再输出。
所以即使是相同的内容，在RNN里面受memory里面一些hidden layer output的影响，也会有不同的输出

假设现在这个下图中的这个network它所有的weight呢都是1，然后所有的neuron都没有任何的bias，所有的activation function都是linear。
那现在假设我们的input是一个sequence
$$inputsequence=\left[\begin{array}{c}1\\ 1\end{array}\right]\left[\begin{array}{c}1\\ 1\end{array}\right]\left[\begin{array}{c}2\\ 2\end{array}\right]\dots \dots$$
例子如下：

一开始的memory是没东西的，算作是0 0

RNN的特别之处就来了，刚刚得出的绿色部分的2会被写入memory中。

然后会被当做input的一部分

然后[6,6]放入memory

以上个结果的计算过程如下：

具体将其运用到我们刚刚的智慧订票系统，如下：
注：这里不是3个network，而是同1个network在3个不同的时间点被使用了3次

所以即使是同一个Taipei的输入，但是由于memory的内容不同，所以其output的结果也不同。
9
RNN也是可以deep
我们只需把每层的hidden layer的记录在memory，然后再与对应层的input相关联即可
不过input也可能是某一个hidden layer的output罢了。
注：这里不是3个network，而是同一个network在3个不同的时间点被使用了3次

2.2 RNN的变形

1.Jordan Network
recurrent neural network有不同的变形
我们刚刚学习的是Elman Network（就是记忆hidden layer的值）

而Jordan Network就是把最后output的值记忆下来，然后再倒过去影响input的值。
相比于Elman Network 在Jordan Network里面这个y它是有target的，所以可以比较清楚我们放在memory里面的是什么样的东西。

2.Bidirectional RNN（双向性RNN）
你input一个句子的话，它就是从句首一直读到句尾
但是它的读取方向也可以是反过来的

可以同时train一个正向的recurrent neural network，又同时train一个逆向的recurrent network
把这两个recurrent neural network的hidden layer拿出来都接给一个output layer，得到最后的y
以此类推，产生y^(t+1) 与y^(t+2)

2.3 Long Short Term Memory（LSTM,长短期记忆网络）

刚才的memory是最简单的
即我们随时都可以把值呢存到memory里面去，也可以随时把值呢从memory里面读出来
但现在比较常用的memory呢，称之为long short term memory（长短期记忆网络）
LSTM通过引入记忆单元（memory cell）和门控机制（gate mechanism），有效地捕捉序列数据中的长期依赖关系。
具体如下：

更详细的结构如下图所示：
在要被存到cell里面的input叫做z
操控input gate signal叫做z_i。
操控Forget Gate 叫做z_f
注意：Forget Gate有点反直觉，因为我们说等于1的时候一般是开启，等于0的时候一般是关闭。
这里的z_f = 1时，表示任然记住原来的值（保留）；z_f = 0的时候，则忘记原来的值；。
操作Output Gate 叫做z_o。
假设我们现在cell里面在有这个四个输入之前，它里面已经存了值c
z_i、z_f跟z_o（即控制阀门的input），通过的activation function通常我们会选择sigmoid function。
选择sigmoid方程的意义就是sigmoid方程只是记在0到1之间，而这个0到1之间的值代表了这个gate被打开的程度。
如果activation function的output是1，代表gate是处于被打开的状态；反之，代表这个gate是被关起来的。

举个例子说明：
network 只有一个LSTM cell
input都是三维的vector
output都是一维的vector

如下如所示

我们带入到刚刚的memory cell模型中，实际做一下运算
3个input值再乘上3个weight的再加上bias，得到activation function 的 input


其实我们在学习LSTM的使用，无非就是把neuron换成LSTM就可以了
但是又有所差别
对于LSTM来说，这四个input都不一样**（因为weight和bias不同）**。
一般的neural network只需要部分的参数，但LSTM还要操控另外三个gate，所以它需要四倍的参数。

但是我们还是无法深刻的体会到Recurrent Neural network的模型。
假设一整排的LSTM里面每一个memory里面都存了一个scalar（值），把所有的scalar接起来就变成了一个vector，写为c^t-1

每一个memory里面存的scalar就代表这个vector里面的一个dimension

在时间点t时input一个vector x^t，把x^t乘上一个matrix变成z
z个vector的每一个dimension就代表了操控每一个LSTM的input（就正好是LSTM的memory cell的数量）
第一维就丢给第一个cell，第二维就丢给第二个cell，以此类推。

x^t 也会乘上一个transform 得到zⁱ
同z一样，zⁱ的每一个dimension都会去操控一个memory，不过是操控其input gate
经过x^t乘上不同的transform，求出来的z^f、z^o也同理，分别操控forget gate与output gate

这四个vector合起来就会去操控这些memory cell的运作
注意：这四个z其实都是vector丢到memory里面的值其实只是每一个vector的一个dimension
因为每一个input的dimension都是不一样的，所以每一个cell input值都会是不一样，但是所有的值是可以共同一起被运算

计算过程如下：

这个process就反复的继续下去，在下一个时间点input x^t+1 重复上述操作即可。

2.3.1 LSTM最终形态

但是这个不是LSTM的最终形态，这个只是一个si3plified version（简化版本）
真正的LSTM会把hidden layer的输出呢接进来，当做下一个时间点的input。
也就是说下一个时间点操控这些gate的值不是只看那个时间点的input x^t+1，还看前一个时间点的output h^t。

其实还不止这样
还会加一个东西叫做peephole(窥视孔)
peephole(窥视孔)就是把存在memory cell里面的值也拉过来作为input
所以在操纵LSTM的四个gate的时候
同时考虑了x、同时考虑了h、同时考虑了c
把这三个vector并在一起乘上4个不同的transform，得到这四个不同的vector再去操控LSTM。

通常不会只有一层，一般要叠个五六层，如下图所示
非常复杂
当用RNN做了什么事情的时候，其实就是用LSTM。

Pytorch学习

1. 优化器代码实战

上一周，我们学习了反向传播算法，了解到了使用backward()可以计算出grad，为更新参数提供依据，这个依据可以为我们的优化器提供优化的方向，因此这一周我们开始学习优化器的代码实战。
优化器的定义方式如下：

说到学习率和动量，我们就有必要做一个简短的复习了：

动量：点击进入第五周周报（动量）链接

所谓动量就是用来对抗遇到saddle point和local minima的方法之一
下图为local minima与saddle point：

其原理类似于我们的物理的惯性
在我们真实的物理世界中，小球的下落伴随着有一定的惯性，遇到一个凹面，如果其下落的速度足够快，就可能冲出这个凹面。

解释如下：

学习率：点击进入第六周周报（学习率）链接

在之前的周报学习中，遇到critical point也是一件不容易的事情来引入对学习率的学习
我们遇到的训练卡顿，多数时候training在还没有走到critical point的时候就已经停止了，说不定就是一直在反复横跳，而并非遇到了critical point

特制化的learning rate怎么做呢？
从刚才的例子里面，其实我们可以学习到一个原则：
1、如果在某一个方向上我们的gradient的值很小，即在某一个方向上非常的平坦，那我们会希望learning rate调大一点。
2、如果在某一个方向上我们的gradient的值很大，即在某一个方向上非常的非常的陡峭，那我们那我们会希望learning rate可以调小一点。

$${\mathbf{\theta }}_i^{\mathbf{t}+1}\leftarrow {\mathbf{\theta }}_i^{\mathbf{t}}-\frac{\eta }{{\sigma }_i^t}{\mathbf{g}}_i^{\mathbf{t}}$$

σ与η组合叫做Parameter dependent（参数依赖）

于是便有了：
1、Root Mean Square（RMS，均方根）、 RMSProp

2、Learning Rate Scheduling（学习率调整策略）
例如：

learning rate decay（学习率衰减）： 随着时间不断的进行，随着参数不断的update，让η越来越小。
这个也是合理的。因为一开始我们距离终点很远。随着参数不断update，我们距离终点越来越近，所以我们把learning rate减小，让参数的更新踩一个刹车，让我们参数的更新能够慢下来。

Warm up（学习率预热）： learning rate要先变大再后变小。

具体点击链接进行复习即可

接下来我们开始优化器的代码实战：

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

datasets = torchvision.datasets.CIFAR10(root='./datasets', train=False, transform=torchvision.transforms.ToTensor(),
                                        download=True)

dataloader = DataLoader(datasets, batch_size=1)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.model1 = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2, 2),
            nn.Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        x = self.model1(x)
        return x


net = Net()
# 引入交叉熵损失函数
loss_cross = nn.CrossEntropyLoss()
# 定义优化器，Learning rate 不能太大\太小，因为训练效果会很差\很慢，一般先大再慢慢减小
optimizer = torch.optim.SGD(net.parameters(), lr=0.01)

# 一个epoch为一轮，如果我们只跑一轮没什么效果，因为只是把不同的图片给过了一遍
for epoch in range(20):
    # 每一轮都把running_loss设置为0
    running_loss = 0.0
    for data in dataloader:
        images, labels = data
        outputs = net(images)
        # 让结果经过一次损失函数
        result_loss = loss_cross(outputs, labels)
        optimizer.zero_grad()
        result_loss.backward()
        optimizer.step()
        # 把一轮中每一次计算到的loss求和
        running_loss += result_loss.item()
    # 最后输出每一轮的总loss
    print(running_loss)

可以看到，我们的优化器再不断的优化参数，减少我们的loss

总结

本周学习的内容还是比较丰富的，具体表现在理论学习方面中，并且在其中也进行了较多的复习回顾，但是下周开始进入校内课程的学习，所以进度会有所减缓。
在机器学习的部分中，主要对上一周的注意力机制进进行进行了学习。通过提出相关的复杂性问题引入了multi-head self-attention（多头注意力机制），通过设置更多的相关性参数来完成更加精确的判断。然后又学习了Positional Encoding（位置编码），用了一个词性辨析的案例来解释位置在注意力机制的重要性。如果没有位置编码，那么对所有的input来说，它们的计算都没有先后顺序，就没有任何差别了。然后还学习了截断式注意力机制，主要是为了解决在语音辨析中vector过长的问题，通过截断简化，防止overfitting。最后对Self-attention与CNN和RNN进行了比较，通过比较我们得知，CNN其实就是特殊化或者简化版的Self-attention；self-attention能比RNN的表现更好。最后，我们还将注意力机制引入到图表中，也就是所谓的RNN。除此之外，本周我还学习了RNN，通过一个智慧订票系统，了解了vector的编码方式，例如：1-of-N encoding以及其改进版Dimension for “other”、word还有hashing（字串比对）的编码方式。最后还学习了RNN中的核心——LSTM，其有4个input和一个output，其中有三个input分被控制3个gate（input gate、output gate、forget gate），这三个input的activation function都是sigmoid（范围在0~1，表示打开的程度），一个input就是输入memory cell的
，output就是从memory cell的输出结果，最后学习了LSTM的完全体，学习到了peephole等概念。
在pytorch的部分中，主要对优化器中的参数，例如学习率η、动量m是如何影响gradient descent的过程的，以及其原理进行了回顾。然后对优化器的代码进行了学习，了解了各个参数的意义，以及其是如何跟backward联动起来的，最后对CIFAR-10的图片进行了20轮的训练，发现在优化器的帮助下，loss也一直在减少。
下一周计划学习李宏毅机器学习视频继续学习RNN，并开始学习GNN模型，此外还要学习B站Pytorch中的网络模型修改以及其使用，尽量在后面的学习中加快学习的脚步。