【PyTorch】深度学习实践 b站 第12讲RNN基础篇

最新推荐文章于 2023-03-12 21:32:57 发布
最新推荐文章于 2023-03-12 21:32:57 发布
阅读量3.7k 收藏 59
点赞数 25
分类专栏： NLP 文章标签： RNN pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_ps/article/details/114493682
版权

代码来源：https://github.com/EricPengShuai/Pytorch-Learning 如果有帮助的话求一个星星⭐️

Pytorch for RNN

B站 刘二大人 ，传送门PyTorch深度学习实践——循环神经网络(基础篇)
来源：https://www.bilibili.com/video/BV1Y7411d7Ys?p=12

How to use RNNCell

注意几个参数

  1. 输入和隐层（输出）维度

  2. 序列长度

  3. 批处理大小

  • 注 调用RNNCell这个需要循环，循环长度就是序列长度
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)

# (seq, batch, features)
dataset = torch.randn(seq_len, batch_size, input_size)
hidden = torch.zeros(batch_size, hidden_size)

# 这个循环就是处理seq_len长度的数据
for idx, data in enumerate(dataset):
    print('=' * 20, idx, '=' * 20)
    print('Input size:', data.shape, data)

    hidden = cell(data, hidden)

    print('hidden size:', hidden.shape, hidden)
    print(hidden)

输出结果

==================== 0 ====================
Input size: torch.Size([1, 4]) tensor([[ 1.9129, -0.7440,  0.2329,  1.3065]])
hidden size: torch.Size([1, 2]) tensor([[-0.0790, -0.8957]], grad_fn=<TanhBackward>)
tensor([[-0.0790, -0.8957]], grad_fn=<TanhBackward>)
==================== 1 ====================
Input size: torch.Size([1, 4]) tensor([[-0.6290, -0.2338, -0.2949,  0.3956]])
hidden size: torch.Size([1, 2]) tensor([[ 0.0170, -0.0005]], grad_fn=<TanhBackward>)
tensor([[ 0.0170, -0.0005]], grad_fn=<TanhBackward>)
==================== 2 ====================
Input size: torch.Size([1, 4]) tensor([[-0.6959,  1.0590, -0.6798,  0.6989]])
hidden size: torch.Size([1, 2]) tensor([[0.4216, 0.6813]], grad_fn=<TanhBackward>)
tensor([[0.4216, 0.6813]], grad_fn=<TanhBackward>)

How to use RNN

确定几个参数

  1. input_size和hidden_size: 输入维度和隐层维度
  2. batch_size: 批处理大小
  3. seq_len: 序列长度
  4. num_layers: 隐层数目
  • 注 直接调用RNN这个不用循环
  • 注：如果使用batch_first: if True, the input and output tensors are provided as:(batch_size, seq_len, input_size)
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)

# (seqLen, batchSize, inputSize)
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)        # (seq_len, batch_size, hidden_size)
print('Output:', out)
print('Hidden size:', hidden.shape)     # (num_layers, batch_size, hidden_size)
print('Hidden:', hidden)

输出结果

Output size: torch.Size([3, 1, 2])
Output: tensor([[[ 0.3689,  0.5982]],

        [[ 0.1233,  0.2617]],

        [[-0.3517, -0.7246]]], grad_fn=<StackBackward>)
Hidden size: torch.Size([1, 1, 2])
Hidden: tensor([[[-0.3517, -0.7246]]], grad_fn=<StackBackward>)

Example: Using RNNCell

Hello --> ohlol

  1. 首先需要将输入的单词转成向量one-hot vector
  2. 注意input_size，如下图

RNN_example

注意交叉熵在计算loss的时候维度关系

这里的hidden是([1, 4]), label是 ([1])

源代码

数据准备
import torch
input_size = 4
hidden_size = 4
batch_size = 1

idx2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 3, 3]    # hello中各个字符的下标
y_data = [3, 1, 2, 3, 2]    # ohlol中各个字符的下标

one_hot_lookup = [[1, 0, 0, 0],
                  [0, 1, 0, 0],
                  [0, 0, 1, 0],
                  [0, 0, 0, 1]]
x_one_hot = [one_hot_lookup[x] for x in x_data] # (seqLen, inputSize)

