免責事項：この記事はブロガーオリジナル記事です、続くBY-SAのCC 4.0を著作権契約、複製、元のソースのリンクと、この文を添付してください。
コード出典：のhttp：//nlp.seas.harvard.edu/2018/04/03/attention.html
1.まず、パッケージをロードします：
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import math, copy, time
from torch.autograd import Variable
import matplotlib.pyplot as plt
import seaborn
seaborn.set_context(context="talk")2.最もエンコーダ - 次のようにデコーダ構造、テキストの生成が構成されています。
encode-機能、エンコーダ - ネットワーク構造
テキスト入力テキストsrc-入力テキスト、src_mask-マスク、src_embed-埋め込みを入力した後
対象のテキスト対象のテキストは、テキスト、tgt_mask-マスクをターゲットTGT-後、tgt_embed-埋め込み
メモリ - メモリ
编码エンコード：エンコーダ（self.src_embed（SRC）、src_mask）
解码デコード：デコーダ（self.tgt_embed（TGT）、メモリ、src_mask、tgt_mask）
向前フォワード传播：デコード（self.encode（SRC、src_mask）、src_mask、TGT、tgt_mask）
class EncoderDecoder(nn.Module):
"""
A standard Encoder-Decoder architecture. Base for this and many
other models.
"""
def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
super(EncoderDecoder, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.src_embed = src_embed
self.tgt_embed = tgt_embed
self.generator = generator
def forward(self, src, tgt, src_mask, tgt_mask):
"Take in and process masked src and target sequences."
return self.decode(self.encode(src, src_mask), src_mask,
tgt, tgt_mask)
def encode(self, src, src_mask):
return self.encoder(self.src_embed(src), src_mask)
def decode(self, memory, src_mask, tgt, tgt_mask):
return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)次のようにテキスト生成構造は次のとおりです。
リニア層：nn.Linear（d_model、単語）
ソフトマックス层：F.log_softmax（self.proj（X）、DIM = -1）
class Generator(nn.Module):
"Define standard linear + softmax generation step."
def __init__(self, d_model, vocab):
super(Generator, self).__init__()
self.proj = nn.Linear(d_model, vocab)
def forward(self, x):
return F.log_softmax(self.proj(x), dim=-1)3.エンコーダ
まず、定義エンコーダ
def clones(module, N):
# 产生N个相同的层，N=6
# ModuleList 可以像常规Python列表一样编制索引，包含的模块已正确注册
# copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象
# copy.deepcopy 深拷贝 拷贝对象及其子对象
return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
class Encoder(nn.Module):
# "Core encoder is a stack of N layers"
def __init__(self, layer, N):
super(Encoder, self).__init__()
self.layers = clones(layer, N)
# 归一化层 LayerNorm(normalized_shape, eps=1e-05, elementwise_affine=True)
# normalized_shape 输入尺寸 [∗×normalized_shape[0]×normalized_shape[1]×…×normalized_shape[−1]]
# eps-为保证数值稳定性（分母不能趋近或取0）,给分母加上的值。默认为1e-5
# elementwise_affine 布尔值，当设为true，给该层添加可学习的仿射变换参数
self.norm = LayerNorm(layer.size)
def forward(self, x, mask):
# "Pass the input (and mask) through each layer in turn."
for layer in self.layers:
x = layer(x, mask)
return self.norm(x)
次いで、二つの副層に使用される残基は、それぞれ、接続されて、正規化層をLayerNormを構築
class LayerNorm(nn.Module):
def __init__(self, features, eps=1e-6):
super(LayerNorm, self).__init__()
self.a_2 = nn.Parameter(torch.ones(features))
self.b_2 = nn.Parameter(torch.zeros(features))
self.eps = eps
def forward(self, x):
mean = x.mean(-1, keepdim=True)
std = x.std(-1, keepdim=True)
return self.a_2 * (x - mean) / (std + self.eps) + self.b_2各副層の出力は、ここで
サブ層自体によって実現される機能です。ドロップアウトは、各サブレイヤの出力に適用し、次に入力し、正規化サブレイヤに追加します。これらの残留接続を容易にするために、すべての副層と層間層モデル寸法は、生成され
た出力を。
class SublayerConnection(nn.Module):
"""
A residual connection followed by a layer norm.
Note for code simplicity the norm is first as opposed to last.
"""
def __init__(self, size, dropout):
super(SublayerConnection, self).__init__()
self.norm = LayerNorm(size)
self.dropout = nn.Dropout(dropout)
def forward(self, x, sublayer):
"Apply residual connection to any sublayer with the same size."
return x + self.dropout(sublayer(self.norm(x)))それぞれの層は、2つの副層、一つの長い自己注目機構マルチヘッド自己注目機構を有し、第二の位置ごとに完全に接続されたフィードフォワードネットワークの完全に接続されたフィードフォワードネットワーク上の場所です。
class EncoderLayer(nn.Module):
"Encoder is made up of self-attn and feed forward (defined below)"
def __init__(self, size, self_attn, feed_forward, dropout):
super(EncoderLayer, self).__init__()
self.self_attn = self_attn
self.feed_forward = feed_forward
self.sublayer = clones(SublayerConnection(size, dropout), 2)
self.size = size
def forward(self, x, mask):
"Follow Figure 1 (left) for connections."
x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
return self.sublayer[1](x, self.feed_forward)4.デコーダ
これは、新しいエンコーディング追加 - 長い注意層をデコードし、エンコーダとそうでない場合と類似します：
class Decoder(nn.Module):
"Generic N layer decoder with masking."
# N=6
def __init__(self, layer, N):
super(Decoder, self).__init__()
self.layers = clones(layer, N)
self.norm = LayerNorm(layer.size)
def forward(self, x, memory, src_mask, tgt_mask):
for layer in self.layers:
x = layer(x, memory, src_mask, tgt_mask)
return self.norm(x)############
我々はまた防ぐために、デコーダスタックに自己注目サブ層を変更します
あなたはを参照できます。
https://www.cnblogs.com/guoyaohua/p/transformer.html