精华内容
下载资源
问答
  • 基于神经网络的机器学习是目前最为流行的一种机器翻译的方法。传统的统计学翻译不同,这种翻译方式是通过构建一个神经网络来最大限度提升翻译的性能。该模型是encoder–decoders模型家族中的一种。他使用编码器...

    1、摘要

    基于神经网络的机器学习是目前最为流行的一种机器翻译的方法。与传统的统计学翻译不同,这种翻译方式是通过构建一个神经网络来最大限度提升翻译的性能。该模型是encoder–decoders模型家族中的一种。他使用编码器(encoder)将原始句子编码成一个定长向量,然后使用解码器(decoder)来实现翻译。在本文中,我们推测,在encoder–decoder模型架构下,使用定长向量将是提升翻译性能的瓶颈。为了解决这个瓶颈,我们从原始的句子当中检索最为重要的子句来实施编码解码,而不是通过现在这种硬性分割的方式。通过这种新的方法,在英语到法语的翻译任务中,我们将模型性能提升与state-of-the-artphrase-based 系统相同的水平。此外,性能分析系统还显示,这种软对齐的方式与我们的直观感受非常的契合。

    2、神经网络机器翻译的背景知识

    从概率学的角度来讲,翻译要做的事情就是在给定原句子 X的情况下,找到能使条件概率P(Y|X)达到最大值的目标句子y。在神经网络翻译中,我们是通过训练一个参数化模型来完成相同的工作。一旦这种条件概率分布被翻译模型学习到,那么我们就可以通过模型对给定的语句进行翻译。

    目前,有很多专关于神经网络直接通过训练学习条件概率分布的论文发表。比如(Kalchbrenner and Blunsom, 2013; Cho et al., 2014a; Sutskever et al.,2014; Cho et al., 2014b)神经网络翻译模型有两个最为主要的组件:编码器(encoder)与解码器(decoder),分别负责对原始句子的编码以及对目标句子的解码。有一种典型应用就是将变长的句子首先编码成定长的向量然后在解码成变长的目标语句。

    尽管这是一种新的方案,但模型的整体表现还是很优秀的。Sutskever et al. (2014)的这篇论文显示,在英语到法语的翻译工作中。使用lstm单元的rnn翻译模型已经达到了传统的state-of-the-art翻译系统的水平。

    2.1 RNN encoder-decoder

    首先需要介绍一下模型的基本框架: rnn encoder-decoder,我们在这个框架的基础上来创新性的构建我们的对齐以及翻译模型。在该模型中编码器读取要翻译的句子,该句子是由一组向量序列组成的,可以将其表示为将其编码成一个向量c,这个工作一般是由RNN模型来完成的。我们可以将编码过程表示如下

    其中,ht是在时间t的隐藏状态,c是有ht生成的一个定长向量,f,q是非线性函数。

    训练解码器的过程主要是在给定表示上下文的向量C以及之前已经预测的所有单词的情况下,预测下一个时间单词 ,可以用下面公式来表示这个过程:

    其中 在RNN模型中,该公式还可以表示如下:

    在上面的公示的 g是RNN模型训练出来的非线性,多层的模型函数,st是RNN的隐藏状态。

    3、训练对齐与翻译

    在本章节,我们编写了一种新的模型结构包含给予RNN的编码器与解码器。

    3.1 解码器

    在这种新的模型结构中,我们将解码器的概率函数做如下定义:

    其中si是RNN的隐藏状态可以有下面公式计算得到

    需要注意的是,不同于传统编码解码方法,对于目标单词yi是建立在唯一的向量ci基础上的,而每一个ci对于yi不是固定的。

    ci表示上下文向量,是由将输入句子映射到隐藏状态然后计算得到。输入句子的每一个单词对于翻译结果的影响程度都涵盖在隐藏状态hi中。在下一节中我们将详细讨论hi的相关计算方法。

    ci是有hi与一个权重矩阵点积得到,运算公式如下:

    其中可以表示如下:

    其中,

    eij表示一个对齐模型,该模型表示了,输入句子的第 j 个位置的单词与输出的第 i 个单词的匹配程度。

    我们将整个对齐模型参数化成一个前馈的神经网络,这个模型是由其他关键元素联合训练而成。这不同于传统的机器学习翻译系统,将对齐函数作为一个潜在的变量。相反的,对齐模型通过反向传播的梯度下降函数来优化整个模型,而达到一种软对齐的效果。

    我们可以这样理解,将所有的标注权重参数求和以获取我们期望的权重参数。而这个权重参数是在整体考虑所有对齐的情况下而得到的一种规律分析结果。假定 为原单词xi到目标单词yi需要对齐的概率,那么第i个上下文向量ci就是这个概率在整个模型中所占的比重。

    概率值aij与参数eij相关,而eij是反映隐藏变量hj的重要程度。而hj所反映的情况则是通过上一个隐藏状态并生成预测值yi。直观上来讲,这实现了解码器(decoder)的注意力机制,注意力机制通过学习将指导句子的哪一个部分更重要。通过这种注意力机制我们缓解了编码器编码压力,编码器不再需要将整个句子统一编码成一个定长向量。

     

    3.2 编码器

    编码器就是一个传统RNN模型,该模型首先读入要翻译的句子序列。但是,我们认为当前的单词不光与他之前的单词相关,也与他之后的单词相关,所以这里我们采用了一种双向的RNN的机制。(BiRNN, Schuster and Paliwal, 1997),双向的RNN模型在语音识别(see, e.g., Graves et al., 2013)的领域已经非常成熟。

    双向RNN,包含前向RNN与后向RNN两个基本结构。前向RNN通过句子的原顺序学习前向的隐藏状态序列,二反向的RNN则倒叙学习另一组状态序列

    而最终的隐藏状态变量是由前向与后向两种隐藏状态组合而成,可表示如下:

    使用这种及考虑前向又考虑后向的方式,可以通过hj变量充分反应单词以及其周围的词对整体翻译结果的影响。而hj是模型用于计算上下文向量ci的关键因素。

    3.3 架构选择

    之前的论述是我们对模型的一种理论设计。比如我们用f表示模式的激活函数,用a表示对齐模型。在本节当中,我们将详细讨论在实验中实现该模型的所有细节。

    3.3.1 RNN

    我们使用隐藏门来作为模型的激活函数,这种门函数在下面论文中有提及Choet al. (2014a)。我们用这种隐藏门来替代简单的双曲正切函数(tanh)。这种门单元的机制与lstm类似,拥有相关的记忆机制。所以在模型中也可以采用lstm单元来替代这种隐藏门。

    rnn的一个新的隐藏状态可以通过如下计算获得:

    运算符代表矩阵的元素乘积,zi是更新门的输出,这个会在后面消息讨论。计划更新状态可以参考如下公式

    e(yi-1)是一个第i-1个单词的m维词向量表示,ri是重置门的输出,当yi是一个1*k的向量表示时,e(yi)是一个m*K矩阵的E中的一列。更新们决定之前状态的多少信息被保留,而充值门则决定之前有多少信息被遗忘或者去除。我们可以使用下面公式计算他们。

    是一个传统的sogmoid激活函数

    3.3.2 对齐模型

    假如输入句子的序列长度为Tx,输出序列的句子长度为Tx,而对齐模型需要进行Tx*Ty次评估并自我更新。为了减少运算量,我们可以采用如下计算方式。

    其中,Wa,Ua,Va都是模型参数矩阵。由于与i无关,所以可以提前计算获得

     

     

     

     

     

     

     

    展开全文
  • 一、机器翻译 机器翻译:将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度不同。 ...

    一、机器翻译
    机器翻译:将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能与源序列的长度不同。
    机器翻译的步骤:
    ①数据预处理(数据清洗、转换成神经网络输入的minibatch);
    ②分词:(字符串—单词组成的列表);
    ③建立词典:单词id组成的列表;
    ④载入数据集;

    生成模型:Encoder-decoder
    在这里插入图片描述
    适用于生成系统对话任务中。

    Sequence to sequence模型:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    维特比算法:
    在这里插入图片描述
    维特比算法是一种特殊的但应用最广的动态规划算法。利用动态规划可以解决任何一个图中的最短路径问题,而维特比算法则是针对一种特殊的图——篱笆网络的有向图的最短路径问题提出的。之所以重要,是因为凡是使用隐马尔可夫模型描述的问题都可以用它来解码。
    转载了一篇写的很好的便于理解的博客:https://blog.csdn.net/qq_16234613/article/details/82835641

    简单贪心搜索:
    在这里插入图片描述

    以下于https://blog.csdn.net/qq_16234613/article/details/83012046转载
    集束搜索(beam search):
    集束搜索可以认为是维特比算法的贪心形式,在维特比所有中由于利用动态规划导致当字典较大时效率低,而集束搜索使用beam size参数来限制在每一步保留下来的可能性词的数量。集束搜索是在测试阶段为了获得更好准确性而采取的一种策略,在训练阶段无需使用。

    假设字典为[a,b,c],beam size选择2,则如下图有:

    1:在生成第1个词的时候,选择概率最大的2个词,那么当前序列就是a或b

    2:生成第2个词的时候,我们将当前序列a或b,分别与字典中的所有词进行组合,得到新的6个序列aa ab ac ba bb bc,然后从其中选择2个概率最高的,作为当前序列,即ab或bb

    3:不断重复这个过程,直到遇到结束符为止。最终输出2个概率最高的序列。

    在这里插入图片描述
    二、注意力机制于seq2seq模型
    解码器在各个时间步依赖相同的背景变量(context vector)来获取输⼊序列信息。当编码器为循环神经⽹络时,
    ①背景变量来⾃它最终时间步的隐藏状态。
    ②将源序列输入信息以循环单位状态编码,
    ③然后将其传递给解码器以生成目标序列。
    然而这种结构存在着问题,尤其是RNN机制实际中存在长程梯度消失的问题,对于较长的句子,我们很难寄希望于将输入的序列转化为定长的向量而保存所有的有效信息,所以随着所需翻译句子的长度的增加,这种结构的效果会显著下降。
    与此同时,解码的目标词语可能只与原输入的部分词语有关,而并不是与所有的输入有关。例如,当把“Hello world”翻译成“Bonjour le monde”时,“Hello”映射成“Bonjour”,“world”映射成“monde”。在seq2seq模型中,解码器只能隐式地从编码器的最终状态中选择相应的信息。然而,注意力机制可以将这种选择过程显式地建模。
    在这里插入图片描述
    注意力机制框架:
    Attention 是一种通用的带权池化方法,输入由两部分构成:询问(query)和键值对(key-value pairs)。对于一个query来说,attention layer 会与每一个key计算注意力分数并进行权重的归一化,输出的向量 o则是value的加权求和,而每个key计算的权重与value一一对应。
    在这里插入图片描述
    在这里插入图片描述
    不同的attetion layer的区别在于score函数的选择

    引入注意力机制的Seq2seq模型:
    将注意机制添加到sequence to sequence 模型中,以显式地使用权重聚合states。
    在这里插入图片描述
    时间步为t的时候。此刻attention layer保存着encoding看到的所有信息——即encoding的每一步输出。
    在decoding阶段,解码器的t时刻的隐藏状态被当作query,encoder的每个时间步的hidden states作为key和value进行attention聚合.
    Attetion model的输出当作成上下文信息context vector,并与解码器输入 Dt 拼接起来一起送到解码器。

    下图展示了seq2seq机制的所以层的关系,下面展示了encoder和decoder的layer结构
    在这里插入图片描述
    3.Transformer
    CNN、RNN分别特点:
    ·CNNs易于并行化,但是不适合捕捉长序列的依赖关系。
    ·RNNs适合捕捉长距离变长序列的依赖,但是却难以实现并行化处理序列
    为了整合CNN和RNN的优势,[Vaswani et al., 2017] 创新性地使用注意力机制设计了Transformer模型。该模型利用attention机制实现了并行化捕捉序列依赖,并且同时处理序列的每个位置的tokens,上述优势使得Transformer模型在性能优异的同时大大减少了训练时间。
    Transformer结构:
    在这里插入图片描述
    与seq2seq主要有以下三点区别
    1.Transformer blocks:将seq2seq模型重的循环网络替换为了Transformer Blocks,该模块包含一个多头注意力层(Multi-head Attention Layers)以及两个position-wise feed-forward networks(FFN)。对于解码器来说,另一个多头注意力层被用于接受编码器的隐藏状态。
    2.Add and norm:多头注意力层和前馈网络的输出被送到两个“add and norm”层进行处理,该层包含残差结构以及层归一化。
    3.Position encoding:由于自注意力层并没有区分元素的顺序,所以一个位置编码层被用于向序列元素里添加位置信息。

    多头注意力层
    自注意力(self-attention):自注意力模型是一个正规的注意力模型,序列的每一个元素对应的key,value,query是完全一致的。如图自注意力输出了一个与输入长度相同的表征序列,与循环神经网络相比,自注意力对每个元素输出的计算是并行的,所以我们可以高效的实现这个模块。

    在这里插入图片描述
    多头注意力层包含 h个并行的自注意力层,每一个这种层被成为一个head。对每个头来说,在进行注意力计算之前,我们会将query、key和value用三个现行层进行映射,这 h个注意力头的输出将会被拼接之后输入最后一个线性层进行整合。
    在这里插入图片描述
    在这里插入图片描述
    位置编码:
    与循环神经网络不同,无论是多头注意力网络还是前馈神经网络都是独立地对每个位置的元素进行更新,这种特性帮助我们实现了高效的并行,却丢失了重要的序列顺序的信息。为了更好的捕捉序列信息,Transformer模型引入了位置编码保持输入序列元素的位置
    在这里插入图片描述
    解码器:
    Transformer 模型的解码器与编码器结构类似,然而,除了之前介绍的几个模块之外,编码器部分有另一个子模块。该模块也是多头注意力层,接受编码器的输出作为key和value,decoder的状态作为query。与编码器部分相类似,解码器同样是使用了add and norm机制,用残差层归一化将各个子层的输出相连。
    在这里插入图片描述

    展开全文
  • 人工智能与机器翻译 自动分词 人工智能与机器翻译- 自动分词2010-10-21 1648 部著作中的词语逐个逐个的切 分出来汉语不象拼音文字那样有自然切分标志,而且词语长短不一,词语的定义也 不统一,语言中对词的定义多种...
  • 机器翻译与数据集1.1数据集预处理1.2 创建dataloader2. Encoder Decoder3. Sequence to Sequence3.1 结构3.2 代码实现4. 实验5.注意力机制5.1注意力机制框架5.2 实验部分 1. 机器翻译与数据集 ...

    pytorch task04动手学pytorch-机器翻译

    1. 机器翻译与数据集

    机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。
    主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能与源序列的长度不同。
    数据集采用 http://www.manythings.org/anki/ 的fra-eng数据集

    1.1数据集预处理

    #数据字典 char to index and index to char
    class Vocab(object):
        def __init__(self, tokens, min_freq=0, use_special_tokens=False):
            counter = collections.Counter(tokens)
            self.token_freqs = list(counter.items())
            self.idx_to_token = []
            if use_special_tokens:
                # padding, begin of sentence, end of sentence, unknown
                self.pad, self.bos, self.eos, self.unk = (0, 1, 2, 3)
                self.idx_to_token += ['', '', '', '']
            else:
                self.unk = 0
                self.idx_to_token += ['']
            self.idx_to_token += [token for token, freq in self.token_freqs
                            if freq >= min_freq and token not in self.idx_to_token]
            self.token_to_idx = dict()
            for idx, token in enumerate(self.idx_to_token):
                self.token_to_idx[token] = idx
    
        def __len__(self):
            return len(self.idx_to_token)
    
        def __getitem__(self, tokens):
            if not isinstance(tokens, (list, tuple)):
                return self.token_to_idx.get(tokens, self.unk)
            return [self.__getitem__(token) for token in tokens]
    
        def to_tokens(self, indices):
            if not isinstance(indices, (list, tuple)):
                return self.idx_to_token[indices]
            return [self.idx_to_token[index] for index in indices]
    
    #数据清洗, tokenize, 建立数据字典
    class TextPreprocessor():
        def __init__(self, text, num_lines):
            self.num_lines = num_lines
            text = self.clean_raw_text(text)
            self.src_tokens, self.tar_tokens = self.tokenize(text)
            self.src_vocab = self.build_vocab(self.src_tokens)
            self.tar_vocab = self.build_vocab(self.tar_tokens)
        
        def clean_raw_text(self, text):
            text = text.replace('\u202f', ' ').replace('\xa0', ' ')
            out = ''
            for i, char in enumerate(text.lower()):
                if char in (',', '!', '.') and i > 0 and text[i-1] != ' ':
                    out += ' '
                out += char
            return out
            
        def tokenize(self, text):
            sources, targets = [], []
            for i, line in enumerate(text.split('\n')):
                if i > self.num_lines:
                    break
                parts = line.split('\t')
                if len(parts) >= 2:
                    sources.append(parts[0].split(' '))
                    targets.append(parts[1].split(' '))
            return sources, targets
            
        def build_vocab(self, tokens):
            tokens = [token for line in tokens for token in line]
            return Vocab(tokens, min_freq=3, use_special_tokens=True)
    

    1.2 创建dataloader

    # pad, 构建数据dataset, 创建dataloader
    class TextUtil():
        def __init__(self, tp, max_len):
            self.src_vocab, self.tar_vocab = tp.src_vocab, tp.tar_vocab
            src_arr, src_valid_len = self.build_array(tp.src_tokens, tp.src_vocab, max_len = max_len, padding_token = tp.src_vocab.pad, is_source=True)
            tar_arr, tar_valid_len = self.build_array(tp.tar_tokens, tp.tar_vocab, max_len = max_len, padding_token = tp.tar_vocab.pad, is_source=False)
            self.dataset = torch.utils.data.TensorDataset(src_arr, src_valid_len, tar_arr, tar_valid_len)
            
        def build_array(self,lines, vocab, max_len, padding_token, is_source):
            def _pad(line):
                if len(line) > max_len:
                    return line[:max_len]
                else:
                    return line + (max_len - len(line)) * [padding_token]
            lines = [vocab[line] for line in lines]
            if not is_source:
                lines = [[vocab.bos] + line + [vocab.eos] for line in lines]
            arr = torch.tensor([_pad(line) for line in lines])
            valid_len = (arr != vocab.pad).sum(1)
            return arr, valid_len
            
        def load_data_nmt(self, batch_size):
            train_loader = torch.utils.data.DataLoader(self.dataset, batch_size, shuffle = True)
            return self.src_vocab, self.tar_vocab, train_loader
    

    2. Encoder Decoder

    encoder:输入到隐藏状态
    decoder:隐藏状态到输出

    Image Name

    3. Sequence to Sequence

    3.1 结构

    训练
    Image Name
    预测

    Image Name

    具体结构:
    Image Name

    3.2 代码实现

    class Encoder(nn.Module):
        def __init__(self,**kwargs):
            super(Encoder, self).__init__(**kwargs)
        
        def forward(self, X, *args):
            raise NotImplementedError
        
    class Decoder(nn.Module):
        def __init__(self, **kwargs):
            super(Decoder, self).__init__(**kwargs)
        
        def init_state(self, encoded_state, *args):
            raise NotImplementedError
            
        def forward(self, X, state):
            raise NotImplementedError
    
    class EncoderDecoder(nn.Module):
        def __init__(self, encoder, decoder, **kwargs):
            super(EncoderDecoder, self).__init__(**kwargs)
            self.encoder = encoder
            self.decoder = decoder
            
        def forward(self, enc_X, dec_X, *args):
            encoded_state = self.encoder(enc_X, *args)[1]
            decoded_state = self.decoder.init_state(encoded_state, *args)
            return self.decoder(dec_X, decoded_state)
    
    class Seq2SeqEncoder(Encoder):
        def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):
            super(Seq2SeqEncoder, self).__init__(**kwargs)
            self.num_hiddens = num_hiddens
            self.num_layers = num_layers
            self.embedding = nn.Embedding(vocab_size, embed_size)
            self.rnn = nn.LSTM(embed_size, num_hiddens, num_layers, dropout=dropout)
        
        def begin_state(self, batch_size, device):
            H = torch.zeros(size=(self.num_layers, batch_size, self.num_hiddens),  device=device)
            C = torch.zeros(size=(self.num_layers, batch_size, self.num_hiddens),  device=device)
            return (H, C)
        
        def forward(self, X, *args):
            X = self.embedding(X)
            X = X.transpose(0, 1)
            out, state = self.rnn(X)
            return out, state
            
    class Seq2SeqDecoder(Decoder):
        def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):
            super(Seq2SeqDecoder, self).__init__(**kwargs)
            self.embedding = nn.Embedding(vocab_size, embed_size)
            self.rnn = nn.LSTM(embed_size, num_hiddens, num_layers, dropout=dropout)
            self.dense = nn.Linear(num_hiddens, vocab_size)
            
        def init_state(self, encoded_state, *args):
            return encoded_state
        
        def forward(self, X, state):
            X = self.embedding(X).transpose(0, 1)
            out, state = self.rnn(X, state)
            out = self.dense(out).transpose(0, 1)
            return out, state
    
    def grad_clipping(params, theta, device):
        """Clip the gradient."""
        norm = torch.tensor([0], dtype=torch.float32, device=device)
        for param in params:
            norm += (param.grad ** 2).sum()
        norm = norm.sqrt().item()
        if norm > theta:
            for param in params:
                param.grad.data.mul_(theta / norm)
    
    def grad_clipping_nn(model, theta, device):
        """Clip the gradient for a nn model."""
        grad_clipping(model.parameters(), theta, device)
        
    
    class MaskedSoftmaxCELoss(nn.CrossEntropyLoss):
        def get_mask(self, X, valid_len, value=0):
            max_len = X.size(1)
            mask = torch.arange(max_len)[None, :].to(valid_len.device) < valid_len[:, None]
            X[~mask] = value
            return X
        
        def forward(self, pred, label, valid_len):
            weights = torch.ones_like(label)
            weights = self.get_mask(weights, valid_len)
            self.reduction = 'none'
            output = super(MaskedSoftmaxCELoss, self).forward(pred.transpose(1,2), label)
            return (output * weights).mean(dim=1)
            
    

    4. 实验

    #训练函数
    def train(model, data_iter, lr, num_epochs, device):  # Saved in d2l
        model.to(device)
        optimizer = optim.Adam(model.parameters(), lr=lr)
        loss = MaskedSoftmaxCELoss()
        tic = time.time()
        for epoch in range(1, num_epochs+1):
            l_sum, num_tokens_sum = 0.0, 0.0
            for batch in data_iter:
                optimizer.zero_grad()
                X, X_vlen, Y, Y_vlen = [x.to(device) for x in batch]
                Y_input, Y_label, Y_vlen = Y[:,:-1], Y[:,1:], Y_vlen-1
                
                Y_hat, _ = model(X, Y_input, X_vlen, Y_vlen)
                l = loss(Y_hat, Y_label, Y_vlen).sum()
                l.backward()
    
                with torch.no_grad():
                    grad_clipping_nn(model, 5, device)
                num_tokens = Y_vlen.sum().item()
                optimizer.step()
                l_sum += l.sum().item()
                num_tokens_sum += num_tokens
            if epoch % 10 == 0:
                print("epoch {0:4d},loss {1:.3f}, time {2:.1f} sec".format( 
                      epoch, (l_sum/num_tokens_sum), time.time()-tic))
                tic = time.time()
    
    #测试函数
    def translate(model, src_sentence, src_vocab, tgt_vocab, max_len, device):
        src_tokens = src_vocab[src_sentence.lower().split(' ')]
        src_len = len(src_tokens)
        if src_len < max_len:
            src_tokens += [src_vocab.pad] * (max_len - src_len)
        enc_X = torch.tensor(src_tokens, device=device)
        enc_valid_length = torch.tensor([src_len], device=device)
        # use expand_dim to add the batch_size dimension.
        encoded_state = model.encoder(enc_X.unsqueeze(dim=0), enc_valid_length)[1]
        dec_state = model.decoder.init_state(encoded_state, enc_valid_length)
        dec_X = torch.tensor([tgt_vocab.bos], device=device).unsqueeze(dim=0)
        predict_tokens = []
        for _ in range(max_len):
            Y, dec_state = model.decoder(dec_X, dec_state)
            # The token with highest score is used as the next time step input.
            dec_X = Y.argmax(dim=2)
            py = dec_X.squeeze(dim=0).int().item()
            if py == tgt_vocab.eos:
                break
            predict_tokens.append(py)
        return ' '.join(tgt_vocab.to_tokens(predict_tokens))
    embed_size, num_hiddens, num_layers, dropout = 256, 256, 2, 0.3
    batch_size, num_examples, max_len = 256, 5e4, 10
    lr, num_epochs = 0.005, 300
    tp = TextPreprocessor(raw_text, num_lines=num_examples)
    tu = TextUtil(tp, max_len = max_len)
    src_vocab, tar_vocab, train_loader = tu.load_data_nmt(batch_size = batch_size)
    encoder = Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
    decoder = Seq2SeqDecoder(len(tar_vocab), embed_size, num_hiddens, num_layers, dropout)
    model = EncoderDecoder(encoder, decoder)
    train_ch7(model, train_loader, lr, num_epochs, device=device)
    for sentence in ['Go .', 'Wow !', "I'm OK .", 'I won !']:
        print(sentence + ' => ' + translate_ch7(
            model, sentence, src_vocab, tgt_vocab, max_len, ctx))
    Go . => va !
    Wow ! => <unk> !
    I'm OK . => ça va .
    I won ! => j'ai gagné !
    

    5.注意力机制

    在“编码器—解码器(seq2seq)”⼀节⾥,解码器在各个时间步依赖相同的背景变量(context vector)来获取输⼊序列信息。当编码器为循环神经⽹络时,背景变量来⾃它最终时间步的隐藏状态。将源序列输入信息以循环单位状态编码,然后将其传递给解码器以生成目标序列。然而这种结构存在着问题,尤其是RNN机制实际中存在长程梯度消失的问题,对于较长的句子,我们很难寄希望于将输入的序列转化为定长的向量而保存所有的有效信息,所以随着所需翻译句子的长度的增加,这种结构的效果会显著下降。

    与此同时,解码的目标词语可能只与原输入的部分词语有关,而并不是与所有的输入有关。例如,当把“Hello world”翻译成“Bonjour le monde”时,“Hello”映射成“Bonjour”,“world”映射成“monde”。在seq2seq模型中,解码器只能隐式地从编码器的最终状态中选择相应的信息。然而,注意力机制可以将这种选择过程显式地建模。

    Image Name

    5.1注意力机制框架

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JIqOTs2U-1582014373453)(C:\Users\chenlang\AppData\Roaming\Typora\typora-user-images\image-20200218160142253.png)]

    Image Name

    5.2 实验部分

    import math
    import torch 
    import torch.nn as nn
    import os
    def file_name_walk(file_dir):
        for root, dirs, files in os.walk(file_dir):
    #         print("root", root)  # 当前目录路径
             print("dirs", dirs)  # 当前路径下所有子目录
             print("files", files)  # 当前路径下所有非目录子文件
    
    file_name_walk("/home/kesci/input/fraeng6506")
    dirs []
    files ['_about.txt', 'fra.txt']
    

    Softmax屏蔽

    在深入研究实现之前,我们首先介绍softmax操作符的一个屏蔽操作。

    def SequenceMask(X, X_len,value=-1e6):
        maxlen = X.size(1)
        #print(X.size(),torch.arange((maxlen),dtype=torch.float)[None, :],'\n',X_len[:, None] )
        mask = torch.arange((maxlen),dtype=torch.float)[None, :] >= X_len[:, None]   
        #print(mask)
        X[mask]=value
        return X
    def masked_softmax(X, valid_length):
        # X: 3-D tensor, valid_length: 1-D or 2-D tensor
        softmax = nn.Softmax(dim=-1)
        if valid_length is None:
            return softmax(X)
        else:
            shape = X.shape
            if valid_length.dim() == 1:
                try:
                    valid_length = torch.FloatTensor(valid_length.numpy().repeat(shape[1], axis=0))#[2,2,3,3]
                except:
                    valid_length = torch.FloatTensor(valid_length.cpu().numpy().repeat(shape[1], axis=0))#[2,2,3,3]
            else:
                valid_length = valid_length.reshape((-1,))
            # fill masked elements with a large negative, whose exp is 0
            X = SequenceMask(X.reshape((-1, shape[-1])), valid_length)
     
    return softmax(X).reshape(shape)
    masked_softmax(torch.rand((2,2,4),dtype=torch.float), torch.FloatTensor([2,3]))
    

    输出结果:

    tensor([[[0.5423, 0.4577, 0.0000, 0.0000],
             [0.5290, 0.4710, 0.0000, 0.0000]],
    
            [[0.2969, 0.2966, 0.4065, 0.0000],
             [0.3607, 0.2203, 0.4190, 0.0000]]])
    

    超出2维矩阵的乘法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b0619Gdq-1582014373457)(C:\Users\chenlang\AppData\Roaming\Typora\typora-user-images\image-20200218160725722.png)]

    输入:

    torch.bmm(torch.ones((2,1,3), dtype = torch.float), torch.ones((2,3,2), dtype = torch.float))
    

    输出:

    tensor([[[3., 3.]],
    
            [[3., 3.]]])
    
    
      [0.5290, 0.4710, 0.0000, 0.0000]],
    
        [[0.2969, 0.2966, 0.4065, 0.0000],
         [0.3607, 0.2203, 0.4190, 0.0000]]])
    
    
     **超出2维矩阵的乘法** 
    
    [外链图片转存中...(img-b0619Gdq-1582014373457)]
    
    输入:
    
    ```python
    torch.bmm(torch.ones((2,1,3), dtype = torch.float), torch.ones((2,3,2), dtype = torch.float))
    

    输出:

    tensor([[[3., 3.]],
    
            [[3., 3.]]])
    
    
    展开全文
  • 清华大学研究整理的机器翻译和人工智能报告,包括概述、人才、技术、应用,内含各种图表,需要的可以下载学习
  • 神经机器翻译NMT 神经机器翻译的架构 神经机器翻译的青铜时代 现代神经机器翻译的序列模型 RNN Encoder Decoder:循环语言模型 机器翻译的发展 神经机器翻译的四大优势 统计/神经机器翻译 神经机器翻译主要...

    目录

    神经机器翻译NMT

    神经机器翻译的架构

    神经机器翻译的青铜时代

    现代神经机器翻译的序列模型

    RNN Encoder

    Decoder:循环语言模型

    机器翻译的发展

    神经机器翻译的四大优势

    统计/神经机器翻译

    神经机器翻译主要由工业界促进

    Attention:朴素RNN&长序列

    Attention机制

    词语对齐

    同时学习翻译和对齐

    Scoring


    • 神经机器翻译NMT

    神经机器翻译是用一个大型神经网络建模整个翻译过程的系统。

    神经机器翻译的架构

    神经机器翻译的青铜时代

    80年代神经网络是个很边缘的领域,另外计算力也很有限。当时的NMT系统很简陋:词表四五十,固定的50个输入(二进制编码),固定的66个输出,一到三层隐藏层,150个单元。

    90年代出现了一种类似RNN的更复杂的框架:

    现代神经机器翻译的序列模型

    一个RNN做encoder,另一个RNN做decoder。

    实际系统中使用深层RNN:

    这里的RNN可视作条件循环语言模型:

    RNN Encoder

    最后一个隐藏层的状态Y是整个原文的总结。

    常见的encoder实际上加了一些扩展,比如GRU或LSTM。

    Decoder:循环语言模型

    常见的做法是把encoder的最后一层(最后一个时刻)作为decoder的第一层,这样就必须用LSTM保持中期记忆。

    另一种做法是将encoder最后一层喂给decoder的每一层,这样就不会有记忆丢失的后顾之忧了。

    机器翻译的发展

    神经机器翻译的四大优势

    1. End-to-end training
      为优化同一个损失函数调整所有参数

    2. Distributed representation
      更好地利用词语、短语之间的相似性

    3. Better exploitation of context
      利用更多上下文——原文和部分译文的上下文

    4. More fluent text generation
      深度学习文本生成质量更好

    统计/神经机器翻译

    不同年份google翻译的效果测试:

    神经机器翻译主要由工业界促进

    2016-02 微软在Android和iOS上发布了离线NMT系统。

    2016-08 Systran发布了NMT模型。

    2016-09 Google发布了NMT系统,声称比得上人工翻译质量。

     

    • Attention:朴素RNN&长序列

    朴素encoder-decoder的问题是,只能用固定维度的最后一刻的encoder隐藏层来表示源语言Y,必须将此状态一直传递下去,这是个很麻烦的事情。事实上,早期的NMT在稍长一点的句子上效果就骤降。

    Attention机制

    解决方法是将encoder的历史状态视作随机读取内存,这样不仅增加了源语言的维度,而且增加了记忆的持续时间(LSTM只是短时记忆)。

    词语对齐

    传统的SMT中需要显式地做双语对齐:

    而attention model是在翻译的过程中隐式地对齐。

    同时学习翻译和对齐

    attention model成功地对齐了法语和英语,其中一小段语序的调整也反应出来了:

    Scoring

    在图示问号时刻,究竟应该关注哪些时刻的encoder状态呢?关注的强度是多少呢?

    有一种打分机制,以前一刻的decoder状态和某个encoder状态为参数,输出得分:

    然后softmax归一化分值转化为概率,这个概率称为对齐权值(alignment weights):

    这个概率也代表模型应该将多少比例的注意力放在一个历史状态上:

    加权和得到一个context vector,作为条件之一生成decoder的当前状态:

    而分数的获得,是通过attention function进行的。attention function有多种选择,其中流行的是中间这种。Wa给了两个向量更复杂的interaction,而最后一种根本没有interaction。

    有一些观点认为模型不应该注意所有的事情:

    但这些观点并没有取得更好的成绩:

    句子特别短的时候,模型的得分都不高。这纯粹是因为语料中的短句子本来就语义隐晦,比如某个专有名词作为标题。而有attention的模型在句子很长的时候,效果依然没有下降,说明了attention的重要性。

    LSTM非常擅长生成自然的文本,但有时候译文与原文相去甚远,没有把注意力放在原文上。比如下面红色的名字不知道从哪里冒出来的:

    加了attention好了很多,还是比不上人类,有时候会把同一个意思的词重复两遍:

     

    展开全文
  • Transformer机器翻译及其相关技术编码器和解码器编码器解码器束搜索贪婪搜索束搜索注意力机制Seq2Seq模型计算背景变量Transformer 机器翻译及其相关技术 机器翻译(MT):将一段文本从一种语言自动翻译为另一种...
  • 机器翻译及其技术 学习笔记 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源...
  • 机器翻译主要用到的是seq2seq模型,这种模型通常由encoder-decoder组成,能够实现many-to-many的映射,符合翻译任务中输入输出句子长度不同的情况。 encoder-decoder seq2seq 训练 很明显,可以将编码器解码...
  • 动手深度学习:机器翻译及相关技术,注意力机制seq2seq模型,Transformer 初次学习机器翻译相关,把课程的概念题都记录一下。 目录: 1、机器翻译及相关技术 2、注意力机制seq2seq模型 3、Transformer 1、机器...
  • 机器翻译及相关技术 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的...
  • 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度...
  • 机器翻译 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度不同。 ...
  • 动手深度学习:机器翻译及相关技术,注意力机制seq2seq模型,Transformer 内容摘自伯禹人工智能AI公益课程 初次学习机器翻译相关,把课程的概念题都记录一下。 目录: 1、机器翻译及相关技术 2、注意力机制seq...
  • 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言。 用神经网络解决这个问题通常称为神经机器翻译(NMT) 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度不同。 包的...
  • 【一】机器翻译及相关技术 机器翻译(MT): 将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出的是单词序列而不是单个单词。 输出序列的长度可能...
  • 今天学习了机器翻译及相关技术、注意力机制Seq2seq模型、Transformer这三节的内容,特来打卡。 一、机器翻译及相关技术 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常...
  • 机器翻译 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度不同。 ...
  • 文章目录1 机器翻译及相关技术1.1 机器翻译基本原理1.2 Encoder-Decoder1.3 Sequence to Sequence模型1.4 Beam Search2 注意力机制Seq2seq模型2.1 注意力机制2.2 注意力机制的计算函数介绍2.3 引入注意力机制的Seq...
  • 机器翻译和数据集 数据预处理 分词 建立词典 载入数据集 Encoder-Decoder Sequence to Sequence模型 模型 具体结构 Encoder Decoder 损失函数 训练 测试 . . 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言...
  • Task04 :机器翻译及相关技术;注意力机制Seq2seq模型;Transformer 1.机器翻译及相关技术 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器...
  • 小晨的电脑上安装了一个机器翻译软件,他经常用这个软件来翻译英语文章。 这个翻译软件的原理很简单,它只是从头到尾,依次将每个英文单词用对应的中文含义来替换。对于每个英文单词,软件会先在内存中查找这个...
  • 机器翻译:统计建模深度学习方法 Machine Translation: Statistical Modeling and Deep Learning Methods 推荐一本来自东北大学自然语言处理实验室 (NEUNLPLab) / 小牛翻译 (NiuTrans Research)关于机器翻译的教材...
  • 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的长度...
  • 最近参加了伯禹平台和Datawhale等举办的《动手深度学习PyTorch版》课程,机器翻译及相关技术,注意力机制Seq2seq模型做下笔记。 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,...
  • 机器翻译和数据集 机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的...
  • 1.机器翻译和数据集 1.1机器翻译 定义:将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT) 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能源序列的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,185
精华内容 474
关键字:

机器翻译与翻译学