inputs = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
labels = torch.LongTensor(y_data).view(-1, 1)   # torch.Tensor默认是torch.FloatTensor是32位浮点类型数据，torch.LongTensor是64位整型
print(inputs.shape, labels.shape)

输出结果：

torch.Size([5, 1, 4]) torch.Size([5, 1])
构建模型
import torch.nn as nn

class Model(nn.Module):
    def __init__(self, input_size, hidden_size, batch_size):
        super(Model, self).__init__()
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.rnncell = nn.RNNCell(input_size=self.input_size, hidden_size=self.hidden_size)

    def forward(self, inputs, hidden):
        hidden = self.rnncell(inputs, hidden)   # (batch_size, hidden_size)
        return hidden

    def init_hidden(self):
        return torch.zeros(self.batch_size, self.hidden_size)

net = Model(input_size, hidden_size, batch_size)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.1)
训练数据
epochs = 15

for epoch in range(epochs):
    loss = 0
    optimizer.zero_grad()
    hidden = net.init_hidden()
    print('Predicted string:', end='')
    for input, label in zip(inputs, labels):
        hidden = net(input, hidden)
        # 注意交叉熵在计算loss的时候维度关系，这里的hidden是([1, 4]), label是 ([1])
        loss += criterion(hidden, label)
        _, idx = hidden.max(dim = 1)
        print(idx2char[idx.item()], end='')
    loss.backward()
    optimizer.step()
    print(', Epoch [%d/15] loss=%.4f' % (epoch+1, loss.item()))

输出结果：

Predicted string:lhlhh, Epoch [1/15] loss=6.8407
Predicted string:lllll, Epoch [2/15] loss=5.2957
Predicted string:lllol, Epoch [3/15] loss=4.9344
Predicted string:lllol, Epoch [4/15] loss=4.7035
Predicted string:oolol, Epoch [5/15] loss=4.4781
Predicted string:oolol, Epoch [6/15] loss=4.2419
Predicted string:ohlol, Epoch [7/15] loss=3.9733
Predicted string:ohlol, Epoch [8/15] loss=3.6942
Predicted string:ohlol, Epoch [9/15] loss=3.4917
Predicted string:ohloo, Epoch [10/15] loss=3.3837
Predicted string:ohloo, Epoch [11/15] loss=3.2953
Predicted string:ohlol, Epoch [12/15] loss=3.1331
Predicted string:ohlol, Epoch [13/15] loss=2.9294
Predicted string:ohlol, Epoch [14/15] loss=2.7344
Predicted string:ohlol, Epoch [15/15] loss=2.5680

Example: Using RNN

注意inputs和labels的维度

  • inputs维度是: (seqLen, batch_size, input_size)
  • labels维度是: (seqLen * batch_size)

注意outputs维度，对应和labels做交叉熵的维度

  • outputs维度是: (seqLen, batch_size, hidden_size)
  • 为了能和labels做交叉熵，需要reshape一下: outputs.view(-1, hidden_size)

源代码

数据准备
import torch
input_size = 4
hidden_size = 4
batch_size = 1
seq_len = 5
num_layers = 1

idx2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 3, 3]    # hello中各个字符的下标
y_data = [3, 1, 2, 3, 2]    # ohlol中各个字符的下标

one_hot_lookup = [[1, 0, 0, 0],
                  [0, 1, 0, 0],
                  [0, 0, 1, 0],
                  [0, 0, 0, 1]]
x_one_hot = [one_hot_lookup[x] for x in x_data] # (seqLen, inputSize)

inputs = torch.Tensor(x_one_hot).view(seq_len, batch_size, input_size)
labels = torch.LongTensor(y_data)  
print(inputs.shape, labels.shape)

输出结果：

torch.Size([5, 1, 4]) torch.Size([5])
构建模型
import torch.nn as nn

class Model(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 = nn.RNN(input_size=self.input_size, hidden_size=self.hidden_size, )

    def forward(self, inputs):
        hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)
        out, _ = self.rnn(inputs, hidden)    # 注意维度是(seqLen, batch_size, hidden_size)
        return out.view(-1, self.hidden_size) # 为了容易计算交叉熵这里调整维度为(seqLen * batch_size, hidden_size)

net = Model(input_size, hidden_size, batch_size)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.1)
训练模型
epochs = 15

