句向量，翻译，seq2seq框架，attention

最新推荐文章于 2024-06-27 00:19:02 发布
最新推荐文章于 2024-06-27 00:19:02 发布
阅读量115 收藏
点赞数
原文链接：https://mofanpy.com/tutorials/machine-learning/nlp/seq2seq/
版权

文章目录

什么是编码

把某些特征组合起来，变成新的特征。
比如词向量到句向量

seq2seq框架

编码：机器产生对语言的理解
解码：在理解的基础上做任务

seq2seq无注意力，效果不好

step->train_logits->encode(x)->encoder(x)->dec_embeddings(y)->decoder_train(x,y)

# [Sequence to Sequence Learning with Neural Networks](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf)
import tensorflow as tf
from tensorflow import keras
import numpy as np
import utils    # this refers to utils.py in my [repo](https://github.com/MorvanZhou/NLP-Tutorials/)
import tensorflow_addons as tfa

class Seq2Seq(keras.Model):
    def __init__(self, enc_v_dim, dec_v_dim, emb_dim, units, max_pred_len, start_token, end_token):
        super().__init__()
        self.units = units

        # encoder
        self.enc_embeddings = keras.layers.Embedding(
            input_dim=enc_v_dim, output_dim=emb_dim,  # [enc_n_vocab, emb_dim]
            embeddings_initializer=tf.initializers.RandomNormal(0., 0.1),
        )
        self.encoder = keras.layers.LSTM(units=units, return_sequences=True, return_state=True)

        # decoder
        self.dec_embeddings = keras.layers.Embedding(
            input_dim=dec_v_dim, output_dim=emb_dim,  # [dec_n_vocab, emb_dim]
            embeddings_initializer=tf.initializers.RandomNormal(0., 0.1),
        )
        self.decoder_cell = keras.layers.LSTMCell(units=units)
        decoder_dense = keras.layers.Dense(dec_v_dim)
        # train decoder训练时的解码器是，带标签的。对错误视而不见，直接输入正确的标签
        self.decoder_train = tfa.seq2seq.BasicDecoder(
            cell=self.decoder_cell,
            sampler=tfa.seq2seq.sampler.TrainingSampler(),   # sampler for train
            output_layer=decoder_dense
        )
        # predict decoder真实预测时是不带标签的
        self.decoder_eval = tfa.seq2seq.BasicDecoder(
            cell=self.decoder_cell,
            sampler=tfa.seq2seq.sampler.GreedyEmbeddingSampler(),       # sampler for predict
            output_layer=decoder_dense
        )

        self.cross_entropy = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
        self.opt = keras.optimizers.Adam(0.01)
        self.max_pred_len = max_pred_len
        self.start_token = start_token
        self.end_token = end_token

    def encode(self, x):
        embedded = self.enc_embeddings(x)#(8, 8, 16)
        init_s = [tf.zeros((x.shape[0], self.units)), tf.zeros((x.shape[0], self.units))]
        o, h, c = self.encoder(embedded, initial_state=init_s)
        return [h, c]

    def inference(self, x):
        s = self.encode(x)
        done, i, s = self.decoder_eval.initialize(
            self.dec_embeddings.variables[0],
            start_tokens=tf.fill([x.shape[0], ], self.start_token),
            end_token=self.end_token,
            initial_state=s,
        )
        pred_id = np.zeros((x.shape[0], self.max_pred_len), dtype=np.int32)
        for l in range(self.max_pred_len):
            o, s, i, done = self.decoder_eval.step(
                time=l, inputs=i, state=s, training=False)
            pred_id[:, l] = o.sample_id
        return pred_id

    def train_logits(self, x, y, seq_len):
        s = self.encode(x)
        dec_in = y[:, :-1]   # ignore <EOS>
        dec_emb_in = self.dec_embeddings(dec_in)
        o, _, _ = self.decoder_train(dec_emb_in, s, sequence_length=seq_len)
        logits = o.rnn_output
        return logits

    def step(self, x, y, seq_len):
        with tf.GradientTape() as tape:
            logits = self.train_logits(x, y, seq_len)
            dec_out = y[:, 1:]  # ignore <GO>
            loss = self.cross_entropy(dec_out, logits)
            grads = tape.gradient(loss, self.trainable_variables)
        self.opt.apply_gradients(zip(grads, self.trainable_variables))
        return loss.numpy()


