开发一个深度学习模型以自动
使用 Keras 和 Python 进行德语到英语的翻译，分步讲解。
机器翻译是一项具有挑战性的任务，传统上涉及使用高度复杂的语言知识开发的大型统计模型。
神经机器翻译是使用深度神经网络来解决机器翻译问题。
在本教程中，您将学习如何开发一个神经机器翻译系统，用于将德语短语翻译成英语。
完成本教程后，您将了解：
- 如何清理和准备数据以训练神经机器翻译系统。
- 如何为机器翻译开发一个编码器-解码器模型。
- 如何使用训练好的模型对新输入的短语进行推理，并评估模型的技能。
开启您的项目，阅读我的新书《自然语言处理深度学习》，其中包含分步教程以及所有示例的Python源代码文件。
让我们开始吧。
- 更新于 2019 年 4 月：修复了 BLEU 分数计算中的错误（作者：Zhongpu Chen）。
- 更新于 2020 年 10 月：添加了指向原始数据集的直接链接。
如何在 Keras 中开发神经机器翻译系统
照片由 Björn Groß 拍摄，保留部分权利。
教程概述
本教程分为4个部分，它们是：
- 德语到英语翻译数据集
- 准备文本数据
- 训练神经翻译模型
- 评估神经翻译模型
Python 环境
本教程假设您已安装 Python 3 SciPy 环境。
您必须安装 Keras（2.0 或更高版本），并使用 TensorFlow 或 Theano 后端。
本教程还假设您已安装 NumPy 和 Matplotlib。
如果您在环境方面需要帮助，请参阅此帖子
本教程不需要 GPU，但您可以在 Amazon Web Services 上廉价地访问 GPU。在此教程中学习如何操作
让我们开始吧。
需要深度学习处理文本数据的帮助吗？
立即参加我的免费7天电子邮件速成课程（附代码）。
点击注册，同时获得该课程的免费PDF电子书版本。
德语到英语翻译数据集
在本教程中，我们将使用一个德语到英语词汇的数据集，该数据集用作语言学习闪卡的基础。
该数据集来自 ManyThings.org 网站，其中的示例来自 Tatoeba Project。该数据集包含德语短语及其对应的英语短语，旨在与 Anki 闪卡软件一起使用。
该页面提供了许多语言对的列表，鼓励您探索其他语言。
请注意，原始数据集已更改，如果直接使用，将导致本教程中断并出现错误。
|
1 |
ValueError: 要解包的值太多 (预期为2) |
因此，您可以直接从此处下载正确格式的原始数据集。
将数据集文件下载到您当前的工件目录。
您将获得一个名为 deu.txt 的文件，其中包含 152,820 对英语到德语短语，每行一对，用制表符分隔语言。
例如，文件的前 5 行如下所示：
|
1 2 3 4 5 |
Hi. Hallo! Hi. Grüß Gott! Run! Lauf! Wow! Potzdonner! Wow! Donnerwetter! |
我们将把预测问题构建为给定德语单词序列作为输入，翻译或预测英语单词序列。
我们将开发的模型将适用于一些初学者德语短语。
准备文本数据
下一步是准备好文本数据以供建模。
如果您不熟悉文本数据清理，请参阅此帖子
查看原始数据，注意我们可能需要在数据清理操作中处理的内容。
例如，在我查看原始数据时，我注意到一些观察结果：
- 存在标点符号。
- 文本包含大写和小写。
- 德语中有特殊字符。
- 英语中有重复的短语，但德语中有不同的翻译。
- 文件按句子长度排序，文件末尾的句子非常长。
您是否注意到其他可能重要的内容？
在下面的评论中告诉我。
良好的文本清理程序可以处理其中一些或所有观察结果。
数据准备分为两个小节：
- 清理文本
- 拆分文本
1. 清理文本
首先，我们必须以一种可以保留德语 Unicode 字符的方式加载数据。下面的 load_doc() 函数会将文件加载为纯文本。
|
1 2 3 4 5 6 7 8 9 |
# 加载文档到内存 def load_doc(filename): # 以只读方式打开文件 file = open(filename, mode='rt', encoding='utf-8') # 读取所有文本 text = file.read() # 关闭文件 file.close() 返回 文本 |
每一行包含一对短语，先是英语，然后是德语，用制表符分隔。
我们必须按行分割加载的文本，然后再按短语分割。下面的 to_pairs() 函数将分割加载的文本。
|
1 2 3 4 5 |
# 将加载的文档分割成句子 def to_pairs(doc): lines = doc.strip().split('\n') pairs = [line.split('\t') for line in lines] return pairs |
现在我们可以清理每个句子了。我们将执行的具体清理操作如下：
- 删除所有不可打印字符。
- 删除所有标点符号字符。
- 将所有 Unicode 字符标准化为 ASCII（例如，拉丁字符）。
- 将大小写标准化为小写。
- 删除任何剩余的非字母字符。
我们将对加载数据集中的每个短语对执行这些操作。
下面的 clean_pairs() 函数实现了这些操作。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# 清理行列表 def clean_pairs(lines): cleaned = list() # 准备用于字符过滤的正则表达式 re_print = re.compile('[^%s]' % re.escape(string.printable)) # 准备用于删除标点符号的转换表 table = str.maketrans('', '', string.punctuation) for pair in lines: clean_pair = list() for line in pair: # 标准化 Unicode 字符 line = normalize('NFD', line).encode('ascii', 'ignore') line = line.decode('UTF-8') # 根据空白符进行分词 line = line.split() # 转换为小写 line = [word.lower() for word in line] # 从每个标记中删除标点符号 line = [word.translate(table) for word in line] # 从每个 token 中删除不可打印字符 line = [re_print.sub('', w) for w in line] # 删除包含数字的标记 line = [word for word in line if word.isalpha()] # 存储为字符串 clean_pair.append(' '.join(line)) cleaned.append(clean_pair) return array(cleaned) |
最后，数据清理完毕后，我们可以将短语对列表保存到文件中，以供使用。
save_clean_data() 函数使用 pickle API 将清理后的文本列表保存到文件。
将所有这些整合在一起，完整的示例如下所示。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
import string import re from pickle import dump from unicodedata import normalize from numpy import array # 加载文档到内存 def load_doc(filename): # 以只读方式打开文件 file = open(filename, mode='rt', encoding='utf-8') # 读取所有文本 text = file.read() # 关闭文件 file.close() return text # 将加载的文档分割成句子 def to_pairs(doc): lines = doc.strip().split('\n') pairs = [line.split('\t') for line in lines] return pairs # 清理行列表 def clean_pairs(lines): cleaned = list() # 准备用于字符过滤的正则表达式 re_print = re.compile('[^%s]' % re.escape(string.printable)) # 准备用于删除标点符号的转换表 table = str.maketrans('', '', string.punctuation) for pair in lines: clean_pair = list() for line in pair: # 标准化 Unicode 字符 line = normalize('NFD', line).encode('ascii', 'ignore') line = line.decode('UTF-8') # 根据空白符进行分词 line = line.split() # 转换为小写 line = [word.lower() for word in line] # 从每个标记中删除标点符号 line = [word.translate(table) for word in line] # 从每个 token 中删除不可打印字符 line = [re_print.sub('', w) for w in line] # 删除包含数字的标记 line = [word for word in line if word.isalpha()] # 存储为字符串 clean_pair.append(' '.join(line)) cleaned.append(clean_pair) return array(cleaned) # 将清理后的句子列表保存到文件 def save_clean_data(sentences, filename): dump(sentences, open(filename, 'wb')) print('已保存： %s' % filename) # 加载数据集 filename = 'deu.txt' doc = load_doc(filename) # 分割成英语-德语对 pairs = to_pairs(doc) # 清理句子 clean_pairs = clean_pairs(pairs) # 将清理后的对保存到文件 save_clean_data(clean_pairs, 'english-german.pkl') # 抽查 for i in range(100): print('[%s] => [%s]' % (clean_pairs[i,0], clean_pairs[i,1])) |
运行此示例会在当前工件目录中创建一个名为 english-german.pkl 的新文件，其中包含清理后的文本。
运行结束后，会打印出一些清理后的文本示例供我们评估，以确认清理操作已按预期执行。
|
1 2 3 4 5 6 7 8 9 10 11 |
[hi] => [hallo] [hi] => [gru gott] [run] => [lauf] [wow] => [potzdonner] [wow] => [donnerwetter] [fire] => [feuer] [help] => [hilfe] [help] => [zu hulf] [stop] => [stopp] [wait] => [warte] ... |
2. 拆分文本
清理后的数据包含略多于 150,000 对短语，文件末尾的一些短语对非常长。
这对于开发小型翻译模型来说是一个不错的示例数量。模型的复杂性随着示例数量、短语长度和词汇量的大小而增加。
尽管我们有了一个用于翻译建模的不错数据集，但我们将稍微简化问题，以大幅减少所需模型的规模，进而减少拟合模型所需的训练时间。
您可以探索将模型开发在更完整的数据集上作为扩展；我很想听听您的进展。
我们将通过将数据集减少到文件中的前 10,000 个示例来简化问题；这些将是数据集中最短的短语。
此外，我们将把前 9,000 个示例用作训练示例，其余 1,000 个示例用于测试拟合模型。
下面是加载清理后的数据、拆分它并将拆分后的数据部分保存到新文件的完整示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
from pickle import load from pickle import dump from numpy.random import rand from numpy.random import shuffle # 加载干净的数据集 def load_clean_sentences(filename): return load(open(filename, 'rb')) # 将清理后的句子列表保存到文件 def save_clean_data(sentences, filename): dump(sentences, open(filename, 'wb')) print('已保存： %s' % filename) # 加载数据集 raw_dataset = load_clean_sentences('english-german.pkl') # 减少数据集大小 n_sentences = 10000 dataset = raw_dataset[:n_sentences, :] # 随机打乱 shuffle(dataset) # 分割成训练/测试集 train, test = dataset[:9000], dataset[9000:] # 保存 save_clean_data(dataset, 'english-german-both.pkl') save_clean_data(train, 'english-german-train.pkl') save_clean_data(test, 'english-german-test.pkl') |
运行示例会创建三个新文件：english-german-both.pkl 包含所有训练和测试示例，可用于定义问题参数，如最大短语长度和词汇量；以及 english-german-train.pkl 和 english-german-test.pkl 文件，分别用于训练和测试数据集。
现在我们可以开始开发我们的翻译模型了。
训练神经翻译模型
在本节中，我们将开发神经翻译模型。
如果您是神经翻译模型的新手，请参阅这篇博文：
这包括加载和准备用于建模的清理后的文本数据，以及定义和在准备好的数据上训练模型。
让我们先加载数据集，以便我们可以准备数据。下面名为 load_clean_sentences() 的函数可用于依次加载训练、测试和所有数据集。
|
1 2 3 4 5 6 7 8 |
# 加载干净的数据集 def load_clean_sentences(filename): return load(open(filename, 'rb')) # 加载数据集 dataset = load_clean_sentences('english-german-both.pkl') train = load_clean_sentences('english-german-train.pkl') test = load_clean_sentences('english-german-test.pkl') |
我们将使用“both”数据集或训练和测试数据集的组合来定义问题中的最大长度和词汇量。
这是为了简化。或者，我们可以仅从训练数据集中定义这些属性，并截断测试集中过长或包含词汇量外单词的示例。
我们可以使用 Keras 的 Tokenize 类将单词映射到整数，这对于建模是必需的。我们将为英语序列和德语序列使用单独的分词器。下面的 create_tokenizer() 函数将在一系列短语上训练一个分词器。
|
1 2 3 4 5 |
# 训练一个分词器 def create_tokenizer(lines): tokenizer = Tokenizer() tokenizer.fit_on_texts(lines) return tokenizer |
类似地，下面名为 max_length() 的函数将查找短语列表中最长序列的长度。
|
1 2 3 |
# 最大句子长度 def max_length(lines): return max(len(line.split()) for line in lines) |
我们可以使用组合数据集调用这些函数来为英语和德语短语准备分词器、词汇量大小和最大长度。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 准备英语分词器 eng_tokenizer = create_tokenizer(dataset[:, 0]) eng_vocab_size = len(eng_tokenizer.word_index) + 1 eng_length = max_length(dataset[:, 0]) print('英语词汇量大小: %d' % eng_vocab_size) print('英语最大长度: %d' % (eng_length)) # 准备德语分词器 ger_tokenizer = create_tokenizer(dataset[:, 1]) ger_vocab_size = len(ger_tokenizer.word_index) + 1 ger_length = max_length(dataset[:, 1]) print('德语词汇量大小: %d' % ger_vocab_size) print('德语最大长度: %d' % (ger_length)) |
现在我们可以准备训练数据集了。
每个输入和输出序列都必须编码为整数，并填充到最大短语长度。这是因为我们将为输入序列使用词嵌入，并对输出序列进行独热编码。下面名为 encode_sequences() 的函数将执行这些操作并返回结果。
|
1 2 3 4 5 6 7 |
# 编码和填充序列 def encode_sequences(tokenizer, length, lines): # 整数编码序列 X = tokenizer.texts_to_sequences(lines) # 用 0 值填充序列 X = pad_sequences(X, maxlen=length, padding='post') return X |
输出序列需要进行独热编码。这是因为模型将预测词汇表中每个单词的概率作为输出。
下面名为 encode_output() 的函数将对英语输出序列进行独热编码。
|
1 2 3 4 5 6 7 8 9 |
# 对目标序列进行独热编码 def encode_output(sequences, vocab_size): ylist = list() for sequence in sequences: encoded = to_categorical(sequence, num_classes=vocab_size) ylist.append(encoded) y = array(ylist) y = y.reshape(sequences.shape[0], sequences.shape[1], vocab_size) return y |
我们可以利用这两个函数，准备好训练和测试数据集，以便训练模型。
|
1 2 3 4 5 6 7 8 |
# 准备训练数据 trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1]) trainY = encode_sequences(eng_tokenizer, eng_length, train[:, 0]) trainY = encode_output(trainY, eng_vocab_size) # 准备验证数据 testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1]) testY = encode_sequences(eng_tokenizer, eng_length, test[:, 0]) testY = encode_output(testY, eng_vocab_size) |
我们现在可以定义模型了。
我们将在此问题上使用一个编码器-解码器 LSTM 模型。在此架构中，输入序列由一个称为编码器的前端模型编码，然后由一个称为解码器的后端模型逐字解码。
下面的 define_model() 函数定义了模型，并接受用于配置模型的许多参数，例如输入和输出词汇表的大小、输入和输出短语的最大长度以及用于配置模型的内存单元数量。
该模型使用高效的 Adam 随机梯度下降方法进行训练，并最小化分类损失函数，因为我们将预测问题构建为多类分类问题。
此模型的配置并未针对此问题进行优化，这意味着您有充足的机会对其进行调整并提高翻译的准确性。我很想看看你们能取得什么成果。
有关配置神经网络机器翻译模型的更多建议，请参阅这篇文章
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 定义 NMT 模型 def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units): model = Sequential() model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True)) model.add(LSTM(n_units)) model.add(RepeatVector(tar_timesteps)) model.add(LSTM(n_units, return_sequences=True)) model.add(TimeDistributed(Dense(tar_vocab, activation='softmax'))) return model # 定义模型 model = define_model(ger_vocab_size, eng_vocab_size, ger_length, eng_length, 256) model.compile(optimizer='adam', loss='categorical_crossentropy') # 总结已定义的模型 print(model.summary()) plot_model(model, to_file='model.png', show_shapes=True) |
最后，我们可以训练模型。
我们将模型训练 30 个 epoch，批量大小为 64 个示例。
我们使用检查点来确保每次模型在测试集上的性能提高时，模型都会被保存到文件中。
|
1 2 3 4 |
# 拟合模型 filename = 'model.h5' checkpoint = ModelCheckpoint(filename, monitor='val_loss', verbose=1, save_best_only=True, mode='min') model.fit(trainX, trainY, epochs=30, batch_size=64, validation_data=(testX, testY), callbacks=[checkpoint], verbose=2) |
我们可以将所有这些内容结合起来，并拟合神经网络翻译模型。
下面列出了完整的可运行示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
from pickle import load from numpy import array from keras.preprocessing.text import Tokenizer from keras.preprocessing.sequence import pad_sequences from keras.utils import to_categorical from keras.utils.vis_utils import plot_model from keras.models import Sequential 从 keras.layers 导入 LSTM from keras.layers import Dense from keras.layers import Embedding from keras.layers import RepeatVector from keras.layers import TimeDistributed from keras.callbacks import ModelCheckpoint # 加载干净的数据集 def load_clean_sentences(filename): return load(open(filename, 'rb')) # 训练一个分词器 def create_tokenizer(lines): tokenizer = Tokenizer() tokenizer.fit_on_texts(lines) return tokenizer # 最大句子长度 def max_length(lines): return max(len(line.split()) for line in lines) # 编码和填充序列 def encode_sequences(tokenizer, length, lines): # 整数编码序列 X = tokenizer.texts_to_sequences(lines) # 用 0 值填充序列 X = pad_sequences(X, maxlen=length, padding='post') return X # 对目标序列进行独热编码 def encode_output(sequences, vocab_size): ylist = list() for sequence in sequences: encoded = to_categorical(sequence, num_classes=vocab_size) ylist.append(encoded) y = array(ylist) y = y.reshape(sequences.shape[0], sequences.shape[1], vocab_size) return y # 定义 NMT 模型 def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units): model = Sequential() model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True)) model.add(LSTM(n_units)) model.add(RepeatVector(tar_timesteps)) model.add(LSTM(n_units, return_sequences=True)) model.add(TimeDistributed(Dense(tar_vocab, activation='softmax'))) return model # 加载数据集 dataset = load_clean_sentences('english-german-both.pkl') train = load_clean_sentences('english-german-train.pkl') test = load_clean_sentences('english-german-test.pkl') # 准备英语分词器 eng_tokenizer = create_tokenizer(dataset[:, 0]) eng_vocab_size = len(eng_tokenizer.word_index) + 1 eng_length = max_length(dataset[:, 0]) print('英语词汇量大小: %d' % eng_vocab_size) print('英语最大长度: %d' % (eng_length)) # 准备德语分词器 ger_tokenizer = create_tokenizer(dataset[:, 1]) ger_vocab_size = len(ger_tokenizer.word_index) + 1 ger_length = max_length(dataset[:, 1]) print('德语词汇量大小: %d' % ger_vocab_size) print('德语最大长度: %d' % (ger_length)) # 准备训练数据 trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1]) trainY = encode_sequences(eng_tokenizer, eng_length, train[:, 0]) trainY = encode_output(trainY, eng_vocab_size) # 准备验证数据 testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1]) testY = encode_sequences(eng_tokenizer, eng_length, test[:, 0]) testY = encode_output(testY, eng_vocab_size) # 定义模型 model = define_model(ger_vocab_size, eng_vocab_size, ger_length, eng_length, 256) model.compile(optimizer='adam', loss='categorical_crossentropy') # 总结已定义的模型 print(model.summary()) plot_model(model, to_file='model.png', show_shapes=True) # 拟合模型 filename = 'model.h5' checkpoint = ModelCheckpoint(filename, monitor='val_loss', verbose=1, save_best_only=True, mode='min') model.fit(trainX, trainY, epochs=30, batch_size=64, validation_data=(testX, testY), callbacks=[checkpoint], verbose=2) |
运行示例首先打印数据集参数的摘要，例如词汇量大小和最大短语长度。
|
1 2 3 4 |
英语词汇量大小: 2404 英语最大长度: 5 德语词汇量大小: 3856 德语最大长度: 10 |
接下来，打印已定义模型的摘要，让我们确认模型配置。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
_________________________________________________________________ 层（类型） 输出形状 参数数量 ================================================================= embedding_1 (Embedding) (None, 10, 256) 987136 _________________________________________________________________ lstm_1 (LSTM) (None, 256) 525312 _________________________________________________________________ repeat_vector_1 (RepeatVecto (None, 5, 256) 0 _________________________________________________________________ lstm_2 (LSTM) (None, 5, 256) 525312 _________________________________________________________________ time_distributed_1 (TimeDist (None, 5, 2404) 617828 ================================================================= 总参数: 2,655,588 可训练参数: 2,655,588 不可训练参数: 0 _________________________________________________________________ |
还创建了模型的图，提供了模型配置的另一个视角。
NMT 模型图
接下来，训练模型。
在现代 CPU 硬件上，每个 epoch 大约需要 30 秒；不需要 GPU。
注意：您的结果可能因算法或评估过程的随机性、或数值精度的差异而有所不同。可以尝试多次运行示例并比较平均结果。
在运行期间，模型将保存到文件 model.h5 中，准备好在下一步中进行推理。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
... Epoch 26/30 Epoch 00025: val_loss 从 2.20048 提高到 2.19976，将模型保存到 model.h5 17s - loss: 0.7114 - val_loss: 2.1998 Epoch 27/30 Epoch 00026: val_loss 从 2.19976 提高到 2.18255，将模型保存到 model.h5 17s - loss: 0.6532 - val_loss: 2.1826 Epoch 28/30 Epoch 00027: val_loss 未改进 17s - loss: 0.5970 - val_loss: 2.1970 Epoch 29/30 Epoch 00028: val_loss 从 2.18255 提高到 2.17872，将模型保存到 model.h5 17s - loss: 0.5474 - val_loss: 2.1787 Epoch 30/30 Epoch 00029: val_loss 未改进 17s - loss: 0.5023 - val_loss: 2.1823 |
评估神经翻译模型
我们将评估模型在训练集和测试集上的表现。
模型在训练集上的表现应该非常好，并且理想情况下已经泛化到在测试集上表现良好。
理想情况下，我们应该使用单独的验证数据集来帮助模型在训练期间进行选择，而不是测试集。您可以尝试将其作为扩展。
必须像以前一样加载和准备干净的数据集。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
... # 加载数据集 dataset = load_clean_sentences('english-german-both.pkl') train = load_clean_sentences('english-german-train.pkl') test = load_clean_sentences('english-german-test.pkl') # 准备英语分词器 eng_tokenizer = create_tokenizer(dataset[:, 0]) eng_vocab_size = len(eng_tokenizer.word_index) + 1 eng_length = max_length(dataset[:, 0]) # 准备德语分词器 ger_tokenizer = create_tokenizer(dataset[:, 1]) ger_vocab_size = len(ger_tokenizer.word_index) + 1 ger_length = max_length(dataset[:, 1]) # 准备数据 trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1]) testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1]) |
接下来，必须加载训练期间保存的最佳模型。
|
1 2 |
# 加载模型 model = load_model('model.h5') |
评估涉及两个步骤：首先生成翻译后的输出序列，然后为许多输入示例重复此过程，并汇总模型在多个案例中的性能。
从推理开始，模型可以一次性预测整个输出序列。
|
1 |
translation = model.predict(source, verbose=0) |
这将是一个整数序列，我们可以枚举它并在分词器中查找，以便将其映射回单词。
下面的 word_for_id() 函数将执行此反向映射。
|
1 2 3 4 5 6 |
# 将整数映射到单词 def word_for_id(integer, tokenizer): for word, index in tokenizer.word_index.items(): if index == integer: return word return None |
我们可以对翻译中的每个整数执行此映射，并将结果作为单词字符串返回。
下面的 predict_sequence() 函数对单个编码的源短语执行此操作。
|
1 2 3 4 5 6 7 8 9 10 11 |
# 根据源序列生成目标 def predict_sequence(model, tokenizer, source): prediction = model.predict(source, verbose=0)[0] integers = [argmax(vector) for vector in prediction] target = list() for i in integers: word = word_for_id(i, tokenizer) if word is None: break target.append(word) return ' '.join(target) |
接下来，我们可以为数据集中的每个源短语重复此操作，并将预测结果与预期的英语目标短语进行比较。
我们可以将其中一些比较打印到屏幕上，以了解模型在实践中的表现。
我们还将计算 BLEU 分数，以量化模型表现的程度。
您可以在这里了解有关 BLEU 分数的更多信息
下面的 evaluate_model() 函数实现了这一点，它为提供的每个短语调用上面的 predict_sequence() 函数。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# 评估模型的技能 def evaluate_model(model, tokenizer, sources, raw_dataset): actual, predicted = list(), list() for i, source in enumerate(sources): # 翻译编码的源文本 source = source.reshape((1, source.shape[0])) translation = predict_sequence(model, eng_tokenizer, source) raw_target, raw_src = raw_dataset[i] if i < 10: print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation)) actual.append([raw_target.split()]) predicted.append(translation.split()) # 计算 BLEU 分数 print('BLEU-1: %f' % corpus_bleu(actual, predicted, weights=(1.0, 0, 0, 0))) print('BLEU-2: %f' % corpus_bleu(actual, predicted, weights=(0.5, 0.5, 0, 0))) print('BLEU-3: %f' % corpus_bleu(actual, predicted, weights=(0.3, 0.3, 0.3, 0))) print('BLEU-4: %f' % corpus_bleu(actual, predicted, weights=(0.25, 0.25, 0.25, 0.25))) |
我们可以将所有这些内容结合起来，并在训练集和测试集上评估已加载的模型。
完整的代码列表如下。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
from pickle import load from numpy import array from numpy import argmax from keras.preprocessing.text import Tokenizer from keras.preprocessing.sequence import pad_sequences from keras.models import load_model from nltk.translate.bleu_score import corpus_bleu # 加载干净的数据集 def load_clean_sentences(filename): return load(open(filename, 'rb')) # 训练一个分词器 def create_tokenizer(lines): tokenizer = Tokenizer() tokenizer.fit_on_texts(lines) return tokenizer # 最大句子长度 def max_length(lines): return max(len(line.split()) for line in lines) # 编码和填充序列 def encode_sequences(tokenizer, length, lines): # 整数编码序列 X = tokenizer.texts_to_sequences(lines) # 用 0 值填充序列 X = pad_sequences(X, maxlen=length, padding='post') return X # 将整数映射到单词 def word_for_id(integer, tokenizer): for word, index in tokenizer.word_index.items(): if index == integer: return word return None # 根据源序列生成目标 def predict_sequence(model, tokenizer, source): prediction = model.predict(source, verbose=0)[0] integers = [argmax(vector) for vector in prediction] target = list() for i in integers: word = word_for_id(i, tokenizer) if word is None: break target.append(word) return ' '.join(target) # 评估模型的技能 def evaluate_model(model, tokenizer, sources, raw_dataset): actual, predicted = list(), list() for i, source in enumerate(sources): # 翻译编码的源文本 source = source.reshape((1, source.shape[0])) translation = predict_sequence(model, eng_tokenizer, source) raw_target, raw_src = raw_dataset[i] if i < 10: print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation)) actual.append([raw_target.split()]) predicted.append(translation.split()) # 计算 BLEU 分数 print('BLEU-1: %f' % corpus_bleu(actual, predicted, weights=(1.0, 0, 0, 0))) print('BLEU-2: %f' % corpus_bleu(actual, predicted, weights=(0.5, 0.5, 0, 0))) print('BLEU-3: %f' % corpus_bleu(actual, predicted, weights=(0.3, 0.3, 0.3, 0))) print('BLEU-4: %f' % corpus_bleu(actual, predicted, weights=(0.25, 0.25, 0.25, 0.25))) # 加载数据集 dataset = load_clean_sentences('english-german-both.pkl') train = load_clean_sentences('english-german-train.pkl') test = load_clean_sentences('english-german-test.pkl') # 准备英语分词器 eng_tokenizer = create_tokenizer(dataset[:, 0]) eng_vocab_size = len(eng_tokenizer.word_index) + 1 eng_length = max_length(dataset[:, 0]) # 准备德语分词器 ger_tokenizer = create_tokenizer(dataset[:, 1]) ger_vocab_size = len(ger_tokenizer.word_index) + 1 ger_length = max_length(dataset[:, 1]) # 准备数据 trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1]) testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1]) # 加载模型 model = load_model('model.h5') # 在一些训练序列上进行测试 print('train') evaluate_model(model, eng_tokenizer, trainX, train) # 在一些测试序列上进行测试 print('test') evaluate_model(model, eng_tokenizer, testX, test) |
运行示例首先打印源文本、预期翻译和预测翻译的示例，以及训练数据集和测试数据集的分数。
注意：您的结果可能因算法或评估过程的随机性、或数值精度的差异而有所不同。可以尝试多次运行示例并比较平均结果。
查看测试数据集的结果，我们可以看到翻译是可读的，并且大部分是正确的。
例如，“ich bin brillentrager”被正确翻译为“i wear glasses”。
我们还可以看到翻译并不完美，“hab ich nicht recht”被翻译为“am i fat”，而不是预期的“am i wrong”。
我们还可以看到大约 0.45 的 BLEU-4 分数，这为我们期望从该模型获得的性能提供了一个上限。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
src=[er ist ein blodmann], target=[hes a jerk], predicted=[hes a jerk] src=[ich bin brillentrager], target=[i wear glasses], predicted=[i wear glasses] src=[tom hat mich aufgezogen], target=[tom raised me], predicted=[tom tricked me] src=[ich zahle auf tom], target=[i count on tom], predicted=[ill call tom tom] src=[ich kann rauch sehen], target=[i can see smoke], predicted=[i can help you] src=[tom fuhlte sich einsam], target=[tom felt lonely], predicted=[tom felt uneasy] src=[hab ich nicht recht], target=[am i wrong], predicted=[am i fat] src=[gestatten sie mir zu gehen], target=[allow me to go], predicted=[do me to go] src=[du hast mir gefehlt], target=[i missed you], predicted=[i missed you] src=[es ist zu spat], target=[it is too late], predicted=[its too late] BLEU-1: 0.844852 BLEU-2: 0.779819 BLEU-3: 0.699516 BLEU-4: 0.452614 |
看看测试集上的结果，我们确实看到了可读的翻译，这并非易事。
例如，我们看到“tom erblasste”被正确翻译为“tom turned pale”。
我们也看到了一些糟糕的翻译，并且一个很好的例子说明模型可以从进一步的调优中受益，例如“ich brauche erste hilfe”被翻译为“i need them you”，而不是预期的“i need first aid”。
达到了大约 0.153 的 BLEU-4 分数，为通过改进模型提供了可供改进的基线性能。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
src=[mein hund hat es gefressen], target=[my dog ate it], predicted=[my dog is tom] src=[ich hore das telefon], target=[i hear the phone], predicted=[i want this this] src=[ich fuhlte mich hintergangen], target=[i felt betrayed], predicted=[i didnt] src=[wer scherzt], target=[whos joking], predicted=[whos is] src=[wir furchten uns], target=[were afraid], predicted=[we are] src=[reden sie weiter], target=[keep talking], predicted=[keep them] src=[was fur ein spa], target=[what fun], predicted=[what an fun] src=[ich bin auch siebzehn], target=[im too], predicted=[im so expert] src=[ich bin dein vater], target=[im your father], predicted=[im your your] src=[ich brauche erste hilfe], target=[i need first aid], predicted=[i need them you] BLEU-1: 0.499623 BLEU-2: 0.365875 BLEU-3: 0.295824 BLEU-4: 0.153535 |
扩展
本节列出了一些您可能希望探索的扩展本教程的想法。
- 数据清理。可以对数据执行不同的数据清理操作，例如不删除标点符号或不规范化大小写，或者也许删除重复的英语短语。
- 词汇表。可以细化词汇表，也许删除数据集中使用次数少于 5 或 10 次的单词，并替换为“unk”。
- 更多数据。用于拟合模型的数据集可以扩展到 50,000、100,000 个短语或更多。
- 输入顺序。输入的短语顺序可以颠倒，据报道这可以提高性能，或者可以使用双向输入层。
- 层。编码器和/或解码器模型可以扩展额外的层并训练更多的 epoch，为模型提供更多的表示能力。
- 单元。可以增加编码器和解码器中的内存单元数量，为模型提供更多的表示能力。
- 正则化。模型可以使用正则化，例如权重或激活正则化，或者在 LSTM 层上使用 dropout。
- 预训练词向量。可以在模型中使用预训练词向量。
- 递归模型。可以使用模型的递归公式，其中输出序列的下一个单词可以以输入序列和到目前为止生成的输出序列为条件。
进一步阅读
如果您想深入了解，本节提供了更多关于该主题的资源。
总结
在本教程中，您学习了如何开发一个神经网络机器翻译系统，用于将德语句子翻译成英语。
具体来说，你学到了：
- 如何清理和准备数据以训练神经机器翻译系统。
- 如何为机器翻译开发一个编码器-解码器模型。
- 如何使用训练好的模型对新输入的短语进行推理，并评估模型的技能。
你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。
注意：这篇文章是摘录自：“深度学习用于自然语言处理”。如果您想了解更多关于在处理文本数据时充分利用深度学习方法的循序渐进的教程，请看看它。
立即开发文本数据的深度学习模型！
在几分钟内开发您自己的文本模型
...只需几行python代码
在我的新电子书中探索如何实现
用于自然语言处理的深度学习
它提供关于以下主题的自学教程：
词袋模型、词嵌入、语言模型、标题生成、文本翻译等等...
最终将深度学习应用于您的自然语言处理项目
跳过学术理论。只看结果。
再次感谢您的精彩工作。有一个问题。您是否有单独的教程来解释 LSTM 层（Timedistributed, Repeatvector 等）？
是的，您可能想从这里开始
https://machinelearning.org.cn/timedistributed-layer-for-long-short-term-memory-networks-in-python/
嗨，Jason，您的工作太棒了。我遇到了一个问题。如何将大型数据集转换为独热向量，因为它会占用更多内存？？
也许可以逐步加载数据集并进行转换？
也许可以使用较小的数据样本？
也许可以使用内存更多的机器？
也许可以使用 hadoop 这样的大数据管道？
translation = model.predict(source, verbose=0) 我无法运行。我得到了一个错误。Source 未定义。我该如何解决？
您可能跳过了一些示例代码。
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/how-do-i-copy-code-from-a-tutorial
你好，
您是否解决了这个问题？因为我也遇到了同样的问题，如果您解决了这个问题，请告诉我如何解决。
假设我有两个文件——第一个包含英语-德语文本，第二个包含英语-西班牙语文本。现在我如何才能从德语翻译成西班牙语？
为什么？这个问题似乎有问题/不完整。
提取德语文本和对应的西班牙语文本，形成一个新文件，然后用它来训练模型。我猜的 🙂
你好 Jason，在 Python 中没有 re_print，你能指导我一下吗？
“re_print” 是一个变量名。
你好 Jason，我在清理数据后得到了三个不同的元素，我不明白列表中第三个元素是什么意思，你能解释一下吗？
array([[‘theres nothing left to eat at home’,
‘es ist nichts zu essen mehr im haus’,
‘ccby france attribution tatoebaorg shekitten pfirsichbaeumchen’]
也许你可以试试重新训练模型？
如何使用预测结果将新的英语文本翻译成德语？
您的教程确实很棒。谢谢！
希望您有时间处理上面列出的扩展。这将使这个精彩的教程更加完善。
再次感谢！
谢谢！
太棒了，谢谢 Jason。我很期待尝试一下。
不客气。
嘿，我想知道一件事，如果我们给模型提供 9000 条英语到德语的翻译进行训练，1000 条进行测试，那么编码器-解码器模型到底在做什么……因为我们在测试时将所有内容都提供给了模型。
模型没有给出答案，它必须翻译新的例子。
也许我没有理解你的问题？
那我该如何输入示例？您从哪一行获取它？
嗨，Jason，
我是您文章的常读者，也购买了您的书籍。我想研究一下本地语言到英语的翻译。能否请您就步骤给出建议？
谢谢您
开始吧！
# 准备用于字符过滤的正则表达式
re_print = re.compile(‘[^%s]’ % re.escape(string.printable))
您能解释一下这段代码的意思吗？例如 string.printable 到底做了什么，以及 (‘[^%s]’ 的意思是？
我选择的是“非可打印字符”。
您可以从一本好的 Python 书籍中了解更多关于正则表达式的信息。
解释得太好了！简直太棒了！我正打算用您的模型开发文本到音素的转换！！！
谢谢！
你好，Jason，你的工作太棒了。在我运行这段代码时，我发现了这个，我想知道是否需要重塑序列？以及 sequence.shape[0],sequence.shape[1] 是做什么的。
以及为什么我们需要词汇量大小？
y = y.reshape(sequences.shape[0], sequences.shape[1], vocab_size)
您可以在这篇帖子中了解更多关于 numpy 数组及其形状的信息
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
*想知道为什么需要重塑序列？以及什么
我们必须确保数据具有模型期望的正确形状，例如 MLP 为 2D，LSTM 为 3D 等。
嗨，
我想问您为什么我们没有对德语文本进行独热编码？
输入数据经过整数编码并传递给词嵌入。在这种情况下不需要进行独热编码。
你好先生，
这里 load_model 没有定义。
谢谢。
from keras.models import load_model
您能告诉我
translation = model.predict(source, verbose=0)
错误：source 未定义
抱歉，我没有看到这个错误。也许可以尝试复制帖子末尾的整个示例？
运行上述代码时，我在 to_categorical 函数中遇到内存错误。我正在进行英语到印地语的翻译。请给我一些建议。
也许试试更新 Keras？
也许试试修改代码以使用渐进式加载？
也许试试在具有更多 RAM 的实例上运行 AWS？
请做一个关于 attention with gru 和 beam search 的模型
感谢您的建议。
我使用了双向 LSTM，取得了更好的结果……我想进一步改进……但我不知道如何在 Keras 中实现 attention 层……你能帮我一下吗？
我这里有一些可能有所帮助的帖子
https://machinelearning.org.cn/?s=attention&submit=Search
你好，我想知道你为什么使用 model.add(RepeatVector(tar_timesteps))？
重复编码的输入向量 n 次。
您可以在此处了解更多关于此方法的信息
https://machinelearning.org.cn/encoder-decoder-long-short-term-memory-networks/
可以使用此方法计算 NMT 模型分数吗？
model.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])
scores = model.evaluate(testX,testY)
它将估计准确率和损失，但不会提供关于 NMT 在文本数据上技能的任何见解。
嗨 Jason，这篇文章太棒了！
只是一个快速的问题，当您配置编码器-解码器模型时，似乎没有像您在之前的文章中提到的推理模型？如果此模型实现了推理模型的功能，是在哪个层实现的？如果没有，它与训练模型、推理编码器模型和推理解码器模型的套件相比如何？非常感谢！
在这里，相同的模型用于推理。
text_to_sequences 是否对数据进行编码？
根据文档，它只是将文本转换为序列列表。
是的，它将文本中的单词编码为整数。
您能否验证此文档。其中提到 text_to_sequences 返回 STR。
我现在很困惑。
https://keras.org.cn/preprocessing/text/
对于 Tokenizer 的“texts_to_sequences”说明
“返回：序列列表（每个文本输入一个）。”
ImportError: cannot import name ‘corpus_bleu’
有人知道这个错误吗？
您必须安装最新版本的 NLTK。
例如，我正在使用：nltk: 3.2.5
将此链接的代码保存到您的包中，作为 bleu_score：https://www.nltk.org/_modules/nltk/translate/bleu_score.html
然后从 bleu_score 导入 corpus_bleu
根据您的教程，我在测试数据集上获得了 BLEU 分数如下：
BLEU-1: 0.069345
BLEU-2: 0.255634
BLEU-3: 0.430785
BLEU-4: 0.490818
因此，我们可以注意到它们与训练数据集上的分数非常接近。
这是关于过拟合还是正常现象？
干得好！
训练集和测试集上的分数相似是模型稳定的标志。如果技能很差，它可能是一个稳定但欠拟合的模型。
先生，您正在使用测试数据作为验证数据。这意味着模型在训练阶段只看到了测试数据。我认为测试数据是分开保存的。我说对了吗？如果是，请解释一下背后的逻辑。
不，数据已分为训练集和测试集，并用于这些目的。
您可以在此处了解更多关于数据集的信息
https://machinelearning.org.cn/difference-test-validation-datasets/
先生您好，解释得很棒。给定语料库一切正常。当我使用自己的语料库时，它会显示 .pkl 文件未编码为 utf-8。
您能否分享上述项目使用的文本文件的编码？
它显示以下错误
—————————————————————————
IndexError Traceback (最近一次调用)
in ()
65 # spot check
66 for i in range(100)
—> 67 print(‘[%s] => [%s]’ % (clean_pairs[i,0], clean_pairs[i,1]))
IndexError: 数组索引过多
请帮忙
也许双重检查您使用的是 Python 3？
是的，我使用的是 python 3.5。
您能否确认所有其他库都已更新，并且您复制了示例中的所有代码？
是的 Jason，我已经更新了所有库。对于 deu.txt 文件，它工作得非常好。
每当我使用我自己的文本文件时，它就会出现以下错误。
您能否告知文本文件使用的格式？
谢谢
如帖子中所述，格式是“制表符分隔的双语句子对”。
你好 Jason，我是你的粉丝，我实现了这个机器翻译，效果很棒，我得到了所有完美的结果。现在我想使用 RNN 通过自然语言生成代码，当我读取我的声明和文档字符串文件时，它没有像预期的那样显示输出。例如，它应该显示声明，但它显示的是 x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/
但它应该显示
if cint(frappe.db.get_single_value(u’System DCSP Settings’, u’setup_complete’))
很有趣的项目。
也许模型需要更多的训练/调整，或者问题需要重新定义？
这里有一些很棒的想法
https://machinelearning.org.cn/improve-deep-learning-performance/
在您的数据中，x 是英语，y 是德语……但代码中，x 是德语，y 是英语……为什么会有这种区别????????
我们正在将德语 (X) 翻译成英语 (Y)。
如果您愿意，可以学习反向翻译。我选择不这样做是因为我的英语比德语好。
你好，
我正在尝试使用预训练的词嵌入来进行翻译。
但是，经过一些研究，我发现预训练的词嵌入仅用于初始化编码器和解码器，而且我们只需要源嵌入。
所以，目前我很困惑。
通常，我们必须将源和目标嵌入提供给算法吗？
请提供有关此主题的文档或链接。
我不确定我是否理解，您到底是什么意思？
您可以使用预训练的嵌入。这与需要输入和输出数据对来训练模型分开。
关于扩展中的递归模型，它难道不是已经在当前代码中实现了吗？因为解码器部分是 lstm，并且一个单元的 lstm 输出被馈送到下一个单元。
*在“扩展”部分
*并且在 lstm 中，一个时间单元的输出被馈送到下一个时间单元。
不，请参阅此帖子了解更多有趣的架构
https://machinelearning.org.cn/caption-generation-inject-merge-architectures-encoder-decoder-model/
“be stolen returned” 是我的系统翻译的“vielen dank jason”，它应该表示：非常感谢 Jason！
这篇文章对我帮助很大，我现在将继续进行调整。继续保持出色的工作！
干得好！
谢谢 Max，很高兴听到这个。
在机器翻译中，为什么我们需要英语文本和德语文本的词汇表？
我们需要限制我们建模的词语数量，它不能是无限的，至少在我选择建模问题的方式中是这样。
这表明如果以不同的方式建模，它可以是无限的。
当然，这都是代码。
嗨，Jason，
我刚刚用同一网站上提供的 ENG-PL 数据集测试了 clean_pairs 方法。其中一个字符未打印在屏幕上（‘所有其他非 ASCII 字符都已正确转换），我认为它被忽略了，如这行所示
我做了一个实验，用 normalize(‘NFD’, line).encode(‘utf-8’, ‘ignore’) 替换了上面的内容，但结果与两者没有任何区别。我不确定为什么会发生这种情况，因为它只有一个字母。另外，(我假设您选择的是 ascii，因为您构建了一个德语到英语的翻译器，我说的对吗？)。如果可能的话，您能否分享您的想法？
也许您能够检查文本或搜索文本中的非 ascii 字符，看看是什么引起问题的字符？
这可能会让你了解发生了什么。
我正在处理这个问题 - 看起来问题可能出在 re.escape 方法上，而不是编码本身。
删除标点符号不会阻止模型用于预测段落吗？您如何用测试集之外的一个句子或段落来评估它？
您可以将数据提供给模型并进行预测。
调用我们上面写的 predict_sequence() 函数。
来自 Keras.Preprocessing.Text import Tokenizer
..
安装 keras 后不起作用。
..
它说没有名为 tensorflow 的模块。
..
我有一个 windows 32 位机器。
..
您的文章非常好！
.
但我因此问题无法继续前进！
听起来您的环境没有正确安装。
请参阅此教程
https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
感谢您的文章，Jason！
我有一个关于您的实现与 Keras 教程“https://blog.keras.org.cn/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html”之间差异的问题。对我来说，在“Keras 教程”中使用“目标”（偏移一位）作为“解码器输入数据”存在一个“教师强制”元素。您的模型中没有这个元素。我的问题是，有必要吗？或者您只是使用“RepeatedVector”和“TimeDistributed”来实现类似的功能？
谢谢！
是的，我们使用的是简化版的架构。
我在这里提供了一个教师强制的例子
https://machinelearning.org.cn/develop-a-deep-learning-caption-generation-model-in-python/
Jason，非常感谢，再次感谢，我想问你
如何实现双向 LSTM 代码以进一步改进？下面是我在代码中所做的，请根据您的知识修复它。
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units)
model = Sequential()
model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True))
model.add(Bidirectional(LSTM(n_units)))
model.add(RepeatVector(tar_timesteps))
model.add(Bidirectional(LSTM(n_units, return_sequences=True)))
model.add(TimeDistributed(Dense(tar_vocab, activation=’softmax’)))
return model
我认为双向 LSTM 只在输入/编码器上有意义。
有关配置建议，请参阅此帖子
https://machinelearning.org.cn/configure-encoder-decoder-model-neural-machine-translation/
在下面的代码中
# remove non-printable chars form each token
line = [re_print.sub(”, w) for w in line]
在土耳其语单词中，我遇到了以下示例错误，例如
“kaç” -> “kac” , “koş”->”kos”
我该如何解决？
谢谢你
抱歉，我不明白。确切的问题是什么？
我在土耳其语-英语语料库文件上使用了这些代码，并且一些土耳其语字符
丢失了 (ç,ğ,ü,ğ,Ö,Ğ,Ü,İ,ı)
谢谢您。
转换后丢失？
也许规范化为拉丁字符并非最适合您特定问题的方法？
非常感谢。您能否帮助我找到泰语到英语的好数据集？ManyThings.org 网站上的泰语数据集数据较少。我正试图使用这种方法为泰语构建类似的模型。
抱歉，我不知道。
请忽略我的问题，我已搜索并找到了数据集。感谢这些文章
不客气。
Sai，你能把数据集（英泰）发给我吗？
fexex44@gmail.com
模型训练完成后，能否用于双向预测，即：英语-德语，德语-英语。
不，只能用于训练方向。
Jason，您好，感谢您提供的精彩教程。它真的帮助了我。我实现了上面的代码并理解了每个函数。此外，我想实现如下的神经对话模型 https://arxiv.org/pdf/1506.05869.pdf 在对话数据上。因此，我有两个问题，第一个是如何在对话数据中进行配对，第二个是如何将之前的对话作为输入馈送给解码器模型。
抱歉，我没有对话系统的示例。我希望将来能涵盖它。
早上好，Jason 先生……
在我的模型中，我在训练数据集上得到的 BLEU 分数如下：
BLEU-1: 0.736022
BLEU-2: 0.717377
BLEU-3: 0.710192
BLEU-4: 0.692681
所以我们可以注意到它们比训练数据集上的分数高。
这是正常行为还是不好？
测试集上的分数高于训练集上的分数确实会发生，我在其中解释了一些想法
https://machinelearning.org.cn/faq/single-faq/what-if-model-skill-on-the-test-dataset-is-better-than-the-training-dataset
嗨，Jason，
工作伟大而有益，我正在尝试代码来翻译阿拉伯语到英语，但在第一步（清理文本）时，它给了我一个空的 [ ]？！我该如何解决这个问题。
[hi] => []
[run] => []
[help] => []
嗨，Jason，
感谢分享简单易懂的翻译方法。
我尝试让您的代码处理印地语，并在您共享德语数据集的相同位置找到了印地语数据集。
以下用于印地语的 normalize 代码会从行中删除字符。我尝试了 NFC，但仍然遇到相同的问题。如果我跳过这一行，那么非可打印字符行就会跳过印地语文本。
print(‘Before: ‘, line)
# normalize unicode characters
line = normalize(‘NFD’, line).encode(‘ascii’, ‘ignore’)
print(‘After: ‘,line)
Before: Go.
After: b’Go.’
Before: जा.
After: b’.’
跳过这两行代码是否会以任何方式影响训练？
谢谢，
Sastry
是的，代码示例期望处理拉丁字符。
Sastry 先生您好
您的问题与印地语数据是否已解决？
你好，先生
使用 Keras 训练 NMT 的最低硬件要求是什么？
这是我在这里回答的一个常见问题
https://machinelearning.org.cn/faq/single-faq/do-i-need-special-hardware-for-deep-learning
嗨，Jason，
这篇帖子非常有帮助。谢谢。
我正在尝试构建一个从英语翻译到印地语（或其他任何印度语言）的翻译器。但我在清理数据时遇到问题。
normalize 代码对印度语言不起作用，如果我跳过该行代码，那么在训练数据后我就得不到任何输出。
是否有办法使用您帖子中的相同代码以及其他方法来清理印度语言的数据以获得所需的输出？例如，是否有任何 Python 模块/库我应该安装以便用于印度语言？
谢谢！
您可能需要研究如何为 NLP 准备印地语数据。
也许转换为拉丁字符不是最好的方法。
你好，
我们是不是应该将英语数据连同编码数据一起传递给解码器？据我所知，只有编码后的德语数据被传递给了解码器，对吗？？
在这个例子中不是。
嗨，Jason，
我现在已经进展到训练模型了。清理和标记数据集花费了时间，因为我使用的是不同的语言，但这是一个很好的学习过程。
想知道“30 个 epoch 和 64 个样本的批次大小”在您的示例中有什么意义。它们与总词汇量（或）总可训练参数有任何关系吗？
另外，您能否指导我阅读您的一篇关于 epoch、BLEU 分数、损失等的文章？
谢谢你
不相关。我通过试错（系统实验）来配置模型。
更多关于 epoch 的信息
https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-a-batch-and-an-epoch
更多关于 BLEU 的信息
https://machinelearning.org.cn/calculate-bleu-score-for-text-python/
损失是正在优化的误差分数。
嗨，Jason，
我有一个愚蠢的问题，但想寻求澄清。
在“训练神经翻译模型”步骤中：我使用了数据集中的 10,000 行，并在 model.h5 文件中为 xxx 个词汇量建立了模型。
如果我从数据中提取接下来的 10,000 行并继续使用上述相同的代码行训练模型，它会使用 model.h5 中已建立的模型，还是会被覆盖并开始作为新数据进行训练？
谢谢你，
是的，模型将使用现有模型作为起点进行训练。
嗨，Jason，
好的，明白了。
参考了您的文章 https://machinelearning.org.cn/check-point-deep-learning-models-keras/ 并理解到，在编译模型之前使用 model.compile()，我必须从文件中加载模型，才能使用现有模型作为训练的起点。
非常感谢。
很高兴能帮到你。
您尝试过使用 model.fit_generator 吗？
嗨，Jason，
Word2Vec 能用作输入嵌入来增强 LSTM 模型吗？或者说，Word2Vec 预训练的词向量作为模型的输入能否获得更好的效果？
谢谢！
是的。我有一些例子，搜索词嵌入。
你好 Jason，
文章写得非常好，复杂的概念都以非常简单的方式解释了。但是，如果能添加一个注意力层来处理更长的句子就更好了。
我尝试在上述代码中添加一个注意力层，参考了下面的代码。
https://github.com/keras-team/keras/issues/4962
我无法添加注意力层。我读过您之前关于添加注意力的博客
https://machinelearning.org.cn/encoder-decoder-attention-sequence-to-sequence-prediction-keras/
但是输出端的词汇量太大，无法处理，这并没有解决问题。
如果您能将注意力（Bahdanu 或 Luong）添加到上述代码中并解决长句问题，那就太好了。
谢谢！
谢谢，我希望在 Keras 正式支持注意力后能开发一些注意力教程。
您能否像在后面的情况一样包含注意力片段？这段代码对我来说工作正常，除了注意力可以处理更长的句子，而这正是我遇到问题的地方。我实际上是要求您将注意力添加到上面的代码中，就像您在后面的情况中所做的那样。
抱歉，我无法为您创建自定义示例。
我希望在 Keras 正式支持注意力时提供更多注意力示例。
您好，我想从英语翻译到德语，请帮我修改什么？我做了一些修改但不起作用。请帮助我如何撤销它？
这应该很简单。抱歉，我没有能力为您准备示例。
先生，如何修改此项目以使用现有模型 (.h5) 进行下一个项目运行，而无需重新训练，因此我只需使用模型？
您可以保存模型，然后稍后加载它并进行预测。
有关如何进行预测的更多信息
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
我的意思是使用预训练模型进行下一次运行（例如：聊天机器人），因此当我运行聊天机器人进行问答时，不需要训练模型。谢谢
抱歉，我对聊天机器人不了解。
Jason – 您的下一个教程是什么？我会热切地等待下一个教程。我如何收到有关您下一个教程的通知？
我会在新教程出来时发送电子邮件，您可以在此注册
https://www.getdrip.com/forms/387997427/submissions/new
Jason，您好！感谢您的精彩教程！非常清晰易懂。在我重现您的代码时，出现了一个问题：控制台警告“假设包含 0 个 2-gram、3-gram 和 4-gram 重叠计数”，这导致 BLEU-2 到 4 都为 0。我找不到原因，因为我只是完全复制了您的代码，它仍然不起作用。您能帮帮我吗？谢谢！
您可以忽略该警告，它与性能指标的计算有关。
https://machinelearning.org.cn/calculate-bleu-score-for-text-python/
你好，
您能否帮助我将一个德语单词转换为一系列数字？
请看这篇文章
https://machinelearning.org.cn/prepare-text-data-deep-learning-keras/
你好，
非常棒的文章！在这里，我们将序列编码（为独热向量），然后将其输入到编码器 LSTM，再传递到解码器 LSTM。我的理解是正确的吗？如何将输入提供给 LSTM 的隐藏状态？
不，我们不将输入进行独热编码，我们向词嵌入提供整数序列。
你好，
谢谢您的回答。我还有另一个问题。我如何为返回 2D 数组而不是 3D 数组的序列使用独热编码？
也许这会有帮助。
https://machinelearning.org.cn/why-one-hot-encode-data-in-machine-learning/
非常棒的文章！对准确性和有限的训练时间感到惊讶。我尝试将模型与不同的数据集（两列句子）一起使用，但在加载清理后的数据、拆分数据以及将拆分后的数据保存到新文件的代码中遇到了问题。第 20 行
dataset = raw_dataset[:n_sentences, :]
IndexError: 数组索引过多
对于 print(raw_dataset) 使用您的 deu.txt，我得到
[[‘Sentence A’ ‘Sentence a’] [‘Sentence B’ ‘Sentence b’] 等。]
但是对于 print(raw_dataset) 使用我的文件，我得到
[ list([‘sentence A’, ‘sentence a’]) list([‘sentence B’, ‘sentence b’]) 等。]
您有什么建议吗？
我有一些建议可以尝试
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我遇到了同样的错误。有什么解决方案吗？
嘿 Jason，这篇文章太棒了，它极大地帮助我理解了 NMT 在后台的工作原理！
我遇到了与 Alex J 相同的问题，即代码的评估部分，其中 BLEU-2、3 和 4 分数都为 0 并出现警告，例如
“假设包含 0 个 2-gram 重叠计数。
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()”
我不确定 nltk.bleu_score.corpus_bleu 自您创建此脚本以来是否发生了变化，但看起来您需要在 actual 中为每个条目添加一个额外的列表。这可以通过将该脚本的第 60 行从
actual.append(raw_target.split())
推广到
actual.append([raw_target.split()])
谢谢 Josh。
是的，确实有效
actual.append([raw_target.split()])
每个句子的参考应该是不同正确句子的列表。
Jason，您是否也可以使用此模型在一个语言内进行“翻译”？例如，使用重复的句子作为对，如
[‘地球到月球的距离是384.400公里’ ‘月球距离地球384.400公里’]
有了足够好的例子，您认为这会奏效吗？我试过了，结果很糟糕。可能我做错了什么。
有足够的训练数据，是的，您可以做到这一点。
Jason，我刚刚用一个包含两列英语句子的数据集替换了deu.txt数据集，并得到了以下（奇怪的）预测。您有什么关于可能原因的建议吗？
src=[the best apps for increasing vocabulary are], target=[what are the best apps for increasing vocabulary], predicted=[and and and and and and and and and and and does does el el el el el]
BLEU-1: 0.027778
BLEU-2: 0.166667
BLEU-3: 0.341279
BLEU-4: 0.408248
也许可以确认您正在按预期加载数据集。
然后您可能需要调整模型以适应此新数据集。
你好，
我正在做类似的事情，因为我正试图将语法错误的法语翻译成正确的法语。问题是，我也得到了一些奇怪的结果，就像您一样
我不确定您是否会看到此消息，但您是否已解决您的问题？🙂
或许尝试调整模型？
也许可以尝试更多数据？
也许可以尝试不同的模型架构？
“英语中存在具有不同德语翻译的重复短语”。重复的短语会带来什么问题？如果我希望模型学习与输入句子含义相似的句子（即一个输入有多个可能的输出）怎么办？您会推荐哪种模型来处理这种情况？
这可能会让模型感到困惑，并导致技能下降。
尽可能简化问题。
打印 Bleu 分数需要多长时间？
实际上，代码的那部分对我来说不起作用，它没有打印 Bleu 分数，而且当我尝试绘制模型时，它会显示安装 Graphviz，但我已经有了。
这取决于您的硬件，但它不应该花费过长时间。
如果您得到奇怪的结果，请确保您拥有所有库的最新版本，并且您已复制代码。
首先，感谢您的教程，它给了我很大的帮助。
如果我想在解码器中集成注意力机制和束搜索，需要更改代码的哪个部分？
根据我从您的教程中获得的初步理解
https://machinelearning.org.cn/encoder-decoder-attention-sequence-to-sequence-prediction-keras/
我需要替换以下代码
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units)
model = Sequential()
model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True))
model.add(LSTM(n_units))
model.add(RepeatVector(tar_timesteps))
model.add(LSTM(n_units, return_sequences=True))
model.add(TimeDistributed(Dense(tar_vocab, activation=’softmax’)))
return model
替换为
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units)
model = Sequential()
model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True))
model.add(LSTM(n_units))
model.add(AttentionDecoder(n_units, n_features))
return model
在编写该帖子中给出的自定义注意力层代码之后。
我不确定此问题的 n_features 参数。您能澄清一下吗？此外，您能帮我找到束搜索的实现吗？
感谢您的时间。
抱歉，我无法帮助进行这些扩展。
先生，我正在使用英语-印地语翻译数据集。在打印保存的文件时，代码显示输出如下…
[has tom left] => []
[he is french] => []
[i am at home] => []
[i cant move] => []
[i dont know] => []
为什么我看不到印地语文本？是否需要重新编码解码？
抱歉，我不知道。我没有任何使用印地语文本的示例。
使用这些步骤，您将获得印地语文本。
def clean_pairs(lines)
cleaned = list()
table = str.maketrans(”, ”, string.punctuation)
for pair in lines
clean_pair = list()
for line in pair
line = line.split()
line = [word.lower() for word in line]
line = [word.translate(table) for word in line]
clean_pair.append(‘ ‘.join(line))
cleaned.append(clean_pair)
return np.array(cleaned)
你好 Jason，
是否可以包含图表或可视化来显示维度如何在使用的层中匹配？我很难弄清楚网络到底是什么样的。例如，为什么重复向量是必需的。
是的，您可以总结模型期望的内容
并且您可以查看您的数据
保存模型并加载模型后，我想随机翻译一行，该怎么做？
model.predict(…)
如何使用我的自定义输入进行检查？而不是测试数据集
以与训练相同的方式准备新数据（清理和标记化），然后像我们在上面教程的最后部分所做的那样提供给模型。
嗨 Jason，
感谢这篇教程。
我正尝试从中文翻译到英文，并查看 clean_pairs 函数，我认为它不能用于中文字符。
您能否给我一些关于如何为翻译模型生成干净文本的指导？
我使用的是 many.org 的数据集。
您可能需要更新示例以使用 Unicode 而不是字符。
Jason，这是一篇很棒的文章。我尝试为德语-英语实现它，并且工作正常。但当我为韩语-英语实现时，输出是乱码
src=[경고 고마워], target=[thanks for the warning], predicted=[i i the]
src=[입조심해라], target=[watch your language], predicted=[i i you]
src=[없다], target=[there arent any], predicted=[i i you]
src=[톰은 외롭고 불행해], target=[tom is lonely and unhappy], predicted=[i i the]
src=[그녀의 신앙심은 굳건하다], target=[her faith in god is unshaken], predicted=[i i the to]
src=[세계는 너를 중심으로 돌아가지 않는다], target=[the world doesnt revolve around you], predicted=[i i i to to]
src=[못 믿겠는데], target=[i can hardly believe it], predicted=[i i the]
src=[그 약은 효과가 있었다], target=[that medicine worked], predicted=[i i]
src=[모두 그녀를 사랑한다], target=[everybody loves her], predicted=[i i]
我使用了 manythings.org 的训练数据，有 773 行（600 行用于训练，173 行用于测试）。
您能指导我可能是什么问题吗？
也许韩文字符需要特殊处理？
也许模型需要进一步调整？
嘿 Jason，感谢您提供如此精彩的内容。我有一个关于为什么需要将 Unicode 转换为 ASCII 来准备数据集的疑问。为什么专门使用 NFD 格式？
这并非必需，只是让我的示例更简单。
嗨，这个博客上的工作非常好。我也将 LSTM 应用于印第安本地语言，并取得了良好的结果和分数。很棒的教程！！！
我的问题是，我想在这里做一种联邦学习。使用此数据集创建的模型将作为通用模型。假设我有一个另一个数据集（相似但较小），我使用相同的代码训练模型，并生成一个新模型。现在我想将这个新模型的权重与之前生成的模型合并。
我该如何实现？任何建议都将不胜感激。
干得好！
您可以保留这两个模型，并在集成中使用它们。
嗨 Bhimasen
我也在从事印第安语言的工作。
在旁遮普语的预处理中遇到困难
嗨 Jason
很棒的教程 – 德语->英语效果很好，但当我使用自己的词典时，预测输出是空的（“[]”）。
我的词典非常具体，它是句子到句子，例如
“when raining then use umbrella6” -> “trigger raining check umbrella6”
我有大约 1000 行类似的句子（可能太少了），它们包含这种奇怪的“umbrella6”字符串（即字符串+ID）。
我曾期望结果可能毫无意义，但空的预测有些奇怪——应该有东西吗？
您可能需要更改模型并针对新数据集进行调整。
样本数量较少可能意味着模型会很快过拟合，您可以通过正则化来限制这一点。
供将来参考，评论会经过审核，我每天处理一次。无需重复发布，如果它们没有立即出现。更多信息在此
https://machinelearning.org.cn/faq/single-faq/where-is-my-blog-comment
也许我错过了，但如果输入文本中有一个新词/未见过的词会怎样？或者输出中有什么？
未见过的单词会被 Tokenizer 标记为 0。
嗨，Jason，
很棒的教程，喜欢您的博客！我想知道如何输入我自己的输入进行翻译。我该如何只输入一个句子。我尝试过的所有方法都不奏效！
如果您有需要翻译的文本，可以使用谷歌翻译。
如果您想使用该模型进行预测，则必须使用与准备训练数据相同的方案对新文本进行编码，然后调用 model.predict()。
嗨，Jason，
感谢您详细的步骤说明。我需要一些帮助。
对于中葡机器翻译，需要更改哪些内容？
我的目标是做一个（双向）LSTM，但找不到现成的词数据文件作为源。
希望您能指明方向，谢谢。
此致，
汤姆
可能需要为您的新数据集调整模型。
当我运行评估时，我得到以下结果
用户警告
假设包含 0 个 4-gram 重叠计数。
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()
warnings.warn(_msg)
BLEU-1: 0.077830
BLEU-2: 0.000000
BLEU-3: 0.000000
BLEU-4: 0.000000
我该如何解决这个问题？
也许可以检查模型生成的文本类型，您的模型可能没有收敛到有用的解决方案。
我们如何解决这个问题？我尝试从头重新运行模型。它显示的结果相同。
/usr/local/lib/python3.5/dist-packages/nltk/translate/bleu_score.py:503: UserWarning
假设包含 0 个 4-gram 重叠计数。
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()
warnings.warn(_msg)
BLEU-1: 0.077346
BLEU-2: 0.000000
BLEU-3: 0.000000
BLEU-4: 0.000000
2-gram 和 3-gram 也有同样的警告。
也许可以尝试更改模型的配置？
嗨，感谢您的贡献。
您能否澄清一些疑问
1. 在 CLEAN TEXT 步骤中，在 clean_pairs() 函数内，第 7 行是关于为去除标点符号制作翻译表的。
在代码中，str.maketrans(”, ”, string.punctuation)
使用 str 作为未定义属性时会出错。
还有，“maketrans”函数是什么？
2. 关于“to_pairs”函数，该函数将数据集转换为以下格式
原始
Hi. Hallo!
Hi. Grüß Gott!
Run! Lauf!
之后
您好。
Hallo!
您好。
Grüß Gott!
Run!
Lauf!
即通过分割短语对，将相应的翻译放在下一行。
谢谢。
您可能正在使用 Python 2.7，我建议使用 Python 3.5 或更高版本。
这个实现与 keras 的实现有何不同？
https://blog.keras.org.cn/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html
哪个更好？
这里我们使用自动编码器方法，而在 keras 博客文章中，使用的是仅使用内部状态的编码器-解码器。
使用一种能为您的问题带来最佳性能的方法。
嗨 Jason，
感谢您写了这篇精彩的文章。我一直在尝试实现它，我在
prediction = model.predict(testX, verbose=1)[0]
这里有一个疑问。为什么我们只取单个编码源？
只有一个预测/行，所以我们从二维数组中取出来。
抱歉，我不明白，prediction 的形状应该是 (1000, 5, 2309)，但我们只取它的第零个元素。为什么？
不，我们一次只翻译一个单词句子。
为了确认，请在只选择第零个元素之前打印 predict 函数的输入和输出的形状。
嗨，Jason，
感谢您分享这篇精彩的文章。由于我在学习德语方面进展缓慢，在讲德语国家生活了四年之后，我决定创建一个应用程序，我认为它可以帮助我，也许也能帮助别人。
作为第一步，我认为您的方法可能很适合我的要求。我的问题是，这里展示的所有代码都可以自由复制吗，还是有版权？
再次感谢，
Dani。
它们受版权保护，但只要您清楚注明其来源，就可以使用它们。
更多细节在此
https://machinelearning.org.cn/faq/single-faq/can-i-use-your-code-in-my-own-project
你好
您能帮帮我吗
我正在做同样的神经翻译工作，从英语到阿拉伯语！
我按照提供的步骤进行，但遇到了错误
也许把你的错误发到 stackoverflow 上？
先生，你好
运行结果是这样，但似乎不准确
train
src=[], target=[continue digging], predicted=[i is to]
src=[], target=[tom laid the gun down on the floor], predicted=[i is to]
src=[], target=[i have to find it], predicted=[i is to]
src=[], target=[i believe in god], predicted=[i is to]
src=[], target=[im a free man], predicted=[i is to]
src=[], target=[can i use my credit card], predicted=[i is to]
src=[], target=[she is about to leave], predicted=[i is to]
src=[], target=[she raised her hands], predicted=[i is to]
src=[], target=[my uncle died a year ago], predicted=[i is to]
src=[], target=[im sitting alone in my house], predicted=[i is to]
/anaconda3/lib/python3.6/site-packages/nltk/translate/bleu_score.py:490: UserWarning
语料库/句子包含 0 个 2-gram 重叠计数。
BLEU 分数可能不理想；请使用 SmoothingFunction()。
warnings.warn(_msg)
BLEU-1: 0.266528
BLEU-2: 0.516264
BLEU-3: 0.672548
BLEU-4: 0.718515
test
src=[], target=[im working in a town near rome], predicted=[i is to]
src=[], target=[she despised him], predicted=[i is to]
src=[], target=[the clock is ticking], predicted=[i is to]
src=[], target=[this river is one mile across], predicted=[i is to]
src=[], target=[birds of a feather flock together], predicted=[i is to]
src=[], target=[why did you turn down his offer], predicted=[i is to]
src=[], target=[shes as clever as they make em], predicted=[i is to]
src=[], target=[how can i help], predicted=[i is to]
src=[], target=[our living room is sunny], predicted=[i is to]
src=[], target=[can you speak french], predicted=[i is to]
BLEU-1: 0.260667
BLEU-2: 0.510555
BLEU-3: 0.668076
BLEU-4: 0.714531
也许尝试再次拟合模型？
我的数据集是英语-阿拉伯语
加载并清理数据时，我得到了这个
[hi] => []
[run] => []
[help] => []
[跳] => []
[停止] => []
[继续] => []
[继续] => []
[你好] => []
[快点] => []
[快点] => []
[我明白了] => []
[我赢了] => []
[放松] => []
[微笑] => []
[干杯] => []
[明白了] => []
[他跑了] => []
[我知道] => []
[我知道] => []
[我知道] => []
[我] => []
[我没事] => []
[听] => []
[没门] => []
[真的吗] => []
[谢谢] => []
[为什么是我] => []
[太棒了] => []
[给我打电话] => []
[给我打电话] => []
[进来] => []
[进来] => []
[来吧] => []
[来吧] => []
[来吧] => []
[出去] => []
[出去] => []
[出去] => []
[走开] => []
[走开] => []
[走开] => []
[再见] => []
[他来了] => []
[他跑] => []
[救救我] => []
[救救我] => []
[我很难过] => []
[我也是] => []
[闭嘴] => []
[闭嘴] => []
[闭嘴] => []
[闭嘴] => []
[别这样] => []
[拿着] => []
[汤姆赢了] => []
[汤姆赢了] => []
[醒醒] => []
[欢迎] => []
[欢迎] => []
[欢迎] => []
[欢迎] => []
[谁赢了] => []
[谁赢了] => []
[为什么不] => []
[为什么不] => []
[玩得开心] => []
[快点] => []
[我忘了] => []
[我明白了] => []
[我明白了] => []
[我明白了] => []
[我用了] => []
[我会付钱的] => []
[我很忙] => []
[我很忙] => []
[我冷] => []
[我有空] => []
[我在这里] => []
[我回家了] => []
[我很穷] => []
[我很富有] => []
[这很疼] => []
[天气很热] => []
[这是新的] => []
[我们走吧] => []
[我们走吧] => []
[我们走吧] => []
[我们走吧] => []
[我们走吧] => []
[小心] => []
[小心] => []
[小心] => []
[大声说] => []
[站起来] => []
[太棒了] => []
[太棒了] => []
[汤姆死了] => []
[汤姆死了] => []
[汤姆走了] => []
[汤姆撒谎了] => []
也许您的模型需要进一步调整？
我需要通用网络语言（Universal networking language）算法，了解它是如何工作的，并想将其他算法与UNL框架的编码和解码功能集成。
我没有这方面的内容，抱歉。
精彩的作品！谢谢你，Jason！
谢谢！
我可以用这个模型来训练中文到英文的翻译吗？中文与其他语言不同，我需要注意什么？
也许可以。
先生您好，非常感谢您提供的精彩指南！！！
我只有一个疑问……我们能构建一个可以双向翻译的模型吗？即语言1到语言2，以及语言2到语言1？
也许可以，我暂时看不出怎么做。
Jason您好，请问您能澄清一下吗：在这个模型中，我们是将词嵌入作为隐藏状态输入到编码器的LSTM吗？
提前感谢！
词嵌入是作为LSTM的输入提供的，而不是隐藏状态。
感谢您的回复🙂 第二个LSTM有直接输入吗？或者它只接收第一个LSTM的隐藏输入？
您可以使用输出和隐藏状态，或者只使用输出。我更喜欢后者——就像一个自动编码器。它更简单，而且性能非常好。
你在这里实现的是一个自动编码器吗？
不，它是一个编码器-解码器。
https://machinelearning.org.cn/encoder-decoder-long-short-term-memory-networks/
我能否使用任何预训练模型来开发多语言机器翻译？如何做到？
也许可以。
抱歉，我没有关于此主题的教程。
嗨，Jason，
感谢这篇精彩的文章。我正在尝试在另一种翻译（英语到印地语）上运行代码，训练运行正常，但在评估时遇到了以下错误
使用 TensorFlow 后端。
train
回溯（最近一次调用）
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\ptvsd_launcher.py”，第119行，在
vspd.debug(filename, port_num, debug_id, debug_options, run_as)
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\debugger.py”，第37行，在 deb
ug
run(address, filename, *args, **kwargs)
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_local.py”，第64行，在 run_f
ile
run(argv, addr, **kwargs)
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_local.py”，第125行，在 _run
_pydevd.main()
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_vendored\pydevd\pydevd.py”，
第1752行，在 main
globals = debugger.run(setup[‘file’], None, None, is_module)
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_vendored\pydevd\pydevd.py”，
第1099行，在 run
return self._exec(is_module, entry_point_fn, module_name, file, globals, loc
als)
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_vendored\pydevd\pydevd.py”，
第1106行，在 _exec
pydev_imports.execfile(file, globals, locals) # 执行脚本
文件“c:\program files (x86)\microsoft visual studio\2017\enterprise\common7\i
de\extensions\microsoft\python\core\Packages\ptvsd\_vendored\pydevd\_pydev_imps\
_pydev_execfile.py”，第25行，在 execfile
exec(compile(contents+”\n”, file, ‘exec’), glob, loc)
文件“D:\kudave\EEM\Code\EEMDNN\EEMDNN\infer.py”，第88行，在
evaluate_model(model, eng_tokenizer, trainX, train)
文件“D:\kudave\EEM\Code\EEMDNN\EEMDNN\infer.py”，第56行，在 evaluate_model
translation = predict_sequence(model, eng_tokenizer, source)
文件“D:\kudave\EEM\Code\EEMDNN\EEMDNN\infer.py”，第40行，在 predict_sequence
prediction = model.predict(source, verbose=0)[0]
文件“C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python36_64\lib\si
te-packages\keras\engine\training.py”，第1149行，在 predict
x, _, _ = self._standardize_user_data(x)
文件“C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python36_64\lib\si
te-packages\keras\engine\training.py”，第751行，在 _standardize_user_data
exception_prefix=’input’)
文件“C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python36_64\lib\si
te-packages\keras\engine\training_utils.py”，第138行，在 standardize_input_data
str(data_shape))
ValueError: Error when checking input: expected embedding_1_input to have shape
(8,) but got array with shape (11,)
————————————————————–
我在评估测试数据时遇到同样的错误。您知道是什么问题吗？首先，我没有怎么改代码，只是改了数据。
抱歉，我没有能力调试您的修改，也许可以把您的代码和错误发布到stackoverflow上？
嗨，Jason！
我正在使用您的NMT代码将句子从现在完成时转换为过去完成时。我训练了50个epoch
第 50/50 轮
2500/2500 [==============================] – 37s 15ms/step – loss: 1.0273 – acc: 0.8178 – val_loss: 1.1926 – val_acc: 0.8187
但它的输出是这样的
train
src=[我不知道我现在要做什么], target=[我不知道我当时要做什么], predicted=[我曾没有过曾有过有过有过有过]
src=[如果我有个地方睡觉，我就会过得去], target=[如果我有个地方睡觉，我就会过得去], predicted=[我曾没有过有过有过有过有过有过]
src=[这是我读过的最糟糕的书], target=[这是我读过的最糟糕的书], predicted=[我曾没有过有过有过有过有过]
src=[有人有好消息吗], target=[有人有过好消息吗], predicted=[我曾有过有过]
src=[我这里什么都有], target=[我这里什么都有], predicted=[我曾有过有过]
src=[我能把我的枪还给我吗], target=[我能把我的枪还给我吗], predicted=[我曾有过]
src=[我想去喝一杯], target=[我想去喝一杯], predicted=[我曾有过]
src=[我有一个橙子和一个苹果], target=[我有一个橙子和一个苹果], predicted=[我曾有过]
src=[我有一只跑得很快的狗], target=[我有一只跑得很快的狗], predicted=[我曾有过]
src=[我喜欢甜食], target=[我喜欢甜食], predicted=[我曾有过]
src=[我已经告诉汤姆我不会帮他], target=[我已经告诉汤姆我不会帮他], predicted=[我曾没有过有过有过有过有过]
以及在测试数据上
src=[我对所做的一切无怨无悔], target=[我对所做的一切无怨无悔], predicted=[我曾有过有过有过]
src=[汤姆一定听说了发生的事情], target=[汤姆一定听说了发生的事情], predicted=[我曾有过有过有过]
src=[我把雨伞忘在公交车上了], target=[我把雨伞忘在公交车上了], predicted=[我曾有过]
src=[我能借钱交钢琴课吗], target=[我能借钱交钢琴课吗], predicted=[我曾有过]
src=[我说我很抱歉], target=[我说我很抱歉], predicted=[我曾有过]
src=[我来过U], target=[我来过U], predicted=[我曾有过]
src=[请给我一杯牛奶], target=[请给我一杯牛奶], predicted=[我曾有过]
src=[最近我食欲不振], target=[最近我食欲不振], predicted=[我曾有过]
src=[我的朋友这周来过], target=[我的朋友这周来过], predicted=[我曾有过]
src=[我等了两个小时], target=[我等了两个小时], predicted=[我曾有过]
你能告诉我我哪里做错了。源语言和目标语言都是英语。
也许可以尝试重新拟合模型几次并比较结果？
TypeError : int() argument must be a string, a bytes-like object or a number, not ‘TensorShapeProto’
我收到了这个错误
我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我有一个训练好的模型，并且它在model.h5中成功评估，我需要一个代码来翻译单行句子。比如我输入hallo！然后它会输出hello
我在上面的教程中展示了如何在推理模式下使用该模型。
from tensorflow.python import pywrap_tensorflow
ImportError: cannot import name ‘pywrap_tensorflow’ from ‘tensorflow.python’ (unknown location)
我该如何解决这个bug？
这似乎与本文无关，试试发布到stackoverflow。
嗨，Jason，
您能告诉我如何使用德语输入一个句子，并用构建的模型找到它的翻译吗？
使用最后的代码示例并调用
其中“source”是你文本的整数编码句子，形状为[1, n]
这意味着我们必须先用分词器转换我们的文本吗？
是的。
嘿，你翻译了吗……如果你能帮我一下
Jason，工作很棒，我尝试构建相同的模型，但用于英语到阿拉伯语的翻译，但在加载和验证模型时遇到了错误
使用 TensorFlow 后端。
2019-01-22 10:00:35.388677: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
train
回溯（最近一次调用）
File “validation.py”，第88行，在
evaluate_model(model, eng_tokenizer, trainX, train)
File “validation.py”，第56行，在 evaluate_model
translation = predict_sequence(model, eng_tokenizer, source)
File “validation.py”，第40行，在 predict_sequence
prediction = model.predict(source, verbose=0)[0]
ValueError: Error when checking input: expected embedding_1_input to have shape (36,) but got array with shape (14,)
看起来提供的数据和模型的预期之间存在不匹配。
更改数据或模型。
你好，Jason
感谢这篇文章，
我试用了这个代码，它运行得很好，但是当我尝试使用更大的数据集时，我遇到了一个错误
英语词汇量：20428
英语最大长度：48
阿拉伯语词汇量：33623
阿拉伯语最大长度：59
回溯（最近一次调用）
File “tokniezer.py”，第79行，在
trainY = encode_output(trainY, eng_vocab_size)
File “tokniezer.py”，第43行，在 encode_output
y = array(ylist)
内存错误
我能在不增加RAM内存的情况下解决这个错误吗？我现在使用16GB内存，数据集大约有100000行。
也许可以在内存更大的机器上尝试？
也许可以尝试处理数据集的一个子集？
我尝试将其用于英语乌尔都语，但在清理后，我在乌尔都语方面得到了空白。
[我们赢了] => []
[走开] => []
[走开] => []
[我们输了] => []
[干得好] => []
[我们走吧] => []
[汤姆来了] => []
[我病了] => []
[让我进来] => []
[我们试试] => []
[保持苗条] => []
[保持苗条] => []
[保持苗条] => []
[保持苗条] => []
[汤姆胖了] => []
[汤姆生气了] => []
[汤姆伤心了] => []
[汤姆害羞了] => []
[我们谈过了] => []
[我们试试] => []
[我们会赢] => []
[怎么了] => []
[你还好吗] => []
[我喜欢茶] => []
[我爱她] => []
[我爱你] => []
[我爱你] => []
[我需要你] => []
[我需要你] => []
[我困了] => []
[我困了] => []
[汤姆死了] => []
[汤姆聋了] => []
[汤姆死了] => []
[汤姆很快] => []
[汤姆有空] => []
[汤姆走了] => []
[汤姆在这里] => []
[汤姆在家] => []
[汤姆受伤了] => []
[汤姆安全了] => []
[汤姆生病了] => []
[汤姆虚弱了] => []
[汤姆很好] => []
[我们会帮忙] => []
[我们会等的] => []
[你好吗] => []
[你好吗] => []
[我住在这里] => []
[我住在这里] => []
[我爱摇滚] => []
[我需要帮助] => []
[我信任你] => []
[我在家] => []
[它是白色的吗] => []
[可能会下雨] => []
[可能会下雪] => []
[我们开始吧] => []
[汤姆很无聊] => []
[汤姆喝醉了] => []
[汤姆是对的] => []
也许您的模型需要调整？
亲爱的Ashraf，
我遇到了同样的问题。
ValueError: Error when checking input: expected embedding_1_input to have shape (26,) but got array with shape (19,)
您有什么关于如何解决这个问题的建议吗？您的支持将不胜感激。
Zahra
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
抱歉，如果问错地方了，但我无法清理和保存数据。它一直显示IndexError: index 1 is out of bounds for axis 1 with size 1。这是否意味着我创建的clean_pairs是错误的？
也许可以把你的代码和错误发布到stackoverflow上？
如果我处理像印地语这样的语言，我该如何进行数据清理，因为它们的文字和符号完全不同？
您可能需要更新示例以支持unicode字符。
嘿 Jason，
我看到了您的帖子，工作很棒。我正在用Python做一个SMT项目。我想知道您是否可以提供一个可运行的项目代码，或者在某种程度上帮助我获得它。
谢谢。
抱歉，我不明白，您能重述或详细说明您的问题吗？
我正尝试将此转换为在TPU上运行。遵循其他TPU的笔记本，我使用TensorFlow中的Keras层而不是反之。在进入TPU部分之前，我正在进行此转换，以查看它是否仍在GPU上运行。这主要意味着更改此函数
# 定义 NMT 模型
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units)
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True))
model.add(tf.keras.layers.LSTM(n_units))
model.add(tf.keras.layers.RepeatVector(tar_timesteps))
model.add(tf.keras.layers.LSTM(n_units, return_sequences=True))
model.add(tf.keras.layers.TimeDistributed(tf.keras.layers.Dense(tar_vocab, activation=’softmax’)))
return model
然而，这会导致一个抱怨，然后在运行fit时出现运行时错误
lib\site-packages\tensorflow\python\ops\gradients_impl.py:112: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.
“正在将稀疏 IndexedSlices 转换为未知形状的密集 Tensor。”
然后，在fit期间，GPU上会因为BLAS加载而失败，如下所示
InternalError: Blas GEMM launch failed : a.shape=(64, 256), b.shape=(256, 256), m=64, n=256, k=256
[[{{node lstm/while/MatMul}} = MatMul[T=DT_FLOAT, _class=[“loc:@training/Adam/gradients/lstm/while/strided_slice_grad/StridedSliceGrad”], transpose_a=false, transpose_b=false, _device=”/job:localhost/replica:0/task:0/device:GPU:0″](lstm/while/TensorArrayReadV3, lstm/while/strided_slice)]]
[[{{node loss/time_distributed_loss/broadcast_weights/assert_broadcastable/AssertGuard/Assert/Switch/_175}} = _Recv[client_terminated=false, recv_device=”/job:localhost/replica:0/task:0/device:CPU:0″, send_device=”/job:localhost/replica:0/task:0/device:GPU:0″, send_device_incarnation=1, tensor_name=”edge_2728_…ert/Switch”, tensor_type=DT_BOOL, _device=”/job:localhost/replica:0/task:0/device:CPU:0″]()]]
有什么想法？
抱歉，我没有使用kf.keras，我也不使用笔记本或TPU，我给不了你任何好建议。
也许可以试试在TensorFlow用户组或Stack Overflow上发帖？
嗨，Jason，
干得好！谢谢您的教程。
我试了一下。我只用了你的数据集，但遇到了一些问题。例如：
train
src=[er lief], target=[he ran], predicted=[he he]
src=[er rannte], target=[he ran], predicted=[ran he]
src=[donnerwetter], target=[wow], predicted=[]
src=[keine bewegung], target=[freeze], predicted=[]
src=[ich verstehe], target=[i see], predicted=[i fell]
src=[feuer], target=[fire], predicted=[]
src=[im ernst], target=[really], predicted=[]
src=[mach mit], target=[hop in], predicted=[he he]
src=[ich bin jahre alt], target=[im], predicted=[i fell]
src=[ausgeschlossen], target=[no way], predicted=[]
BLEU-1: 0.066384
BLEU-2: 0.128366
BLEU-3: 0.167111
BLEU-4: 0.178502
test
/usr/local/lib/python3.6/dist-packages/nltk/translate/bleu_score.py:490: UserWarning
语料库/句子包含 0 个 2-gram 重叠计数。
BLEU 分数可能不理想；请使用 SmoothingFunction()。
warnings.warn(_msg)
—————————————————————————
ZeroDivisionError Traceback (most recent call last)
in ()
89 # test on some test sequences
90 print(‘test’)
—> 91 evaluate_model(model, eng_tokenizer, testX, test)
in evaluate_model(model, tokenizer, sources, raw_dataset)
61 predicted.append(translation.split())
62 # calculate BLEU score
—> 63 print(‘BLEU-1: %f’ % corpus_bleu(actual, predicted, weights=(1.0, 0, 0, 0)))
64 print(‘BLEU-2: %f’ % corpus_bleu(actual, predicted, weights=(0.5, 0.5, 0, 0)))
65 print(‘BLEU-3: %f’ % corpus_bleu(actual, predicted, weights=(0.3, 0.3, 0.3, 0)))
/usr/local/lib/python3.6/dist-packages/nltk/translate/bleu_score.py in corpus_bleu(list_of_references, hypotheses, weights, smoothing_function, auto_reweigh, emulate_multibleu)
181 # Collects the various precision values for the different ngram orders.
182 p_n = [Fraction(p_numerators[i], p_denominators[i], _normalize=False)
–> 183 for i, _ in enumerate(weights, start=1)]
184
185 # Returns 0 if there’s no matching n-grams
/usr/local/lib/python3.6/dist-packages/nltk/translate/bleu_score.py in (.0)
181 # Collects the various precision values for the different ngram orders.
182 p_n = [Fraction(p_numerators[i], p_denominators[i], _normalize=False)
–> 183 for i, _ in enumerate(weights, start=1)]
184
185 # Returns 0 if there’s no matching n-grams
/usr/lib/python3.6/fractions.py in __new__(cls, numerator, denominator, _normalize)
176
177 if denominator == 0
–> 178 raise ZeroDivisionError(‘Fraction(%s, 0)’ % numerator)
179 if _normalize
180 if type(numerator) is int is type(denominator)
ZeroDivisionError: Fraction(0, 0)
我不确定你为什么会收到错误。
也许可以再试一次拟合模型，看看是否会得到不同的结果。
您好，先生。
我在使用英语和另一种印度语言运行代码时遇到了问题。
在打印句子对时，右侧显示为空白。请提供一些修复建议。
[jaipur popularly known as the pink city is the capital of rajasthan state india] => []
[the city is famous for its majestic forts palaces and beautiful lakes which attract tourists from all over the world] => []
[the city palace was built by maharaja jai singh ii and is a synthesis of mughal and rajasthani architecture] => []
[the hawa mahal was built by the maharaja sawai pratap singh in ad and lal chand usta was the architect] => []
[the amber fort complex has several apartments with palaces halls stairways pillared pavilions gardens and temples] => []
[the amber palace is a classic example of mughal and hindu architecture] => []
[the government central museum was constructed in when the prince of wales had visited india and was opened to public in] => []
[the government central museum has a rich collection of ivory work textiles jewellery carved wooden objects miniature paintings marble statues arms and weapons] => []
[sisodiya ranikabagh was built by sawai jai singh ii for his sisodiya queen] => []
[the jal mahal is a picturesque palace which was built for royal duck shooting parties] => []
[kanak vrindavan is a popular picnic spot in jaipur] => []
[jaipur bazaars are vibrant and the shops are full with colorful items which include handicraft items precious stones textiles minakari items jewellery rajasthani paintings etc] => []
[jaipur is also famous for marble statues blue pottery and the rajasthani shoes] => []
我有一些想法。
也许是你的代码有bug？
也许模型没有适应这个问题？
也许需要不同的模型配置？
你好，我的代码有问题，找不到错误。每次预测的结果都差不多。我尝试了你的英语-印地语教程。请找到代码并告诉我哪里出错了。
def define_model(src_vocab, tar_vocab, src_timesteps, tar_timesteps, n_units)
model = Sequential()
model.add(Embedding(src_vocab, n_units, input_length=src_timesteps, mask_zero=True))
model.add(LSTM(n_units))
model.add(RepeatVector(tar_timesteps))
model.add(LSTM(n_units, return_sequences=True))
model.add(TimeDistributed(Dense(tar_vocab, activation=’softmax’)))
return model
# 定义模型
model = define_model(english_vocab_size, hindi_vocab_size, english_max_sentence_size, hindi_max_sentence_size, 32)
print(english_vocab_size, hindi_vocab_size, english_max_sentence_size, hindi_max_sentence_size)
model.compile(optimizer=’adam’, loss=’categorical_crossentropy’)
# 总结已定义的模型
打印(model.summary())
# plot_model(model, to_file=’model.png’, show_shapes=True)
checkpoint = ModelCheckpoint(“model.h6″, monitor=’val_loss’, verbose=1, save_best_only=True, mode=’min’)
# print(hindi_preproc.shape, english_preproc.shape)
model.fit(english_train_preproc, hindi_train_preproc, epochs=30, validation_data=(english_test_preproc, hindi_test_preproc), batch_size=16, callbacks=[checkpoint], verbose=2)
model = load_model(‘model.h6’)
print(english_test_preproc.shape)
hindi_index_to_words = {id:word for word, id in hindi_tokenize.word_index.items()}
hindi_index_to_words[0] = ”
english_index_to_words = {id:word for word, id in english_tokenize.word_index.items()}
english_index_to_words[0] = ”
english_test_preproc_temp = english_train_preproc[600:620,:]
for i, source in enumerate(english_test_preproc_temp)
print(‘ ‘.join([english_index_to_words[p] for p in source.tolist()]))
source = source.reshape((1, source.shape[0]))
prediction = model.predict(source, verbose=0)
print(ids_to_text(prediction[0], hindi_tokenize))
所有变量的值都与其名称含义相符。
也许模型没有很好地拟合，我这里有一些建议供您尝试：
https://machinelearning.org.cn/framework-for-better-deep-learning/
在代码中，str.maketrans(””, ””, string.punctuation)
会报错，因为str没有未定义的属性maketrans。
我们尝试使用string.maketrans，它会报错 -
maketrans() 需要正好2个参数
如果我们只传递2个参数，它会报错 - 参数必须长度相同。
我们使用的是Python 3.5和Eclipse平台，但仍然出现错误。
可能的原因和解决方案是什么？
谢谢。
我相信makestrans()是Python 2的函数，请尝试Python 2.7。
或者，在Python 3中尝试这个：
非常感谢您，先生。这有帮助。
先生，但我们现在遇到了Keras的问题。
请帮助我们继续前进，因为我们已经尝试了所有安装Keras的方法。
这是Spyder上的复制粘贴错误，即使我们已经用conda安装了Keras
runfile(‘/home/ccoewitlab1-99/.spyder2-py3/temp.py’, wdir=’/home/ccoewitlab1-99/.spyder2-py3′)
回溯（最近一次调用）
File “”, line 1, in
runfile(‘/home/ccoewitlab1-99/.spyder2-py3/temp.py’, wdir=’/home/ccoewitlab1-99/.spyder2-py3′)
File “/usr/lib/python3/dist-packages/spyderlib/widgets/externalshell/sitecustomize.py”, line 699, in runfile
execfile(filename, namespace)
File “/usr/lib/python3/dist-packages/spyderlib/widgets/externalshell/sitecustomize.py”, line 88, in execfile
exec(compile(open(filename, ‘rb’).read(), filename, ‘exec’), namespace)
File “/home/ccoewitlab1-99/.spyder2-py3/temp.py”, line 10, in
from keras.preprocessing.sequence import pad_sequences
ImportError: No module named ‘keras’
看起来Keras没有安装，也许可以尝试这个教程来设置你的环境。
https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
再次非常感谢您，先生。
按照上述步骤操作后，所有错误都已解决。
我们的代码现在可以运行于小数据集，但对于本教程中包含的数据集，它会给出内存负载错误，并且无法给出最终输出。
此外，是否有办法让用户输入德语（无论是单词还是段落），然后运行代码输出英语，而不是像src[]、target[]和prdicted[]这样的输出？简而言之，将测试数据作为用户输入。
谢谢并致以诚挚的问候。
也许可以试试在内存更多的机器上运行代码，例如在EC2实例上。
https://machinelearning.org.cn/develop-evaluate-large-deep-learning-models-keras-amazon-web-services/
您可以在常规软件中使用该模型，但这属于软件工程问题，而不是机器学习问题。
亲爱的Jason
请在此示例中添加注意力层。这将极大地帮助我们。
非常感谢。
感谢您的建议。
很棒的文章，非常感谢。
当你提到“取得了0.076238的BLEU-4分数，为进一步改进模型提供了基准技能”时，是否需要每次添加新行时都对模型进行训练以改进翻译？
此致！
可能需要。这是可以测试和考虑的事情。
你好，
当我运行代码并使用整个数据集时，我收到一个错误，提示IndexError: too many indices for array
它说错误发生在eng_tokenizer = create_tokenizer(dataset[:,0])。
你能帮忙吗？
我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
你好，
我查看了链接中的说明，一切似乎都符合要求。
当我运行代码时，我仍然收到这个错误
runfile(‘/home/ccoewitlab1-99/.config/spyder-py3/temp.py’, wdir=’/home/ccoewitlab1-99/.config/spyder-py3′)
Saved: english-german.pkl
[hi] => [hallo]
[hi] => [gru gott]
[run] => [lauf]
[wow] => [potzdonner]
[wow] => [donnerwetter]
[fire] => [feuer]
[help] => [hilfe]
[help] => [zu hulf]
[stop] => [stopp]
[wait] => [warte]
[go on] => [mach weiter]
[hello] => [hallo]
[i ran] => [ich rannte]
[i see] => [ich verstehe]
[i see] => [aha]
[i try] => [ich probiere es]
[i won] => [ich hab gewonnen]
[i won] => [ich habe gewonnen]
[smile] => [lacheln]
[cheers] => [zum wohl]
[freeze] => [keine bewegung]
[freeze] => [stehenbleiben]
[got it] => [kapiert]
[got it] => [verstanden]
[got it] => [einverstanden]
[he ran] => [er rannte]
[he ran] => [er lief]
[hop in] => [mach mit]
[hug me] => [druck mich]
[hug me] => [nimm mich in den arm]
Saved: english-german-both.pkl
Saved: english-german-train.pkl
Saved: english-german-test.pkl
回溯（最近一次调用）
File “”, line 1, in
runfile(‘/home/ccoewitlab1-99/.config/spyder-py3/temp.py’, wdir=’/home/ccoewitlab1-99/.config/spyder-py3′)
File “/home/ccoewitlab1-99/anaconda3/lib/python3.6/site-packages/spyder/utils/site/sitecustomize.py”, line 866, in runfile
execfile(filename, namespace)
File “/home/ccoewitlab1-99/anaconda3/lib/python3.6/site-packages/spyder/utils/site/sitecustomize.py”, line 102, in execfile
exec(compile(f.read(), filename, 'exec'), namespace)
File “/home/ccoewitlab1-99/.config/spyder-py3/temp.py”, line 203, in
eng_tokenizer = create_tokenizer(dataset[:, 0])
IndexError: 数组索引过多
请帮助我，这个错误已经困扰我两周了。您的帮助将非常有价值，先生。
很抱歉听到这个，您使用的是哪个版本的Keras？
TypeError: data type not understood
这是我在model.fit()时遇到的错误。
请帮我解决这个问题。
很抱歉听到这个消息，这可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
你好，
keras fit_on_texts 为每个单词分配一个唯一的整数。那么您能否告诉我它是否考虑了
相似的词，如果考虑了，又是怎么考虑的呢？提前感谢。
不，不考虑相似的词。
你好，这个NMT是否支持训练长句子？我正在尝试训练我自己的3000个句子对和900个测试句子，但在评估后，所有预测结果对于所有测试数据都是相同的字符。
是的，一些模型在长句子上表现得相当好。这 realmente取决于模型和训练数据的选择。
如果我使用双向层，输入形状应该是多少？
输入形状不受影响。
先生，我是深度学习的新手。您能建议我如何使用双向层作为输入层吗？
是的，请看这篇文章
https://machinelearning.org.cn/develop-bidirectional-lstm-sequence-classification-python-keras/
先生，我刚开始用23000个句子对进行训练，就遇到了内存错误。
trainY = encode_output(trainY, eng_vocab_size)
File “nmt.py”, line 43, in encode_output
y = array(ylist)
内存错误
我还有16GB的内存。
也许可以尝试渐进式加载（例如，数据生成器）？
也许可以尝试AWS EC2？
也许可以尝试使用更少的数据？
先生，
我是一名学生，我正在尝试使用您的代码从印地语翻译到英语。代码在训练时运行良好，但在预测序列时，它返回null。预测输出是空的。我只修改了代码中的一个地方，那就是将印地语的Devanagari脚本音译成拉丁脚本，以便对源语言数据进行归一化。您对此问题有什么看法？
也许模型需要针对您的特定数据集进行调整，我这里有一些建议：
https://machinelearning.org.cn/start-here/#better
如果源语言是印地语，我们应该进行音译吗？
先生，您好。我尝试着对您的代码做了一些修改，做了印地语到英语的翻译器。对于4-gram，我得到了0.74的BLEU分数，但预测效果非常差。它几乎对所有句子都给出相同的预测。有什么建议吗？
也许模型需要一些调整。
https://machinelearning.org.cn/start-here/#better
我在创建Tokenizer时遇到了错误。
# 训练一个分词器
2 def create_tokenizer(lines)
—-> 3 tokenizer = Tokenizer()
4 tokenizer.fit_on_texts(lines)
5 return tokenizer
NameError: name ‘Tokenizer’ is not defined
很抱歉听到这个，请确保您已复制了完整代码示例的所有代码行。
你好，你是如何解决这个错误的，@Syed Abdul Basit？
您的问题解决了吗？
很高兴听到这个消息。
嗨
我尝试了从英语到印度尼西亚语的翻译，但在预测方面遇到了问题。它只重复预测我之前有的英语单词：I had, I do, I you。但BLEU值在0.5 - 9.0之间是正常的。
我尝试修复BLEU代码中的权重，但仍然是这样。
您说过模型需要微调，但您能建议一下问题所在吗？是分词器问题，还是训练不足，或者verbose设置？
我按照您的书中的说明更改了模型中的所有参数，但预测结果仍然相同。
也许可以确认一下数据中的输入和输出是否符合您的预期？
您好，我遇到了一个问题，当我在模型训练完后立即使用它，或者保存后加载它与另一个数据集使用时，结果是不同的。这可能是因为分词器的改变，即新数据有与训练前创建的分词器不同的分词器。我该如何解决这个问题，或者我必须在每次使用前都训练新模型？
您必须使用相同的分词器。也许可以将其与模型一起保存，或者开发一种创建它的统一方法？
我该怎么做？您有什么建议吗？提前感谢。
您可以使用pickle，博客上有许多示例，包括上述教程中使用的pickle示例。
代码中存在一些错误。具体来说，根据语料库级别BLEU分数中引用的定义，您必须使用 `actual.append([raw_target.split()])`。
您确定吗？这会影响您的结果吗？您的库是最新的吗？
list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
hypotheses = [hyp1, hyp2]
corpus_bleu(list_of_references, hypotheses)
上面的代码来自[bleu_score.html](https://www.nltk.org/_modules/nltk/translate/bleu_score.html)。如您所见，`list_of_references`中的每个项目都是**一个列表的列表**。
是的，这里也有展示。
https://machinelearning.org.cn/calculate-bleu-score-for-text-python/
谢谢，已修复！
嗨，Jason，
您发布的深度学习内容是互联网上最好的之一。非常值得称赞的努力。
您能否发布一个关于使用LSTM在TensorFlow中构建自动语音识别的项目，并教授如何处理音频数据和标记句子？通常ASR是提供预处理数据的，但这并非我的需求。不仅是我，很多人都会从中受益。
非常感谢
感谢您的建议。
你能建议我如何在这里使用model.fit_generator吗？ 提前感谢
你到底遇到了什么问题？
我猜前面的发帖人拥有非常大的数据集，内存不足，并且想知道如何使用model.fit_generator而不是model.fit来解决上面的NMT示例。
好问题，你可以开发一个函数来逐步加载数据，我在本教程中提供了一个例子，你可以用它作为起点。
https://machinelearning.org.cn/develop-a-deep-learning-caption-generation-model-in-python/
嗨
本教程非常有帮助，我只想知道您是否可以提供整个数据集的翻译。这里我只能看到几个翻译。
帖子中使用的数据集包含所有英文短语及其翻译。
这开始还好，但是调用了pydot.py但是它不存在。
(base) C:\Users\Roger\Documents\Python Scripts>python model.py
使用 Theano 后端。
英文词汇量：2233
英语最大长度: 5
德文词汇量：3566
德语最大长度: 10
_________________________________________________________________
层（类型） 输出形状 参数 #
=================================================================
embedding_1 (Embedding) (None, 10, 256) 912896
_________________________________________________________________
lstm_1 (LSTM) (None, 256) 525312
_________________________________________________________________
repeat_vector_1 (RepeatVecto (None, 5, 256) 0
_________________________________________________________________
lstm_2 (LSTM) (None, 5, 256) 525312
_________________________________________________________________
time_distributed_1 (TimeDist (None, 5, 2233) 573881
=================================================================
总参数：2,537,401
可训练参数：2,537,401
不可训练参数: 0
_________________________________________________________________
无
回溯（最近一次调用）
文件 “model.py”，第79行，在
plot_model(model, to_file=’model.png’, show_shapes=True)
文件 “C:\Users\Roger\Anaconda3\lib\site-packages\keras\utils\vis_utils.py”，第132行，在 plot_model
dot = model_to_dot(model, show_shapes, show_layer_names, rankdir)
文件 “C:\Users\Roger\Anaconda3\lib\site-packages\keras\utils\vis_utils.py”，第55行，在 model_to_dot
_check_pydot()
文件 “C:\Users\Roger\Anaconda3\lib\site-packages\keras\utils\vis_utils.py”，第20行，在 _check_pydot
‘未能导入
pydot。‘ImportError: 未能导入
pydot。请安装pydot。例如使用pip install pydot。如果需要，您可以注释掉 plot_model 行。
嗨，Jason！
我正在处理英语到越南语的NMT，我已经完成了文章中的所有步骤，但我的BLEU分数非常差，我的自定义数据集包含50000个句子
train
BLEU-1: 0.015223
BLEU-2: 0.004198
BLEU-3: 0.003481
BLEU-4: 0.001052
test
BLEU-1: 0.013051
BLEU-2: 0.001648
BLEU-3: 0.001538
BLEU-4: 0.000486
如何提高结果？谢谢！
我在这里有一些建议
https://machinelearning.org.cn/start-here/#better
也许可以尝试拟合模型几次？
也许模型需要针对你的数据集进行调整？
也许数据集需要不同的准备？
嗨，Jason，
这可能是一件非常基本的事情，但我不知道为什么要在词汇量大小上加1
eng_vocab_size = len(eng_tokenizer.word_index) + 1
好问题，这样我们就能为0==没有单词或“未知”留出空间，因此词汇表中的第一个单词将被映射到1，我们可以为我们词汇表中没有的所有单词使用0。
好的，那么当我们有代码将OOV替换为UNK时，我们应该确保使用“0”…我说对了吗？
正确。
我的predict_sequence()函数输出为空字符串‘ ‘。这是为什么？
也许模型没有收敛，尝试重新拟合模型？
数据清洗。可以对数据执行不同的数据清洗操作，例如不删除标点符号或不规范化大小写，或者删除重复的英文短语
Jason，你认为删除标点符号或不规范化大小写有什么帮助？因为将所有内容转换为小写似乎比保持原样更好。请分享你的想法。
这将产生更大的词汇量和更多的单词细微差别。它还需要更多训练数据、更大的模型和更长的训练时间。
Jason，我正在使用更大的语料库数据运行模型，即大约160000条记录，模型在第5个epoch后停止，因为损失没有改善……
所以我想考虑你在扩展中列出的几点并开始训练，我已将模型修改如下，即在输入/编码器中添加双向（Bidirectional），包括更多单元（256到512）并在编码器和解码器LSTM层后添加dropout。
我不确定如何添加更多额外的层以及在哪里添加它们以获得更强的表示能力……如果您能帮助我，我将不胜感激。
# 定义模型
model = Sequential()
model.add(Embedding(ger_vocab_size, 512, input_length=ger_length, mask_zero=True))
model.add(Bidirectional(LSTM(512), merge_mode=’concat’))
model.add(Dropout(0.2))
model.add(RepeatVector(eng_length))
model.add(LSTM(512, return_sequences=True))
model.add(Dropout(0.2))
model.add(TimeDistributed(Dense(eng_vocab_size, activation=’softmax’)))
我有一些建议可能会有所帮助
https://machinelearning.org.cn/start-here/#better
Jason，需要你的帮助…
我看了你的一篇文章，其中描述了一个基线模型配置。
Embedding: 512维
RNN Cell: Gated Recurrent Unit 或 GRU
Encoder: Bidirectional (双向)
Encoder Depth: 2层 (每个方向1层)
Decoder Depth: 2层
Attention: Bahdanau风格
Optimizer: Adam
Dropout: 输入层20%
我对以下内容感到困惑…
Encoder: Bidirectional (双向)
Encoder Depth: 2层 (每个方向1层)
这是我们如何构建上述Encoder Bidirectional，具有2层深度（每个方向1层）的方式吗？
model = Sequential()
model.add(Embedding(ger_vocab_size, 256, input_length=ger_length, mask_zero=True))
model.add(Bidirectional(LSTM(256, return_sequences=True), merge_mode=’concat’))
model.add(Bidirectional(LSTM(256, go_backwards=True),merge_mode=’concat’))
model.add(Dropout(0.2))
这看起来不错，也许测试一下以确认。
好的，我会试试然后告诉你。
同时，我已经尝试了以下模型架构的传递
1.海量数据约160000 (通过生成器逐步加载)，
2.有限的词汇量，将出现次数少于5次的单词转换为“unk”。
2.增加了单元数，即256 -> 512
3.双向输入/编码器层
4.编码器和解码器的Dropout/正则化 (20%)
令人惊讶的是，我发现损失在1或2个epoch后不再进一步下降。有什么想法吗？请帮助。
model = Sequential()
model.add(Embedding(ger_vocab_size, 512, input_length=ger_length, mask_zero=True))
model.add(Bidirectional(LSTM(512), merge_mode=’concat’))
model.add(Dropout(0.2))
model.add(RepeatVector(eng_length))
model.add(LSTM(512, return_sequences=True))
model.add(Dropout(0.2))
model.add(TimeDistributed(Dense(eng_vocab_size, activation=’softmax’)))
也许你需要更深的编码器、解码器或两者兼而有之？
也许试试relu？
我在这里有大量的建议
https://machinelearning.org.cn/start-here/#better
Jason，我将尝试构建更深的编码器/解码器。同时您能否确认Keras是否可以实现Attention和Beam Search，Keras是否支持？否则我该如何使用上面粘贴的基础模型进行尝试？
抱歉，我无法确认你的代码/模型。
我建议测试一套方法以发现最适合您特定数据集的方法。
嘿Jason，我不是在要求确认我的模型/代码。
我想知道的是，Keras是否支持实现Attention Layers和Beam Search？如果支持，是否有相关的参考资料？
Keras不支持attention或beam search，您必须自己实现它们。
这可能有助于attention
https://machinelearning.org.cn/?s=attention&post_type=post&submit=Search
这可能有助于beam search
https://machinelearning.org.cn/?s=beam+search&post_type=post&submit=Search
我正在遇到内存错误，如下所示：
回溯（最近一次调用）
文件 “cleantext.py”，第70行，在
save_clean_data(clean_pairs, ‘english-german.pkl’)
文件 “cleantext.py”，第56行，在 save_clean_data
dump(sentences, open(filename, ‘wb’))
内存错误
请告诉我如何解决它。
听到这个消息我很难过。
也许试试处理更少的数据？
也许尝试在内存更多的机器上运行？
训练神经网络模型时出错
使用 TensorFlow 后端。
回溯（最近一次调用）
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow.py”，第58行，在
from tensorflow.python.pywrap_tensorflow_internal import *
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow_internal.py”，第28行，在
_pywrap_tensorflow_internal = swig_import_helper()
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow_internal.py”，第24行，在 swig_import_helper
_mod = imp.load_module(‘_pywrap_tensorflow_internal’, fp, pathname, description)
文件 “D:\anaconda\envs\myenv\lib\imp.py”，第243行，在 load_module
返回 load_dynamic(name, filename, file)
文件 “D:\anaconda\envs\myenv\lib\imp.py”，第343行，在 load_dynamic
返回 _load(spec)
ImportError: DLL 加载失败：%1 不是有效的 Win32 应用程序。
处理上述异常时，发生了另一个异常
回溯（最近一次调用）
文件 “train.py”，第3行，在
from keras.preprocessing.text import Tokenizer
文件 “D:\anaconda\envs\myenv\lib\site-packages\keras\__init__.py”，第3行，在
from . import utils
文件 “D:\anaconda\envs\myenv\lib\site-packages\keras\utils\__init__.py”，第6行，在
from . import conv_utils
文件 “D:\anaconda\envs\myenv\lib\site-packages\keras\utils\conv_utils.py”，第9行，在
from .. import backend as K
文件 “D:\anaconda\envs\myenv\lib\site-packages\keras\backend\__init__.py”，第89行，在
from .tensorflow_backend import *
文件 “D:\anaconda\envs\myenv\lib\site-packages\keras\backend\tensorflow_backend.py”，第5行，在
import tensorflow as tf
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\__init__.py”，第22行，在
from tensorflow.python import pywrap_tensorflow # pylint: disable=unused-import
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\__init__.py”，第49行，在
from tensorflow.python import pywrap_tensorflow
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow.py”，第74行，在
raise ImportError(msg)
ImportError: 回溯（最近一次调用）
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow.py”，第58行，在
from tensorflow.python.pywrap_tensorflow_internal import *
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow_internal.py”，第28行，在
_pywrap_tensorflow_internal = swig_import_helper()
文件 “D:\anaconda\envs\myenv\lib\site-packages\tensorflow\python\pywrap_tensorflow_internal.py”，第24行，在 swig_import_helper
_mod = imp.load_module(‘_pywrap_tensorflow_internal’, fp, pathname, description)
文件 “D:\anaconda\envs\myenv\lib\imp.py”，第243行，在 load_module
返回 load_dynamic(name, filename, file)
文件 “D:\anaconda\envs\myenv\lib\imp.py”，第343行，在 load_dynamic
返回 _load(spec)
ImportError: DLL 加载失败：%1 不是有效的 Win32 应用程序。
谁能帮帮我…
谢谢…
看起来是TensorFlow的问题。
也许可以试试这个教程来设置和测试你的环境
https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
如何找到完整数据集中句子的数量？
原始文件中的行数就是句子的数量。
收到错误
NameError: name ‘Tokenizer’ is not defined
也许你错过了导入语句。
你好，先生，教程很棒。请帮助我，我该如何翻译其他句子，比如我想翻译“我爱你”这句句子，使用保存的模型，请帮助我？
你可以加载模型并直接进行翻译。你具体遇到了什么问题？
Jason，教程很好。当我阅读你清理文本的部分时，我想知道商业翻译器是如何处理数字和其他特殊符号（例如货币）的。例如，在Google翻译中，如果我们输入包含数字、大写单词等的文本，它们会以相同的符号输出最终文本。您对他们如何恢复在预处理步骤中“丢失”的信息有什么想法吗？我想了解他们是如何恢复信息的。
很好的问题。
我预计能够访问大量文本的系统实际上可以直接处理几乎所有符号。例如，它们的使用频率都非常高。
一个愚蠢的问题。我如何确定LSTM输出单元的合适值？
model.add(LSTM(n_units))我必须使用n_units吗？determin -> determine
好问题，我在这里回答
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
你好
我从法语翻译成英语，并使用了法语-英语语料库。我添加了一些步骤来更好地理解正在发生的事情。我想获得至少与Moses一样好的性能，并试图使用您的代码使用更多数据训练模型。我将数据集从10000增加到100000，但遇到了以下错误 categorical = np.zeros((n, num_classes))
MemoryError。看来我的RAM（8GB）不够用。我不使用BLUE，而是通过后期编辑手动评估输出。使用Moses，我使用了整个Europarl语料库，并期望在NMT中使用它。我需要找到一种方法来训练大量数据，以便它能被个人使用。
也许试试使用更少的数据？
也许试试在更大的机器上运行，例如AWS EC2？
也许试试使用数据生成器一次准备一个批次的数据？
你好，Jason！
我在哪里可以学习如何为model.fit_generator()准备数据生成器？
您可以在博客上看到许多图像和文本数据的示例。
也许这个生成器示例会有帮助
https://machinelearning.org.cn/develop-a-deep-learning-caption-generation-model-in-python/
超过10000个句子，one-hot编码就会耗尽我的所有内存。我可以在8G内存上训练Moses，但是使用您的代码训练NMT似乎无法构建一个严肃的系统。我不想使用AWS，数据生成器是如何工作的？
你可以修改这里的示例
https://machinelearning.org.cn/develop-a-deep-learning-caption-generation-model-in-python/
我在Floydhub上使用具有59 GB CPU和11GB GPU内存的机器成功训练了一个模型，使用了100000个句子。对我来说麻烦的是，在MT术语中这真的是一小部分数据。我用100万个段落训练了Moses，Koehn等人表明，在Nematus和Moses的测试中，Nematus直到使用这么多数据才等于Moses。问题是，使用您的方法可能会耗费巨大的资源，主要是因为所有必须存储的one-hot向量，而我可以轻松地在我的笔记本电脑上训练我的Moses引擎。
从法语到英语，使用10000个句子，唯一可以说的是输出是英语。这是必然的，因为单词由被翻译成英语的令牌表示。
我的下一步是尝试150000个句子，因为这是所有数据。
在您的教程中，我们将epochs数量固定为30。我该如何安排继续进行，直到成本不再改变？
请注意，本教程中的模型仅用于教育目的，它可能不是最高效的通用模型。
也许你可以使用早期停止
https://machinelearning.org.cn/how-to-stop-training-deep-neural-networks-at-the-right-time-using-early-stopping/
我非常喜欢你的博客，它非常棒。
但我不知道如何用模型进行预测。你能帮我解除疑惑吗？
是的，请看这篇文章
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
你好，Jason。
这里做得非常好。
在您的 `predict_sequence` 代码中，我认为您可以使用 predict_classes 方法。
同意。谢谢。
我该如何输入自己的输入到模型中??????
我还发现此代码只能预测我输入的前两行。我们如何编写代码来预测和翻译两行或更多行的句子????
例如，请看 `evaluate_model()` 函数中的这行代码
我该如何创建自己的数据集????
你可以自己翻译？
这可能太耗时了，也许可以从公共数据集开始？
我只能正确翻译句子中的两个单词。我想完全翻译。这该如何实现？？帮帮我？？
如果我给出的例子是“Als Jugendlicher war Tom sehr beliebt。”，它的意思是英语中的“As a teenager, Tom was very popular.”，但我的输出是“you you you to to to you”。它在某种程度上部分翻译了句子，但如何得到确切的输出？？？
也许你的模型过拟合了？
也许试试再次运行示例并拟合新模型？
也许在一个不同的数据集上开发一个更大的模型？
也许使用预训练模型？
Jass
这个模型只是一个玩具，实际上不会翻译任何内容。它只使用了 10K 个句子（或片段），我认为你需要训练近 100 万个句子才能获得合理的性能。请记住，谷歌在开发神经翻译方面投入了巨大的资源。我发现这个教程在学习 Python、Keras 和 TensorFlow 等方面非常有益，但它有点像学习焊接。以我的情况为例，教练在五分钟内演示了如何操作，但我从未成功掌握它。
是的，这个教程（就像我网站上的所有教程一样）是用于教育目的的示例。
它是您开始自己项目的起点。
问题是它看起来不像是在启动我自己的项目。昨天我尝试用 149,000 个句子训练一个模型。它有一个 12004 个单词的英语词汇量，最大长度为 12，但 59 GB 的内存仍然不够。这已经是一个已知的问题（Khan 201，p61 https://arxiv.org/abs/1709.07809），并且词汇量被限制在 20000 到 80000 个单词之间。
对我来说，这里的主要教训是，神经机器翻译并没有吹嘘得那么好。
这只是一种方法，不要根据一个教程来评判整个领域。
也许可以尝试斯坦福提供的一些高效实现
https://nlp.stanford.edu/projects/nmt/
你好 Browniee，
非常感谢您对简单神经机器翻译系统的精彩介绍，
您能否提供训练模型的链接？我没找到，而且我在使用 GTX-1070 8GB 显卡、12 核处理器时也无法训练 😐
抱歉，我无法提供训练模型的链接。我不想从事模型托管业务。
嗨，Jason，
您能否告诉我，在 hindi-english 音译时，我应该使用什么代码来代替
line = normalize(‘NFD’, line).encode(‘ascii’, ‘ignore’)
line = line.decode(‘UTF-8’)？
我对那种翻译不太熟悉，也许可以试试试验一下？
这是我的输出
train
src=[फर्ग्यूसन], target=[ferguson], predicted=[raymond]
src=[काम्प्लैक्स], target=[complex], predicted=[raymond]
src=[लूकीज], target=[lookeys], predicted=[raymond]
src=[च्यवनप्राश], target=[chyavanprash], predicted=[raymond]
src=[कौशल], target=[koshala], predicted=[raymond]
src=[माइम], target=[mime], predicted=[raymond]
src=[अनअनपेन्टियम], target=[ununpentium], predicted=[raymond]
src=[केडीईलिब्स], target=[kdelibs], predicted=[raymond]
src=[जैस], target=[jais], predicted=[raymond]
src=[दक्षिणा], target=[dakshina], predicted=[raymond]
/usr/local/lib/python3.6/dist-packages/nltk/translate/bleu_score.py:490: UserWarning
语料库/句子包含 0 个 2-gram 重叠计数。
BLEU 分数可能不理想；请使用 SmoothingFunction()。
warnings.warn(_msg)
BLEU-1: 0.000054
BLEU-2: 0.007376
BLEU-3: 0.052566
BLEU-4: 0.085885
test
src=[ड्रेगन], target=[dragons], predicted=[raymond]
src=[कंवर्जेंस], target=[convergence], predicted=[raymond]
src=[हेदुआ], target=[hedua], predicted=[raymond]
src=[शुएब], target=[shoaib], predicted=[raymond]
src=[ब्रेंट], target=[brent], predicted=[raymond]
src=[करने], target=[kane], predicted=[raymond]
src=[हेस्टिंग्स], target=[hastings], predicted=[raymond]
src=[कैप्टिव], target=[captive], predicted=[raymond]
src=[नाटिका], target=[natika], predicted=[raymond]
src=[शंभु], target=[sambhu], predicted=[raymond]
BLEU-1: 0.000000
BLEU-2: 0.000000
BLEU-3: 0.000000
BLEU-4: 0.000000
您能否帮我弄清楚为什么只有一个输出？
取得了不错的进展，坚持下去。
你好，
这篇文章真的很有帮助。我在英语-印度尼西亚语语料库上尝试了代码，但验证数据训练为 0 个样本。如何解决？
也许可以确认您已正确加载数据集？
我下载了您建议的数据。我确定我加载了正确的数据。
我还尝试了 deu-eng 像示例一样。我取得了不错的 BLEU 分数。
干得好！
Jason，演示得很棒！请问我们需要对目标集中的所有填充标记进行掩码处理，以便不将其包含在损失函数中吗？如果我们想尝试这样做，那么我们需要进行哪些更改？
或者您认为以下嵌入层已经完成了？但我认为这只是针对嵌入层的，对吧？它不会影响损失函数的计算方式。
model.add(Embedding(ger_vocab_size, 512, input_length=ger_length, mask_zero=True))
谢谢。
是的，对填充值进行掩码处理是一个好主意。
是的，嵌入层可以为您完成此操作。
执行代码后
filename =’model.h5′
checkpoint = ModelCheckpoint(filename, monitor=’val_loss’, verbose=1, save_best_only=True, mode=’min’)
model.fit(trainX, trainY, epochs=60, batch_size=64, validation_data=(testX, testY), callbacks=[checkpoint], verbose=2)
模型没有保存，尽管它完成了 30 个 epoch。
很抱歉听到这个消息，我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
谢谢您，先生，感谢这篇精彩的文章和您的快速回复。
模型保存到 model.h5 后，我执行了
model = load_model(‘model.h5’)
下一条语句是
translation = model.predict(source, verbose=0)
这里的源是什么？我们可以给源一个包含句子的文本文件吗？
“源”是经过与训练数据相同方式（相同转换）准备的数据，代表您希望进行翻译的一个或多个样本。
谢谢 Jason
这是德语到英语的代码，如果是英语到德语呢？代码需要在哪里更改？
能帮帮我吗？
是的，您可以为此类情况更改代码，例如更改模型的输入和输出。
我没有能力概述需要更改什么或为您更改。更多信息请参见此处
https://machinelearning.org.cn/faq/single-faq/can-you-change-the-code-in-the-tutorial-to-___
你好 Jason，
感谢这篇很棒的教程。
在评估（您的代码的第 2 部分）时出现错误，如下所示：
File “xxx.py” , line 57, in evaluate_model
raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
我尝试了几个 NLTK 版本，但出现了同样的错误。
您有什么建议吗？
很抱歉听到这个消息，我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
试试这个
evaluate_model(load_model(‘model.h5’), eng_tokenizer, testX, test[:,:2])
嗨，Jason，
感谢您的快速回复。我在网上检查了错误。
“ValueError: too many values to unpack (expected 2)” 是由于维度不匹配。
我打开了 raw_dataset，发现这个数据集有 3 列，因此我稍微修改了您的代码，只添加了 “,test”。您的代码又可以正常工作了。
_________________________________________________________________________
raw_target, raw_src = raw_dataset[i] # 原始代码有错误
raw_target, raw_src, test = raw_dataset[i] # 运行成功！test 是 raw_dataset 的第 3 列
_________________________________________________________________________
顺便说一句，raw_dataset 的第 3 列包含奇怪的内容，例如：
“ccby france attribution …”
我认为这可能是由于 Python 包的不同版本。raw_dataset 包含第 1 和第 2 列干净的数据，但不知何故也包含无用的第 3 列，这导致了错误。总之，在按照上述方法添加 “, test” 后，您代码的第 2 部分运行正常。
Jiasheng
很高兴听到您取得了进展！
非常感谢 @Bonasaint King，您的更正对我帮助很大。
再次感谢您，先生。
非常感谢 Bonsaint King。它也解决了我的问题。书中的示例没有更正。
谢谢 Bonsaint。你太棒了！
你好，
一切都奏效了，但下面的代码片段没有生成 model.h5。
filename = ‘model.h5’
checkpoint = ModelCheckpoint(‘model.h5′, monitor=’val_loss’, verbose=1, ave_best_only=True, mode=’min’)
model.fit(trainX, trainY, epochs=30, batch_size=64,validation_data=(testX, testY), callbacks=[checkpoint], verbose=2)
也许可以尝试不同的配置？
我在这里解释了更多
https://machinelearning.org.cn/check-point-deep-learning-models-keras/
你好 Jason，请问这个错误是什么意思？
File “mtTest1.py”, line 16
file = open(filename, mode=’rt’, encoding=’utf-8′)
^
IndentationError: 期望一个缩进块
看起来你需要更改你的缩进。
谢谢 Jason，这个错误表示 RAM 不足？
train
回溯（最近一次调用）
File “mtTest4.py”, line 95, in
evaluate_model(model, eng_tokenizer, trainX, train)
File “mtTest4.py”, line 64, in evaluate_model
raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
不，这可能表明存在复制粘贴错误。
我完全按照示例进行了复制粘贴，但仍然显示相同的错误！
很抱歉听到这个消息，我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我终于修复了错误。
raw_target, raw_src= raw_dataset[i] 改为 => raw_target, raw_src,test = raw_dataset[i]
并得到了以下结果：
train
src=[er respektiert mich], target=[he respects me], predicted=[he respects me]
src=[sei tapfer], target=[be brave], predicted=[be brave]
src=[uns wird es gut gehen], target=[well be fine], predicted=[well be fine]
src=[tom drehte durch], target=[tom went nuts], predicted=[tom went pale]
src=[wer fastet], target=[whos fasting], predicted=[whos fasting]
src=[wahlen sie mich], target=[vote for me], predicted=[vote for me]
src=[sind sie im ruhestand], target=[are you retired], predicted=[are you retired]
src=[darf ich gehen], target=[may i go], predicted=[can i go]
src=[wir brauchen das], target=[we need this], predicted=[we need this]
src=[tom wird tanzen], target=[tom will dance], predicted=[tom will dance]
BLEU-1: 0.874297
BLEU-2: 0.822932
BLEU-3: 0.727685
BLEU-4: 0.407115
test
src=[tom gesellte sich zu uns], target=[tom joined us], predicted=[tom grabbed us]
src=[ich bin besser], target=[im better], predicted=[im am better]
src=[ich muss mich sputen], target=[i must hurry], predicted=[i must to you]
src=[seid diskret], target=[be discreet], predicted=[be discreet]
src=[er ist sauber], target=[its clean], predicted=[its is]
src=[es war meine absicht], target=[it was my plan], predicted=[it was be]
src=[konnt ihr mich auslassen], target=[can you skip me], predicted=[can you read]
src=[schau genau zu], target=[watch closely], predicted=[look closely]
src=[boston ist der hammer], target=[boston is great], predicted=[my my fun]
src=[ich benotige sie], target=[i need them], predicted=[i need you]
BLEU-1: 0.551442
BLEU-2: 0.427450
BLEU-3: 0.347021
BLEU-4: 0.171442
干得好！
先生，
我的要求是将英语语言风格从非正式转换为正式。对此方法是否适用于我的任务？
哇，听起来是个很有趣的项目。
或许可以试试看？
嗨，Jason，
我最近才偶然发现了您的网站。您的工作非常棒！
感谢分享您的知识！
这个教程也非常棒。但我很好奇，有没有办法将整个机器翻译输出保存到 txt 文件中？
因为，我只得到了 10 个翻译。有没有办法看到测试集剩下的 990 个句子？
谢谢！
谢谢！
是的，您可以将结果存储在 numpy 数组中，并直接将 numpy 数组保存到文件，例如 savetxt()。
https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.savetxt.html
嗨，先生……我遇到了
value error: too many values to unpack (expected 2) 在 model_evalute() 函数中，这个错误出现在代码末尾。
我只是将训练和测试数据集大小改为了 1500 和 500。
我该如何解决这个问题？
您能帮帮我吗？
也许可以从原始工作值开始，然后根据需要慢慢调整？
是的……我也尝试了相同的训练和测试值。但问题又出现了。
很明显，错误在于：
ValueError 回溯 (最近一次调用)
in
86 # 在一些训练序列上进行测试
87 print(‘train’)
—> 88 evaluate_model(model, eng_tokenizer, trainX, train)
89 # test on some test sequences
90 print(‘test’)
in evaluate_model(model, tokenizer, sources, raw_dataset)
55 source = source.reshape((1, source.shape[0]))
56 translation = predict_sequence(model, eng_tokenizer, source)
—> 57 raw_target, raw_src = raw_dataset[i]
58 if i < 10
59 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨，即使我复制了代码，我也遇到了同样的问题。请帮忙。
ValueError 回溯 (最近一次调用)
in
86 # 在一些训练序列上进行测试
87 print(‘train’)
—> 88 evaluate_model(model, eng_tokenizer, trainX, train)
89 # test on some test sequences
90 print(‘test’)
in evaluate_model(model, tokenizer, sources, raw_dataset)
55 source = source.reshape((1, source.shape[0]))
56 translation = predict_sequence(model, eng_tokenizer, source)
—> 57 raw_target, raw_src = raw_dataset[i]
58 if i < 10
59 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
这可能有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
首先，这是反向传播吗？
其次，如果有反向传播，您能否指出来并标记出那一行？
是的，我们总是使用反向传播。
当您调用 fit() 时会发生。
谢谢先生
model.fit(trainX, trainY, epochs=30, batch_size=64, validation_data=(testX, testY), callbacks=[checkpoint], verbose=2)
epochs=30 就是反向传播，我说对了吗，先生！
是的，它将使用反向传播来更新权重。
您好 Jason……我在准备部分（最后两行）遇到了问题（正在处理埃塞俄比亚语对）。
已保存：AAO.pkl
回溯（最近一次调用）
File “D:\Python Projects\Amh-AO\1_Prepare-AAO.py”, line 58, in
print(‘[%s] => [%s]’ % (clean_pairs[i,0], clean_pairs[i,1]))
IndexError: 数组索引过多
您能帮帮我吗？
也许可以确认您的数据已按预期加载？
问题是由于语料库文档中单词和句子之间的不必要空格引起的。我收到一个错误：
1. [today] => []
[me] => []
[like] => []
[hard] => []
[interesting] => []
[answer] => []
空方括号([])应该显示非英语语言。
临时解决方案…… #line = [re_print.sub(”, w) for w in line]……起作用了。
您能提供永久解决方案吗……？
干得好！
你好 Daniel 先生，我也在尝试埃塞俄比亚语言的神经机器翻译。我遇到了同样的问题，能否请您详细写一下解决方案？
谢谢
回溯（最近一次调用）
File “nmt.py”, line 59, in
dataset = load_clean_sentences(‘english-german-both.pkl’)
File “nmt.py”, line 18, in load_clean_sentences
return load(open(filename, ‘rb’))
_pickle.UnpicklingError: invalid load key, ‘H’。
训练时我们遇到了这个错误。您能否帮助我们纠正？
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
感谢 Jason，您的教程总是帮了我很多。
我遇到了以下错误，可能的原因是什么？
NameError Traceback (最近一次调用)
in
9 file = open(filename, mode=’rt’, encoding=’utf-8′)
10 # 读取所有文本
—> 11 text = file.read()
12 # 关闭文件
13 file.close()
NameError: name ‘file’ is not defined
也许请确认文件是否已按您预期的方式打开。
请给出此问题的解决方案
已保存：english-amharic.pkl
—————————————————————————
IndexError Traceback (最近一次调用)
in
65 # spot check
66 for i in range(100)
—> 67 print(‘[%s] => [%s]’ % (clean_pairs[i,0], clean_pairs[i,1]))
IndexError: too many indices for arra
我需要帮助
—————————————————————————
NameError Traceback (最近一次调用)
in
8 return max(len(line.split()) for line in lines)
9 # 准备英语分词器
—> 10 eng_tokenizer = create_tokenizer(dataset[:, 0])
11 eng_vocab_size = len(eng_tokenizer.word_index) + 1
12 eng_length = max_length(dataset[:, 0])
in create_tokenizer(lines)
1 # 拟合分词器
2 def create_tokenizer(lines)
—-> 3 tokenizer = Tokenizer()
4 tokenizer.fit_on_texts(lines)
5 return tokenizer
NameError: name ‘Tokenizer’ is not defined
看起来您可能跳过了一些代码行。
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨，Jason，
在训练中，我遇到了以下错误。
请，我需要常规的帮助。
谢谢你！！
C:\Users\Habib\Anaconda3\lib\site-packages\theano\scan_module\scan_perform_ext.py:76: UserWarning: The file scan_perform.c is not available. This donot happen normally. You are probably in a strangesetup. This mean Theano can not use the cython code for scan. If youwant to remove this warning, use the Theano flag’cxx=’ (set to an empty string) to disable all ccode generation.
“The file scan_perform.c is not available. This do”
很抱歉听到这个。我对这个错误不熟悉，但它看起来像是您开发环境中的一个问题。
本教程可能有助于您设置环境
https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
嗨 Jason
这是我得到的结果，我认为是最差的
我不知道为什么
求助
train
src=[japan und nordkorea unterhalten noch immer keine diplomatischen beziehungen], target=[diplomatic relations have not yet been established between japan and north korea], predicted=[the the the the the the the the the the]
src=[lasst uns losgehen], target=[lets go], predicted=[tom]
src=[tom hat gezahlt], target=[tom paid], predicted=[tom]
src=[ich bin sicher], target=[im sure], predicted=[tom]
src=[mir geht es gut], target=[im fine], predicted=[tom]
src=[er kleidet sich wie ein gentleman aber er spricht und benimmt sich wie ein clown], target=[his dress is that of gentleman but his speech and behavior are those of a clown], predicted=[the the the the the the the the the the the the the]
src=[ist dir schon mal der gedanke gekommen dass ich vielleicht noch ein paar tage in boston konnte bleiben wollen], target=[did it ever occur to you that i might want to stay in boston for a few more days], predicted=[the the the the the the the the the the the the the the the the the]
src=[je mehr zeit tom und maria zusammen verbrachten desto besser lernten sie sich kennen], target=[as tom and mary spent time together they began to get to know each other better], predicted=[the the the the the the the the the the the the the]
src=[tom ist total geistesabwesend und vergisst manchmal die kinder von der schule abzuholen], target=[tom is quite absentminded and sometimes forgets to pick the kids up from school], predicted=[the the the the the the the the the the the the]
src=[tom fand dass der lehrer ihm viel mehr hausaufgaben aufgegeben hatte als er an einem tage schaffen konnte], target=[tom thought the teacher had given him way too much homework to finish in one day], predicted=[the the the the the the the the the the the the the]
BLEU-1: 0.062208
BLEU-2: 0.000000
BLEU-3: 0.000000
BLEU-4: 0.000000
test
src=[einige begebenheiten aus meiner kindheit sind kristallklar andere hingegen sind nur eine dunkle erinnerung], target=[some incidents from my childhood are crystal clear others are just a dim memory], predicted=[the the the the the the the the the the the the]
src=[als ich seine mutter gestern traf sagte diese er ware vor einer woche aus dem krankenhaus entlassen worden], target=[when i saw his mother yesterday she said he had left the hospital a week before], predicted=[the the the the the the the the the the the the the]
src=[es klappt], target=[it works], predicted=[]
src=[letztendlich wird jemand tom sagen mussen dass er sich zu benehmen hat], target=[eventually someone is going to have to tell tom that he needs to behave himself], predicted=[the the the the the the the the the the the the]
src=[tom sagt er habe dem polizisten mitgeteilt er sei nur zum fotografieren dort gewesen], target=[tom says he told the police officer that he was just there to take some pictures], predicted=[the the the the the the the the the the the the]
src=[vertraue mir], target=[trust me], predicted=[]
src=[schauen sie uns zu], target=[watch us], predicted=[tom]
src=[dieses worterbuch dessen dritter band fehlt hat mich hundert dollar gekostet], target=[this dictionary of which the third volume is missing cost me a hundred dollars], predicted=[the the the the the the the the the the]
src=[nimm das hier], target=[use this], predicted=[tom]
src=[wegen seines groen beruflichen geschicks hat der anwalt eine groe klientel], target=[because of his great professional skill the lawyer has a large number of clients], predicted=[the the the the the the the the the the]
BLEU-1: 0.052077
BLEU-2: 0.000000
BLEU-3: 0.000000
BLEU-4: 0.000000
也许尝试重新训练模型，并根据验证技能选择不同的模型。
嗨 Jason
我需要以下错误的帮助
C:\Users\Habib\Anaconda3\lib\site-packages\nltk\translate\bleu_score.py:523: UserWarning
The hypothesis contains 0 counts of 2-gram overlaps.
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()
warnings.warn(_msg)
C:\Users\Habib\Anaconda3\lib\site-packages\nltk\translate\bleu_score.py:523: UserWarning
The hypothesis contains 0 counts of 3-gram overlaps.
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()
warnings.warn(_msg)
C:\Users\Habib\Anaconda3\lib\site-packages\nltk\translate\bleu_score.py:523: UserWarning
假设包含 0 个 4-gram 重叠计数。
因此，BLEU 分数评估为 0，无论
它包含多少低阶 N-gram 重叠。
考虑使用较低的 n-gram 阶数或使用 SmoothingFunction()
warnings.warn(_msg)
这些是警告，不是错误，您可以安全地忽略它们。
抱歉，我之前在错误的帖子里发布了问题（但感谢您的快速回复），因为我正在阅读和比较多个帖子中的信息。它们都信息量很大且很有帮助，谢谢！！
所以，我理解您的法语到英语示例是一个seq2seq模型，但是这个呢——英语到德语模型（这是我最初想问的）？这是因为这个模型的结构似乎更简单，没有指定状态。
我认为我的困惑在于，多对多RNN序列预测模型和Seq2seq有什么区别，或者它们只是相同的东西？希望您能帮助我澄清。
是的，它们是同一件事。
先生，我在这个项目中遇到了一个错误
回溯（最近一次调用）
File “D:\ANANTH\onlinetry\translatess\punjabi\german\preparedataset1.py”, line 286, in
evaluate_model(model, eng_tokenizer, trainX, train)
File “D:\ANANTH\onlinetry\translatess\punjabi\german\preparedataset1.py”, line 255, in evaluate_model
raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
很抱歉听到这个消息，这可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨，Jason，
很棒的教程！
关于值错误：评估部分可能存在一个错误：由于 raw_dataset 的每个内部列表有 3 个项目，因此第 57 行中只有两个变量的解包无法工作。我用 ‘source’ 到 ‘raw_target, raw_src, source = raw_dataset[i]’ 完成了它，然后它就可以工作了。您能否检查一下这是否是正确的代码？
我相信代码是正确的，也许这会有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
谢谢，Jason，精彩的解释。
我有一个问题
当我尝试英语到印地语时，我只得到英语标记
[wow] => []
[help] => []
[跳] => []
[跳] => []
.....
....
但是代码对英语到德语有效。
[hi] => [hallo]
[hi] => [gru gott]
[run] => [lauf]
[wow] => [potzdonner]
.....
....
我正在调试但无法解决……
也许数据预处理在删除非 ASCII 字符方面过于激进。
嗨 Uday，你解决你的问题了吗？我面临同样的问题，请帮助
我解决了。
问题出在 clean_pairs() 函数。
尝试注释掉那里的一些行，然后再次运行
干得好。
嗨，Jason
感谢精彩的教程。如果我们不将数据集缩减到前 10,000 个示例，而是使用完整数据集，这段代码是否仍然有效？
可以试试，去实验一下。
首先，很棒的教程！！
如何使用模型翻译单个字符串？
谢谢。
您可以使用与训练数据相同的预处理来准备单个字符串，然后调用 model.predict()
我需要为单个字符串创建一个 .pkl 文件吗？还是我可以在代码中完成？
您可以在代码中完成，例如，在拟合模型后直接进行预测。
我如何重新训练模型？
似乎我训练到大约 1.7 的 val_loss，然后如果我再次运行训练程序，它会从 3.8 的 val_loss 开始。
您可以加载保存的模型并继续训练，可能使用更小的学习率。
我做了以下事情
制作了一个脚本来重新生成训练和测试文件，以及另一个脚本来加载模块并对其进行训练。10 个 epoch 后，它会生成新的训练和测试文件。
但我不知道模型是否在变好。每次新训练都以大约 2.1 的 val_loss 开始，文件大小也不变。
这正常吗？
另外，我如何更改学习率？
提前感谢。
这将有助于解释模型获得的学习
https://machinelearning.org.cn/learning-curves-for-diagnosing-machine-learning-model-performance/
这将有助于解决学习率问题
https://machinelearning.org.cn/understand-the-dynamics-of-learning-rate-on-deep-learning-neural-networks/
嗨 Jason。首先，非常感谢您所做的一切。
我需要一些帮助。我尝试了教程的次数不计其数。我重新安装了许多次，当我到达 Tokenizer 部分时，我一直收到此错误
>>> eng_tokenizer = create_tokenizer(dataset[:, 0])
回溯（最近一次调用）
File “”, line 1, in
File “”, line 2, in create_tokenizer
NameError: name ‘Tokenizer’ is not defined
我不知道哪里出了问题。我到处都搜索过了，包括这里。您告诉别人检查他们是否错过了代码行。我反复检查代码，确保没有遗漏任何内容，但仍然收到此错误。
你能帮我吗？
先谢谢您了。
不客气。
看起来您没有导入 Tokenizer 类。
我建议您将完整的示例粘贴到教程的末尾。这将有所帮助
https://machinelearning.org.cn/faq/single-faq/how-do-i-copy-code-from-a-tutorial
谢谢。通过从 keras 导入，它奏效了。现在我遇到了一些其他问题，但我会尝试在再次向您求助之前解决它们……
谢谢！ 🙂
如果您在开发环境方面需要帮助，这可能会有所帮助
https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
又来了，Jason。我成功了！我再高兴不过了。🙂
如果这对任何人有帮助：清理数据（因为它有三个列，就像另一个人说的）的最佳方法是导入到 Excel，删除第三列，然后保存为制表符分隔的文本文件 (.txt)。
只有一个最后的疑问：是否可以在训练后添加更多训练数据以提高结果？您是否有解释此问题的帖子，也许？我将阅读更多您的帖子以尝试理解其背后的科学。
如果之前问过，请原谅。
祝好！
干得好！
是的，更多的数据会让模型更好。我们使用的训练数据很小且有限。
抱歉，我没有这方面的例子。
又来了！
那么，只要我添加更多数据集并用模型加载它们，以前的数据集是否仍然被保存？
提前感谢！
抱歉，我不明白。也许您可以详细说明？
我的意思是，如果我用其他数据（所需语言组合中的其他翻译 [例如，EN-DE]）重新进行整个过程，但加载以前的模型（model.h5），它是否会从新数据中学习更多，同时仍然利用以前加载的数据集？
希望我现在更清楚了。基本上，我的意思是，如果我可以添加更多数据供它学习。
谢谢！
也许吧。如果模型在新数据上进行大量/激进的训练，它可能会忘记原始数据集。
我将通过 NMT 方法开发双向英语-埃塞俄比亚语机器翻译……使用各种格式的数据，如 pdf、word、excel 等，不像英语-德语数据集那样有组织。您有什么建议吗，先生？谢谢
这听起来是一个很棒的项目！
我建议第一步将所有文本提取为单一格式。
嗨，Jason，
您是否有使用 Keras 的注意力机制和束搜索开发 NMT 的示例？
您是否推荐任何示例或书籍？
您是否还推荐任何用于使用 Keras 构建复杂生成模型的资源？
目前还没有。
不行。
许多模型都很复杂。也许从语言模型开始。
抱歉，我没有跟上，您能解释一下您所说的“从语言模型开始”是什么意思吗？
您可以在这里了解语言模型
https://machinelearning.org.cn/statistical-language-modeling-and-neural-language-models/
运行示例时，我看到以下警告
/Users/XXXX/opt/anaconda2/envs/XXXX/lib/python3.6/site-packages/tensorflow_core/python/framework/indexed_slices.py:433: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.
这是因为我们设置 NMT 模型的方式吗？
还有以下内容，可能无害
2020-03-18 12:31:12.023801: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:561] remapper failed: Invalid argument: MutableGraphView::MutableGraphView error: node ‘loss/time_distributed_1_loss/categorical_crossentropy/weighted_loss/concat’ has self cycle fanin ‘loss/time_distributed_1_loss/categorical_crossentropy/weighted_loss/concat’.
2020-03-18 12:31:12.046204: E tensorflow/core/grappler/optimizers/dependency_optimizer.cc:717] Iteration = 0, topological sort failed with message: The graph couldn’t be sorted in topological order.
2020-03-18 12:31:12.060268: E tensorflow/core/grappler/optimizers/dependency_optimizer.cc:717] Iteration = 1, topological sort failed with message: The graph couldn’t be sorted in topological order.
2020-03-18 12:31:12.174409: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:561] arithmetic_optimizer failed: Invalid argument: The graph couldn’t be sorted in topological order.
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
代码原封不动地运行在 evaluate_model 中会失败。evaluate_model 因 ValueError 而崩溃
回溯（最近一次调用）
File “/Users/XXXXX/evaluate.py”, line 96, in
evaluate_model(model, eng_tokenizer, trainX, train)
File “/Users/XXXXX/evaluate.py”, line 64, in evaluate_model
raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
我找到了原因，是由于数据集。
在此数据集中，有一第三列包含贡献。如果您从给定的来源下载，您会发现还有另一列
CC-BY 2.0 (France) Attribution: tatoeba.org #2877272 (CM) & #8597805 (Roujin)
代码本身是完美的。问题是给出的 URL 中的数据已被更改。
也许您可以在教程中提到这一点。
干得好！
谢谢 Nashid，目前我正在对数据进行切片以解决此问题。你帮了我，伙计。我一直卡在这个问题上
看这里
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨，Jason，
我看到 BLEU 分数不高。您能建议如何改进吗？
BLEU-1: 0.519256
BLEU-2: 0.388424
BLEU-3: 0.300428
BLEU-4: 0.125028
您能建议如何构建更好的模型吗？
您是否有任何书籍能提供构建更好的 NMT 模型以及如何使用 Keras 实现它们的直观理解？
这些教程将帮助您诊断模型问题并提高性能
https://machinelearning.org.cn/start-here/#better
我正确地认为这里的模型是一个生成式自动编码器吗？那么为什么在 reddit 上我看到这个帖子“为什么自动编码器不被认为是生成式”？
这里第一个编码器是用 LSTM 实现的，解码器是用后面的 LSTM 实现的。
第一个 LSTM（编码器）的输出直接馈送到解码器。
而且在这里我们已经为无监督学习实现了这一点。
不，它不是自动编码器。
这里模型是一个序列到序列预测模型，使用了编码器-解码器架构。
您是否遵循了任何特定的论文来构建这个模型？
有一个参考会非常有帮助。
不，这是一个通用的编码器-解码器 LSTM 模型。基础知识。
如果这对您来说是新的，您可以在这里开始学习 LSTM
https://machinelearning.org.cn/start-here/#lstm
为什么我不能解压缩文件？请帮帮我
您是否从给定的链接下载了文件？
如果您无法在工作站上解压缩文件，我认为我的教程对您来说会太高级了。
尽管如此，如果您在 Windows 上，这可能会有所帮助
https://support.microsoft.com/en-au/help/14200/windows-compress-uncompress-zip-files
您在这里使用了 Keras Tokenizer 的词嵌入。它与 word2vec 相同吗？
是的，这里有一个例子
https://machinelearning.org.cn/develop-word-embedding-model-predicting-movie-review-sentiment/
对于输出序列，您提到它需要进行独热编码。为什么我们用于输入序列的 Keras 相同分词器不起作用？
输入和输出数据必须使用单独的分词器，因为它们是不同的语言。
# 在一些训练序列上进行测试
print(‘train’)
evaluate_model(model, eng_tokenizer, trainX, train)
输出: train
—————————————————————————
ValueError 回溯 (最近一次调用)
in ()
1 print(‘train’)
—-> 2 evaluate_model(model, eng_tokenizer, trainX, train)
in evaluate_model(model, tokenizer, sources, raw_dataset)
5 source = source.reshape((1, source.shape[0]))
6 translation = predict_sequence(model, eng_tokenizer, source)
—-> 7 raw_target, raw_src = raw_dataset[i]
8 if i < 10
9 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
嗨，Jason，
我遇到了这个错误，你能帮我一下吗？
根据我已阅读的常见问题解答和所有评论，我已尝试了（教程不起作用）文章中提到的所有必需的事情和步骤。
谢谢
我很抱歉听到这个消息。
请确认您使用的是 Keras 2.3 和 TensorFlow 2.1。
请确认您复制了完整的代码示例。
嘿，
假设我用 10k 个样本训练模型。
训练完成后，如果我生成一个包含 10k 个样本的新数据集，模型会忘记之前训练过的数据集吗？如果会，我该如何为模型提供更大的数据集？
现在我唯一的选择是只训练 30k 个样本，因为我的内存不够用了。
好问题！它可能会忘记。
您可以通过保留旧数据并时不时地对其进行少量训练，或者拥有一个大型训练数据集来解决此问题。
谢谢！
您建议训练网络多少个短语？我最终想在所有数据上训练它。
所以我目前在 28000 个训练数据和 2000 个测试数据上进行训练。您
认为可以吗？
这是一个开放性问题
https://machinelearning.org.cn/faq/single-faq/how-much-training-data-do-i-need
你好，Jason。
我尝试了我的自己的数据集，它是一个制表符分隔的 .txt 文件（UTF-8 编码），但它一直给我这三个错误
File “”, line 1, in
File “C:\Users\John\Desktop\Attempts\Attempt #4 – Ubuntu\env\lib\site packages\keras\engine\training.py”, line 1239, in fit
validation_freq=validation_freq)
File “C:\Users\John\Desktop\Attempts\Attempt #4 – Ubuntu\env\lib\site-packages\keras\engine\training_arrays.py”, line 210, in fit_loop
verbose=0)
File “C:\Users\John\Desktop\Attempts\Attempt #4 – Ubuntu\env\lib\site-packages\keras\engine\training_arrays.py”, line 469, in test_loop
outs[0] /= num_samples # Index 0 ==
LossIndexError: 列表索引超出范围
我正确地复制了所有代码，并且尝试了几次……使用您提到的网站上的数据集，它工作正常，但使用我的数据就不行了。我到处查找，但找不到解决方法……
Keras 版本是 2.3.0（我尝试了 2.3.1 结果一样），tensorflow 2.1.0 如果有帮助的话。
先谢谢您了。
抱歉，我没有能力帮助您调试加载自定义数据，也许可以试试在 stackoverflow 上发帖？
谢谢您的建议！🙂
不客气。
嗨 Jason，如果我使用英印数据集，清洗后的印地语字体在结果中**不**显示。
也许可以更改数据清理，使其适合您的特定数据集。
是的，我通过删除那一行………..# line = [exp.sub(”, w) for w in line] 来做，但这会导致：
[我忘了] => []
[我会付钱的] => []
[im fine] => []
[im full] => [ भर ]
[我们走吧] => []
[answer me] => []
[birds fly] => []
[excuse me] => []
[fantastic] => []
[i fainted] => []
[i fear so] => []
[i laughed] => []
[im bored] => []
[im broke] => []
[im tired] => [ थक ]
现在它只显示其中一些。请建议一些解决方案
抱歉，我没有能力帮助您调试您的修改。
好的，谢谢，我明白了。我还删除了那一行 #line = [word for word in line if word.isalpha()]。
它起作用了。但是你能告诉我那一行到底是什么意思吗？
太棒了！
那一行只收集包含字母数字字符的单词。
如何微调我们的 NLP 模型。
这里有一些建议。
https://machinelearning.org.cn/start-here/#better
ValueError 回溯 (最近一次调用)
in
86 # 在一些训练序列上进行测试
87 print(‘train’)
—> 88 evaluate_model(model, eng_tokenizer, trainX, train)
89 # test on some test sequences
90 print(‘test’)
in evaluate_model(model, tokenizer, sources, raw_dataset)
55 source = source.reshape((1, source.shape[0]))
56 translation = predict_sequence(model, eng_tokenizer, source)
—> 57 raw_target, raw_src = raw_dataset[i]
58 if i < 10
59 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
很遗憾您遇到了麻烦，也许这会有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
由于 to_categorical 导致的 OOM（内存不足），我使用了 sparse_categorical_crossentropy 并删除了 encode_output，结果是我能够训练系统更多的数据。这样做对吗？
听起来不错！
嗨 Jason，感谢您关于 NMT 的精彩分步解释。
我尝试了类似的 कोड逻辑来将泰米尔语翻译成英语。我的输入文件有 130 对句子，我的模型训练得非常好，验证和训练集之间的偏差很小。
我尝试了两种优化器：RMSPROP 和 ADAM。在这两种情况下，我都获得了相似的结果。
当我尝试预测测试数据的类时，输出变量只有零。因此，预测输出类为空。请建议要调整哪个参数才能获得期望的结果。我认为很多人都面临类似的问题，请调试我的 colab 代码并为我提供建议以获得结果。
请找到我的 colab 链接以供我的项目使用。
代码
preds5 = model1.predict_classes(testX.reshape((testX.shape[0],testX.shape[1])))
preds5
输出
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
实际 预测
0 她和他一起跳舞
1 她打了他
2 她有 2000 本书
3 它是塞尔维亚第三大城市
4 交给我
5 他有三个儿子
6 这是我们的房子
7 就是这样
8 她是谁
9 再见
10 他是你的朋友吗
11 我怕熊
12 对老人好一点
13 我以为你会生气
14 举起你的手
https://colab.research.google.com/drive/1JkEI1ukdaz9uqUnWEXAJDUHiuaoEwj2K
此致，
N.Shailaja
听起来是个很棒的项目。
也许这里的教程能帮助您找出模型的问��并提出提高性能的方法。
https://machinelearning.org.cn/start-here/#better
嗨 Jason
我尝试在 google colabs 中使用此方法，但我无法加载文件
from google.colab import files
filename = files.upload()
出现此错误
TypeError Traceback (most recent call last)
in ()
56 # load dataset
57 filename = files.upload()
—-> 58 doc = load_doc(filename)
59 # split into english-german pairs
60 pairs = to_pairs(doc)
in load_doc(filename)
8 def load_doc(filename)
9 # open the file as read only
—-> 10 file = open(filename, mode=’rt’, encoding=’utf-8′)
11 # read all text
12 text = file.read()
TypeError: expected str, bytes or os.PathLike object, not dict
嗨，Jason，
我解决了这个问题
谢谢你
干得好！
尝试直接在您的工作站上运行。
Jason，干得好
请，我在最后一个函数 evaluate_model() 中遇到了一个问题，具体是在
raw_target, raw_src = raw_dataset[i] ！
当我应用到 evaluate_model(model, eng_tokenizer, trainX, train) 时
我收到了这个错误
in evaluate_model(model, tokenizer, sources, raw_dataset)
55 source = source.reshape((1, source.shape[0]))
56 translation = predict_sequence(model, eng_tokenizer, source)
—> 57 raw_target, raw_src = raw_dataset[i]
58 if i < 10
59 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
我很遗憾听到这个消息，看看这个
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
非常感谢您的工作，
请就如何使用训练好的模型来翻译新数据提供建议。
例如，我想输入“I love my mom”，然后看到翻译，该怎么做？
请参阅教程末尾的示例。
嗨！一如既往的精彩教程，但我有一个问题：如果我理解得没错，您通过 RepeatVector(tar_timesteps) 预定义了最大可能的输出长度，所以任何输出句子都不能超过 tar_timesteps？那么在推理过程中也无法获得比 tar_timesteps 更长的输出吗？您为什么选择这种方法而不是使用“停止”令牌的想法，例如这里使用的 https://blog.keras.org.cn/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html，它会提供更可变的输出长度？
谢谢。
没错。我这样做是为了简化。
是的，另一种方法是使用动态 rnn，这对初学者来说可能更具挑战性。
你好，
有必要将非拉丁字符转换为拉丁字符吗？我想知道有什么办法可以确保我的模型会将英文单词“angle”翻译成波兰语单词“kąt”，而不是“kat”（这意味着刽子手：））。我可以省略这部分代码吗？
感谢您所有的辛勤工作！
不，这只是我为这个例子选择的方法，它可以使一些代码更简单。
是的，可能更容易调整示例以直接处理 unicode。
嗨，Jason，
感谢这篇信息丰富的文章。我有一个问题，在另一篇文章中，神经翻译模型的构建方式非常不同。在那篇文章中，编码器的输出状态被传递给解码器。（https://machinelearning.org.cn/define-encoder-decoder-sequence-sequence-model-neural-machine-translation-keras/）
这里的模型定义方式与那篇文章中的有什么区别？
此致，
Deepak
链接的文章使用了一个动态 RNN 编码器-解码器模型，而这里我们使用的是基于 LSTM 自动编码器（更简单）的编码器-解码器，具有固定的输入长度。
再次感谢 Jason 的精彩工作。
我有一个关于 BLEU 分数的问题。
为了说“我在 BLEU 上达到了 X 分”，我们最终应该选择哪个（1、2、3 或 4）？
谢谢你
您可以选择报告哪种方法，或者全部报告，并说明您是如何计算的。
但大多数我认识的文章都没有说明方法，它们只说它们在 BLEU 分数上达到了一个数字 X！！
是的，许多论文都写得很差，难以理解或复现。
也许您正在使用的数据集有标准的评估方法和结果报告方式？
也许直接联系论文的作者？
好的，Jason 先生。
非常感谢您 🙂
不客气。
嗨 Jason，感谢这个很棒的教程。
我有一个问题，如果我想让模型在序列（输入）到序列（输出）的数据上进行训练，并使预测输出固定（例如 10 个单词），我知道这在翻译方面没有意义，但我在另一个应用程序中使用这种架构，那么这是可能的吗？
您可以设计任何您喜欢的模型。
嗨，Jason，
谢谢发帖。快速提问：我是否可以使用类似的模型进行字符串字符到字符的预测，而不是单词到单词的预测？如果是，我需要更改哪些参数，例如，标记将是字符而不是单词，唯一字符大小而不是词汇大小等等。您知道任何例子吗？
谢谢！
不客气。
不，该模型是为处理单词而设计的。对于字符输入和输出，需要完全不同的模型。
亲爱的，非常感谢您的奉献。
我需要您的支持。
当我按如下方式在 Pycharm IDE 上运行代码时
import string
import re
from pickle import dump
from unicodedata import normalize
from numpy import array
# 加载文档到内存
def load_doc(filename)
# 以只读方式打开文件
file = open(filename, mode=’rt’, encoding=’utf-8′)
# 读取所有文本
text = file.read()
# 关闭文件
file.close()
return text
# 将加载的文档分割成句子
def to_pairs(doc)
lines = doc.strip().split(‘\n’)
pairs = [line.split(‘\t’) for line in lines]
return pairs
# 清理行列表
def clean_pairs(lines)
cleaned = list()
# 准备用于字符过滤的正则表达式
re_print = re.compile(‘[^%s]’ % re.escape(string.printable))
# prepare translation table for removing punctuation
table = str.maketrans(”, ”, string.punctuation)
for pair in lines
clean_pair = list()
for line in pair
# normalize unicode characters
line = normalize(‘NFD’, line).encode(‘ascii’, ‘ignore’)
line = line.decode(‘UTF-8’)
# tokenize on white space
line = line.split()
# convert to lowercase
line = [word.lower() for word in line]
# 从每个令牌中去除标点符号
line = [word.translate(table) for word in line]
# remove non-printable chars form each token
line = [re_print.sub(”, w) for w in line]
# remove tokens with numbers in them
line = [word for word in line if word.isalpha()]
# store as string
clean_pair.append(‘ ‘.join(line))
cleaned.append(clean_pair)
return array(cleaned)
# 将清理后的句子列表保存到文件
def save_clean_data(sentences, filename)
dump(sentences, open(filename, ‘wb’))
print(‘Saved: %s’ % filename)
# 加载数据集
filename = ‘deu.txt’
doc = load_doc(filename)
# 分割成英语-德语对
pairs = to_pairs(doc)
# 清理句子
clean_pairs = clean_pairs(pairs)
# 将清理后的对保存到文件
save_clean_data(clean_pairs, ‘english-german.pkl’)
# 抽查
for i in range(100)
print(“[%s] => [%s]” % (clean_pairs[i, 0], clean_pairs[i, 1]))
我发现了以下错误，如何修复此错误？
IndexError: too many indices for array: array is 1-dimensional, but 2 were indexed
很抱歉听到这个消息，这些技巧会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
Jason，谢谢，我调试了错误并得到了所需的结果。
在 evaluate_model 中，raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
我该如何修复这个错误？非常感谢。
我的目的是在成功实现您的实验后，准备我自己的语料库，并尝试为我们的本地语言开发模型。
很遗憾听到这个消息，这里的一些建议可能会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨，我正在尝试使用您的代码来实现一个英梵语翻译器。我尝试使用您的代码和英德语数据集，它工作正常。
我的情况有两个问题
1. 我需要在整个过程中使用 UTF-8。我修改了清理代码，以保留 UTF-8 字符编码，它会生成一个 UTF-8 的 english-sanskrit.pkl 文件。
然而，当我尝试创建模型的代码时，它会抛出一个错误
W tensorflow/core/framework/op_kernel.cc:1753] OP_REQUIRES failed at cudnn_rnn_ops.cc:1517 : Unknown: CUDNN_STATUS_BAD_PARAM
in tensorflow/stream_executor/cuda/cuda_dnn.cc(1496): ‘cudnnSetRNNDataDescriptor( data_desc.get(), data_type, layout, max_seq_length, batch_size, data_size, seq_lengths_array, (void*)&padding_fill)’
2. 如果我将 UTF-8 数据源标准化为 ASCII，我就可以完成模型的创建以及对其有效性的评估。
问题是，我得到的结果很奇怪，比如
src=[aham grhe eva tyaktva agatavan], target=[i have left it at home], predicted=[i is you the the]
src=[kintu asyah bhayam asti], target=[but she is afraid], predicted=[i is the the]
src=[idanim samayah atitah], target=[it is getting late], predicted=[i is you]
src=[adya api sarah eva], target=[just soup today also], predicted=[i is the]
数据集（2300 个短语）是否太小？或者还有其他问题？
提前感谢您的关注。
干得好！！！
抱歉，我不知道那个错误，您必须自己调试它，或者发布到 stackoverflow.com
这可能足够了。也许运行一个敏感性分析，看看模型性能如何随着使用的短语数量而变化。
嗨，我认为这是语料库大小的问题。
我通过将德语语料库的大小限制在 2300 个并再次执行所有步骤来证明了这一点。
结果与梵语的结果相似
src=[ich bin spion], target=[im a spy], predicted=[im a]
src=[es ist sieben uhr funfundvierzig], target=[its], predicted=[its]
src=[ich vermisse sie], target=[i miss you], predicted=[i can you]
src=[such dir eine aus], target=[choose one], predicted=[we you]
我认为 10000 可能是获得有效结果的最低要求。
不幸的是，在梵语中获得如此大量的现代日常用语极其困难。
无论如何，祝贺您的网站和您的代码。
也许您可以尝试一个更大的（超定）模型，并添加大量强正则化（权重衰减/dropout/等）？
另外，对于 UTF-8 编码，作为最后的资源，如果我找不到在过程中使用 UTF-8 的解决方案，梵语可以用多种方式书写，其中一些是纯 ASCII，例如哈佛-京都转写，所以我可能会在过程开始时转换文本，并在结束时转换回来。
再见
这都是数字。定义一组整数来表示您的字符，并定义一个映射从字符到整数再映射回的进程。这样就可以处理任何字符集。
Jason，谢谢您的帖子，我终于调试了错误并得到了要求的结果。
我对您的代码有一个建议，请在第 57 行评估模型精度的代码中添加变量“test”，并重新发布它，=============raw_target, raw_src , test= raw_dataset[i]，除非在运行代码时出现以下错误。
在 evaluate_model 中，raw_target, raw_src = raw_dataset[i]
ValueError: 要解包的值太多 (预期为2)
因此，如果可能的话，请更新代码。
非常感谢。
谢谢。
你好 Jason，这是一个很棒的教程。我想为我们的埃塞俄比亚本地语言开发语言模型，我准备了不同来源的样本语料库，并尝试开发模型，但遇到了麻烦，我猜麻烦在于准备样本语料库时。在准备语料库时，我需要考虑哪些要点？或者上述算法只适用于制表符分隔的语料库吗？
谢谢。
也许可以使用上面的代码作为起点，并确保在训练之前检查您的原始训练数据，看看它是否包含任何意外内容。
你好，您知道 tatoeba 数据集，包括英语-德语数据集是如何准备的吗？我想根据他们的标准和要求准备自己的数据集。
谢谢。
没有，抱歉。
为了确保我对翻译模型的理解是正确的……我有 3 个问题
1- 这个 LSTM 编码器-解码器模型有多少个隐藏层？
2- model.add(RepeatVector(tar_timesteps)) 的目的是什么？我认为这一行是将编码器和解码器分开。我说对了吗？哪些行对应编码器，哪些行对应解码器？
3- 如果您想添加其他隐藏层，您会在哪里添加？
顺便感谢这个很棒的教程！
我们在编码器中有一个隐藏层，在编码器中也有一个。
我们将编码的输入重复到输出的每一步。
您可以在编码器和/或解码器中现有隐藏层之后添加更多隐藏层。
非常感谢！
不客气。
如何翻译一句多语言文本？
句子 = “ਜਲਦੀ ਮਿਲਦੇ ਹਾਂ जल्द ही फिर मिलेंगे see you soon விரைவில் சந்திப்போம்”
有什么方法可以实现，或者我可以使用这个相同的模型来实现吗？
也许您可以使用上述模型作为起点。
你好，
我正在尝试运行代码进行处理，并遇到了以下错误
“for i in range(100)
print(‘[%s]=>[%s]’ % (clean_pairs[i,0], clean_pairs[i,1]))
”
错误：IndexError Traceback (most recent call last)
in
49
50 for i in range(100)
—> 51 print(‘[%s]=>[%s]’ % (clean_pairs[i,0], clean_pairs[i,1]))
IndexError: too many indices for array: array is 1-dimensional, but 2 were indexed
为什么会这样，您知道吗？
很抱歉听到您遇到麻烦，这些建议会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
—————————————————————————
NameError Traceback (最近一次调用)
in ()
1 # 准备英语分词器
—-> 2 eng_tokenizer = create_tokenizer(dataset[:, 0])
in create_tokenizer(lines)
1 # 拟合分词器
2 def create_tokenizer(lines)
—-> 3 tokenizer = Tokenizer()
4 tokenizer.fit_on_texts(lines)
5 return tokenizer
NameError: name ‘Tokenizer’ is not defined
很抱歉听到这个，也许您跳过了一些代码行。
也许可以尝试复制该部分末尾的完整示例，这将有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
您好，我是一名专业的翻译（主要是英语到法语），拥有 20 年的经验。在过去的几年里，我开始比较规律地使用 DeepL。我想使用基于更具选择性的数据，例如完全高质量的翻译的 NMT。假设我使用我过去几年的生产量，即大约 700 万词，加上其他一些我知道质量好的精选文件，这个数量是否足以训练一个强大的翻译系统？还是系统通常仍然需要更多的数据才能正确训练，即使是 NMT？
是的，这听起来数据足够了，也许可以试试看。
谢谢您的回复！
我来自哪里？我想在一家大公司工作多年后开始自己的翻译业务。我将 MT 视为一种生产力工具，尤其是在它现在能取得更好结果的情况下。技术、科学和哲学维度当然非常有趣，但现实中我几乎没有时间投入其中。
作为翻译产品，我追求高产量，同时不牺牲质量。我认为 DeepL 在其功能和与之前可用的相比方面都非常出色。在正确的人手中，它非常有用（但实际上对不熟练的译者来说是一种不公平的待遇）。我问 DeepL 是否可以将他们的系统定制化，就像我描述的那样，使用我自己的语料库，但他们不允许这种选择。一个稍好一点的 DeepL，例如质量提高 15-25%，就能满足我的需求，以便我能更“舒适地”按照自己的质量标准交付高产。
很想尝试一下
有利的一面是，我知道我想要什么。
不利的一面是，我几乎没有编程经验。DeepL 等公司有合格的团队，而我一个人，只有基础技能……对我要投入的东西以及需要多长时间都没有清晰的概念。
保重，
goelette
感谢分享。
嗨，非常感谢这些教程，它们对我帮助很大。我不知道如何部署模型，以便它可以在独立应用程序或网站中使用。请帮帮我
也许这些建议会有帮助
https://machinelearning.org.cn/faq/single-faq/how-do-i-deploy-my-python-file-as-an-application
我正在尝试从德语翻译到英语，想知道，如果我对评估进行了修改以实现这一点，这是否是反转词序的有效方法？
请注意，我怀疑训练脚本中的某些内容会影响项目的准确性，特别是“trainY = encode_output(trainY, eng_vocab_size)”是我认为会影响最终在德语中预测的数据。
我在评估中所做的更改包括
将 translation = predict_sequence(model, eng_tokenizer, source) 更改为 translation = predict_sequence(model, ger_tokenizer, source)
以及重新排列这些变量 raw_target, raw_src = raw_dataset[i] 为 raw_src, raw_target = raw_dataset[i]
最后更改 trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1]), testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1]), evaluate_model(model, eng_tokenizer, trainX, train), evaluate_model(model, eng_tokenizer, testX, test)
推广到
trainX = encode_sequences(eng_tokenizer, eng_length, train[:, 1]), testX = encode_sequences(ger_tokenizer, eng_length, test[:, 1]), evaluate_model(model, ger_tokenizer, trainX, train), evaluate_model(model, ger_tokenizer, testX, test)
我粗略估计，我认为反转数据集是唯一需要的更改。然后您可以查看模型、词汇量大小等的更改是否会影响性能。
我也开始认为我可能需要更改 NMT 模型本身来达到我的目的，而不是我最初建议修改训练脚本。
嗨，Jason，
首先，我要感谢您出色的工作，我非常欣赏！！！
我尝试使用英语到意大利语的数据集进行算法，在评估过程中遇到了一些问题。我收到以下错误：ValueError: too many values to unpack (expected 2)。这指的是这行代码：for i, source in enumerate(sources)
# 翻译编码的源文本
source = source.reshape((1, source.shape[0]))
translation = predict_sequence(model, eng_tokenizer, source)
raw_target, raw_src = raw_dataset[i].
我认为这可能是因为我们拥有的值相对于目标变量的数量过多。您能帮我避免这个错误吗？
祝您有美好的一天，并提前感谢您的帮助。
祝好，
也许先检查一下教程中的代码示例是否对您有效，然后慢慢调整。
我猜是因为数据集没有按您预期的方式加载。仔细检查原始数据是否只有 2 列并且已正确加载。
嗨 Jason！感谢您提供的精彩教程，这个模型是否适用于大量的短语，例如，如果德语和英语短语的长度为 300 或 400。如果您能提供一些其他神经机器翻译模型的参考，那将是很好的。谢谢！
不，您可能需要为您的数据集调整模型和数据准备。
我没明白您的意思
没问题，是哪个部分？
使用这个
translation = predict_sequence(model, eng_tokenizer, source)
raw_target, raw_src,*rest = raw_dataset[i]
你好，
您的教程太棒了！
我想做同样的事情，但也添加从英语到德语的翻译。
是否可以在一个 notebook 中双向翻译？
非常感谢！
当然，为反向情况拟合一个单独的模型。
请问长句子如何使用 NMT？
这将为您提供一些思路
https://machinelearning.org.cn/handle-long-sequences-long-short-term-memory-recurrent-neural-networks/
Brownlee 博士，
除了 BLEU，您是否有关于此项目的其他性能审查代码？
也许可以查看该主题的现代论文，看看哪些指标是常见的。
你好，
我在我的笔记本电脑和 p3.2xlarge AWS 实例上运行了相同的代码（在此页面上发布的那个）。
在 NVIDIA GeForce GTX 850M（每迭代 9 秒）和 Tesla V100-SXM2-16GB（3 秒）之间出现非常小的性能差异是否正常？
这是 TensorFlow 使用的板卡的报告代码结果
physical_device_desc: “device: 0, name: NVIDIA GeForce GTX 850M, pci bus id: 0000:0a:00.0, compute capability: 5.0”
physical_device_desc: “device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:1e.0, compute capability: 7.0”
我以为会有巨大差异……
抱歉，我不是 GPU 硬件专家。
嗨，Jason，
感谢您提供的精彩说明，您能否为这部分添加一个部分，使用渐进式加载而不是一次性加载所有数据，我真的很想看看您是如何做的。
不客气。
感谢您的建议。
嗨，Jason，
您是否因为没有使用“tf.keras.preprocessing.text.one_hot”来获得输出的独热编码？
是的，该教程是在 tf.keras 出现之前编写的。
嗨，杰森，
我遇到了一个错误：NotImplementedError: Cannot convert a symbolic Tensor (lstm/strided_slice:0) to a numpy array. This error may indicate that you’re trying to pass a Tensor to a NumPy call, which is not supported
听到这个消息很遗憾，也许这些提示会有帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
好！但是……将数据集大小从 10000 增加到 15000，我遇到了这个错误（（
numpy.core._exceptions.MemoryError: Unable to allocate 7.97 MiB for an array with shape (57, 36657) and data type float32
……在这一行……
encoded = to_categorical(sequence, num_classes=vocab_size)
google.colab 没帮到我
您耗尽了内存。除非您替换 numpy，否则无法真正帮助。或者您可以看看是否可以加载半精度（float16）数据。这可能也有帮助。
我尝试了英语和印地语数据文件，并执行了与上述代码相同的操作。我删除了编码，以便我也可以读取印地语文本，但在预测部分的输出中，我什么也没得到，没有输出。我想将我的印地语文本翻译成英语文本，我该怎么做？
这里的代码保证您一定能得到一些输出；无论它是否在一种语言中有意义，或者只是胡言乱语（在这种情况下，也许语言太复杂，需要更复杂的模型）。如果您什么都没看到，您可能应该检查您的代码。
代码看起来不错，但在我的情况下，predicted[] = empty，我的输入句子是印地语，输出是英语。
我读不懂印地语，但这一行可能会删除所有非 ASCII 字符：“line = normalize(‘NFD’, line).encode(‘ascii’, ‘ignore’)”
在训练模型之前我已经删除了这一行，一切都很好，但在应用模型后，有些东西出了问题。
也许是您的输入数据有问题导致了这个问题？
输入数据格式与您相同，输入数据的第一列是英语（即目标语言），然后是空格，然后是源语言，在我看来是印地语，例如
Komal had married only two months ago. कोमल की दो महीने पहले ही शादी हुई थी。
你好 Nikhil Garg，
您在使用英语-印地语数据集方面有什么进展？我也对此很感兴趣。所以请告诉我您是否有任何进展。
如果您能提供帮助，我将不胜感激，尽管所有其他输出，如绘图模型和模型摘要都可以正常工作，但与您的模型输出有所不同，这是可以理解的，但我没有任何输出，如果您能帮助我解决这个问题，我将非常感激。
我们可以使用 BART 模型进行英译泰吗？我刚开始接触这种自定义 MT。
你好 Hemanth……以下内容可能会引起您的兴趣
https://www.researchgate.net/publication/334115937_Neural_Machine_Translation_for_English-Tamil
ValueError: 要解包的值太多 (预期为2)
我在倒数第三行代码时遇到此错误
# 在一些训练序列上进行测试
print(‘train’)
evaluate_model(model, eng_tokenizer, trainX, train)
# 在一些测试序列上进行测试
print(‘test’)
evaluate_model(model, eng_tokenizer, testX, test)
错误
—————————————————————————
ValueError 回溯 (最近一次调用)
in ()
1 # 在一些训练序列上测试
2 print(‘train’)
—-> 3 evaluate_model(model, eng_tokenizer, trainX, train)
4 # 在一些测试序列上测试
5 print(‘test’)
in evaluate_model(model, tokenizer, sources, raw_dataset)
6 source = source.reshape((1, source.shape[0]))
7 translation = predict_sequence(model, eng_tokenizer, source)
—-> 8 raw_target, raw_src = raw_dataset[i]
9 if i < 10
10 print('src=[%s], target=[%s], predicted=[%s]' % (raw_src, raw_target, translation))
ValueError: 要解包的值太多 (预期为2)
该怎么办？
你好 Akansha……虽然我无法针对您的具体代码列表和调试发表评论，但我建议您回顾以下内容以获得更多见解。
https://itsmycode.com/valueerror-too-many-values-to-unpack-expected-2/
作者您好，我在运行代码时遇到这些问题
# 准备德语分词器
ger_tokenizer = create_tokenizer(dataset[:, 1])
ger_vocab_size = len(ger_tokenizer.word_index) + 1
ger_length = max_length(dataset[:, 1])
# 准备数据
trainX = encode_sequences(ger_tokenizer, ger_length, train[:, 1])
testX = encode_sequences(ger_tokenizer, ger_length, test[:, 1])
# 加载模型
model = load_model(‘model.h5’)
translation = model.predict(source, verbose=0)
错误是
NameError Traceback (最近一次调用)
in ()
42 # 加载模型
43 model = load_model(‘model.h5’)
—> 44 translation = model.predict(source, verbose=0)
NameError: name ‘source’ is not defined
请帮助我找到这个错误，source 文件在哪里？我想在罗马英语上训练模型。
感谢您提供的精彩教程。我想知道如何将此代码用于蛋白质无序区域预测。
输入是蛋白质序列，输出是二元序列（如果相应残基无序则为 1，否则为 0）。
例如
输入：AAAALLLLAKKK
输出：111111100001
你好
我可以用这个程序将英语翻译成我的本地语言吗？我有并行语料库？
您好，我通过稍微调整代码，在 Windows 机器上使用 Python 3.12.2 和 Tensorflow 2.16.1 成功运行了您的代码。但是，您可能知道，此版本的 Tensorflow 不支持 CUDA GPU，因此它只能使用 CPU 运行，速度非常慢。
这个编码-解码模型的 C# 代码是什么样的？我曾尝试使用 Microsoft 的 ML.NET，并且可以使用我的 Nvidia GPU。ML.NET 是 Tensorflow 的 C# 版本，它使用 Torchsharp-cuda-windows 来支持 GPU。
一个简单的语言分类模型的代码如下：
var pipeline = mlContext.Transforms.Conversion.MapValueToKey(outputColumnName:@”col0″,inputColumnName:@”col0″,addKeyValueAnnotationsAsText:false)
.Append(mlContext.MulticlassClassification.Trainers.TextClassification(labelColumnName: @”col0″, sentence1ColumnName: @”col1″))
.Append(mlContext.Transforms.Conversion.MapKeyToValue(outputColumnName:@”PredictedLabel”,inputColumnName:@”PredictedLabel”));
我在这类库中没有找到 LSTM。
谢谢