Tomato学习笔记-Seq2Seq

最新推荐文章于 2022-06-17 09:17:56 发布
最新推荐文章于 2022-06-17 09:17:56 发布
阅读量543 收藏
点赞数 1
文章标签： python pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GitTomato/article/details/118527882
版权

目录

  1. 简介
  2. 循环神经网络及其变形
  3. Seq2Seq

1.简介

        Seq2Seq有什么用呢？当我们期望输入一个序列例如X={x1,x2……xn}时，期待获得一个Y={y1,y2……ym}的输出，此时n\neqm，例如翻译任务。本次学习经历均是基于翻译任务进行，故而之后我将把输入序列称之为源语句，每个xi代表单词向量，对应Y称之为目标语句。

        那么你能想到用什么样的神经网络模型来处理呢？显然类似于全连接和卷积的传统神经网络例如AlexNet肯定不行，因为它本身都不太适合序列的输出。循环神经网络倒是可以输出序列，但通常输出的序列个数人为恒定，不方便于使用；再加上通常RNN模型一般是一个输入对应一个输出，m<=n，这导致例如翻译中，目标语句的单词个数大于源语句的单词个数时难以处理。

        不过，RNN倒是给了我们灵感，若我们将源语句放进RNN中跑，拿取最后一个结果当做能表征整个源语句的特征向量（如果你觉得这一个向量不能表征的话，那么恭喜你，你已经想到了Attention模型了），再用该特征向量结合目标语句进行训练。

2.循环神经网络及其变形

        图片是我随便从baidu上下载下来的图片，其实RNN模型随手一搜基本上都没啥问题，毕竟是最基础的循环神经网络模型。

        那么我简单从Pytorch上来讲讲它的RNN，Pytorch并没有实现RNN，可能它觉得如需使用，用户可以自行编写吧。但没学懂之前可倒了大霉了（-_-||）

        直接丢一段伪代码给大家李姐，当然这个伪代码不能直接跑

import torch.nn as nn

def train(RNN, input, hidden):
    hidden = RNN.initHidden() # 可以直接设置为全0，主要用于初始隐藏向量
    output, hidden = RNN(input, hidden)

#将RNN的内部分解即
class RNN(nn.Module):
    def __init__(self): 略

    def forward(self ,input, hidden):
        temp_output = input
        seq_len, _ = input.shape
        for i in range(seq_len):
            temp_output, hidden = RNNCell(output, hidden)
            output.append(temp_output)
        return output, hidden

    def initHidden(self):
        return np.zeros(...)

class RNNCell(nn.Module):
    '''略'''
    def forward(self, input, hidden):
        #这里可以自由发挥，如果你真的有想法，
        #可以简单的自己创造一个，例如全连接（最基础的RNN）、各种门来控制（LSTM和GRU之类）

3.Seq2Seq

        Seq2Seq最常见的是Encoder-Decoder模型，也就是我在简介中所说的将源语句编码再与目标语句链接进行训练的模型。如图：

      

        Encoder部分和Decoder部分都是一个RNN模型，当然若你不想用RNN模型当Encoder和Decoder也行，那将直接进入地狱难度的学习，请左转Transformer模型。该模型直接将Encoder，Decoder用矩阵乘法表示，并且可以不用当前一个RNNCell运行而直接跑出结果，不仅效率很快，而且特征提取能力也大大提升。

        Encoder-Decoder代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import random

trans_sentences = {'SOS glad to meet you EOS':'SOS ni hao EOS', 
                   'SOS nice to meet you EOS':'SOS ni hao EOS',
                   'SOS how old are you EOS':'SOS ni ji sui EOS',
                   'SOS you are handsome EOS':'SOS ni zhen shuai EOS',
                   'SOS you are so good EOS':'SOS ni zhen bang EOS',
                   'SOS you are nice EOS':'SOS ni zhen hao EOS',
                   'SOS I love you EOS':'SOS wo ai ni EOS',
                   'SOS I dislike you EOS':'SOS wo bu xi huan ni EOS',
                   'SOS I have an apple EOS':'SOS wo you yi ge ping guo EOS'}

def getTotalWords(trans_sentences):
    words = []
    for sen in trans_sentences.keys():
        for word in sen.split(' '):
            words.append(word)
    for sen in trans_sentences.values():
        for word in sen.split(' '):
            words.append(word)        
    return sorted(list(set(words)))


