PyTorch实战：深入解析Seq2seq模型

最新推荐文章于 2024-07-28 15:37:27 发布
最新推荐文章于 2024-07-28 15:37:27 发布
阅读量855 收藏 24
点赞数 22
文章标签： pytorch 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbeely/article/details/139975824
版权
  1. Sequence-to-Sequence 简介

大多数常见的
sequence-to-sequence (seq2seq) model
为 encoder-decoder model，主要由两个部分组成，分别是
Encoder
和
Decoder
，而这两个部分大多数是由
recurrent neural network (RNN)
实现。

Encoder
是将一连串的输入，如文字、影片、声音讯号等，编码为单个向量，这个向量可以想像为整个输入的抽象表示，包含了整个输入的资讯。

Decoder
是將 Encoder 输出的向量进行逐步解码，一次输出一个结果，直到将最终的目标全部输出为止，每次输出会影响下一个输出，一般会在开始输入
< BOS >
来表示开始解码，会在结尾出输出
< EOS >
来表示解码结束。

  1. 任务介绍
  • 英文翻译为中文
    • 输入： 一句英文 （e.g. tom is a student .）
    • 输出： 中文翻译 （e.g. 汤姆 是 个 学生 。）
  1. 实现过程

首先要做的是下载资料，主要是用来下载本次任务需要的数据集

!gdown --id '1r4px0i-NcrnXy1-tkBsIwvYwbWnxAhcg' --output data.tar.gz
!tar -zxvf data.tar.gz
!mkdir ckpt
!ls

之后导入需要用到的包（如果
nltk
包没有下载的话，可使用第一段代码进行下载）

!pip3 install --user nltk


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.utils.data as data
import torch.utils.data.sampler as sampler
import torchvision
from torchvision import datasets, transforms

import numpy as np
import sys
import os
import random
import json

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 判斷是用 CPU 還是 GPU 執行運算

需要注意的是，不同的句子往往有着不同的长度，这无疑给训练带来了不小的麻烦（因为 RNN 的输入维度要进行相应的改变）。为了解决这个麻烦，我们使用
<pad>
长度较短的句子进行填充。因此这里定义一个长度转换的类

import numpy as np

class LabelTransform(object):
  def __init__(self, size, pad):
    self.size = size
    self.pad = pad

  def __call__(self, label):
    label = np.pad(label, (0, (self.size - label.shape[0])), mode='constant', constant_values=self.pad)
    return label

下一步就是数据的准备了，我们定义一个Dataset。

  • Data (出自manythings 的 cmn-eng):

    • 训练资料：18000句
    • 验证资料： 500句
    • 测试资料： 2636句

  • 资料预处理:

    • 英文：
      • 用 subword-nmt 套件将word转为subword
      • 建立字典：取出标签中出现频率高于预定阈值的subword
    • 中文：
      • 用 jieba 将中文句子进行断句
      • 建立字典：取出标签中出现频率高于预定阈值的词
    • 特殊字元： < PAD >, < BOS >, < EOS >, < UNK >
      • < PAD > ：无意义，将句子拓展到相同长度
      • < BOS > ：Begin of sentence, 开始字元
      • < EOS > ：End of sentence, 结尾字元
      • < UNK > ：单字沒有出现在字典里的字
    • 将字典里出现的 subword (词) 用一个整数表示，分为英文和中文的字典，方便之后转化为 one-hot vector
import re
import json

