【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练

这篇具有很好参考价值的文章主要介绍了【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、实验介绍

二、实验环境

1. 配置虚拟环境

2. 库版本介绍

三、实验内容

0. 导入必要的工具包

1. RNN与梯度裁剪

2. LSTM模型

3. 训练函数

a. train_epoch

b. train

4. 文本预测

5. GPU判断函数

6. 训练与测试

7. 代码整合


        经验是智慧之父,记忆是智慧之母。

——谚语

一、实验介绍

        本实验实现了基于 LSTM 的语言模型训练及测试

  • 基于门控的循环神经网络(Gated RNN)
    • 门控循环单元(GRU)
      • 门控循环单元(GRU)具有比传统循环神经网络更少的门控单元,因此参数更少,计算效率更高。GRU通过重置门更新门来控制信息的流动,从而改善了传统循环神经网络中的长期依赖问题。
    • 长短期记忆网络(LSTM)
      • 长短期记忆网络(LSTM)是另一种常用的门控循环神经网络结构。LSTM引入了记忆单元输入门输出门以及遗忘门等门控机制,通过这些门控机制可以选择性地记忆、遗忘和输出信息,有效地处理长期依赖和梯度问题。
  • LSTM示意图

【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练,深度学习实验,深度学习,rnn,人工智能

二、实验环境

        本系列实验使用了PyTorch深度学习框架,相关操作如下:

1. 配置虚拟环境

conda create -n DL python=3.7 
conda activate DL
pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html
conda install matplotlib
 conda install scikit-learn

2. 库版本介绍

软件包 本实验版本 目前最新版
matplotlib 3.5.3 3.8.0
numpy 1.21.6 1.26.0
python 3.7.16
scikit-learn 0.22.1 1.3.0
torch 1.8.1+cu102 2.0.1
torchaudio 0.8.1 2.0.2
torchvision 0.9.1+cu102 0.15.2

三、实验内容

0. 导入必要的工具包

import torch
from torch import nn
from d2l import torch as d2l

1. RNN与梯度裁剪

【深度学习实验】循环神经网络(一):循环神经网络(RNN)模型的实现与梯度裁剪_QomolangmaH的博客-CSDN博客https://blog.csdn.net/m0_63834988/article/details/133742433?spm=1001.2014.3001.5501

2. 自定义LSTM模型RNNModel

【深度学习实验】循环神经网络(三):门控制——自定义循环神经网络LSTM(长短期记忆网络)模型-CSDN博客https://blog.csdn.net/m0_63834988/article/details/133864731?spm=1001.2014.3001.5501

3. 训练函数

a. train_epoch

def train_epoch(net, train_iter, loss, updater, device, use_random_iter):
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和,词元数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化state
            state = net.begin_state(batch_size=X.shape[0], device=device)
        if isinstance(net, nn.Module) and not isinstance(state, tuple):
            # state对于nn.GRU是个张量
            state.detach_()
        else:
            # state对于nn.LSTM或对于我们从零开始实现的模型是个张量
            for s in state:
                s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了mean函数
            updater(batch_size=1)
        metric.add(l * d2l.size(y), d2l.size(y))
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()
  • 参数:

    • net:神经网络模型
    • train_iter:训练数据迭代器
    • loss:损失函数
    • updater:更新模型参数的方法(如优化器)
    • device:计算设备(如CPU或GPU)
    • use_random_iter:是否使用随机抽样
  • 函数内部定义了一些辅助变量:

    • state:模型的隐藏状态变量
    • timer:计时器,用于记录训练时间
    • metric:累加器,用于计算训练损失之和和词元数量
  • 函数通过迭代train_iter中的数据进行训练。每次迭代中,执行以下步骤:

    • 如果是第一次迭代或者使用随机抽样,则初始化隐藏状态state
    • 如果netnn.Module的实例并且state不是元组类型,则将state的梯度信息清零(detach_()函数用于断开与计算图的连接,并清除梯度信息)
    • 对于其他类型的模型(如nn.LSTM或自定义模型),遍历state中的每个元素,将其梯度信息清零
    • 将输入数据X和标签Y转移到指定的计算设备上
    • 使用神经网络模型net和当前的隐藏状态state进行前向传播,得到预测值y_hat和更新后的隐藏状态state
    • 计算损失函数loss对于预测值y_hat和标签y的损失,并取均值
    • 如果updatertorch.optim.Optimizer的实例,则执行优化器的相关操作(梯度清零、梯度裁剪、参数更新)
    • 否则,仅执行梯度裁剪和模型参数的更新(适用于自定义的更新方法)
    • 将当前的损失值乘以当前批次样本的词元数量,累加到metric
  • 训练完成后,函数返回以下结果:

    • 对数似然损失的指数平均值(通过计算math.exp(metric[0] / metric[1])得到)
    • 平均每秒处理的词元数量(通过计算metric[1] / timer.stop()得到)

