Pytorch深度学习实践笔记12（b站刘二大人）

最新推荐文章于 2024-07-20 06:19:20 发布

发狂的小花

最新推荐文章于 2024-07-20 06:19:20 发布

阅读量966

点赞数 28

分类专栏：人工智能 # pytorch深度学习文章标签：深度学习 pytorch python RNN 循环神经网络

本文链接：https://blog.csdn.net/m0_47324800/article/details/139268251

版权

人工智能同时被 2 个专栏收录

26 篇文章 2 订阅

订阅专栏

pytorch深度学习

12 篇文章 8 订阅

订阅专栏

🎬个人简介：一个全栈工程师的升级之路！
📋个人专栏：pytorch深度学习
🎀CSDN主页发狂的小花
🌄人生秘诀：学习的本质就是极致重复!

《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibili

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())

🌈我的分享也就到此结束啦🌈
如果我的分享也能对你有帮助，那就太好了！
若有不足，还请大家多多指正，我们一起学习交流！
📢未来的富豪们：点赞👍→收藏⭐→关注🔍，如果能评论下就太惊喜了！
感谢大家的观看和支持！最后，☺祝愿大家每天有钱赚！！！欢迎关注、关注！

发狂的小花

关注

28
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
Pytorch深度学习实践笔记12（b站刘二大人）

用于处理一些具有前后关系的序列问题。循环神经网络（Recurrent Neural Network, RNN）是一类以序列数据为输入，在序列的演进方向进行递归且所有节点（循环单元）按链式连接的递归神经网络。常见的循环神经网络包括双向循环神经网络（Bidirectional RNN, Bi-RNN）和长短期记忆网络（Long Short-Term Memory networks，LSTM）。循环神经网络的真正形式是左边这种，但是也常表现为右边这种，一般隐藏层初始状态为0，当输入x1后，计算出下一个状态h1，
复制链接

扫一扫