for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = net(inputs) 
    # print(outputs.shape, labels.shape)
    # 这里的outputs维度是([seqLen * batch_size, hidden]), labels维度是([seqLen])
    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/15] loss = %.3f' % (epoch + 1, loss.item()))

输出结果：

Predicted:  ololl, Epoch [1/15] loss = 1.189
Predicted:  ollll, Epoch [2/15] loss = 1.070
Predicted:  ollll, Epoch [3/15] loss = 0.976
Predicted:  ohlll, Epoch [4/15] loss = 0.883
Predicted:  ohlol, Epoch [5/15] loss = 0.788
Predicted:  ohlol, Epoch [6/15] loss = 0.715
Predicted:  ohlol, Epoch [7/15] loss = 0.652
Predicted:  ohlol, Epoch [8/15] loss = 0.603
Predicted:  ohlol, Epoch [9/15] loss = 0.570
Predicted:  ohlol, Epoch [10/15] loss = 0.548
Predicted:  ohlol, Epoch [11/15] loss = 0.530
Predicted:  ohlol, Epoch [12/15] loss = 0.511
Predicted:  ohlol, Epoch [13/15] loss = 0.488
Predicted:  ohlol, Epoch [14/15] loss = 0.462
Predicted:  ohlol, Epoch [15/15] loss = 0.439

将一个单词变成vector

One-hot encoding of words and characters

  • one-hot vectors high-dimension --> lower-dimension

  • one-hot vectors sparse --> dense

  • one-hot vectors hardcoded --> learn from data

Embedding

ont_hot_VS_embedding.png
embedding.png

源代码

构建模型
import torch.nn as nn

# parameters
num_class = 4 
input_size = 4 
hidden_size = 8 
embedding_size = 10 
num_layers = 2 
batch_size = 1 
seq_len = 5

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.emb = torch.nn.Embedding(input_size, embedding_size)
        self.rnn = nn.RNN(input_size=embedding_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_class)

    def forward(self, x):
        hidden = torch.zeros(num_layers, x.size(0), hidden_size)
        x = self.emb(x)                 # (batch, seqLen, embeddingSize) 
        x, _ = self.rnn(x, hidden)      # 输出(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆, 𝒔𝒆𝒒𝑳𝒆𝒏, hidden_size)
        x = self.fc(x)                  # 输出(𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆, 𝒔𝒆𝒒𝑳𝒆𝒏, 𝒏𝒖𝒎𝑪𝒍𝒂𝒔𝒔)
        return x.view(-1, num_class)    # reshape to use Cross Entropy: (𝒃𝒂𝒕𝒄𝒉𝑺𝒊𝒛𝒆×𝒔𝒆𝒒𝑳𝒆𝒏, 𝒏𝒖𝒎𝑪𝒍𝒂𝒔𝒔)
        
net = Model()

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
准备数据并训练
idx2char = ['e', 'h', 'l', 'o'] 
x_data = [[1, 0, 2, 2, 3]]  # (batch, seq_len) 
y_data = [3, 1, 2, 3, 2]    # (batch * seq_len)

inputs = torch.LongTensor(x_data)   # Input should be LongTensor: (batchSize, seqLen)
labels = torch.LongTensor(y_data)   # Target should be LongTensor: (batchSize * seqLen)

epochs = 15