class EN2CNDataset(data.Dataset):
  def __init__(self, root, max_output_len, set_name):
    self.root = root

    self.word2int_cn, self.int2word_cn = self.get_dictionary('cn')
    self.word2int_en, self.int2word_en = self.get_dictionary('en')

    # 载入资料
    self.data = []
    with open(os.path.join(self.root, f'{set_name}.txt'), "r") as f:
      for line in f:
        self.data.append(line)
    print (f'{set_name} dataset size: {len(self.data)}')

    self.cn_vocab_size = len(self.word2int_cn)
    self.en_vocab_size = len(self.word2int_en)
    self.transform = LabelTransform(max_output_len, self.word2int_en['<PAD>'])

  def get_dictionary(self, language):
    # 载入字典
    with open(os.path.join(self.root, f'word2int_{language}.json'), "r") as f:
      word2int = json.load(f)
    with open(os.path.join(self.root, f'int2word_{language}.json'), "r") as f:
      int2word = json.load(f)
    return word2int, int2word

  def __len__(self):
    return len(self.data)

  def __getitem__(self, Index):
    # 先将中英文词分开
    sentences = self.data[Index]
    sentences = re.split('[\t\n]', sentences)
    sentences = list(filter(None, sentences))
    #print (sentences)
    assert len(sentences) == 2

    # 特殊字元
    BOS = self.word2int_en['<BOS>']
    EOS = self.word2int_en['<EOS>']
    UNK = self.word2int_en['<UNK>']

    # 在开头添加 <BOS>，在结尾添加 <EOS> ，不在字典的 subword (词) 用 <UNK> 取代
    en, cn = [BOS], [BOS]
    # 将句子拆解为 subword 并转为整数
    sentence = re.split(' ', sentences[0])
    sentence = list(filter(None, sentence))
    #print (f'en: {sentence}')
    for word in sentence:
      en.append(self.word2int_en.get(word, UNK))
    en.append(EOS)

    # 将句子拆解为 subword 并转为整数
    # e.g. < BOS >, we, are, friends, < EOS > --> 1, 28, 29, 205, 2
    sentence = re.split(' ', sentences[1])
    sentence = list(filter(None, sentence))
    #print (f'cn: {sentence}')
    for word in sentence:
      cn.append(self.word2int_cn.get(word, UNK))
    cn.append(EOS)

    en, cn = np.asarray(en), np.asarray(cn)

    # 用 <PAD> 將将句子拓展到相同长度
    en, cn = self.transform(en), self.transform(cn)
    en, cn = torch.LongTensor(en), torch.LongTensor(cn)

    return en, cn

接下来就是构建自己的模型

Encoder

  • seq2seq模型的编码器为RNN。对于每个输入，
    Encoder
    会输出
    一个向量
    和
    一个隐藏层状态(hidden state)
    ，并将隐藏层状态用于下一个输入，换句话说，
    Encoder
    会逐步读入输入序列。
  • 参数:
    • en_vocab_size 是英文字典的大小，也就是英文的 subword 的个数
    • emb_dim 是 embedding 的维度，主要将 one-hot vector 的单词向量压缩到指定的维度，可以使用预先训练好的 word embedding，如 Glove 和 word2vector
    • hid_dim 是 RNN 输出和隐藏状态的维度
    • n_layers 是 RNN 要叠多少层
    • dropout 是决定有多少的机率将某某个节点变为 0，主要是为了防止 overfitting ，一般来说是在训练集使用，测试集不使用
  • Encoder 的输入和输出:
    • 輸入:
      • 英文的整数序列 e.g. 1, 28, 29, 205, 2
    • 輸出:
      • outputs: 最上层 RNN 全部的输出，可以用 Attention 再进行处理
      • hidden: 每层最后的隐藏状态，将传输到后面的 Decoder 进行解码
class Encoder(nn.Module):
  def __init__(self, en_vocab_size, emb_dim, hid_dim, n_layers, dropout):
    super().__init__()
    self.embedding = nn.Embedding(en_vocab_size, emb_dim)
    self.hid_dim = hid_dim
    self.n_layers = n_layers
    self.rnn = nn.GRU(emb_dim, hid_dim, n_layers, dropout=dropout, batch_first=True, bidirectional=True)
    self.dropout = nn.Dropout(dropout)

  def forward(self, input):
    # input = [batch size, sequence len, vocab size]
    embedding = self.embedding(input)
    outputs, hidden = self.rnn(self.dropout(embedding))
    # outputs = [batch size, sequence len, hid dim * directions]
    # hidden =  [num_layers * directions, batch size  , hid dim]
    # outputs 是最上层RNN的输出
        
    return outputs, hidden

Decoder

  • Decoder
    是另一个 RNN，在最简单的 seq2seq decoder 中，仅使用
    Encoder
    对每一层最后的隐藏状态来进行解码，而这最好的的隐藏状态有些被称为 “content vector”，因为可以想象它对整个前文序列进行了编码， 此 “content vector” 用作
    Decoder
    的
    初始
    隐藏状态， 而
    Encoder
    的输出通常用于 Attention Mechanism 产生相应的 Attention。

  • 参数

    • en_vocab_size 是英文字典的大小，也就是英文的 subword 的个数
    • emb_dim 是 embedding 的维度，主要将 one-hot vector 的单词向量压缩到指定的维度，可以使用预先训练好的 word embedding，如 Glove 和 word2vector
    • hid_dim 是 RNN 输出和隐藏状态的维度
    • output_dim 是最终输出的维度，一般来说是将 hid_dim 转到 one-hot vector 的单词向量
    • n_layers 是 RNN 要叠多少层
    • dropout 是决定有多少的机率将某某个节点变为 0，主要是为了防止 overfitting ，一般来说是在训练集使用，测试集不使用
    • isatt 是来決定是否使用 Attention Mechanism

  • Decoder 的输入和输出:

    • 输入:
      • 前一次解码出來的单词的整数表示
    • 輸出:
      • hidden: 根据输入和前一次的隐藏转态，现在的隐藏转态的更新的结果
      • output: 每个字有多少概率是这次解码的结果
