1.Seq2Seq是什么？
Seq2Seq学习是训练一个模型，将来自一个领域的序列(例如英语语句)转换为另一个领域的序列(例如法语)。
"the cat sat on the mat" -> [Seq2Seq model] -> "le chat etait assis sur le tapis"
Seq2Seq模型可以用于机器翻译或者自由问答(在给定自然语言问题的情况下生成自然语言答案)。通常，它可以在任何需要生成文本的情况下使用。
我们可以使用多种方法来处理Seq2Seq任务，比如循环神经网络(RNN)或者(卷积神经网络)。在这里，我们将重点介绍RNN。
1.1 输入和输出序列的长度相同
当输入和输出序列具有相同的长度时，您可以仅使用LSTM或者GRU网络或者它们的堆叠网络来实现此类模型。例如训练一个教RNN学习加法的模型。
但是，在通常情况下，我们的输入序列和输出序列的长度并不一样。
1.2 输入序列和输出序列长度不同
一般情况下，输入序列和输出序列具有不同的长度(例如，机器翻译)，并且需要整个输入序列才能开始预测目标。这需要更高级的设置，也就是人们在没有其他上下文情况下提到"序列到序列模型"时通常所指的东西。运行方式如下：
-
RNN层(或者RNN的堆叠)作为编码器(encoder)：它处理输入序列并返回其自己的内部状态(internal state)。请注意，我们丢弃了编码器RNN的输出，仅使用其状态(state)。这个状态(state)将作为"上下文"或者"条件"来服务于下一步的decoder。
-
另一个RNN层(或者其堆叠)作为解码器(decoder):在给定目标序列的前一个字符的情况下，对其进行训练以预测目标序列的下一个字符。具体而言，它被训练为将目标序列变成相同的序列，但偏移一个时间步，在这种情况下，称为"teacher forcing"。重要的是，编码器使用来自编码器的状态向量作为初始状态，这就是解码器如何获取有关应该生成的信息的方式。在给定输入序列[…t]的情况，编码器会学习生成目标序列[t+1…]。
上述是训练模型，在推理模式中，即当我们想解码未知的输入序列时，我们会经历一个略有不同的过程:
-
1）将输入序列编码为状态向量
-
2）从大小为1的目标序列开始(仅是序列开始字符)
-
3）将状态向量和1个字符的目标序列提供给解码器，以生成下一个字符的预测。
-
4）使用这些预测来采样下一个字符(argmax)。
-
5）将采样的字符追加到目标序列
-
6）重复上述过程直到生成序列结束字符或达到字符数限制。
在训练的时候也可以采用此种方式，即通过将解码器的预测重新注入到解码器中。
2.keras实现Seq2Seq
-
实现英语到法语的翻译任务
-
编码器和解码器均使用单层LSTM。
-
基于字符级别的序列到序列模型
大概过程如下：
-
1）把输入和输出序列转为3维numpy张量,encoder_input_data, decoder_input_data, decoder_target_data:
-
2）给定encoder_input_data和decoder_input_data，训练一个基础的基于LSTM的Seq2Seq模型来预测decoder_target_data
-
- 解码测试序列检查模型是否有效
因为训练过程和推理过程(解码序列)完全不同，尽管它们都使用相同的内部层，我们对两者使用不同的模型。
2.1 基本参数设置
from __future__ import print_function
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input,LSTM,Dense
import tensorflow.keras as keras
import numpy as np
#参数设置
batch_size=64
epochs=100
latent_dim=256
num_samples=10000 #样本数量
data_path="/content/drive/My Drive/data/fra-en.txt"
2.2 训练数据准备
#训练数据准备
input_texts=[]
target_texts=[]
input_characters=set()
target_characters=set()
with open(data_path,"r",encoding="utf-8") as f:
lines=f.read().split("\n")
for line in lines[:min(num_samples,len(lines)-1)]:
input_text,target_text=line.split("\t")
#对于目标序列使用"\t"键作为序列的起始字符
#使用""\n"作为结束字符
target_text="\t"+target_text+"\n"
input_texts.append(input_text)
target_texts.append(target_text)
for char in input_text:
if char not in input_characters:
input_characters.add(char)
for char in target_text:
if char not in target_characters:
target_characters.add(char)
input_characters=sorted(list(input_characters))
target_characters=sorted(list(target_characters))
num_encoder_tokens=len(input_characters)#所有输入序列去重字符数,区分大小写
num_decoder_tokens=len(target_characters)#所有输出序列去重字符数
max_encoder_seq_length=max([len(txt) for txt in input_texts])
max_decoder_deq_length=max([len(txt) for txt in target_texts])
print("样本数量：",len(input_texts))
print("输入序列字符数:",num_encoder_tokens)
print("输出序列字符数:",num_decoder_tokens)
print("输入序列最长序列长度:",max_encoder_seq_length)
print("输出序列最长序列长度:",max_decoder_deq_length)
input_token_index=dict([(char,i) for i,char in enumerate(input_characters)])
target_token_index=dict([char,i] for i,char in enumerate(target_characters))
encoder_input_data=np.zeros((len(input_texts),max_encoder_seq_length,num_encoder_tokens),dtype="float32")
decoder_input_data=np.zeros((len(input_texts),max_decoder_deq_length,num_decoder_tokens),dtype="float32")
decoder_target_data=np.zeros((len(input_texts),max_decoder_deq_length,num_decoder_tokens),dtype="float32")
for i,(input_text,target_text) in enumerate(zip(input_texts,target_texts)):
for t,char in enumerate(input_text):
encoder_input_data[i,t,input_token_index[char]]=1
encoder_input_data[i,t+1:,input_token_index[" "]]=1 #长度不够的序列使用" "进行padding
for t,char in enumerate(target_text):
decoder_input_data[i,t,target_token_index[char]]=1
if t>0:
#目标数据decoder_target_data不包括起始字符，并向前一步(teacher forcing)
decoder_target_data[i,t-1,target_token_index[char]]=1
decoder_input_data[i,t+1:,target_token_index[" "]]=1
decoder_target_data[i,t:,target_token_index[" "]]=1
2.3 模型网络结构搭建
#模型训练网络结构搭建
#encoder端
encoder_inputs=Input(shape=(None,num_encoder_tokens))
encoder=LSTM(latent_dim,return_state=True) #return_state参数控制是否返回cell state
encoder_outputs,state_h,state_c=encoder(encoder_inputs)
encoder_states=[state_h,state_c]
#decoder
decoder_inputs=Input(shape=(None,num_decoder_tokens))
#返回所有的output sequences和internal states。在训练过程中不使用return states,但在推理中使用
decoder_lstm=LSTM(latent_dim,return_sequences=True,return_state=True)#return_sequences控制是否返回所有时间步的hidden state
decoder_outputs,_,_=decoder_lstm(decoder_inputs,initial_state=encoder_states) #使用encoder的输出状态作为deocder的初始状态
decoder_dense=Dense(num_decoder_tokens,activation="softmax")
decoder_outputs=decoder_dense(decoder_outputs)
model=Model([encoder_inputs,decoder_inputs],decoder_outputs)
model.compile(optimizer="rmsprop",loss="categorical_crossentropy",metrics=["accuracy"])
model.fit([encoder_input_data,decoder_input_data],decoder_target_data,batch_size=batch_size,epochs=epochs,validation_split=0.2)
2.4 模型推理
- 编码输入和获取初始的decoder state
- 使用初始state和序列的开始字符作为目标来运行decoder的一步，输出将作为下一个目标字符
- 使用现在的目标字符和状态来重复以上过程
encoder_model=Model(encoder_inputs,encoder_states) #推理模式的encoder端
#推理模式decoder端
decoder_state_input_h=Input(shape=(latent_dim,)) #hidden state
decoder_state_input_c=Input(shape=(latent_dim,)) #cell state
decoder_states_inputs=[decoder_state_input_h,decoder_state_input_c]
decoder_outputs,state_h,state_c=decoder_lstm(decoder_inputs,initial_state=decoder_states_inputs) #decoder_lstm在训练阶段已经训练好了，推理阶段直接拿来用
decoder_states=[state_h,state_c]
decoder_outputs=decoder_dense(decoder_outputs)#decoder_dense在训练阶段已经训练好了，推理阶段直接拿来用
decoder_model=Model([decoder_inputs]+decoder_states_inputs,[decoder_outputs]+decoder_states)
reverse_input_char_index=dict((i,char) for char ,i in input_token_index.items())
reverse_target_char_index=dict((i,char) for char,i in target_token_index.items())
#生成翻译序列
def decode_sequence(input_seq):
#编码输入作为state向量
states_value=encoder_model.predict(input_seq)
target_seq=np.zeros((1,1,num_decoder_tokens)) #长度为1的目标序列
target_seq[0,0,target_token_index["\t"]]=1
stop_condition=False
decoded_sentence=""
while not stop_condition:
output_tokens,h,c=decoder_model.predict([target_seq]+states_value)
sampled_token_index=np.argmax(output_tokens[0,-1,:])
sampled_char=reverse_target_char_index[sampled_token_index]
decoded_sentence+=sampled_char
if(sampled_char=="\n" or len(decoded_sentence)>max_decoder_deq_length):
stop_condition=True
target_seq=np.zeros((1,1,num_decoder_tokens))
target_seq[0,0,sampled_token_index]=1
states_value=[h,c]
return decoded_sentence
for seq_index in range(100):
input_seq=encoder_input_data[seq_index:seq_index+1]
decoded_sentence=decode_sequence(input_seq)
print("-")
print("Input sentence:",input_texts[seq_index])
print("Decoded sentence:",decoded_sentence)
# 2.5 使用GRU代替LSTM
#encoder
encoder_inputs=Input(shape=(None,num_encoder_tokens))
encoder=keras.layers.GRU(latent_dim,return_state=True)
encoder_outputs,state_h=encoder(encoder_inputs)
#decoder
decoder_inputs=Input(shape=(None,num_decoder_tokens))
decoder_gru=keras.layers.GRU(latent_dim,return_sequences=True)
decoder_outputs=decoder_gru(decoder_inputs,initial_state=state_h)
decoder_dense=Dense(num_decoder_tokens,activation="softmax")
decoder_outputs=decoder_dense(decoder_outputs)
gru_model=Model([encoder_inputs,decoder_inputs],decoder_outputs)
gru_model.compile(optimizer="rmsprop",loss="categorical_crossentropy",metrics=["accuracy"])
gru_model.fit([encoder_input_data,decoder_input_data],decoder_target_data,batch_size=batch_size,epochs=epochs,validation_split=0.2)
数据挖掘与机器学习笔记
参考：
[1]https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html
[2]https://github.com/keras-team/keras/blob/master/examples/lstm_seq2seq.py
扫一扫
1513
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
