🎬个人简介：一个全栈工程师的升级之路！
📋个人专栏：pytorch深度学习
🎀CSDN主页 发狂的小花
🌄人生秘诀：学习的本质就是极致重复!
《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibili
目录
1 全连接
2 矩阵乘法的本质
3 循环神经网络（RNN）
3.1 引入RNN的前言
3.2 RNN
3.3 RNN cell
1 全连接
FC，也加Linear Layer，Dense Layer。在全连接层中，每个神经元与前一层的每个神经元都有连接，每一个连接都有一个权重，形成一个完全连接的网络结构。
获得全局视野，放在神经网络的最后，用来做分类，完成全部特征的信息共享和特征融合，将隐层特征空间逐步映射到样本空间，比如ResNet50会输出1000个特征的得分值，这1000个特征的得分值，遍可以对应到图像的分类。
由于全连接需要当前的每一个神经元与前一层的每一个神经元相连，这样需要的权重参数是巨大的。
2 矩阵乘法的本质
资源的整合和再创。
假设有金酒、利口酒、柠檬汁、可乐四种原料，可以用来调制鸡尾酒。
自由古巴： 0.2 x 金酒+ 0.45 x 利口酒 + 0.1 x 柠檬汁 + 0.25 x 可乐
长岛冰茶： 0.6 x 金酒+ 0.3 x 利口酒 + 0.05 x 柠檬汁 + 0.05 x 可乐
龙舌兰日出：0.3 x 金酒+ 0.1 x 利口酒 + 0.3 x 柠檬汁 + 0.3 x 可乐
可以用矩阵乘法来表示，中间的是权重矩阵。
左矩阵是1行4列，代表原料。右矩阵是4行3列，每一列代表对应鸡尾酒的原料配比。
按照矩阵乘法的规则，他们的结果应该是一个1行3列的矩阵，分别代表调配出的三种鸡尾酒。 由此可以清晰的看出矩阵乘法的对资源的整合和再创。对应在深度学习中，我们得到多张Feature Map后转到1维后，就是得到了图像的多种尺度下的各个特征，然后进行全连接时，我们利用权重矩阵与之相乘后相加，就是对各个特征进行了整合和再创，最后按照分类的数量来输出。
3 循环神经网络（RNN）
3.1 引入RNN的前言
- 为什么不用全连接处理序列数据？
看这个连接
理解RNN的结构+特点+计算公式_rnn结构-CSDN博客
比如预测天天气，就需要知道之前几天的数据，每一天的数据都包含若个特征，需要若干天的数据作为输入
假设现在取前3天，每一天有3个特征
把x1,x2,x3拼成有9个维度的长向量，然后去训练最后一天是否有雨
用全连接进行预测，如果输入的序列很长，而且每一个序列维度很高的话，对网络的训练有很大挑战，全连接层需要的权重很多，这点我们上面已经说过。
- 为什么卷积神经网络的权重比较少呢？
卷积使用了权重共享，整张图像的卷积核是共享的，并不是图像的每一个像素要和下一层的Feature Map建立连接，权重少。
3.2 RNN
用于处理一些具有前后关系的序列问题。
循环神经网络（Recurrent Neural Network, RNN）是一类以序列数据为输入，在序列的演进方向进行递归且所有节点（循环单元）按链式连接的递归神经网络。常见的循环神经网络包括双向循环神经网络（Bidirectional RNN, Bi-RNN）和长短期记忆网络（Long Short-Term Memory networks，LSTM）。循环神经网络的真正形式是左边这种，但是也常表现为右边这种，一般隐藏层初始状态为0，当输入x1后，计算出下一个状态h1，当输入x2时，隐藏层状态输入变为h1，这时再输出一个新的状态h2，依次类推。
RNN专门用来处理带有序列模式的数据，也使用权重共享减少需要训练的权重的数量
我们把x1,x2,x3,xn看成是一个序列，不仅考虑x1,x2之间的连接关系，还考虑x1,x2的时间上的先后顺序
x2依赖于x1,x3依赖于x2,下一天的天气状况部分依赖于前一天的天气状况，RNN主要处理这种具有序列连接的
天气，股市，金融，自然语言处理都是序列数据
3.3 RNN cell
本质上是一个线性层，把一个维度映射到另一个维度。
RNN cell作为线性层是共享的，展开是后面，RNN cell可以依据不同的输入和输出循环调用。
运算过程：
h0和x1经过某种运算将他们拼接在一起，即：分别做线性变换，然后求和，生成h1。然后把h1,作为输出送到下一次RNN cell计算中，这次输入变成x2，x2和h1合在一起运算，生成h2等。
具体计算过程：
输入xt先做线性变换，h t-1也是，xt的维度是input_size,h t-1的维度是hidden_size,输出ht的维度是hidden_size，我们需要先把xt的维度变成hidden_size,所以Wih应该是一个 hidden_size*input_size的矩阵，Wih * xt得到一个 hidden_size*1的矩阵（就是维度为hidden_size的向量），bih是偏置。输入权重矩阵Whh是一个hidden_size* hidden_size的矩阵。
whhHt-1+bhh和WihXt+bih都是维度为hidden_size的向量，两个向量相加，就把信息融合起来了，融合之后用tanh做激活，循环神经网络的激活函数用的是tanh,因为tanh的取值在-1到+1之间，算出结果得到隐藏层输出ht。
把RNN Cell以循环的方式把序列（x1,x2,…）一个一个送进去，然后依次算出隐藏层(h1,h2…)的过程,每一次算出来的h会作为下一个RNN Cell的输入，这就叫循环神经网络 。
RNN 和RNN cell：
【PyTorch学习笔记】21：nn.RNN和nn.RNNCell的使用-CSDN博客
（1）RNN cell
每次向网络中输入batch个样本，每个时刻处理的是该时刻的batch个样本。例如，输入3句话，每句话包含10个单词，每个单词用100维向量表示，那么 seq_len = 10，batch = 3，feature_len = 100
import torch
batch_size=1
seq_len=3
input_size=4
hidden_size=2
Cell=torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)#初始化，构建RNNCell
dataset=torch.randn(seq_len,batch_size,input_size)#设置dataset的维度
print(dataset)
hidden=torch.zeros(batch_size,hidden_size)#隐层的维度：batch_size*hidden_size，先把h0置为0向量
for idx,input in enumerate(dataset):
print('='*10,idx,'='*10)
print('Input size:',input.shape)
hidden=Cell(input,hidden)
print('Outputs size:',hidden.shape)
print(hidden)
（2）RNN构造
import torch
batch_size=1
seq_len=3
input_size=4
hidden_size=2
num_layers=1
cell=torch.nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers)
#构造RNN时指明输入维度，隐层维度以及RNN的层数
inputs=torch.randn(seq_len,batch_size,input_size)
hidden=torch.zeros(num_layers,batch_size,hidden_size)
out,hidden=cell(inputs,hidden)
print('Output size:',out.shape)
print('Output:',out)
print('Hidden size:',hidden.shape)
print('Hidden',hidden)
4 RNN 训练hello 转换到ohlol
#使用RNN
import torch
input_size=4
hidden_size=4
num_layers=1
batch_size=1
seq_len=5
# 准备数据
idx2char=['e','h','l','o'] # 0 1 2 3
x_data=[1,0,2,2,3] # hello
y_data=[3,1,2,3,2] # ohlol
# e h l o
one_hot_lookup=[[1,0,0,0],
[0,1,0,0],
[0,0,1,0],
[0,0,0,1]] #分别对应0,1,2,3项
x_one_hot=[one_hot_lookup[x] for x in x_data] # 组成序列张量
print('x_one_hot:',x_one_hot)
# 构造输入序列和标签
inputs=torch.Tensor(x_one_hot).view(seq_len,batch_size,input_size)
print(inputs)
labels=torch.LongTensor(y_data) #labels维度是: (seqLen * batch_size ，1)
print(labels)
# design model
class Model(torch.nn.Module):
def __init__(self,input_size,hidden_size,batch_size,num_layers=1):
super(Model, self).__init__()
self.num_layers=num_layers
self.batch_size=batch_size
self.input_size=input_size
self.hidden_size=hidden_size
self.rnn=torch.nn.RNN(input_size=self.input_size,
hidden_size=self.hidden_size,
num_layers=self.num_layers)
def forward(self,input):
hidden=torch.zeros(self.num_layers,self.batch_size,self.hidden_size)
out, _=self.rnn(input,hidden)
# 为了能和labels做交叉熵，需要reshape一下:(seqlen*batchsize, hidden_size),即二维向量，变成一个矩阵
return out.view(-1,self.hidden_size)
net=Model(input_size,hidden_size,batch_size,num_layers)
# loss and optimizer
criterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(), lr=0.05)
# train cycle
for epoch in range(20):
optimizer.zero_grad()
#inputs维度是: (seqLen, batch_size, input_size) labels维度是: (seqLen * batch_size * 1)
#outputs维度是: (seqLen, batch_size, hidden_size)
outputs=net(inputs)
loss=criterion(outputs,labels)
loss.backward()
optimizer.step()
_, idx=outputs.max(dim=1)
idx=idx.data.numpy()
print('Predicted: ',''.join([idx2char[x] for x in idx]),end='')
print(',Epoch [%d/20] loss=%.3f' % (epoch+1, loss.item()))
- Embeding 嵌入层
one-hot编码是稀疏的编码方式，转换为稠密的
独热编码向量维度过高；
独热编码向量稀疏，每个向量是一个为1其余为0；
独热编码是硬编码，编码情况与数据特征无关；
采用一种低维度的、稠密的、可学习数据的编码方式：Embedding。
Embedding把一个高维的稀疏的样本映射到一个稠密的低维的空间里面，也就是数据的降维。
理解RNN的结构+特点+计算公式_rnn结构-CSDN博客
查询
输入为2，就表示是第二个字符的索引（索引从0开始），找到第2行，把这个向量输出，这就叫embedding
输入层必须是长整型张量，输出是（seqlen,4）
embedding初始化：
num_bedding: input 独热向量的维度
num_bedding() 和 embedding_dim()构成矩阵的宽度和高度
输入层必须是长整型张量，输出是（input shape,embedding_shape）
#Embedding编码方式
import torch
input_size = 4
num_class = 4
hidden_size = 8
embedding_size = 10
batch_size = 1
num_layers = 2
seq_len = 5
idx2char_1 = ['e', 'h', 'l', 'o']
idx2char_2 = ['h', 'l', 'o']
x_data = [[1, 0, 2, 2, 3]]
y_data = [3, 1, 2, 2, 3]
# inputs 维度为（batchsize，seqLen）
inputs = torch.LongTensor(x_data)
# labels 维度为（batchsize*seqLen）
labels = torch.LongTensor(y_data)
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
#告诉input大小和 embedding大小 ，构成input_size * embedding_size 的矩阵
self.emb = torch.nn.Embedding(input_size, embedding_size)
self.rnn = torch.nn.RNN(input_size=embedding_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True)
# batch_first=True，input of RNN:(batchsize,seqlen,embeddingsize) output of RNN:(batchsize,seqlen,hiddensize)
self.fc = torch.nn.Linear(hidden_size, num_class) #从hiddensize 到 类别数量的 变换
def forward(self, x):
hidden = torch.zeros(num_layers, x.size(0), hidden_size)
x = self.emb(x) # 进行embedding处理，把输入的长整型张量转变成嵌入层的稠密型张量
x, _ = self.rnn(x, hidden)
x = self.fc(x)
return x.view(-1, num_class) #为了使用交叉熵，变成一个矩阵（batchsize * seqlen,numclass）
net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
for epoch in range(15):
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
_, idx = outputs.max(dim=1)
idx = idx.data.numpy()
print('Predicted string: ', ''.join([idx2char_1[x] for x in idx]), end='')
print(", Epoch [%d/15] loss = %.3f" % (epoch + 1, loss.item())🌈我的分享也就到此结束啦🌈
如果我的分享也能对你有帮助，那就太好了！
若有不足，还请大家多多指正，我们一起学习交流！
📢未来的富豪们：点赞👍→收藏⭐→关注🔍，如果能评论下就太惊喜了！
感谢大家的观看和支持！最后，☺祝愿大家每天有钱赚！！！欢迎关注、关注！