class Decoder(nn.Module):
  def __init__(self, cn_vocab_size, emb_dim, hid_dim, n_layers, dropout, isatt):
    super().__init__()
    self.cn_vocab_size = cn_vocab_size
    self.hid_dim = hid_dim * 2
    self.n_layers = n_layers
    self.embedding = nn.Embedding(cn_vocab_size, config.emb_dim)
    self.isatt = isatt
    self.attention = Attention(hid_dim)
    # 如果使用 Attention Mechanism 會使得輸入維度變化，請在這裡修改
    # e.g. Attention 接在輸入後面會使得維度變化，所以輸入維度改為
    # self.input_dim = emb_dim + hid_dim * 2 if isatt else emb_dim
    self.input_dim = emb_dim
    self.rnn = nn.GRU(self.input_dim, self.hid_dim, self.n_layers, dropout = dropout, batch_first=True)
    self.embedding2vocab1 = nn.Linear(self.hid_dim, self.hid_dim * 2)
    self.embedding2vocab2 = nn.Linear(self.hid_dim * 2, self.hid_dim * 4)
    self.embedding2vocab3 = nn.Linear(self.hid_dim * 4, self.cn_vocab_size)
    self.dropout = nn.Dropout(dropout)

  def forward(self, input, hidden, encoder_outputs):
    # input = [batch size, vocab size]
    # hidden = [batch size, n layers * directions, hid dim]
    # Decoder 只會是單向，所以 directions=1
    input = input.unsqueeze(1)
    embedded = self.dropout(self.embedding(input))
    # embedded = [batch size, 1, emb dim]
    if self.isatt:
      attn = self.attention(encoder_outputs, hidden)
      # TODO: 在這裡決定如何使用 Attention，e.g. 相加 或是 接在後面， 請注意維度變化
    output, hidden = self.rnn(embedded, hidden)
    # output = [batch size, 1, hid dim]
    # hidden = [num_layers, batch size, hid dim]

    # 將 RNN 的輸出轉為每個詞出現的機率
    output = self.embedding2vocab1(output.squeeze(1))
    output = self.embedding2vocab2(output)
    prediction = self.embedding2vocab3(output)
    # prediction = [batch size, vocab size]
    return prediction, hidden

Attention

  • 当输入过长时，或是单独靠 “content vector” 无法获取整个输入的意思时，用 Attention Mechanism 来提供
    Decoder
    更多的资讯
  • 主要是根据现在
    Decoder hidden state
    ，去计算在
    Encoder outputs
    中，那些与其有较高的关系，根据关系的数值来决定传给
    Decoder
    哪些额外的资讯
  • 常见 Attention 的操作是用 Neural Network / Dot Product 来计算
    Decoder hidden state
    和
    Encoder outputs
    之间的关系，再对所有算出來的数值做
    softmax
    ，最后根据过完
    softmax
    的值对
    Encoder outputs
    做
    weight sum
  • 李宏毅老师的课程在此处并没有给出具体的代码，需要大家自己补充。大家可以参考这篇文章
    Seq2Seq (Attention) 的 PyTorch 实现
    或者B站的视频
    PyTorch35——基于注意力机制的Seq2Seq的PyTorch实现示例
    。
class Attention(nn.Module):
  def __init__(self, hid_dim):
    super(Attention, self).__init__()
    self.hid_dim = hid_dim
  
  def forward(self, encoder_outputs, decoder_hidden):
    # encoder_outputs = [batch size, sequence len, hid dim * directions]
    # decoder_hidden = [num_layers, batch size, hid dim]
    # 一般來說是取最後一層的 hidden state 來做 attention
    ########
    # TODO #
    ########
    attention=None
    
    return attention

Seq2seq模型

  • 由
    Encoder
    和
    Decoder
    组成
  • 接收输入并传给
    Encoder
  • 将
    Encoder
    的输出传给
    Decoder
  • 不断地将
    Decoder
    的输出传回
    Decoder
    ，进行解码
  • 当解码完成，将
    Decoder
    的输出传回