for epoch in range(epochs):
    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: ', ''.join([idx2char[x] for x in idx]), end='') 
    print(', Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))

输出结果：

Predicted:  ollll, Epoch [1/15] loss = 1.290
Predicted:  olooo, Epoch [2/15] loss = 1.071
Predicted:  ollol, Epoch [3/15] loss = 0.913
Predicted:  ollol, Epoch [4/15] loss = 0.785
Predicted:  ollol, Epoch [5/15] loss = 0.660
Predicted:  ohlol, Epoch [6/15] loss = 0.541
Predicted:  ohlol, Epoch [7/15] loss = 0.435
Predicted:  ohlol, Epoch [8/15] loss = 0.343
Predicted:  ohlol, Epoch [9/15] loss = 0.251
Predicted:  ohlol, Epoch [10/15] loss = 0.171
Predicted:  ohlol, Epoch [11/15] loss = 0.121
Predicted:  ohlol, Epoch [12/15] loss = 0.081
Predicted:  ohlol, Epoch [13/15] loss = 0.052
Predicted:  ohlol, Epoch [14/15] loss = 0.036
Predicted:  ohlol, Epoch [15/15] loss = 0.025
说明

可以看到使用embedding之后收敛的更快了，说明模型的学习能力变强了

一荤配一素
关注
专栏目录
Pytorch十二讲 RNN基础（部分笔记）
Cccc__0的博客
03-10 1737
第12讲 循环神经网络基础篇（部分笔记） B站 刘二大人 传送门：《PyTorch深度学习实践》完结合集 仅把RNN代码复制了过来 ################################################################################ # 刘二大人 RNN基础test1 # 1.RNNCELL ###########################################################################
Pytorch深度学习实践第十二讲 RNN 课后1（LSTM）
weixin_46047643的博客
03-31 941
B站 刘二大人 传送门 循环神经网络（基础篇） 课件链接：https://pan.baidu.com/s/1vZ27gKp8Pl-qICn_p2PaSw 提取码：cxe4 模型还是将输入“hello”训练输出为“ohlol”，用LSTM网络实现。按照计算图实现LSTM之后，又尝试了加入embedding的方法。加embedding的训练快，但是我的LSTM效果不如前面RNN的，不知道是我网络写的有问题还是怎么回事。 LSTM的网络结构示意图和公式： 根据我自己的理解写出来的LSTM模型，有不对的地方
Pytorch 深度学习实践 第12讲
进击的扛把子
12-28 210
import torch from torch.utils.data import Dataset from torch.utils.data import DataLoader import gzip import csv import time import math import matplotlib.pyplot as plt import numpy as np # prepare dataset class NameDataset(Dataset): def __init__(sel
Pytorch深度学习实践第十二讲 循环神经网络（基础篇）
THE FUTURE's blog
11-09 1092
import torch input_size=4 hidden_size=4 batch_size=1 # 准备数据 idx2char=['e','h','l','o'] x_data=[1,0,2,2,3] # hello y_data=[3,1,2,3,2] # ohlol one_hot_lookup=[[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]] #分别对应
刘二大人《Pytorch深度学习与实践》12循环神经网络基础篇
m0_58327216的博客
02-10 1539
RNN的模型中包括两种模块一种是RNNCell模块，另一种是RNN模块，我把这两个模块放在一个代码段里，其中RNNCell模块用''''''掩藏了，只要删除掉这个符号就行 代码如下 import torch batch_size = 1 # 一次输入多少个input_size seq_len = 3 # 一个句子被分为几份进行输入 input_size = 4 # 一次选择多少个句子进行输入 hidden_size = 2 num_layers = 1 # ==========RNNCell模
view()和squeeze()函数区别
feifeiyaa的博客
01-10 1014
最近调程序的时候，需要将三维变为二维，想到使用==squeeze()==这个函数，在使用的时候，发现squeeze（）它只能对维数中含有1的降维，例如： X = torch.rand(40, 10,128) # size:[40,10,128] Y = torch.rand(1, 10,128) # size:[1,10,128] X = X.squeeze(0) ...
Pytorch深度学习实践第十二讲 RNN 课后2（GRU）
weixin_46047643的博客
04-01 645
B站 刘二大人 传送门 循环神经网络（基础篇） 课件链接：https://pan.baidu.com/s/1vZ27gKp8Pl-qICn_p2PaSw 提取码：cxe4 模型还是将输入“hello”训练输出为“ohlol”，用GRU网络实现。按照计算图实现GRU之后，像前面一样又尝试了加入embedding的方法，效果略有改进。 GRU的网络结构示意图和公式： 下面的公式和上面一样，就是写法不同。 首先看公式有6个线性层，之后又进行了非线性运算，所以模型定义了6个linear。输入是4维向量（h、
【B站_刘二大人pytorch深度学习实践】笔记作业代码合集
最新发布
m0_58586235的博客
03-12 2947
手动训练：线性模型，梯度下降，BP Pytorch框架训练：线性回归，LogisticRegression，多维特征输入，加载数据集，多分类，CNN，RNN
Pytorch深度学习实践 第十二讲 循环神经网络（基础篇）
m0_55519533的博客
07-24 1778
循环神经网络RNN：用来处理有序列关系的输入，比如预测天气时，今天的天气要依赖于上一天的天气数据，多用于天气、股票、自然语言处理等。 RNN Cell结构 所有的RNN Cell是同一个Linear模块，只不过是循环使用它对不同的输入序列来进行计算和更新权重： 初始化H0=0，是个向量 for Xi in X: Hi = Linear(Xi, Hi-1) torch.nn.RNNCell()模块 seqLen是序列长度，即x1~x3 inputSize是每个...
(pytorch深度学习)利用三层网络实现数据分类
scarecrow_sun的博客
07-03 2765
目录写在前面深度学习的大致过程过程一、图像预处理化函数定义二、数据导入三、模型搭建 写在前面 这一段时间上课在学习简单的神经网络，最后结课的时候要求搭建一个简单的网络模型，并训练识别几类交通标志牌。写下博客记录，供日后学习。这个简易模型可以根据不同的数据集实现对不同的类别的图片识别。但是层数只有三层，只能训练简易的数据集。 深度学习的大致过程 这段时间的学习下来，我理解的深度学习的流程大致如下： #mermaid-svg-fFPt69gL2zAJivwr .label{font-family:'trebuc
Pytorch：pytorch中的多种训练模型写法
あずにゃん梓喵的博客
07-28 1850
日萌社 人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新） 1.optimizer优化器torch.optim、scheduler优化器步长自动调节器torch.optim.lr_scheduler #优化器 optimizer = torch.optim.SGD(model....
.view(-1)理解
dagewoshiwusong的博客
09-03 1万+
x = x.view(x.size(0), -1) 的理解
whut_ldz的博客
12-23 6万+
之前对于pytorch的网络编程学习都是大致理解每一层的概念，有些语法语句没有从原理上弄清楚，就比如标题的x = x.view(x.size(0), -1)  。 这句话一般出现在model类的forward函数中，具体位置一般都是在调用分类器之前。分类器是一个简单的nn.Linear()结构，输入输出都是维度为一的值，x = x.view(x.size(0), -1)  这句话的出现就是为了将
VS输出窗口（output view）的小技巧--文件行号字符定位
weixin_34413065的博客
11-12 458
在我们的调试输出到VS输出窗口的信息，有时候我们想要鼠标点击就定位该该文件，改行，甚至该列。在强大的VS工具中已经给我们提供了这个功能，我们只需要把输出到输出窗 口的字符串就是一定的格式化就可以了。c#在VS输出窗口格式为：文件名称（行号，列号）:消息信息。比如我 test.cs（100，78）:消息信息。就是对应我们的test.cs文件的100行78个字符。在这里我写了一个简单异常输出信息的扩...
智能数字图像处理：图卷积SGN代码（pytorch）之main.py解读
com_fang_bean的博客
09-15 2713
1.os.environ["CUDA_VISIBLE_DEVICES"] = '0'->目的：使用CUDA环境变量CUDA_VISIBLE_DEVICES来限定CUDA程序所能使用的GPU设备. 2.parser = argparse.ArgumentParser(description='Skeleton-Based Action Recgnition')-》创建解析器，使用 argparse 的第一步是创建一个 ArgumentParser 对象。 fit.add_fit_args(parser
python中view()函数怎么用？
热门推荐
知乎
11-19 8万+
初学者在使用pytorch框架定义神经网络时，经常会在代码中看到： 这样的用法。 view()的作用相当于numpy中的reshape，重新定义矩阵的形状。例如： import torch a = torch.range(1, 16)
Pytorch在训练过程中常见的问题
qq_42647047的博客
05-13 5335
转载自 ：https://oldpan.me/archives/pytorch-conmon-problem-in-training 1 Input type (CUDAFloatTensor) and weight type (CPUFloatTensor) should be the same 仔细看错误信息，CUDA和CPU，输入数据x和模型中的权重值类型不一样，一般来说是因为模型的参数不在GPU中，而输入数据在GPU中，通过添加model.cuda()将模型转移到GPU上以解决这个问题。 2 Inp
周报：PyTorch深度学习实践，CNN与RNN模型探索
"20210410周报总结，周宣辰的工作进展，涉及线性模型，CNN，RNN模型以及Pytorch深度学习实践" 这篇周报总结记录了某位名叫周宣辰的同学在2021年4月10日那一周的IT学习与研究进展，主要集中在深度学习领域，特别是...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值