循环神经网络

最新推荐文章于 2025-02-13 09:00:00 发布

s_yangyang

最新推荐文章于 2025-02-13 09:00:00 发布

阅读量260

点赞数

CC 4.0 BY-SA版权

文章标签： rnn 人工智能深度学习

本文链接：https://blog.csdn.net/weixin_43460403/article/details/133889314

本文介绍了循环神经网络的基本概念，包括一对一到多对多的不同类型，以及如何构建和训练循环神经网络模型，如使用困惑度评估语言模型性能。以PyTorch为例，展示了如何实现一个简单的RNN模型并进行训练和预测。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

循环神经网络（RNN）是神经网络的一种。RNN将状态在自身网络中循环传递，可以接受时间序列结构输入。

1. 类型

一对一：固定的输入到输出，如图像分类
一对多：固定的输入到序列输出，如图像的文字描述
多对一：序列输入到输出，如情感分析，分类正面负面情绪
多对多：序列输入到序列的输出，如机器翻译,称之为编解码网络
同步多对多：同步序列输入到同步输出，如文本生成，视频每一帧的分类，也称之为序列生成

2. 基础循环网络介绍

$\mathbf{x_{t}}$ : 表示每一个时刻的输入
$\mathbf{o_{t}}$ : 表示每一个时刻的输出
$\mathbf{s_{t}}$ : 表示每一个隐层的输出
中间的小圆圈代表隐藏层的一个unit(单元)
所有单元的参数共享

通用公式表示:

$\mathbf{s_{0}=0}$
$\mathbf{s_{t} = g_{1}(U*x_{t}+W*s_{t-1}+b_{a})}$
$\mathbf{o_{t} = g_{2}(V*s_{t} + b_{y})}$

$\mathbf{g_{1},g_{2}}$ :表示激活函数

3. 困惑度

衡量一个语言模型的好坏可以用平均交叉熵 $\mathbf{\pi =\frac{1}{n}\sum_{i=1}^{n}-logp(x_{t}|x_{t-1}, ...)}$
p是语言模型的预测概率， $\mathbf{x_{t}}$ 是真实词
在最好的情况下，模型总是完美地估计标签词元的概率为1。在这种情况下，模型的困惑度为1。
在最坏的情况下，模型总是预测标签词元的概率为0。在这种情况下，困惑度是正无穷大。

4. 总结

对隐状态使用循环计算的神经网络称为循环神经网络（RNN）。
循环神经网络的隐状态可以捕获直到当前时间步序列的历史信息。
循环神经网络模型的参数数量不会随着时间步的增加而增加。
我们可以使用循环神经网络创建字符级语言模型。
我们可以使用困惑度来评价语言模型的质量。

5. 循环神经网络简洁实现

5.1 数据加载

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

batch_size, num_steps = 32, 35
# 自定义函数
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

5.2 定义模型

构造一个具有256个隐藏单元的单隐藏层的循环神经网络层rnn_layer。

# 隐藏单元数目
num_hiddens = 256
# len(vaocab)决定输出输出数量
rnn_layer = nn.RNN(len(vocab), num_hiddens)

使用张量来初始化隐状态，它的形状是（隐藏层数，批量大小，隐藏单元数）

state = torch.zeros((1, batch_size, num_hiddens))

通过一个隐状态和一个输入，我们就可以用更新后的隐状态计算输出。

X = torch.rand(size=(num_steps, batch_size, len(vocab)))
# 返回当前时刻的Y和state
Y, state_new = rnn_layer(X, state)
Y.shape, state_new.shape

为一个完整的循环神经网络模型定义了一个RNNModel类。

#@save
class RNNModel(nn.Module):
    """循环神经网络模型"""
    def __init__(self, rnn_layer, vocab_size, **kwargs):
        super(RNNModel, self).__init__(**kwargs)
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.num_hiddens = self.rnn.hidden_size
        # 如果RNN是双向的（之后将介绍），num_directions应该是2，否则应该是1
        if not self.rnn.bidirectional:
            self.num_directions = 1
            self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
        else:
            self.num_directions = 2
            self.linear = nn.Linear(self.num_hiddens * 2, self.vocab_size)

    def forward(self, inputs, state):
        X = F.one_hot(inputs.T.long(), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        # 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)
        # 它的输出形状是(时间步数*批量大小,词表大小)。
        output = self.linear(Y.reshape((-1, Y.shape[-1])))
        return output, state

    def begin_state(self, device, batch_size=1):
        if not isinstance(self.rnn, nn.LSTM):
            # nn.GRU以张量作为隐状态
            return  torch.zeros((self.num_directions * self.rnn.num_layers,
                                 batch_size, self.num_hiddens),
                                device=device)
        else:
            # nn.LSTM以元组作为隐状态
            return (torch.zeros((
                self.num_directions * self.rnn.num_layers,
                batch_size, self.num_hiddens), device=device),
                    torch.zeros((
                        self.num_directions * self.rnn.num_layers,
                        batch_size, self.num_hiddens), device=device))

5.3 训练与预测

device = d2l.try_gpu()
net = RNNModel(rnn_layer, vocab_size=len(vocab))
net = net.to(device)
d2l.predict_ch8('time traveller', 10, net, vocab, device)

输出：这种模型根本不能输出好的结果

'time travellerbbebbevbbe'

用定义的超参数调用train_ch8

num_epochs, lr = 500, 1
d2l.train_ch8(net, train_iter, vocab, lr, num_epochs, device)

输出：

perplexity 1.3, 103334.1 tokens/sec on cpu
time traveller came back andfilby s aneche oncell on the fire wi
travelleryou can show blad for an aromates if it entthew is

困惑度：