def sent2vector(sent):
    words = sent.split(' ')
    vec = []
    for word in words:
        vec.append(wordList.index(word))
    return torch.tensor(vec)


def label2word(label):
    words = []
    for i in label:
        words.append(wordList[i])
    return words


def output2word(output):
    output = output.squeeze()
    if(len(output.shape) == 1):
        maxv, maxi = torch.topk(output, 1, dim=0)
    elif(len(output.shape) == 2):
        maxv, maxi = torch.topk(output, 1, dim=1)
        
    return label2word(maxi)
    

wordList = getTotalWords(trans_sentences)

# simple encoder-decoder component
class EncoderLSTM(nn.Module):
    
    def __init__(self, input_size, hidden_size, output_size):
        super(EncoderLSTM, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        self.embed = nn.Embedding(self.input_size, 10)
        self.lstm = nn.LSTM(10, self.hidden_size)
        self.fc = nn.Linear(self.hidden_size, self.output_size)
        
    def HiddenInit(self):
        return (torch.zeros(1, 1, self.hidden_size),
                torch.zeros(1, 1, self.hidden_size))
    
    def forward(self, input, hidden):
        x = self.embed(input)
        if(len(x.shape) != 3):
            x = x.view(x.shape[0], 1, -1)
        
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output[-1,:])
        return output.view(1,1,-1), hidden
        
        
class DecoderLSTM(nn.Module):
    
    def __init__(self, input_size, hidden_size, output_size):
        super(DecoderLSTM, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        self.embed = nn.Embedding(self.input_size, 10)
        self.cat2hid = nn.Linear(self.input_size + 10 , self.input_size)
        self.lstm = nn.LSTM(self.input_size, self.hidden_size)
        self.fc = nn.Linear(self.hidden_size, self.output_size)
        
    def HiddenInit(self):
        return (torch.zeros(1, 1, self.hidden_size),
                torch.zeros(1, 1, self.hidden_size))
    
    def forward(self, input, hidden, encoder_embed):
        x = self.embed(input)
        if(len(x.shape) == 2):
            x = x.view(x.shape[0], 1, -1)
        elif(len(x.shape) == 1):
            x = x.view(1, 1, -1)
        
        x = torch.cat((x, encoder_embed), dim = 2)
        x = self.cat2hid(x)
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output)
        return output, hidden

input_size = len(wordList)
hidden_size = len(wordList)
output_size = len(wordList)

encoder = EncoderLSTM(input_size, hidden_size, output_size)
decoder = DecoderLSTM(input_size, hidden_size, output_size)

encoder_opt = optim.Adam(encoder.parameters(), lr=0.01)
decoder_opt = optim.Adam(decoder.parameters(), lr=0.01)
crit = nn.CrossEntropyLoss()

running_loss = 0
for epoch in range(100):
    for input in trans_sentences.keys():
        
        target = trans_sentences[input]
        target_label = sent2vector(target)
        input_vec = sent2vector(input)
        hidden = encoder.HiddenInit()
        decoder_input = target_label[0:1]
        
        encoder_opt.zero_grad()
        decoder_opt.zero_grad()
        
        encoder_embed, decoder_hidden = encoder(input_vec, hidden)
        
        ForcingLearning = True if random.random() < 0.5 else False # True means according to the target, False means according to the prediction
#         ForcingLearning = True
        loss = 0
        predict = []
        decoder_hidden = decoder.HiddenInit()
        if(ForcingLearning == True):
            for i in range(len(target_label) - 1):
                # decoder_output give next word, decoder_hidden for hidden vector input
                decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden, encoder_embed)
                predict.append(output2word(decoder_output))
                loss += crit(decoder_output.view(decoder_output.shape[0], -1), target_label[i+1:i+2])
                decoder_input = target_label[i+1:i+2]
        else:
            for i in range(len(target_label) - 1):
                decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden, encoder_embed)
                predict.append(output2word(decoder_output))
                loss += crit(decoder_output.view(decoder_output.shape[0], -1), target_label[i+1:i+2])
                
                _, predict_i = torch.topk(decoder_output.squeeze(), 1, dim=0)
                decoder_input = predict_i

        loss.backward(retain_graph=True)
        encoder_opt.step()
        decoder_opt.step()
        
        running_loss += loss.data
        if(epoch % 25 == 24):
            print("——————————————————————————————————————")
            print("in epoch ( %d ), the average loss is ( %.5f )" % (epoch, running_loss / 25))
            print("The original sentences is [%s], translation is [%s]" % (input, predict))
            running_loss = 0