class Seq2Seq(nn.Module):
  def __init__(self, encoder, decoder, device):
    super().__init__()
    self.encoder = encoder
    self.decoder = decoder
    self.device = device
    assert encoder.n_layers == decoder.n_layers, \
            "Encoder and decoder must have equal number of layers!"
            
  def forward(self, input, target, teacher_forcing_ratio):
    # input  = [batch size, input len, vocab size]
    # target = [batch size, target len, vocab size]
    # teacher_forcing_ratio 是有多少機率使用正確答案來訓練
    batch_size = target.shape[0]
    target_len = target.shape[1]
    vocab_size = self.decoder.cn_vocab_size

    # 準備一個儲存空間來儲存輸出
    outputs = torch.zeros(batch_size, target_len, vocab_size).to(self.device)
    # 將輸入放入 Encoder
    encoder_outputs, hidden = self.encoder(input)
    # Encoder 最後的隱藏層(hidden state) 用來初始化 Decoder
    # encoder_outputs 主要是使用在 Attention
    # 因為 Encoder 是雙向的RNN，所以需要將同一層兩個方向的 hidden state 接在一起
    # hidden =  [num_layers * directions, batch size  , hid dim]  --> [num_layers, directions, batch size  , hid dim]
    hidden = hidden.view(self.encoder.n_layers, 2, batch_size, -1)
    hidden = torch.cat((hidden[:, -2, :, :], hidden[:, -1, :, :]), dim=2)
    # 取的 <BOS> token
    input = target[:, 0]
    preds = []
    for t in range(1, target_len):
      output, hidden = self.decoder(input, hidden, encoder_outputs)
      outputs[:, t] = output
      # 決定是否用正確答案來做訓練
      teacher_force = random.random() <= teacher_forcing_ratio
      # 取出機率最大的單詞
      top1 = output.argmax(1)
      # 如果是 teacher force 則用正解訓練，反之用自己預測的單詞做預測
      input = target[:, t] if teacher_force and t < target_len else top1
      preds.append(top1.unsqueeze(1))
    preds = torch.cat(preds, 1)
    return outputs, preds

  def inference(self, input, target):
    ########
    # TODO #
    ########
    # 在這裡實施 Beam Search
    # 此函式的 batch size = 1  
    # input  = [batch size, input len, vocab size]
    # target = [batch size, target len, vocab size]
    batch_size = input.shape[0]
    input_len = input.shape[1]        # 取得最大字數
    vocab_size = self.decoder.cn_vocab_size

    # 準備一個儲存空間來儲存輸出
    outputs = torch.zeros(batch_size, input_len, vocab_size).to(self.device)
    # 將輸入放入 Encoder
    encoder_outputs, hidden = self.encoder(input)
    # Encoder 最後的隱藏層(hidden state) 用來初始化 Decoder
    # encoder_outputs 主要是使用在 Attention
    # 因為 Encoder 是雙向的RNN，所以需要將同一層兩個方向的 hidden state 接在一起
    # hidden =  [num_layers * directions, batch size  , hid dim]  --> [num_layers, directions, batch size  , hid dim]
    hidden = hidden.view(self.encoder.n_layers, 2, batch_size, -1)
    hidden = torch.cat((hidden[:, -2, :, :], hidden[:, -1, :, :]), dim=2)
    # 取的 <BOS> token
    input = target[:, 0]
    preds = []
    for t in range(1, input_len):
      output, hidden = self.decoder(input, hidden, encoder_outputs)
      # 將預測結果存起來
      outputs[:, t] = output
      # 取出機率最大的單詞
      top1 = output.argmax(1)
      input = top1
      preds.append(top1.unsqueeze(1))
    preds = torch.cat(preds, 1)
    return outputs, preds
