Python-PyTorch实现基于Transformer的神经机器翻译_pytorch机器翻译,基于transformer的机器翻译资源-CSDN文库

共59个文件

py：53个

ds_store：3个

so：1个

需积分: 48 63 浏览量 2019-08-11 03:08:58 上传评论 11 收藏 468KB ZIP 举报

在本项目中，我们将深入探讨如何使用Python和PyTorch框架来实现基于Transformer的神经机器翻译（Neural Machine Translation, NMT）。Transformer模型是Google在2017年提出的一种序列到序列（Sequence-to-Sequence）学习模型，以其并行化处理能力和优秀的性能在NLP领域引起了广泛的关注。 Transformer模型的核心思想是自注意力（Self-Attention）机制，它摒弃了传统的RNN（循环神经网络）或LSTM（长短时记忆网络）中的顺序依赖，使得模型可以并行计算，极大地提高了训练速度。Transformer由编码器（Encoder）和解码器（Decoder）两部分组成，每一部分都包含多层堆叠的自注意力层和前馈神经网络层。 1. **编码器**： - 自注意力层：通过计算输入序列中每个位置的词向量与其他所有位置词向量的关系，形成注意力权重矩阵，以此捕捉句子内部的长距离依赖。 - 层归一化（Layer Normalization）：用于稳定训练过程，减少内部协变量漂移。 - 增量残差连接（Residual Connections）：有助于信息的流动，防止梯度消失。 - 随机位置编码（Positional Encoding）：由于Transformer没有内在的顺序感知能力，因此需要额外的位置编码来引入序列信息。 2. **解码器**： - 在自注意力层的基础上，解码器增加了掩蔽机制（Masking），防止当前位置访问未来位置的信息，以满足机器翻译的序列生成需求。 - 注意力机制（Encoder-Decoder Attention）：解码器不仅关注输入序列，还通过一个额外的注意力层关注编码器的输出，以便更好地理解源语言信息。 3. **PyTorch实现**： - 使用`torch.nn.Transformer`模块，这是PyTorch提供的内置Transformer实现，包含了编码器和解码器的构建块。 - 定义模型结构：根据任务需求，如词汇表大小、隐藏层维度、注意力头数量等，配置Transformer模型参数。 - 数据预处理：将文本转换为数字序列，构建词汇表，使用`torchtext`库进行数据加载和预处理。 - 训练流程：定义损失函数（如交叉熵损失），优化器，进行反向传播更新模型参数。 - 评估与预测：在验证集上评估模型性能，最终用于翻译任务的预测。 4. **Squirrel-master**：这个压缩包文件可能包含了一个名为"Squirrel-master"的项目目录，其中可能有以下文件和目录： - `README.md`：项目介绍和使用指南。 - `src`：源代码目录，包含模型定义、数据预处理、训练、评估和预测的Python脚本。 - `data`：存放预处理后的训练、验证和测试数据。 - `requirements.txt`：项目所需的Python库及其版本。 - `config.py`：配置文件，用于设置模型参数和路径。通过理解和实践这个项目，你可以掌握Transformer模型的工作原理，以及如何在PyTorch中有效地实现和训练这样的模型，这对于在机器学习，特别是自然语言处理领域的深度学习应用具有重要意义。

资源详情

资源评论

资源推荐

收起资源包目录

Python-PyTorch实现基于Transformer的神经机器翻译.zip （59个子文件）

Squirrel-master

tools

shuffle.py 647B

process_vocab.py 2KB

reorder.py 5KB

.DS_Store 6KB

fast_align 1.01MB

process_multi_vocab.py 2KB

from_src_to_trg.py 635B

.DS_Store 6KB

run.py 7KB

ez_run.py 5KB

squirrel

models

core.py 38KB

insertion_transformer.py 27KB

__init__.py 839B

transformer_indigo.py 54KB

transformer.py 24KB

learner.py 15KB

metrics

bleu_score.py 27KB

editdistance_score.py 385B

ter_score.py 2KB

editdistance.py 2KB

fast_editdistance.cpython-36m-x86_64-linux-gnu.so 135KB

__init__.py 1KB

meteor_score.py 2KB

cider_score.py 9KB

code_matching_score.py 3KB

ribes_score.py 21KB

fast_editdistance.cpp 4KB

gleu_score.py 832B

config

model_configuration.py 9KB

valid_configuration.py 2KB

train_configuration.py 2KB

data_configuration.py 4KB

__init__.py 9KB

checkpoint_configuration.py 962B

utils_configuration.py 1KB

data

