当前位置：首页 > article >正文

深度学习-神经机器翻译模型

article 2025/2/11 3:46:00

以下为你介绍使用Python和深度学习框架Keras（基于TensorFlow后端）实现一个简单的神经机器翻译模型的详细步骤和代码示例，该示例主要处理英 - 法翻译任务。

1. 安装必要的库

首先，确保你已经安装了以下库：

pip install tensorflow keras numpy pandas

2. 代码实现

import numpy as np
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense

# 示例数据，实际应用中应使用大规模数据集
english_sentences = ['I am a student', 'He likes reading books', 'She is very beautiful']
french_sentences = ['Je suis un étudiant', 'Il aime lire des livres', 'Elle est très belle']

# 对输入和目标文本进行分词处理
input_tokenizer = Tokenizer()
input_tokenizer.fit_on_texts(english_sentences)
input_sequences = input_tokenizer.texts_to_sequences(english_sentences)

target_tokenizer = Tokenizer()
target_tokenizer.fit_on_texts(french_sentences)
target_sequences = target_tokenizer.texts_to_sequences(french_sentences)

# 获取输入和目标词汇表的大小
input_vocab_size = len(input_tokenizer.word_index) + 1
target_vocab_size = len(target_tokenizer.word_index) + 1

# 填充序列以确保所有序列长度一致
max_input_length = max([len(seq) for seq in input_sequences])
max_target_length = max([len(seq) for seq in target_sequences])

input_sequences = pad_sequences(input_sequences, maxlen=max_input_length, padding='post')
target_sequences = pad_sequences(target_sequences, maxlen=max_target_length, padding='post')

# 定义编码器模型
encoder_inputs = Input(shape=(max_input_length,))
encoder_embedding = Dense(256)(encoder_inputs)
encoder_lstm = LSTM(256, return_state=True)
_, state_h, state_c = encoder_lstm(encoder_embedding)
encoder_states = [state_h, state_c]

# 定义解码器模型
decoder_inputs = Input(shape=(max_target_length,))
decoder_embedding = Dense(256)(decoder_inputs)
decoder_lstm = LSTM(256, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states)
decoder_dense = Dense(target_vocab_size, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)

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

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

# 训练模型
model.fit([input_sequences, target_sequences[:, :-1]], target_sequences[:, 1:],
          epochs=100, batch_size=1)

# 定义编码器推理模型
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_embedding, 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)

# 实现翻译函数
def translate_sentence(input_seq):
    states_value = encoder_model.predict(input_seq)
    target_seq = np.zeros((1, 1))
    target_seq[0, 0] = target_tokenizer.word_index['<start>']  # 假设存在 <start> 标记
    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_word = target_tokenizer.index_word[sampled_token_index]
        decoded_sentence += ' ' + sampled_word
        if (sampled_word == '<end>' or
                len(decoded_sentence) > max_target_length):
            stop_condition = True
        target_seq = np.zeros((1, 1))
        target_seq[0, 0] = sampled_token_index
        states_value = [h, c]
    return decoded_sentence

# 测试翻译
test_input = input_tokenizer.texts_to_sequences(['I am a student'])
test_input = pad_sequences(test_input, maxlen=max_input_length, padding='post')
translation = translate_sentence(test_input)
print("Translation:", translation)

3. 代码解释

数据预处理：使用Tokenizer对英文和法文句子进行分词处理，将文本转换为数字序列。然后使用pad_sequences对序列进行填充，使所有序列长度一致。
模型构建：
- 编码器：使用LSTM层处理输入序列，并返回隐藏状态和单元状态。
- 解码器：以编码器的状态作为初始状态，使用LSTM层生成目标序列。
- 全连接层：将解码器的输出通过全连接层转换为目标词汇表上的概率分布。
模型训练：使用fit方法对模型进行训练，训练时使用编码器输入和部分解码器输入来预测解码器的下一个输出。
推理阶段：分别定义编码器推理模型和解码器推理模型，通过迭代的方式生成翻译结果。