def train():
    # get and process data
    data = utils.DateData(4000)# 开始标志：GO，结束标志EOS，x是中国时间的id表示，y是美国时间的id表示
    # print("Chinese time order: yy/mm/dd ", data.date_cn[:3], "\nEnglish time order: dd/M/yyyy ", data.date_en[:3])
    # print("vocabularies: ", data.vocab)
    # print("x index sample: \n{}\n{}".format(data.idx2str(data.x[0]), data.x[0]),
    #       "\ny index sample: \n{}\n{}".format(data.idx2str(data.y[0]), data.y[0]))

    model = Seq2Seq(
        data.num_word, data.num_word, emb_dim=16, units=32,
        max_pred_len=11, start_token=data.start_token, end_token=data.end_token)

    # training
    for t in range(1000):
        bx, by, decoder_len = data.sample(64)
        loss = model.step(bx, by, decoder_len)# decoder_len=8
        if t % 70 == 0:
            target = data.idx2str(by[0, 1:-1])
            pred = model.inference(bx[0:1])
            res = data.idx2str(pred[0])# 预测结果
            src = data.idx2str(bx[0])
            if target in res :
                print('true')
            print(
                "t: ", t,
                "| loss: %.3f" % loss,
                "| input: ", src,
                "| target: ", target,
                "| inference: ", res,
            )

if __name__ == "__main__":
    train()

seq2seq有注意力，效果好

  1. 注意力的原理：
    做序列的预测时，要用到(1)当前解码器的状态(2)编码器中所有词的信息、权重、状态生成的注意力
    所以代码中，Decoder在生成语言的时候，也注意到Encoder的对应部分
  2. 流程
