使用Python实现深度学习模型：序列到序列模型（Seq2Seq）

pip install tensorflow

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# 示例数据集
data = [
    ("Hello, how are you?", "Bonjour, comment ça va?"),
    ("I am fine.", "Je vais bien."),
    ("What is your name?", "Quel est ton nom?"),
    ("Nice to meet you.", "Ravi de vous rencontrer."),
    ("Thank you.", "Merci.")
]

# 准备输入和目标句子
input_texts = [pair[0] for pair in data]
target_texts = ['\t' + pair[1] + '\n' for pair in data]

# 词汇表大小
num_words = 10000

# 使用 Keras 的 Tokenizer 对输入和目标文本进行分词和编码
input_tokenizer = Tokenizer(num_words=num_words)
input_tokenizer.fit_on_texts(input_texts)
input_sequences = input_tokenizer.texts_to_sequences(input_texts)
input_sequences = pad_sequences(input_sequences, padding='post')

target_tokenizer = Tokenizer(num_words=num_words, filters='')
target_tokenizer.fit_on_texts(target_texts)
target_sequences = target_tokenizer.texts_to_sequences(target_texts)
target_sequences = pad_sequences(target_sequences, padding='post')

# 输入和目标序列的最大长度
max_encoder_seq_length = max(len(seq) for seq in input_sequences)
max_decoder_seq_length = max(len(seq) for seq in target_sequences)

# 创建输入和目标数据的 one-hot 编码
encoder_input_data = np.zeros((len(input_texts), max_encoder_seq_length, num_words), dtype='float32')
decoder_input_data = np.zeros((len(input_texts), max_decoder_seq_length, num_words), dtype='float32')
decoder_target_data = np.zeros((len(input_texts), max_decoder_seq_length, num_words), dtype='float32')

for i, (input_seq, target_seq) in enumerate(zip(input_sequences, target_sequences)):
    for t, word_index in enumerate(input_seq):
        encoder_input_data[i, t, word_index] = 1
    for t, word_index in enumerate(target_seq):
        decoder_input_data[i, t, word_index] = 1
        if t > 0:
            decoder_target_data[i, t-1, word_index] = 1

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense

# 编码器
encoder_inputs = Input(shape=(None, num_words))
encoder_lstm = LSTM(256, return_state=True)
encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs)
encoder_states = [state_h, state_c]

# 解码器
decoder_inputs = Input(shape=(None, num_words))
decoder_lstm = LSTM(256, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states)
decoder_dense = Dense(num_words, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

# 定义模型
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

# 编译模型
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

# 训练模型
model.fit([encoder_input_data, decoder_input_data], decoder_target_data, batch_size=64, epochs=100, validation_split=0.2)

# 编码器模型
encoder_model = Model(encoder_inputs, encoder_states)

# 解码器模型
decoder_state_input_h = Input(shape=(256,))
decoder_state_input_c = Input(shape=(256,))
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_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)

decoder_model = Model(
    [decoder_inputs] + decoder_states_inputs,
    [decoder_outputs] + decoder_states
)