tokenization.py 4KB

data_loader.py 20KB

datasets.py 5KB

batch.py 10KB

__init__.py 602B

field.py 4KB

noise.py 3KB

reader.py 2KB

build_vocab.py 3KB

.DS_Store 6KB

__init__.py 0B

bert_models

tokenization.py 14KB

__main__.py 932B

__init__.py 478B

convert_tf_checkpoint_to_pytorch.py 4KB

optimization.py 7KB

file_utils.py 8KB

modeling.py 58KB

utils

utils.py 10KB

constant.py 1KB

__init__.py 132B

distributed.py 3KB

decoder.py 8KB

optimizer.py 5KB

#include <pybind11/pybind11.h> #include <pybind11/stl.h> #include <vector> using namespace ::std; vector<vector<uint32_t>> edit_distance2_with_dp(vector<uint32_t> &x, vector<uint32_t> &y) { uint32_t lx = x.size(); uint32_t ly = y.size(); vector<vector<uint32_t>> d(lx + 1, vector<uint32_t>(ly + 1)); for (uint32_t i = 0; i < lx + 1; i++) { d[i][0] = i; } for (uint32_t j = 0; j < ly + 1; j++) { d[0][j] = j; } for (uint32_t i = 1; i < lx + 1; i++) { for (uint32_t j = 1; j < ly + 1; j++) { d[i][j] = min(min(d[i - 1][j], d[i][j - 1]) + 1, d[i - 1][j - 1] + 2 * (x[i - 1] == y[j - 1] ? 0 : 1)); } } return d; } vector<vector<uint32_t>> edit_distance2_backtracking( vector<vector<uint32_t>> &d, vector<uint32_t> &x, vector<uint32_t> &y, uint32_t terminal_symbol) { vector<uint32_t> seq; vector<vector<uint32_t>> edit_seqs(x.size() + 2, vector<uint32_t>()); /* edit_seqs: 0~x.size() cell is the insertion sequences last cell is the delete sequence */ if (x.size() == 0) { edit_seqs[0] = y; return edit_seqs; } uint32_t i = d.size() - 1; uint32_t j = d[0].size() - 1; while ((i >= 0) && (j >= 0)) { if ((i == 0) && (j == 0)) break; if ((j > 0) && (d[i][j - 1] < d[i][j])) { seq.push_back(1); // insert seq.push_back(y[j - 1]); j--; } else if ((i > 0) && (d[i - 1][j] < d[i][j])) { seq.push_back(2); // delete seq.push_back(x[i - 1]); i--; } else { seq.push_back(3); // keep seq.push_back(x[i - 1]); i--; j--; } } uint32_t prev_op, op, s, word; prev_op = 0, s = 0; for (uint32_t i = 0; i < seq.size() / 2; i++) { op = seq[seq.size() - 2 * i - 2]; word = seq[seq.size() - 2 * i - 1]; if (prev_op != 1) { s++; } if (op == 1) // insert { edit_seqs[s - 1].push_back(word); } else if (op == 2) // delete { edit_seqs[x.size() + 1].push_back(1); } else { edit_seqs[x.size() + 1].push_back(0); } prev_op = op; } for (uint32_t k = 0; k < edit_seqs.size(); k++) { if (edit_seqs[k].size() == 0) { edit_seqs[k].push_back(terminal_symbol); } } return edit_seqs; } vector<uint32_t> compute_ed2(vector<vector<uint32_t>> &xs, vector<vector<uint32_t>> &ys) { vector<uint32_t> distances(xs.size()); for (uint32_t i = 0; i < xs.size(); i++) { vector<vector<uint32_t>> d = edit_distance2_with_dp(xs[i], ys[i]); distances[i] = d[xs[i].size()][ys[i].size()]; } return distances; } vector<vector<vector<uint32_t>>> suggested_ed2_path( vector<vector<uint32_t>> &xs, vector<vector<uint32_t>> &ys, uint32_t terminal_symbol) { vector<vector<vector<uint32_t>>> seq(xs.size()); for (uint32_t i = 0; i < xs.size(); i++) { vector<vector<uint32_t>> d = edit_distance2_with_dp(xs[i], ys[i]); seq[i] = edit_distance2_backtracking(d, xs[i], ys[i], terminal_symbol); } return seq; } namespace py = pybind11; PYBIND11_PLUGIN(fast_editdistance) { py::module m("fast_editdistance", "Edit distance made by pybind11"); m.def("compute_ed2", &compute_ed2); m.def("suggested_ed2_path", &suggested_ed2_path); return m.ptr(); }