def predict(model, original):
    
    original = "SOS " + original + " EOS"
    input_vec = sent2vector(original)
    encoder, decoder = model
    decoder_input = sent2vector("SOS")
    
    with torch.no_grad():
        hidden = encoder.HiddenInit()
        encoder_embed, decoder_hidden = encoder(input_vec, hidden)
        
        predict = ["SOS"]
        while (predict[-1] != "EOS"):
                decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden, encoder_embed)
                predict.append(output2word(decoder_output)[0])
                _, predict_i = torch.topk(decoder_output.squeeze(), 1, dim=0)
                decoder_input = predict_i
        
        print(predict[1:-1])
    
predict((encoder, decoder), "ni ji sui")

# complex encoder-decoder with attention mechanicsm
# simple encoder-decoder component
class EncoderLSTM(nn.Module):
    
    def __init__(self, input_size, hidden_size, output_size):
        super(EncoderLSTM, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        self.embed = nn.Embedding(self.input_size, 10)
        self.lstm = nn.LSTM(10, self.hidden_size)
        self.fc = nn.Linear(self.hidden_size, self.output_size)
        
    def HiddenInit(self):
        return (torch.zeros(1, 1, self.hidden_size),
                torch.zeros(1, 1, self.hidden_size))
    
    def forward(self, input, hidden):
        x = self.embed(input)
        if(len(x.shape) != 3):
            x = x.view(x.shape[0], 1, -1)
        
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output)
        return output, hidden
        
        
class AttentionDecoderLSTM(nn.Module):
    
    def __init__(self, input_size, hidden_size, output_size, seq_size):
        super(AttentionDecoderLSTM, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.seq_size = seq_size
        
        self.embed = nn.Embedding(self.input_size, 10)
        self.attn = nn.Linear(self.hidden_size * 2 + 10 , self.seq_size)
        self.attn_combine = nn.Linear(self.hidden_size + 10, self.input_size)
        
        self.lstm = nn.LSTM(self.input_size, self.hidden_size)
        self.fc = nn.Linear(self.hidden_size, self.output_size)
        
    def HiddenInit(self):
        return (torch.zeros(1, 1, self.hidden_size),
                torch.zeros(1, 1, self.hidden_size))
    
    def forward(self, input, hidden, encoder_embed):
        x = self.embed(input)
        if(len(x.shape) == 2):
            x = x.view(x.shape[0], 1, -1)
        elif(len(x.shape) == 1):
            x = x.view(1, 1, -1)
        
        input = x
        x = torch.cat((hidden[0], hidden[1], x), dim = 2)
        weight = F.softmax(self.attn(x), dim=2)
        
#         print(weight[:, :, 0:encoder_embed.shape[0]].shape, encoder_embed.transpose(0, 1).shape)
        attn_applied = torch.bmm(weight[:, :, 0:encoder_embed.shape[0]], encoder_embed.transpose(0, 1))
        x = torch.cat((attn_applied, input), dim=2)
        x = self.attn_combine(x)
        
        output, hidden = self.lstm(x, hidden)
        output = self.fc(output)
        return output, hidden

input_size = len(wordList)
hidden_size = len(wordList)
output_size = len(wordList)

encoder = EncoderLSTM(input_size, hidden_size, output_size)
decoder = AttentionDecoderLSTM(input_size, hidden_size, output_size, 6)

encoder_opt = optim.Adam(encoder.parameters(), lr=0.01)
decoder_opt = optim.Adam(decoder.parameters(), lr=0.01)
crit = nn.CrossEntropyLoss()

running_loss = 0
for epoch in range(1000):
    for input in trans_sentences.keys():
        
        target = trans_sentences[input]
        target_label = sent2vector(target)
        input_vec = sent2vector(input)
        hidden = encoder.HiddenInit()
        decoder_input = target_label[0:1]
        
        encoder_opt.zero_grad()
        decoder_opt.zero_grad()
        
        encoder_embed, decoder_hidden = encoder(input_vec, hidden)
        
#         ForcingLearning = True if random.random() < 0.5 else False # True means according to the target, False means according to the prediction
        ForcingLearning = True
        loss = 0
        predict = []
        if(ForcingLearning == True):
            for i in range(len(target_label) - 1):
                # decoder_output give next word, decoder_hidden for hidden vector input
                decoder_hidden = decoder.HiddenInit()
                decoder_output, _ = decoder(decoder_input, decoder_hidden, encoder_embed)
                predict.append(output2word(decoder_output))
                loss += crit(decoder_output.view(decoder_output.shape[0], -1), target_label[i+1:i+2])
                decoder_input = target_label[i+1:i+2]
        else:
            for i in range(len(target_label) - 1):
                decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden, encoder_embed)
                predict.append(output2word(decoder_output))
                loss += crit(decoder_output.view(decoder_output.shape[0], -1), target_label[i+1:i+2])
                
                _, predict_i = torch.topk(decoder_output.squeeze(), 1, dim=0)
                decoder_input = predict_i

        loss.backward(retain_graph=True)
        encoder_opt.step()
        decoder_opt.step()
        
        running_loss += loss.data
        if(epoch % 250 == 249):
            print("——————————————————————————————————————")
            print("in epoch ( %d ), the average loss is ( %.5f )" % (epoch, running_loss / 250))
            print("The original sentences is [%s], translation is [%s]" % (input, predict))
            running_loss = 0