loss = model.step(bx, by, decoder_len)
logits = self.train_logits(x, y, seq_len)
s = self.set_attention(x)
o, h, c = self.encode(x)
o = self.enc_embeddings(x)
o, h, c = self.encoder(o, initial_state=init_s)
self.attention = tfa.seq2seq.LuongAttention(units, memory=None, memory_sequence_length=None)
# Decoder在生成语言的时候，也注意到Encoder的对应部分
self.decoder_cell = tfa.seq2seq.AttentionWrapper(cell=keras.layers.LSTMCell(units=units),。。
dec_in = y[:, :-1]   # ignore <EOS>
dec_emb_in = self.dec_embeddings(dec_in)
o, _, _ = self.decoder_train(dec_emb_in, s, sequence_length=seq_len)

# [Effective Approaches to Attention-based Neural Machine Translation](https://arxiv.org/pdf/1508.04025.pdf)
import tensorflow as tf
from tensorflow import keras
import numpy as np
import utils    # this refers to utils.py in my [repo](https://github.com/MorvanZhou/NLP-Tutorials/)
import tensorflow_addons as tfa
import pickle


class Seq2Seq(keras.Model):
    def __init__(self, enc_v_dim, dec_v_dim, emb_dim, units, attention_layer_size, max_pred_len, start_token, end_token):
        super().__init__()
        self.units = units

        # encoder
        self.enc_embeddings = keras.layers.Embedding(
            input_dim=enc_v_dim, output_dim=emb_dim,    # [enc_n_vocab, emb_dim]
            embeddings_initializer=tf.initializers.RandomNormal(0., 0.1),
        )
        self.encoder = keras.layers.LSTM(units=units, return_sequences=True, return_state=True)

        # decoder这节内容我们就是让Decoder在生成语言的时候，也注意到Encoder的对应部分
        self.attention = tfa.seq2seq.LuongAttention(units, memory=None, memory_sequence_length=None)
        self.decoder_cell = tfa.seq2seq.AttentionWrapper(
            cell=keras.layers.LSTMCell(units=units),
            attention_mechanism=self.attention,
            attention_layer_size=attention_layer_size,
            alignment_history=True,                     # for attention visualization
        )

        self.dec_embeddings = keras.layers.Embedding(
            input_dim=dec_v_dim, output_dim=emb_dim,    # [dec_n_vocab, emb_dim]
            embeddings_initializer=tf.initializers.RandomNormal(0., 0.1),
        )
        decoder_dense = keras.layers.Dense(dec_v_dim)   # output layer

        # train decoder
        self.decoder_train = tfa.seq2seq.BasicDecoder(
            cell=self.decoder_cell,
            sampler=tfa.seq2seq.sampler.TrainingSampler(),   # sampler for train
            output_layer=decoder_dense
        )
        self.cross_entropy = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
        self.opt = keras.optimizers.Adam(0.05, clipnorm=5.0)

        # predict decoder
        self.decoder_eval = tfa.seq2seq.BasicDecoder(
            cell=self.decoder_cell,
            sampler=tfa.seq2seq.sampler.GreedyEmbeddingSampler(),       # sampler for predict
            output_layer=decoder_dense
        )

        # prediction restriction
        self.max_pred_len = max_pred_len
        self.start_token = start_token
        self.end_token = end_token

    def encode(self, x):
        o = self.enc_embeddings(x)
        init_s = [tf.zeros((x.shape[0], self.units)), tf.zeros((x.shape[0], self.units))]
        o, h, c = self.encoder(o, initial_state=init_s)
        return o, h, c
    # 来自encoder的信息在set_attention()中被加工好，处理好了。 接下来就是我们训练encoder+decoder的过程
    def set_attention(self, x):
        o, h, c = self.encode(x)
        # encoder output for attention to focus
        self.attention.setup_memory(o)
        # wrap state by attention wrapper
        s = self.decoder_cell.get_initial_state(batch_size=x.shape[0], dtype=tf.float32).clone(cell_state=[h, c])
        return s

    def inference(self, x, return_align=False):
        s = self.set_attention(x)
        done, i, s = self.decoder_eval.initialize(
            self.dec_embeddings.variables[0],
            start_tokens=tf.fill([x.shape[0], ], self.start_token),
            end_token=self.end_token,
            initial_state=s,
        )
        pred_id = np.zeros((x.shape[0], self.max_pred_len), dtype=np.int32)
        for l in range(self.max_pred_len):
            o, s, i, done = self.decoder_eval.step(
                time=l, inputs=i, state=s, training=False)
            pred_id[:, l] = o.sample_id
        if return_align:
            return np.transpose(s.alignment_history.stack().numpy(), (1, 0, 2))
        else:
            s.alignment_history.mark_used()  # otherwise gives warning
            return pred_id

    def train_logits(self, x, y, seq_len):
        s = self.set_attention(x)
        dec_in = y[:, :-1]   # ignore <EOS>
        dec_emb_in = self.dec_embeddings(dec_in)
        o, _, _ = self.decoder_train(dec_emb_in, s, sequence_length=seq_len)
        logits = o.rnn_output
        return logits

    def step(self, x, y, seq_len):
        with tf.GradientTape() as tape:
            logits = self.train_logits(x, y, seq_len)
            dec_out = y[:, 1:]  # ignore <GO>
            loss = self.cross_entropy(dec_out, logits)
            grads = tape.gradient(loss, self.trainable_variables)
        self.opt.apply_gradients(zip(grads, self.trainable_variables))
        return loss.numpy()


def train():
    # get and process data
    data = utils.DateData(2000)
    # print("Chinese time order: yy/mm/dd ", data.date_cn[:3], "\nEnglish time order: dd/M/yyyy ", data.date_en[:3])
    # print("vocabularies: ", data.vocab)
    # print("x index sample: \n{}\n{}".format(data.idx2str(data.x[0]), data.x[0]),
    #       "\ny index sample: \n{}\n{}".format(data.idx2str(data.y[0]), data.y[0]))

    model = Seq2Seq(
        data.num_word, data.num_word, emb_dim=12, units=14, attention_layer_size=16,
        max_pred_len=11, start_token=data.start_token, end_token=data.end_token)

    # training
    for t in range(1000):
        bx, by, decoder_len = data.sample(64)
        loss = model.step(bx, by, decoder_len)
        if t % 70 == 0:
            target = data.idx2str(by[0, 1:-1])
            pred = model.inference(bx[0:1])
            res = data.idx2str(pred[0])
            src = data.idx2str(bx[0])
            if target in res :
                print('true')
            print(
                "t: ", t,
                "| loss: %.5f" % loss,
                "| input: ", src,
                "| target: ", target,
                "| inference: ", res,
            )

    pkl_data = {"i2v": data.i2v, "x": data.x[:6], "y": data.y[:6], "align": model.inference(data.x[:6], return_align=True)}

    with open("./visual/tmp/attention_align.pkl", "wb") as f:
        pickle.dump(pkl_data, f)


if __name__ == "__main__":
    train()
2020小小酥
关注
从零实现深度学习框架——Seq2Seq从理论到实战【理论】
日积月累，天道酬勤
09-05 1017
Seq2Seq原理介绍。
从零实现深度学习框架——Seq2Seq从理论到实战【实战】
日积月累，天道酬勤
09-08 816
一步一步从零实习seq2seq完成机器翻译。
Python-PyTorch中seq2seq模型的一个框架
08-09
PyTorch中seq2seq模型的一个框架
seq2seq模型
Leethunder的博客
09-06 1654
seq2seq 是一个结构的网络，它的输入是一个序列，输出也是一个序列。它涉及两个过程：Encoder 中将一个可变长度的信号序列变为固定长度的向量表达。Decoder 将这个固定长度的向量变成可变长度的目标的信号序列。通常encoder及decoder均采用RNN结构如LSTM或GRU等。可用于机器翻译、文本生成、语言模型、语音识别等领域。
序列到序列模型（Seq2Seq）
最新发布
2201_75395747的博客
06-27 1708
本质上，注意力机制能够为表征中较有价值的部分分配较多的计算资源。这个有趣的想法自提出后得到了快速发展，特别是启发了依靠注意力机制来编码输入序列并解码出输出序列的变换器（Transformer）模型的设计 [2]。变换器抛弃了卷积神经网络和循环神经网络的架构。它在计算效率上比基于循环神经网络的编码器—解码器模型通常更具明显优势。含注意力机制的变换器的编码结构在后来的BERT预训练模型中得以应用并令后者大放异彩：微调后的模型在多达11项自然语言处理任务中取得了当时最先进的结果 [3]。
机器翻译seq2seq+Attention（理论+代码）
KaikebaAI的博客
11-04 1387
导语：看本文之前，你应该熟悉RNN（LSTM、GRU）工作原理、pytorch中LSTM的使用以及一些张量操作。 1.前言 seq2seq 是一个Encoder–Decoder 结构的网络，它的输入是一个序列，输出也是一个序列， Encoder 中将一个可变长度的信号序列变为固定长度的向量表达，Decoder 将这个固定长度的向量变成可变长度的目标的信号序列。如下是 Seq2Seq 模型工作的流程： 图1中无论是编码器还是解码器，都是用的循环神经网络，编码器用来分析输入序列，解码器用来生成输出序列。我们可
Seq2Seq的attention
weixin_45599022的博客
09-30 90
Seq2Seq模型存在的问题： 梯度问题，decoding只依赖于context vector，句子开始部分的信息容易丢失。（即梯度消失问题） 实际应用中，翻译某个词可能只需要关注C中的某一部分即可（如翻译weather时只需关注天气这个词），但seq2seq的C是整个句子的向量，所以在翻译weather时可能会出现副作用。 解决方法：引入attention 进入attention的好处：可解释性增强，更容易找bug。 attention原理：下文中汉语的每个词的向量与翻译的每个词进行相.
RNN+Attention实现Seq2Seq中英文机器翻译（pytorch）实现
12-22
本项目使用RNN（循环神经网络）与Attention机制结合实现Seq2Seq（Sequence to Sequence）模型，以进行中英文之间的翻译。PyTorch是一个流行的深度学习框架，它提供灵活的API来构建和训练复杂模型，这里我们将详细...
从零实现深度学习框架——带Attentiond的Seq2seq机器翻译
日积月累，天道酬勤
07-11 865
本文介绍如何应用注意力机制到seq2seq中。
pytorch实现seq2seq和transformer机器翻译
04-16
在本文中，我们将深入探讨如何使用PyTorch实现Seq2Seq和Transformer架构，这两种方法都是在机器翻译领域中广泛使用的深度学习技术。首先，我们来理解这两个概念。 **Seq2Seq（Sequence to Sequence）模型**： Seq2...
【深度学习实战应用案例】时序分析-seq2seq(attention)（代码+数据）.zip
03-24
本资源"【深度学习实战应用案例】时序分析-seq2seq(attention)"是一个深入实践的教程，涵盖了时序数据分析的关键技术——序列到序列（Seq2Seq）模型，并结合注意力机制（Attention）进行详细讲解。以下是关于这些...
Seq2Seq模型：详述其发展历程、深远影响与结构深度剖析
JINGWHALE
06-01 1114
Seq2Seq模型的由来是深度学习技术在NLP领域不断演进的结果，尤其受到RNNs、LSTMs/GRUs等循环神经网络结构发展的深刻影响。其诞生标志了端到端学习在复杂序列转换任务中的可行性，成功的推动了Attention机制、Transformer模型的提出等，持续推动着NLP及相关领域技术的进步。
Transformer、Attention与seq2seq model
谁谓荼苦，其甘如荠
11-22 1665
一、什么是seq2seq，以及它和Attention机制有什么关系 seq2seq是一种NLP常见的框架——这种框架不要求输入和输出序列是维度是一样的。许多NLP task的输入输出维度不统一，比如机器翻译、图像的图注生成、摘要生成、自动问答等。seq2seq框架大多包含encoder和decoder。 Attention机制只是一种思想——即，人在理解一件事物并作出判断的时候，并不是概览了整...
seq2seq详解
huwenxing0801的博客
12-16 2181
前言 我们通常使用RNN来对序列到序列问题建模，但是使用RNN建模，输出序列的长度必须和输入序列的长度相等。seq2seq框架很好地解决了这个问题。本文介绍了两种最常见的seq2seq框架。 seq2seq介绍： seq2seq模型，全称Sequence to sequence，由Encoder和Decoder两个部分组成，每部分都是一个RNNCell（RNN、LSTM、GRU等）结构。Enco...
seq2seq框架中技术要点汇总
Deep Learning and NLP Farm
02-26 875
Copy Mechanism：解决OOV词 来自于文章《Incorporating Copying Mechanism in Sequence-to-Sequence Learning》发表在ACL2016
基于深度学习Seq2Seq框架的技术总结
JDDTechTalk的博客
11-23 4951
随着互联网经济的普及定位技术的快速发展，人们在日常生活中产生了大量的轨迹数据，例如出租车的GPS数据、快递配送员PDA产生的轨迹数据等。轨迹数据是一种典型的时空数据（Spatial-Temporal Data），是按照时间顺序索引且空间变化的一系列数据点。在时空数据的数据挖掘中，我们也会大量借鉴在自然语言处理等时序数据中发展很成熟的技术。 本篇文章为您带来的是Seq2Seq（Sequence to Sequence）模型的技术总结。将着重介绍三个里程碑式的方法，Sequence to SequenceLea
【NLP】含注意力机制的Seq2Seq模型简介及代码示例
qq_42533357的博客
03-19 2387
序列到序列（Sequence-to-Sequence，简称Seq2Seq）模型是一种深度学习架构，主要用于处理输入和输出都是变长序列的任务，例如机器翻译、文本摘要、语音识别转文字、聊天机器人对话等自然语言处理任务。Seq2Seq模型的核心思想是使用两个主要部分组成的神经网络框架：编码器（Encoder）和解码器（Decoder）。
三种传统Seq2Seq的框图，简单理解
Hali_Botebie的博客
04-26 395
统的Seq2Seq模型Encoder负责将输入序列x1 x2 x3 编码；图中的方块可以是一个简单的RNN单元，也可以是LSTM或者GRU单元。Encoder的最后一个hidden state作为Decoder的输入；我们把这个输入Decoder的向量称为context vector，即图中的c。注意，这个向量是固定长度的，不随输入序列的长度变化。上图展示的是Auto-regressive mode，即Decoder的前一个输出yi-1 输入进下一个单元，用于生成yi。
神经机器翻译：Attention、Seq2Seq与Transformer详解
2. **载入数据**：由于模型需要输入向量表示，需要将文本转换为数值形式，如one-hot编码或嵌入向量。pad函数用于规范化输入长度，确保所有样本具有相同的长度，通过填充或截断来达到这个目标。 3. **Encoder-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值