Pytorch_RNN实例代码（低级篇）

最新推荐文章于 2024-06-27 00:45:07 发布

PocFeis

最新推荐文章于 2024-06-27 00:45:07 发布

阅读量606

点赞数 2

分类专栏： pytorch实例代码文章标签：深度学习 pytorch 自然语言处理

本文链接：https://blog.csdn.net/shen0oheng/article/details/115280797

版权

pytorch实例代码专栏收录该内容

2 篇文章 0 订阅

订阅专栏

该博客通过代码展示了如何在 PyTorch 中构建和训练 RNNCell 和 RNN 模块。首先，详细解释了如何使用 RNNCell 实现简单的序列预测任务，然后演示了 RNN 模块的用法。最后，引入了嵌入层（Embedding），将高维稀疏向量转化为低维稠密向量，进一步增强模型的表示能力。每个示例都包括模型定义、损失计算、反向传播和参数更新的过程。

摘要由CSDN通过智能技术生成

本文旨在代码实现，具体内容讲解请参考刘老师的视频：(https://www.bilibili.com/video/BV1Y7411d7Ys?p=12)

构建RNNCell模型以及直接调用RNN的代码如下：

import torch
input_size=4
hidden_size=4
batch_size=1
num_layers=1
idx2char=['e','h','l','o']
x_input=[1,0,2,2,3]
y_output=[3,1,2,3,2]
one_hot_lookup=[[0,1,0,0],
                [1,0,0,0],
                [0,0,1,0],
                [0,0,0,1]]
x_ont_hot=[one_hot_lookup[x] for x in x_input]
inputs=torch.Tensor(x_ont_hot).view(-1,batch_size,input_size)
labers=torch.LongTensor(y_output).view(-1,1)
       #RNNcell模块
class Model(torch.nn.Module):
    def __init__(self,input_size,hidden_size,batch_size):
        super(Model,self).__init__()
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.batch_size=batch_size
        self.runcell=torch.nn.RNNCell(input_size=self.input_size,hidden_size=
                                      self.hidden_size)
    def forward(self,inputs,hidden):
        hidden=self.runcell(inputs,hidden)
        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)
for epoch in range(15):
    loss=0
    optimizer.zero_grad()
    hidden=net.init_hidden()
    print('predict string:',end='')
    for inp,laber in zip(inputs,labers):
        hidden=net(inp,hidden)
        loss+=criterion(hidden,laber)
        _,idx=hidden.max(dim=1)
        print(idx2char[idx.item()],end='')
    loss.backward()
    optimizer.step()
    print(',Epoch [%d/15] loss=%.4f' %(epoch+1,loss.item()))
   
#RNN模块
'''seq_len=5
inputs=torch.Tensor(x_ont_hot).view(seq_len,batch_size,input_size)
labers=torch.LongTensor(y_output)
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.input_size=input_size
        self.hidden_size=hidden_size
        self.batch_size=batch_size
        self.rnn=torch.nn.RNN(input_size=self.input_size,hidden_size=
                                      self.hidden_size,num_layers=num_layers)
    def forward(self,inputs):
        hidden=torch.zeros(self.num_layers,self.batch_size,self.hidden_size)
        out,_=self.rnn(inputs,hidden)
        return out.view(-1,self.hidden_size)
net=Model(input_size,hidden_size,batch_size,num_layers)
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,labers)
    loss.backward()
    optimizer.step()
    _,idx=outputs.max(dim=1)
    idx=idx.data.numpy()
    print('predict string:',''.join([idx2char[x] for x in idx]),end='')
    print(',Epoch [%d/15] loss=%.3f' %(epoch+1,loss.item()))
    '''

下面的RNN_Embedding模型可以将高维稀疏的向量转变为低维稠密的向量:

import torch
num_class=4
input_size=4
hidden_size=8
embedding_size=10
batch_size=1
num_layers=2
seq_len=5
x_input=[[1,0,2,2,3]]
y_output=[3,1,2,3,2]
idx2char=['e','h','l','o']
inputs=torch.LongTensor(x_input)
labers=torch.LongTensor(y_output)        
class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        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)
        self.fc=torch.nn.Linear(hidden_size,num_class)
    def forward(self,x):
        hidden=torch.zeros(num_layers,x.size(0),hidden_size)
        x=self.emb(x)
        x,_=self.rnn(x,hidden)
        x=self.fc(x)
        return x.view(-1,num_class)       
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,labers)
    loss.backward()
    optimizer.step()
    _,idx=outputs.max(dim=1)
    idx=idx.data.numpy()
    print('predict string:',''.join([idx2char[x] for x in idx]),end='')
    print(',Epoch [%d/15] loss=%.3f' %(epoch+1,loss.item()))