fengbeely
关注
  • 22
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
seq2seq:PyTorch中的Seq2Seq代码
05-19
PyTorch中的Seq2seq代码 根据和 数据预处理： 我使用以下步骤 > config/WMT14/download.sh # download WMT14 data into raw_data/WMT14 > config/WMT14/prepare.sh # preprocess the data, and copy the files to data/WMT14 然后运行以下命令以保存在h5文件中： > python scripts/prepro_text.py 训练： 训练需要一些目录来保存模型的快照，张量板事件 > mkdir -p save events 在config.yaml中定义的参数下训练模型 > python nmt.py -c config.yaml 检查options / opts.py以获取有关选项的更多信息。 评估模型：
Seq2Seq-PyTorch:使用PyTorch的序列到序列实现
03-26
Seq2Seq-PyTorch 使用PyTorch的序列到序列实现 安装 克隆项目，进入项目目录并执行 python setup.py install 或者 pip install ./ 或简单地复制源代码。 推荐使用pip install ./ ，因为您可以先激活虚拟环境，然后再在该环境中安装软件包，而不会影响其他环境。 用法 使用之前，将seq2seq文件夹作为软件包安装或复制到项目目录。 看 一些功能 Trainer支持，尽管内存有限，但可以实现更大（等效）的批处理大小。 去做 支持光束搜索。 修理trainer 。 保存培训检查点时， trainer不会保存最佳时期模型。 因此，如果继续训练，则完成后保存的最佳时期实际上不是整个训练阶段的最佳时期，而是检查点之后的最佳时期。 （不知道培训师是否应在每个检查点保存最好的模型，这会使检查点文件变大。） （不确定是否有必要。）
PyTorch实战：基于Seq2seq模型处理机器翻译任务(模型训练及验证)
创作高质量博文，分享知识，共同进步！
04-03 2765
本博客以《PyTorch自然语言处理入门与实战》第九章的Seq2seq模型处理英译中翻译任务作为基础，给出自己的理解及代码的详细注释。
Seq2Seq-PyTorch：深度学习中的序列到序列模型实现
gitblog_00015的博客
04-13 680
Seq2Seq-PyTorch：深度学习中的序列到序列模型实现 项目地址:https://gitcode.com/MaximumEntropy/Seq2Seq-PyTorch 在自然语言处理领域，序列到序列（Sequence-to-Sequence, Seq2Seq）模型是一种强大的工具，尤其适用于机器翻译、对话系统和文本摘要等任务。此项目——Seq2Seq-PyTorch 是一个基于 PyTo...
PyTorch实战：基于Seq2seq模型处理机器翻译任务(模型预测)
创作高质量博文，分享知识，共同进步！
12-27 1862
本博客以《PyTorch自然语言处理入门与实战》第九章的Seq2seq模型处理**英译中翻译任务**作为基础，附上模型预测模块。
PyTorch实战：Seq2Seq模型详解与实现
lazycatlove的博客
07-24 183
Seq2Seq模型用来处理nlp中序列到序列的问题，是一种常见的Encoder-Decoder模型架构，基于RNN同时解决了RNN的一些弊端(输入和输入必须是等长的)。Seq2Seq的模型架构可以参考Seq2Seq详解，也可以读论文原文.本文主要介绍如何用Pytorch实现Seq2Seq模型。
Pytorch实战_Seq2seq模型
hello_JeremyWang的博客
01-27 3622
1. Sequence-to-Sequence 简介 大多数常见的 sequence-to-sequence (seq2seq) model 为 encoder-decoder model，主要由两个部分组成，分别是 Encoder 和 Decoder，而这两个部分大多数是由 recurrent neural network (RNN) 实现。 Encoder 是将一连串的输入，如文字、影片、声音讯号等，编码为单个向量，这个向量可以想像为整个输入的抽象表示，包含了整个输入的资讯。 Decoder 是將 En
PyTorch实现Seq2Seq模型详解
xziyuan的博客
06-29 709
Seq2Seq是一种循环神经网络的变种，是一种端到端的模型，包括 Encoder编码器和 Decoder解码器部分，在nlp任务中是一种重要的模型，在翻译，文本自动摘要生成和机器人自动问答以及一些回归预测任务上有着广泛的运用。Seq2Seq其实就是结构的网络，它的输入是一个序列，输出也是一个序列。在Encoder编码中，将序列转换成一个固定长度的向量，然后通过Decoder将该向量转换成我们想要的序列输出出来Encoder和Decoder一般都是RNN，通常为LSTM或者GRU。
在PyTorch中使用Seq2Seq构建的神经机器翻译模型
deephub
09-18 6053
在这篇文章中，我们将构建一个基于LSTM的Seq2Seq模型，使用编码器-解码器架构进行机器翻译。 本篇文章内容： 介绍 数据准备和预处理 长短期记忆(LSTM) - 背景知识 编码器模型架构(Seq2Seq) 编码器代码实现(Seq2Seq) 解码器模型架构(Seq2Seq) 解码器代码实现(Seq2Seq) Seq2Seq(编码器+解码器)接口 Seq2Seq(编码器+解码器)代码实现 Seq2Seq模型训练 Seq2Seq模型推理 1.介绍 神经机器翻译(NMT)是一种机器翻译方法，它使用人工神
pytorch-chatbot:使用PyTorch的Seq2Seq聊天机器人实现
05-12
使用PyTorch的Seq2Seq聊天机器人实现功能：Seq2Seq +光束搜索+ antiLM 要求 Python3 火炬0.3 语料库 用法 训练 python train . py 测试 python console python console . py . / ckpt model 光束搜索示例： me: ...
pytorch实现seq2seq和transformer机器翻译
04-16
在本文中，我们将深入探讨如何使用PyTorch实现Seq2Seq和Transformer架构，这两种方法都是在机器翻译领域中广泛使用的深度学习技术。首先，我们来理解这两个概念。 **Seq2Seq（Sequence to Sequence）模型**： Seq2...
seq2seq.pytorch：使用PyTorch进行序列到序列学习
03-04
PyTorch中的Seq2Seq 这是用于在训练序列到序列模型的完整套件。 它由几个模型和代码组成，可以训练和推断使用它们。 使用此代码，您可以训练： 神经机器翻译（NMT）模型语言模型图像到字幕的生成跳过思维的句子表示...
深入了解PyTorch的语言模型和seq2seq实现
禅与计算机程序设计艺术
01-25 1039
1.背景介绍 语言模型和seq2seq是自然语言处理(NLP)领域中非常重要的技术，它们在机器翻译、语音识别、文本摘要等任务中发挥着重要作用。在本文中，我们将深入了解PyTorch中的语言模型和seq2seq实现，涵盖了背景介绍、核心概念与联系、核心算法原理和具体操作步骤、数学模型公式详细讲解、具体最佳实践：代码实例和详细解释说明、实际应用场景、工具和资源推荐、总结：未来发展趋势与挑战以及附录：...
【PyTorch】基于YOLO的多目标检测项目（二）
Frost_Descent的博客
07-25 546
YOLO通常使用组合损失函数# 获取损失函数的参数# 获取yolo的参数# 初始化损失loss=0.0# 获取yolo的输出# 获取网格大小# 将yolo的输出reshape为(batch_size,num_anchors,grid_size,grid_size,-1)# 获取预测的边界框# 获取预测的置信度# 获取预测的类别概率# 获取yolo的目标})# 获取目标掩码# 获取目标的x,y,w,h# 获取目标的类别# 获取目标的置信度。
2024钉钉杯A题思路详解
全栈川川
07-26 1911
2024钉钉杯思路
常见的文心一言的指令
知码客
07-25 1764
文心一言，作为百度研发的预训练语言模型“ERNIE 3.0”的一项功能，能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。
昇思25天学习打卡营第1天|快速入门
最新发布
07-28 462
昇思大模型平台是一个集算法选型、创意分享、模型实验和大模型在线体验为一体的AI学习与实践社区，而且还内置了AI实验室，它覆盖多领域任务，体验全流程开发，支持用户在线训练和推理可视化，可创建自己的项目空间对待开发者很友好，提供云上开发环境，无需配置环境，既可灵活调试运行代码，每天免费使用8个小时。
pytorch 自动文摘 seq2seq
04-01
PyTorch中的Seq2Seq模型用于自动生成摘要或总结。它使用一种称为编码器-解码器的框架来实现这一点。编码器将输入序列编码成一个固定长度的向量，然后解码器使用该向量来生成摘要或总结。 具体来说，Seq2Seq模型包含两个循环神经网络（RNN）：编码器RNN和解码器RNN。编码器RNN将输入序列中的每个单词转换为一个向量，并逐步更新其隐藏状态，最终输出一个固定长度的向量。解码器RNN使用该向量作为其初始隐藏状态，并将其作为输入生成摘要或总结。 Seq2Seq模型还使用了一种叫做注意力机制的技术，以帮助模型更好地关注输入序列中最相关的部分。注意力机制将编码器RNN的每个隐藏状态与解码器RNN的当前隐藏状态进行比较，并生成一个注意力向量，该向量指示哪些输入单词是最相关的。 最终，Seq2Seq模型将解码器RNN的输出转换为摘要或总结。这可以通过选择每个时间步的最高概率单词来实现，或者使用其他技术来生成更自然的文本。 总之，PyTorch中的Seq2Seq模型是一种强大的工具，可用于自动生成摘要或总结。它使用编码器-解码器框架和注意力机制来实现这一点，并且可以通过各种技术进行优化和改进。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值