b. train

def train(net, train_iter, vocab, lr, num_epochs, device, use_random_iter=False):
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',
                            legend=['train'], xlim=[10, num_epochs])

    if isinstance(net, nn.Module):
        updater = torch.optim.SGD(net.parameters(), lr)
    else:
        updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)

    for epoch in range(num_epochs):
        ppl, speed = train_epoch(
            net, train_iter, loss, updater, device, use_random_iter)
        if (epoch + 1) % 10 == 0:
            animator.add(epoch + 1, [ppl])
    print('Train Done!')
    torch.save(net.state_dict(), 'chapter6.pth')
    print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')
  • 参数
    • net(神经网络模型)
    • train_iter(训练数据迭代器)
    • vocab(词汇表)
    • lr(学习率)
    • num_epochs(训练的轮数)
    • device(计算设备)
    • use_random_iter(是否使用随机抽样)。
  • 在函数内部,它使用交叉熵损失函数(nn.CrossEntropyLoss())计算损失,创建了一个动画器(d2l.Animator)用于可视化训练过程中的困惑度(perplexity)指标。
  • 根据net的类型选择相应的更新器(updater
    • 如果netnn.Module的实例,则使用torch.optim.SGD作为更新器;
    • 否则,使用自定义的更新器(d2l.sgd)。
  • 通过迭代训练数据迭代器train_iter来进行训练。在每个训练周期(epoch)中
    • 调用train_epoch函数来执行训练,并得到每个周期的困惑度和处理速度。
    • 每隔10个周期,将困惑度添加到动画器中进行可视化。
  • 训练完成后,打印出训练完成的提示信息,并将训练好的模型参数保存到文件中('chapter6.pth')。
  • 打印出困惑度和处理速度的信息。

4. predict(文本预测)

        定义了给定前缀序列,生成后续序列的predict函数。

def predict(prefix, num_preds, net, vocab, device):
    state = net.begin_state(batch_size=1, device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.reshape(torch.tensor(
        [outputs[-1]], device=device), (1, 1))
    for y in prefix[1:]:  # 预热期
        _, state = net(get_input(), state)
        outputs.append(vocab[y])
    for _ in range(num_preds):  # 预测num_preds步
        y, state = net(get_input(), state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return ''.join([vocab.idx_to_token[i] for i in outputs])
  • 使用指定的device和批大小为1调用net.begin_state(),初始化state变量。
  • 使用vocab[prefix[0]]将第一个标记在prefix中对应的索引添加到outputs列表中。
  • 定义了一个get_input函数,该函数返回最后一个输出标记经过reshape后的张量,作为神经网络的输入。
  • 对于prefix中除第一个标记外的每个标记,通过调用net(get_input(), state)进行前向传播。忽略输出的预测结果,并将对应的标记索引添加到outputs列表中。

5. GPU判断函数

def try_gpu(i=0):
    """如果存在,则返回gpu(i),否则返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

6. 训练与测试

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()
lstm_layer = nn.LSTM(vocab_size, num_hiddens)
model_lstm = RNNModel(lstm_layer, vocab_size)
train(model_lstm, train_iter, vocab, lr, num_epochs, device)

print(predict('time ', 10, model_lstm, vocab, device))
  • 训练中每个小批次(batch)的大小和每个序列的时间步数(time step)的值分别为32,25

  • 加载的训练数据迭代器和词汇表

【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练,深度学习实验,深度学习,rnn,人工智能

  • vocab_size 是词汇表的大小,num_hiddens 是 LSTM 隐藏层中的隐藏单元数量,num_epochs 是训练的迭代次数,lr 是学习率。

  • 选择可用的 GPU 设备进行训练,如果没有可用的 GPU,则会使用 CPU。

  • 训练模型

【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练,深度学习实验,深度学习,rnn,人工智能文章来源地址https://www.toymoban.com/news/detail-724590.html

7. 代码整合

# 导入必要的库
import torch
from torch import nn
import torch.nn.functional as F
from d2l import torch as d2l
import math

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
        self.num_directions = 1
        self.linear = nn.Linear(self.num_hiddens, 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))


def train(net, train_iter, vocab, lr, num_epochs, device, use_random_iter=False):
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',
                            legend=['train'], xlim=[10, num_epochs])

    if isinstance(net, nn.Module):
        updater = torch.optim.SGD(net.parameters(), lr)
    else:
        updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)

    for epoch in range(num_epochs):
        ppl, speed = train_epoch(
            net, train_iter, loss, updater, device, use_random_iter)
        if (epoch + 1) % 10 == 0:
            animator.add(epoch + 1, [ppl])
    print('Train Done!')
    torch.save(net.state_dict(), 'chapter6.pth')
    print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')


# 在notebook中,若在训练后直接预测,会直接使用训练后的参数。
# 若想保存模型参数,请解除注释下面的代码,在实例化新的模型进行预测时,请记得读入模型。
# 读入模型的方法请参考前几章实现的Runner类。

#     torch.save(net.state_dict(), 'chapter6.pth')

def train_epoch(net, train_iter, loss, updater, device, use_random_iter):
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和,词元数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化state
            state = net.begin_state(batch_size=X.shape[0], device=device)
        if isinstance(net, nn.Module) and not isinstance(state, tuple):
            # state对于nn.GRU是个张量
            state.detach_()
        else:
            # state对于nn.LSTM或对于我们从零开始实现的模型是个张量
            for s in state:
                s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了mean函数
            updater(batch_size=1)
        metric.add(l * d2l.size(y), d2l.size(y))
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()


def predict(prefix, num_preds, net, vocab, device):
    state = net.begin_state(batch_size=1, device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.reshape(torch.tensor(
        [outputs[-1]], device=device), (1, 1))
    for y in prefix[1:]:  # 预热期
        _, state = net(get_input(), state)
        outputs.append(vocab[y])
    for _ in range(num_preds):  # 预测num_preds步
        y, state = net(get_input(), state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return ''.join([vocab.idx_to_token[i] for i in outputs])


def grad_clipping(net, theta):
    if isinstance(net, nn.Module):
        params = [p for p in net.parameters() if p.requires_grad]
    else:
        params = net.params
    norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))
    if norm > theta:
        for param in params:
            param.grad[:] *= theta / norm

def try_gpu(i=0):
    """如果存在,则返回gpu(i),否则返回cpu()"""
    # if torch.cuda.device_count() >= i + 1:
    #     return torch.device(f'cuda:{i}')
    return torch.device('cpu')

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()
lstm_layer = nn.LSTM(vocab_size, num_hiddens)
model_lstm = RNNModel(lstm_layer, vocab_size)
train(model_lstm, train_iter, vocab, lr, num_epochs, device)

print(predict('time ', 10, model_lstm, vocab, device))


到了这里,关于【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python深度学习026:基于Pytorch的典型循环神经网络模型RNN、LSTM、GRU的公式及简洁案例实现(官方)

    循环神经网络(也有翻译为递归神经网络)最典型的三种网络结构是: RNN(Recurrent Neural Network,循环神经网络) LSTM(Long Short-Term Memory,长短期记忆网络) GRU(Gate Recurrent Unit,门控循环单元) 理解参数的含义非常重要,否则,你不知道准备什么维度的输入数据送入模型 先

    2023年04月22日
    浏览(40)
  • 机器学习&&深度学习——循环神经网络RNN

    👨‍🎓作者简介:一位即将上大四,正专攻机器学习的保研er 🌌上期文章:机器学习深度学习—语言模型和数据集 📚订阅专栏:机器学习深度学习 希望文章对你们有所帮助 在之前介绍了n元语法模型,其中单词xt在时间步t的概率仅取决于前n-1个单词。对于时间步t-(n-1)之前

    2024年02月13日
    浏览(54)
  • 深度学习(2)---循环神经网络(RNN)

     1. 在深度学习中,序列数据(Sequence data)是指具有 前后顺序关联 的数据。常见的时间序列数据、文本数据(单词序列或字符序列)、语音数据等。这种数据不仅十分常见,而且往往具有很高的应用价值,比如我们可以通过过去的天气数据来预测未来的天气状况,通过以往

    2024年02月07日
    浏览(50)
  • 深度学习05-RNN循环神经网络

    循环神经网络(Recurrent Neural Network,RNN)是一种具有循环连接的神经网络结构,被广泛应用于自然语言处理、语音识别、时序数据分析等任务中。相较于传统神经网络,RNN的主要特点在于它可以处理序列数据,能够捕捉到序列中的时序信息。 RNN的基本单元是一个循环单元(

    2024年02月12日
    浏览(46)
  • 深度学习05-CNN循环神经网络

    循环神经网络(Recurrent Neural Network,RNN)是一种具有循环连接的神经网络结构,被广泛应用于自然语言处理、语音识别、时序数据分析等任务中。相较于传统神经网络,RNN的主要特点在于它可以处理序列数据,能够捕捉到序列中的时序信息。 RNN的基本单元是一个循环单元(

    2024年02月11日
    浏览(40)
  • 《动手学深度学习》学习笔记 第9章 现代循环神经网络

    书籍链接: 动手学深度学习 笔记是从第四章开始,前面三章为基础知识,有需要的可以自己去看看 关于本系列笔记: 书里为了让读者更好的理解,有大篇幅的描述性的文字,内容很多,笔记只保留主要内容,同时也是对之前知识的查漏补缺 《动手学深度学习》学习笔记 第

    2024年01月18日
    浏览(54)
  • 深度学习基础:循环神经网络中的长期依赖问题

    在深度学习中,循环神经网络(RNN)是一种经典的模型,用于处理序列数据,如自然语言处理、时间序列预测等任务。然而,传统的RNN存在着一个长期依赖问题,即在处理长序列时,模型往往难以捕捉到序列中远距离的依赖关系,导致性能下降。在本文中,我们将介绍长期依

    2024年04月28日
    浏览(40)
  • 深度学习实战——循环神经网络(RNN、LSTM、GRU)

           忆如完整项目/代码详见github: https://github.com/yiru1225 (转载标明出处 勿白嫖 star for projects thanks) 目录 系列文章目录 一、实验综述 1.实验工具及内容 2.实验数据 3.实验目标 4.实验步骤 二、循环神经网络综述 1.循环神经网络简介 1.1 循环神经网络背景 1.2 循环神经网络

    2023年04月24日
    浏览(44)
  • 深度学习实验3 - 卷积神经网络

    手写二维卷积的实现,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 使用torch.nn实现二维卷积,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 不同

    2024年02月14日
    浏览(49)
  • 《动手学深度学习 Pytorch版》 9.4 双向循环神经网络

    之前的序列学习中假设的目标是在给定观测的情况下对下一个输出进行建模,然而也存在需要后文预测前文的情况。 数学推导太复杂了,略。 双向循环神经网络(bidirectional RNNs)添加了反向传递信息的隐藏层,以便更灵活地处理此类信息。 前向和反向隐状态的更新如下:

    2024年02月07日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包