GitTomato
关注
seq2seq 函数
weixin_30701575的博客
09-25 254
# 复制 tf.contrib.layers.embed_sequence 链接：https://www.tensorflow.org/api_docs/python/tf/contrib/layers/embed_sequence 说明：对序列数据执行embedding操作，输入[batch_size, sequence_length]的tensor，返回[batch_siz...
Seq2Seq数字代码解读
dimaoe2852的博客
08-21 325
# -*- coding: utf-8 -*- import tensorflow as tf import numpy as np import helper ####################################################### 定义模型 PAD = 0 EOS = 1 # UNK = 2 # GO = 3 v...
Seq2Seq 代码笔记
weixin_46934960的博客
06-17 752
🏷As we have discussed in Section 9.5, machine translation is a major problem\color{red}\text{a major problem}a major problem domain for sequence transduction models, whose input and output are both variable-length sequences\color{red}\textbf{variable-leng.
Seq2Seq模型及代码 好的文章
weixin_44317740的博客
06-05 277
https://mp.weixin.qq.com/s/0k71fKKv2SRLv9M6BjDo4w https://blog.csdn.net/qq_32241189/article/details/81591456?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task
深度学习 zuoye4
qq_43573054的博客
09-23 762
Download Dataset 有三個檔案，分別是training_label.txt、training_nolabel.txt、testing_data.txt training_label.txt：有label的training data(句子配上0 or 1) training_nolabel.txt：沒有label的training data(只有句子)，用来做半监督学习，约120万句句子。 比如： hates being this burnt !! ouch，前面没有0或者1的标签 test
tomato-K26-1.28.121-MIPSR2-5G 8M.rar
06-07
tomato路由器固件，含2.4g和5g，8M版本，可刷贝尔金/belkin路由器。tomato性能稳定，功能好用，网上的其他资源都是不带5g的双拨版，现在不好找了，自己不舍得私藏，特分享给大家。
tomato-K26-1.28.0542-MIPSR2-（4M）.zip
08-18
【标题】"tomato-K26-1.28.0542-MIPSR2-（4M）.zip" 提供的信息是关于一种特定的固件版本，该固件基于Tomato操作系统，适用于MIPS R2架构，并且专为具有4MB内存的设备设计。"K26"通常代表内核版本为2.6，这是Linux...
tomato-K26-13.05.0041-MIPSR2-4M
06-01
tomato-K26-13.05.0041-MIPSR2-4M
tomato-Netgear-WNDR4500V1固件
09-07
tomato-Netgear-WNDR4500V1_122--20140901.Hyzoom.RT_AC-32M-AIO-AR-TR-PY-GAE-XUNLEI-NGINX-MYSQL-64K.chk
Tomato-Phoenix-V106-繁体版
06-01
"Tomato-Phoenix-V106-繁体版" 是一个特定版本的固件更新，主要针对路由器设备，特别是那些支持Tomato固件系列的路由器。Tomato是一种开源的、高度自定义的路由器固件，它基于Linux内核，提供了一系列高级功能，使...
torch.squeeze()函数的理解
weixin_41950276的博客
11-04 2977
import torch a=torch.Tensor([[1],[1]]) b=torch.squeeze(a) c=1 print(' a :', a ,' b: ', b , ' c: ' , c) print('\n',a.size(),b.size()) 我们可以看到本来2x1=&gt;2的维度，也就是，[[1],[1]]=&gt;[1,1]...
Python squeeze()函数
热门推荐
happyday_d的博客
01-07 4万+
Python squeeze()函数 作用:移除数组中维度为1的维度 函数形式:numpy.``squeeze(a, axis=None) 参数:axis: 选择数组中的某一维度移除, 如果选择形状输入大于1的轴，则会引发错误。 x = np.array([[[0], [1], [2]]]) x.shape # (1, 3, 1) np.squeeze(x).shape # (3,) np.squ...
pytorch--知识蒸馏--小小实践
qq_35275007的博客
12-03 2649
import math import torch import torch.nn as nn import torch.nn.functional as F import torch.utils.data from torchvision import datasets, transforms from torchvision import models import matplotlib.pyplot as plt torch.manual_seed(0) # torch.cuda.manual_se.
人脸匹配对齐算法pytorch_PyTorch 实现孪生网络识别面部相似度
weixin_34698515的博客
02-05 1717
深度神经网络是涉及图像分类问题的重要算法。这其中的部分原因是，它们具有大量的可训练的参数。然而，这是以需要大量的数据为代价的，而这有时是不可获得的。那么接下来，我就将讨论小样本学习(One Shot Learning)，其旨在缓解诸如此类的问题，以及如何在PyTorch中实现一个使用它的神经网络。本文假设你对神经网络知识有所了解。本文相关材料线索来自于此篇论文标准分类vs小样本分类几乎所有分类模型...
Pytorch squeeze()的简单用法
xiongxyowo的博客
01-18 1万+
squeeze的作用就是对tensor变量进行维度压缩，去除维数为1的的维度。 ☆例如，一个3×2×1×2×1的tensor，squeeze()之后便成了3×2×2。存储的数据并没有发生变化，但是去除了“多余”的维度信息： import torch x = torch.rand(3, 2, 1, 2, 1) print(x.size()) x = x.squeeze() print(x.size()) 输出： torch.Size([3, 2, 1, 2, 1]) torch.Size([3, 2, 2
实战 | 手把手教你搭一个机器翻译模型
CSDN 人工智能
05-21 7241
&#13; &#13; &#13; &#13; &#13; &#13; &#13; 作者 | 李理环信人工智能研发中心 VP，十多年自然语言处理和人工智能研发经验。主持研发过多款智能硬...
[NLP] PyTorch 实现双向LSTM 情感分析
摩登都市天空---专栏
07-05 2万+
一 前言 情感分析（Sentiment Analysis），也称为情感分类，属于自然语言处理（Natural Language Processing，NLP）领域的一个分支任务，随着互联网的发展而兴起。多数情况下该任务分析一个文本所呈现的信息是正面、负面或者中性，也有一些研究会区分得更细，例如在正负极性中再进行分级，区分不同情感强度. 文本情感分析（Sentiment Analysis）是自...
tensorflow代码学习：seq2seq 代码解析
he_wen_jie的博客
06-07 5911
先上一个seq2seq的图片，有几点需要注意 这是两个RNN，编码RNN会将一个序列最后的状态作为解码RNN的初始状态 编码的RNN我们是不需要输出，主要是没啥用，但是attention的时候需要 解码的RNN是有输入的 上图的例子就是，一个输入序列是[A,B,C]，原始标签是[W,X,Y,Z]，编码是我们将序列[A,B,C]依次输入到编码RNN，输完之后得到最终的状态C，解码RNN...
Seq2Seq(Attention)的PyTorch实现（超级详细）
mathor的博客
07-02 1万+
文本主要介绍一下如何使用PyTorch复现Seq2Seq(with Attention)，实现简单的机器翻译任务，请先阅读论文Neural Machine Translation by Jointly Learning to Align and Translate，之后花上15分钟阅读我的这两篇文章Seq2Seq 与注意力机制，图解Attention，最后再来看文本，方能达到醍醐灌顶，事半功倍的效果 数据预处理 数据预处理的代码其实就是调用各种API，我不希望读者被这些不太重要的部分分散了注意力，因此这里我
DIY无线宽带路由器：DD-WRT、TomaTo与Open-WRT深度解析与刷机教程
2. **TomaTo**： - TomaTo 更侧重于双WAN（两个互联网连接）的支持，例如光纤+ADSL组合，以及强大的QoS（服务质量）管理。它能将不同网络的带宽叠加，提升下载速度，对于多线路环境非常实用。 3. **Open-WRT**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值