1
字幕組雙語(yǔ)原文：【精讀】Transformer模型深度解讀
英語(yǔ)原文：The Annotated Transformer
翻譯：雷鋒字幕組（Icarus、）
| from IPython.display import Image Image(filename='images/aiayn.png') |
在過(guò)去的一年里，《注意力就是你所需要的》中的Transformer被很多人所關(guān)注。除了在翻譯質(zhì)量上產(chǎn)生重大改進(jìn)外，它還為許多其他NLP任務(wù)提供了一個(gè)新的架構(gòu)。這篇論文本身寫得非常清楚，但傳統(tǒng)的觀點(diǎn)是，它的正確實(shí)現(xiàn)相當(dāng)困難。
在這篇文章中，我以逐行實(shí)現(xiàn)的形式呈現(xiàn)了論文的 "注釋 "版本。我對(duì)原論文中的一些章節(jié)進(jìn)行了重新排序和刪除，并在全文中添加了注釋。這個(gè)文檔本身就是一個(gè)工作筆記，應(yīng)該是一個(gè)完全可用的實(shí)現(xiàn)?？偣灿?00行庫(kù)代碼，可以在4個(gè)GPU上每秒處理27000個(gè)token。
要想跟上，你首先需要安裝PyTorch。完整的筆記本也可以在github或Google Colab上使用免費(fèi)的GPU。
請(qǐng)注意，這僅僅是研究人員和感興趣的開(kāi)發(fā)人員的一個(gè)起點(diǎn)。這里的代碼主要基于我們的OpenNMT包。(如果有幫助，請(qǐng)自由引用。)對(duì)于其他模型的全服務(wù)實(shí)現(xiàn)，請(qǐng)查看Tensor2Tensor (tensorflow)和Sockeye (mxnet)。
Alexander Rush (@harvardnlp 或 srush@seas.harvard.edu)，得到Vincent Nguyen和Guillaume Klein的幫助。
| # !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn |
| 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") %matplotlib inline |
編碼器
解碼器
注意事項(xiàng)
注意力在我們的模型中的應(yīng)用
編碼器和解碼器堆棧
位置導(dǎo)向的前饋網(wǎng)絡(luò)
嵌入和Softmax
位置編碼
完整模型
標(biāo)簽平滑化
批量和遮蔽
訓(xùn)練回路
硬件和時(shí)間表
優(yōu)化器
正規(guī)化
合成數(shù)據(jù)
損失計(jì)算
greedy解碼
加載數(shù)據(jù)
迭代器
多GPU訓(xùn)練
訓(xùn)練系統(tǒng)
附加組件：BPE、搜索、平均值
注意力可視化
減少順序計(jì)算的目標(biāo)也構(gòu)成了擴(kuò)展神經(jīng)GPU、ByteNet和ConvS2S的基礎(chǔ)，它們都使用卷積神經(jīng)網(wǎng)絡(luò)作為基本構(gòu)件，對(duì)所有輸入和輸出位置并行計(jì)算隱藏表示。在這些模型中，將兩個(gè)任意輸入或輸出位置的信號(hào)關(guān)聯(lián)起來(lái)所需的運(yùn)算次數(shù)隨著位置之間的距離而增長(zhǎng)，對(duì)于ConvS2S來(lái)說(shuō)是線性的，對(duì)于ByteNet來(lái)說(shuō)是對(duì)數(shù)的。這使得學(xué)習(xí)遠(yuǎn)距離位置之間的依賴關(guān)系變得更加困難。在Transformer中，這種情況被減少到了一個(gè)恒定的操作次數(shù)，盡管代價(jià)是由于注意力加權(quán)位置的平均化而導(dǎo)致有效分辨率的降低，我們用多頭注意力來(lái)抵消這種影響。
自注意，有時(shí)也被稱為內(nèi)注意，是一種將單個(gè)序列的不同位置聯(lián)系起來(lái)以計(jì)算序列的表示的注意機(jī)制。自我注意已被成功地應(yīng)用于各種任務(wù)中，包括閱讀理解、抽象概括、文本內(nèi)涵和學(xué)習(xí)任務(wù)無(wú)關(guān)的句子表征。端到端記憶網(wǎng)絡(luò)是基于循環(huán)注意機(jī)制而不是序列對(duì)齊的循環(huán)，并且已經(jīng)被證明在簡(jiǎn)單語(yǔ)言問(wèn)題回答和語(yǔ)言建模任務(wù)上表現(xiàn)良好。
然而，據(jù)我們所知，Transformer是第一個(gè)完全依靠自我注意力來(lái)計(jì)算其輸入和輸出的表征，而不使用序列對(duì)齊的RNNs或卷積的轉(zhuǎn)換模型。
大多數(shù)競(jìng)爭(zhēng)性神經(jīng)序列轉(zhuǎn)導(dǎo)模型都有一個(gè)編碼器-解碼器結(jié)構(gòu)(cite)。在這里，編碼器將輸入的符號(hào)表示序列(x1，...,xn)映射為連續(xù)表示序列z=(z1，...,zn)。在給定z的情況下，解碼器每次生成一個(gè)符號(hào)的輸出序列(y1,...,ym)。在每一步中，該模型都是自動(dòng)遞減的(cite)，在生成下一個(gè)符號(hào)時(shí)，消耗之前生成的符號(hào)作為額外的輸入。
def __init__(self, encoder, decoder, src_embed, tgt_embed, generator): |
class Generator(nn.Module): |
Transformer沿用了這種整體架構(gòu)，編碼器和解碼器都采用堆疊式自關(guān)注和點(diǎn)對(duì)點(diǎn)的全連接層，分別如圖1的左半部分和右半部分所示。
| Image(filename='images/ModalNet-21.png') |
編碼器
編碼器是由N=6個(gè)相同的層組成的堆棧。
def clones(module, N): |
我們?cè)趦蓚€(gè)子層周圍分別采用殘差連接(cite)，然后進(jìn)行層歸一化(cite)。
class LayerNorm(nn.Module): |
也就是說(shuō)，每個(gè)子層的輸出是LayerNorm(x+Sublayer(x))，其中Sublayer(x)是子層自己實(shí)現(xiàn)的函數(shù)。我們?cè)诿總€(gè)子層的輸出中應(yīng)用dropout(引用)，然后再加到子層的輸入中并進(jìn)行歸一化。
為了方便這些殘差連接，模型中的所有子層以及嵌入層都會(huì)產(chǎn)生維度為dmodel=512dmodel=512的輸出。
| 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))) |
每層有兩個(gè)子層。第一層是一個(gè)多頭自注意機(jī)制，第二層是一個(gè)簡(jiǎn)單的、基于位置的全連接前饋網(wǎng)絡(luò)。
| 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) |
解碼器也是由N=6層相同的堆棧組成。
| class Decoder(nn.Module): "Generic N layer decoder with masking." 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) |
除了每個(gè)編碼器層中的兩個(gè)子層外，解碼器還插入了第三個(gè)子層，它在編碼器堆棧的輸出上執(zhí)行多頭關(guān)注。與編碼器類似，我們?cè)诿總€(gè)子層周圍采用殘余連接，然后進(jìn)行層歸一化。
| class DecoderLayer(nn.Module): "Decoder is made of self-attn, src-attn, and feed forward (defined below)" def __init__(self, size, self_attn, src_attn, feed_forward, dropout): super(DecoderLayer, self).__init__() self.size = size self.self_attn = self_attn self.src_attn = src_attn self.feed_forward = feed_forward self.sublayer = clones(SublayerConnection(size, dropout), 3) def forward(self, x, memory, src_mask, tgt_mask): "Follow Figure 1 (right) for connections." m = memory x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask)) x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask)) return self.sublayer[2](x, self.feed_forward) |
我們還修改了解碼器堆棧中的自注意力子層，以防止位置對(duì)后續(xù)位置的關(guān)注。這種遮蔽，加上輸出嵌入偏移這一個(gè)位置的事實(shí)，確保位置ii的預(yù)測(cè)只能依賴于小于i的這個(gè)位置的已知輸出。
| def subsequent_mask(size): "Mask out subsequent positions." attn_shape = (1, size, size) subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8') return torch.from_numpy(subsequent_mask) == 0 |
筆者注：注意力掩碼下方顯示了每個(gè)tgt詞（行）被允許看的位置（列）。在訓(xùn)練過(guò)程中，單詞會(huì)被屏蔽，以便關(guān)注之后的單詞。
| plt.figure(figsize=(5,5)) plt.imshow(subsequent_mask(20)[0]) None |
注意事項(xiàng)
注意函數(shù)可以描述為將一個(gè)查詢和一組鍵值對(duì)映射到一個(gè)輸出，其中查詢、鍵、值和輸出都是向量。輸出是以值的加權(quán)和來(lái)計(jì)算的，其中分配給每個(gè)值的權(quán)重是由查詢與對(duì)應(yīng)鍵的兼容性函數(shù)計(jì)算出來(lái)的。我們把我們的特殊注意力稱為 "Scaled Dot-Product注意力"。輸入由維度為dk的查詢和鍵，以及維度為dv的值組成。我們計(jì)算查詢與所有鍵的點(diǎn)積，每一個(gè)點(diǎn)積除以√dk，然后應(yīng)用一個(gè)softmax函數(shù)來(lái)獲得值的權(quán)重。
| Image(filename='images/ModalNet-19.png') |
在實(shí)際應(yīng)用中，我們對(duì)一組查詢同時(shí)計(jì)算關(guān)注函數(shù)，打包成一個(gè)矩陣QQ。鍵和值也一起打包成矩陣KK和VV。我們計(jì)算輸出的矩陣為：
| def attention(query, key, value, mask=None, dropout=None): "Compute 'Scaled Dot Product Attention'" d_k = query.size(-1) scores = torch.matmul(query, key.transpose(-2, -1)) \ / math.sqrt(d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) p_attn = F.softmax(scores, dim = -1) if dropout is not None: p_attn = dropout(p_attn) return torch.matmul(p_attn, value), p_attn |
最常用的兩個(gè)注意力函數(shù)是加法注意力（cite），和點(diǎn)積（乘法）注意力。點(diǎn)積注意力除了縮放因子為1/√dk外，與我們的算法相同。加法注意力使用單層隱藏層的前饋網(wǎng)絡(luò)計(jì)算兼容性函數(shù)。雖然兩者在理論復(fù)雜度上相似，但點(diǎn)積注意力在實(shí)踐中更快，更節(jié)省空間，因?yàn)樗梢允褂酶叨葍?yōu)化的矩陣乘法代碼來(lái)實(shí)現(xiàn)。
雖然對(duì)于dk的小值，兩種機(jī)制的表現(xiàn)相似，但對(duì)于dk的大值，加法注意力的表現(xiàn)優(yōu)于點(diǎn)積注意力，而沒(méi)有縮放（引用）。我們懷疑，對(duì)于dk的大值，點(diǎn)積的幅度會(huì)變大，將softmax函數(shù)推到它的梯度極小的區(qū)域（為了說(shuō)明點(diǎn)積為什么會(huì)變大，假設(shè)qq和kk的分量是均值00、方差11的獨(dú)立隨機(jī)變量。那么它們的點(diǎn)積q?k=∑dki=1qiki，其均值為00，方差為dk）。
為了抵消這種影響，我們將點(diǎn)乘積的比例為1/√dk。
| Image(filename='images/ModalNet-20.png') |
多頭注意使模型能夠共同注意來(lái)自不同位置的不同表征子空間的信息。在單注意頭的情況下，平均化會(huì)抑制這一點(diǎn)。
其中，投影為參數(shù)矩陣
和
在這項(xiàng)工作中，我們采用了h=8h=8個(gè)平行的注意層，或者說(shuō)頭。對(duì)于其中的每一個(gè)層，我們使用 ：
由于每個(gè)頭的維度減少，總的計(jì)算成本與全維度的單頭注意力相似。
| class MultiHeadedAttention(nn.Module): def __init__(self, h, d_model, dropout=0.1): "Take in model size and number of heads." super(MultiHeadedAttention, self).__init__() assert d_model % h == 0 # We assume d_v always equals d_k self.d_k = d_model // h self.h = h self.linears = clones(nn.Linear(d_model, d_model), 4) self.attn = None self.dropout = nn.Dropout(p=dropout) def forward(self, query, key, value, mask=None): "Implements Figure 2" if mask is not None: # Same mask applied to all h heads. mask = mask.unsqueeze(1) nbatches = query.size(0) # 1) Do all the linear projections in batch from d_model => h x d_k query, key, value = \ [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2) for l, x in zip(self.linears, (query, key, value))] # 2) Apply attention on all the projected vectors in batch. x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout) # 3) "Concat" using a view and apply a final linear. x = x.transpose(1, 2).contiguous() \ .view(nbatches, -1, self.h * self.d_k) return self.linears[-1](x) |
Transformer以三種不同的方式使用多頭注意：
1. 在 "編碼器-解碼器關(guān)注 "層中，查詢來(lái)自前一個(gè)解碼器層，而內(nèi)存鍵和值來(lái)自編碼器的輸出。這使得解碼器中的每個(gè)位置都能在輸入序列的所有位置上進(jìn)行關(guān)注。這模仿了序列到序列模型中典型的編碼器-解碼器的注意機(jī)制，如（引用）。
2. 編碼器包含自注意層。在自注意層中，所有的鍵、值和查詢都來(lái)自同一個(gè)地方，在這種情況下，就是編碼器中上一層的輸出。編碼器中的每個(gè)位置都可以參加編碼器前一層的所有位置。
3. 同樣，解碼器中的自注意層允許解碼器中的每個(gè)位置都可以參加解碼器中的所有位置，直到并包括該位置。我們需要防止解碼器中的左向信息流，以保持自動(dòng)遞減特性。我們通過(guò)屏蔽（設(shè)置為-∞）softmax的輸入中所有對(duì)應(yīng)非法連接的值，在scaled dot- product attention里面實(shí)現(xiàn)。
除了注意力子層，我們的編碼器和解碼器中的每個(gè)層都包含一個(gè)完全連接的前饋網(wǎng)絡(luò)，該網(wǎng)絡(luò)分別和相同地應(yīng)用于每個(gè)位置。這包括兩個(gè)線性變換，中間有一個(gè)ReLU激活。
雖然不同位置的線性變換是相同的，但它們?cè)趯优c層之間使用不同的參數(shù)。另一種描述方式是內(nèi)核大小為1的兩個(gè)卷積。輸入和輸出的維度為dmodel=512，內(nèi)層的維度為dff=2048。
| class PositionwiseFeedForward(nn.Module): "Implements FFN equation." def __init__(self, d_model, d_ff, dropout=0.1): super(PositionwiseFeedForward, self).__init__() self.w_1 = nn.Linear(d_model, d_ff) self.w_2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x): return self.w_2(self.dropout(F.relu(self.w_1(x)))) |
與其他序列轉(zhuǎn)導(dǎo)模型類似，我們使用學(xué)習(xí)的嵌入將輸入令牌和輸出令牌轉(zhuǎn)換為維數(shù)dmodel的向量。我們還使用通常的學(xué)習(xí)線性變換和softmax函數(shù)將解碼器輸出轉(zhuǎn)換為預(yù)測(cè)的下一個(gè)標(biāo)記概率。在我們的模型中，我們?cè)趦蓚€(gè)嵌入層和預(yù)softmax線性變換之間共享相同的權(quán)重矩陣，類似于（引用）。在嵌入層中，我們將這些權(quán)重乘以√dmodel。
| class Embeddings(nn.Module): def __init__(self, d_model, vocab): super(Embeddings, self).__init__() self.lut = nn.Embedding(vocab, d_model) self.d_model = d_model def forward(self, x): return self.lut(x) * math.sqrt(self.d_model) |
由于我們的模型不包含遞歸和卷積，為了使模型能夠利用序列的順序，我們必須注入一些關(guān)于序列中標(biāo)記的相對(duì)或絕對(duì)位置的信息。為此，我們?cè)诰幋a器和解碼器堆棧底部的輸入嵌入中加入 "位置編碼"。位置編碼與嵌入的維度dmodel相同，因此兩者可以相加。位置編碼有很多選擇，有學(xué)習(xí)的和固定的（引用）。
在本工作中，我們使用不同頻率的正弦和余弦函數(shù)。
其中pos是位置，i是維度。即位置編碼的每個(gè)維度對(duì)應(yīng)一個(gè)正弦波。波長(zhǎng)形成從2π到10000?2π的幾何級(jí)數(shù)。我們選擇這個(gè)函數(shù)是因?yàn)槲覀兗僭O(shè)它可以讓模型很容易地學(xué)會(huì)通過(guò)相對(duì)位置來(lái)參加，因?yàn)閷?duì)于任何固定的偏移量k，PEpos+k可以表示為PEpos的線性函數(shù)。
此外，我們對(duì)編碼器和解碼器堆棧中的嵌入和位置編碼的總和應(yīng)用了 dropout。對(duì)于基礎(chǔ)模型，我們使用Pdrop=0.1的速率。
| class PositionalEncoding(nn.Module): "Implement the PE function." def __init__(self, d_model, dropout, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) # Compute the positional encodings once in log space. pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe) def forward(self, x): x = x + Variable(self.pe[:, :x.size(1)], requires_grad=False) return self.dropout(x) |
下面的位置編碼會(huì)根據(jù)位置加入一個(gè)正弦波。每個(gè)維度的波的頻率和偏移量是不同的。
| plt.figure(figsize=(15, 5)) pe = PositionalEncoding(20, 0) y = pe.forward(Variable(torch.zeros(1, 100, 20))) plt.plot(np.arange(100), y[0, :, 4:8].data.numpy()) plt.legend(["dim %d"%p for p in [4,5,6,7]]) None |
我們還試驗(yàn)了使用學(xué)習(xí)的位置嵌入（cite）來(lái)代替，并發(fā)現(xiàn)這兩個(gè)版本產(chǎn)生的結(jié)果幾乎是相同的。我們選擇了正弦版本，因?yàn)樗赡茉试S模型外推到比訓(xùn)練過(guò)程中遇到的序列長(zhǎng)度更長(zhǎng)的序列。
在這里，我們定義了一個(gè)函數(shù)，它可以接受超參數(shù)并產(chǎn)生一個(gè)完整的模型。
| def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1): "Helper: Construct a model from hyperparameters." c = copy.deepcopy attn = MultiHeadedAttention(h, d_model) ff = PositionwiseFeedForward(d_model, d_ff, dropout) position = PositionalEncoding(d_model, dropout) model = EncoderDecoder( Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N), Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N), nn.Sequential(Embeddings(d_model, src_vocab), c(position)), nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)), Generator(d_model, tgt_vocab)) # This was important from their code. # Initialize parameters with Glorot / fan_avg. for p in model.parameters(): if p.dim() > 1: nn.init.xavier_uniform(p) return model |
| # Small example model. tmp_model = make_model(10, 10, 2) None |
本節(jié)介紹了我們模型的訓(xùn)練制度。
筆者注：我們停下來(lái)做一個(gè)快速的插曲，介紹一些訓(xùn)練標(biāo)準(zhǔn)編碼器解碼器模型所需的工具。首先，我們定義了一個(gè)批處理對(duì)象，它保存了用于訓(xùn)練的src和目標(biāo)句子，以及構(gòu)建掩碼。
| class Batch: "Object for holding a batch of data with mask during training." def __init__(self, src, trg=None, pad=0): self.src = src self.src_mask = (src != pad).unsqueeze(-2) if trg is not None: self.trg = trg[:, :-1] self.trg_y = trg[:, 1:] self.trg_mask = \ self.make_std_mask(self.trg, pad) self.ntokens = (self.trg_y != pad).data.sum() @staticmethod def make_std_mask(tgt, pad): "Create a mask to hide padding and future words." tgt_mask = (tgt != pad).unsqueeze(-2) tgt_mask = tgt_mask & Variable( subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data)) return tgt_mask |
筆者注：接下來(lái)我們創(chuàng)建一個(gè)通用的訓(xùn)練和評(píng)分函數(shù)來(lái)跟蹤損失。我們傳遞了一個(gè)通用的損失計(jì)算函數(shù)，它也處理參數(shù)更新。
| def run_epoch(data_iter, model, loss_compute): "Standard Training and Logging Function" start = time.time() total_tokens = 0 total_loss = 0 tokens = 0 for i, batch in enumerate(data_iter): out = model.forward(batch.src, batch.trg, batch.src_mask, batch.trg_mask) loss = loss_compute(out, batch.trg_y, batch.ntokens) total_loss += loss total_tokens += batch.ntokens tokens += batch.ntokens if i % 50 == 1: elapsed = time.time() - start print("Epoch Step: %d Loss: %f Tokens per Sec: %f" % (i, loss / batch.ntokens, tokens / elapsed)) start = time.time() tokens = 0 return total_loss / total_tokens |
我們?cè)跇?biāo)準(zhǔn)的WMT 2014英德數(shù)據(jù)集上進(jìn)行了訓(xùn)練，該數(shù)據(jù)集由大約450萬(wàn)句子對(duì)組成。句子使用字節(jié)對(duì)編碼，其共享的源-目標(biāo)詞匯約為37000個(gè)tokens。對(duì)于英語(yǔ)-法語(yǔ)，我們使用了明顯更大的WMT 2014英法數(shù)據(jù)集，該數(shù)據(jù)集由36M句子組成，并將tokens拆分為32000個(gè)詞片詞匯。
句子對(duì)被按近似序列長(zhǎng)度分批在一起。每個(gè)訓(xùn)練批次都包含一組句子對(duì)，包含大約25000個(gè)源標(biāo)記和25000個(gè)目標(biāo)標(biāo)記。
筆者注：我們將使用火炬文本進(jìn)行批處理。這將在下面詳細(xì)討論。在這里，我們?cè)趖orchtext函數(shù)中創(chuàng)建批處理，以確保我們的批處理大小墊到最大batchsize不超過(guò)一個(gè)閾值（25000，如果我們有8個(gè)gpus）。
| global max_src_in_batch, max_tgt_in_batch def batch_size_fn(new, count, sofar): "Keep augmenting batch and calculate total number of tokens + padding." global max_src_in_batch, max_tgt_in_batch if count == 1: max_src_in_batch = 0 max_tgt_in_batch = 0 max_src_in_batch = max(max_src_in_batch, len(new.src)) max_tgt_in_batch = max(max_tgt_in_batch, len(new.trg) + 2) src_elements = count * max_src_in_batch tgt_elements = count * max_tgt_in_batch return max(src_elements, tgt_elements) |
我們?cè)谝慌_(tái)擁有8個(gè)NVIDIA P100 GPU的機(jī)器上訓(xùn)練我們的模型。對(duì)于我們的基礎(chǔ)模型，使用本文中描述的超參數(shù)，每個(gè)訓(xùn)練步驟大約需要0.4秒。我們總共訓(xùn)練了100,000步或12小時(shí)的基礎(chǔ)模型。對(duì)于我們的大模型，步長(zhǎng)為1.0秒。大模型的訓(xùn)練時(shí)間為30萬(wàn)步（3.5天）。
我們使用了Adam優(yōu)化器（引用），β1=0.9，β2=0.98，?=10^-9。我們根據(jù)公式，在訓(xùn)練過(guò)程中改變學(xué)習(xí)率。
這相當(dāng)于對(duì)第一個(gè)warmupstepswarmupsteps訓(xùn)練步數(shù)線性增加學(xué)習(xí)率，此后按步數(shù)的倒平方根按比例減少。我們使用warmupsteps=4000。
注意：這部分非常重要。需要用這個(gè)設(shè)置的模型進(jìn)行訓(xùn)練。
| class NoamOpt: "Optim wrapper that implements rate." def __init__(self, model_size, factor, warmup, optimizer): self.optimizer = optimizer self._step = 0 self.warmup = warmup self.factor = factor self.model_size = model_size self._rate = 0 def step(self): "Update parameters and rate" self._step += 1 rate = self.rate() for p in self.optimizer.param_groups: p['lr'] = rate self._rate = rate self.optimizer.step() def rate(self, step = None): "Implement `lrate` above" if step is None: step = self._step return self.factor * \ (self.model_size ** (-0.5) * min(step ** (-0.5), step * self.warmup ** (-1.5))) def get_std_opt(model): return NoamOpt(model.src_embed[0].d_model, 2, 4000, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) |
該模型在不同模型大小和優(yōu)化超參數(shù)下的曲線示例。
| # Three settings of the lrate hyperparameters. opts = [NoamOpt(512, 1, 4000, None), NoamOpt(512, 1, 8000, None), NoamOpt(256, 1, 4000, None)] plt.plot(np.arange(1, 20000), [[opt.rate(i) for opt in opts] for i in range(1, 20000)]) plt.legend(["512:4000", "512:8000", "256:4000"]) None |
標(biāo)簽平滑化
在訓(xùn)練過(guò)程中，我們采用了價(jià)值?ls=0.1?ls=0.1的標(biāo)簽平滑（引用）。這傷害了迷惑性，因?yàn)槟Ｐ蛯W(xué)會(huì)了更多的不確定，但提高了準(zhǔn)確性和BLEU得分。
筆者注：我們使用KL div loss實(shí)現(xiàn)標(biāo)簽平滑。而不是使用一個(gè)一熱的目標(biāo)分布，我們創(chuàng)建了一個(gè)分布，有信心的正確的單詞和其余的平滑質(zhì)量分布在整個(gè)詞匯。
| class LabelSmoothing(nn.Module): "Implement label smoothing." def __init__(self, size, padding_idx, smoothing=0.0): super(LabelSmoothing, self).__init__() self.criterion = nn.KLDivLoss(size_average=False) self.padding_idx = padding_idx self.confidence = 1.0 - smoothing self.smoothing = smoothing self.size = size self.true_dist = None def forward(self, x, target): assert x.size(1) == self.size true_dist = x.data.clone() true_dist.fill_(self.smoothing / (self.size - 2)) true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence) true_dist[:, self.padding_idx] = 0 mask = torch.nonzero(target.data == self.padding_idx) if mask.dim() > 0: true_dist.index_fill_(0, mask.squeeze(), 0.0) self.true_dist = true_dist return self.criterion(x, Variable(true_dist, requires_grad=False)) |
在這里，我們可以看到一個(gè)例子，說(shuō)明質(zhì)量是如何根據(jù)置信度分配給單詞的。
| # Example of label smoothing. crit = LabelSmoothing(5, 0, 0.4) predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],[0, 0.2, 0.7, 0.1, 0],[0, 0.2, 0.7, 0.1, 0]]) v = crit(Variable(predict.log()), Variable(torch.LongTensor([2, 1, 0]))) # Show the target distributions expected by the system. plt.imshow(crit.true_dist) None |
標(biāo)簽平滑實(shí)際上是開(kāi)始懲罰模型，如果它對(duì)給定的選擇非常自信的話。
| crit = LabelSmoothing(5, 0, 0.1) def loss(x): d = x + 3 * 1 predict = torch.FloatTensor([[0, x / d, 1 / d, 1 / d, 1 / d], ]) #print(predict) return crit(Variable(predict.log()), Variable(torch.LongTensor([1]))).data[0] plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)]) None |
我們可以先嘗試一個(gè)簡(jiǎn)單的復(fù)制任務(wù)。從一個(gè)小詞匯中給定一組隨機(jī)的輸入符號(hào)，目標(biāo)是生成回這些相同的符號(hào)。
| def data_gen(V, batch, nbatches): "Generate random data for a src-tgt copy task." for i in range(nbatches): data = torch.from_numpy(np.random.randint(1, V, size=(batch, 10))) data[:, 0] = 1 src = Variable(data, requires_grad=False) tgt = Variable(data, requires_grad=False) yield Batch(src, tgt, 0) |
| class SimpleLossCompute: "A simple loss compute and train function." def __init__(self, generator, criterion, opt=None): self.generator = generator self.criterion = criterion self.opt = opt def __call__(self, x, y, norm): x = self.generator(x) loss = self.criterion(x.contiguous().view(-1, x.size(-1)), y.contiguous().view(-1)) / norm loss.backward() if self.opt is not None: self.opt.step() self.opt.optimizer.zero_grad() return loss.data[0] * norm |
| # Train the simple copy task. V = 11 criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0) model = make_model(V, V, N=2) model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) for epoch in range(10): model.train() run_epoch(data_gen(V, 30, 20), model, SimpleLossCompute(model.generator, criterion, model_opt)) model.eval() print(run_epoch(data_gen(V, 30, 5), model, SimpleLossCompute(model.generator, criterion, None))) |
| Epoch Step: 1 Loss: 3.023465 Tokens per Sec: 403.074173 Epoch Step: 1 Loss: 1.920030 Tokens per Sec: 641.689380 1.9274832487106324 Epoch Step: 1 Loss: 1.940011 Tokens per Sec: 432.003378 Epoch Step: 1 Loss: 1.699767 Tokens per Sec: 641.979665 1.657595729827881 Epoch Step: 1 Loss: 1.860276 Tokens per Sec: 433.320240 Epoch Step: 1 Loss: 1.546011 Tokens per Sec: 640.537198 1.4888023376464843 Epoch Step: 1 Loss: 1.682198 Tokens per Sec: 432.092305 Epoch Step: 1 Loss: 1.313169 Tokens per Sec: 639.441857 1.3485562801361084 Epoch Step: 1 Loss: 1.278768 Tokens per Sec: 433.568756 Epoch Step: 1 Loss: 1.062384 Tokens per Sec: 642.542067 0.9853351473808288 Epoch Step: 1 Loss: 1.269471 Tokens per Sec: 433.388727 Epoch Step: 1 Loss: 0.590709 Tokens per Sec: 642.862135 0.5686767101287842 Epoch Step: 1 Loss: 0.997076 Tokens per Sec: 433.009746 Epoch Step: 1 Loss: 0.343118 Tokens per Sec: 642.288427 0.34273059368133546 Epoch Step: 1 Loss: 0.459483 Tokens per Sec: 434.594030 Epoch Step: 1 Loss: 0.290385 Tokens per Sec: 642.519464 0.2612409472465515 Epoch Step: 1 Loss: 1.031042 Tokens per Sec: 434.557008 Epoch Step: 1 Loss: 0.437069 Tokens per Sec: 643.630322 0.4323212027549744 Epoch Step: 1 Loss: 0.617165 Tokens per Sec: 436.652626 Epoch Step: 1 Loss: 0.258793 Tokens per Sec: 644.372296 0.27331129014492034 |
這個(gè)代碼為了簡(jiǎn)單起見(jiàn)，使用貪婪的解碼來(lái)預(yù)測(cè)翻譯。
| def greedy_decode(model, src, src_mask, max_len, start_symbol): memory = model.encode(src, src_mask) ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data) for i in range(max_len-1): out = model.decode(memory, src_mask, Variable(ys), Variable(subsequent_mask(ys.size(1)) .type_as(src.data))) prob = model.generator(out[:, -1]) _, next_word = torch.max(prob, dim = 1) next_word = next_word.data[0] ys = torch.cat([ys, torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1) return ys model.eval() src = Variable(torch.LongTensor([[1,2,3,4,5,6,7,8,9,10]]) ) src_mask = Variable(torch.ones(1, 1, 10) ) print(greedy_decode(model, src, src_mask, max_len=10, start_symbol=1)) |
| 1 2 3 4 5 6 7 8 9 10 [torch.LongTensor of size 1x10] |
筆者注：現(xiàn)在我們考慮使用IWSLT德英翻譯任務(wù)的一個(gè)真實(shí)世界的例子。這個(gè)任務(wù)比論文中考慮的WMT任務(wù)小得多，但它說(shuō)明了整個(gè)系統(tǒng)。我們還展示了如何使用多GPU處理來(lái)使其真正快速。
| #!pip install torchtext spacy #!python -m spacy download en #!python -m spacy download de |
筆者注：我們將使用 torchtext 和 spacy 加載數(shù)據(jù)集進(jìn)行標(biāo)記化。
| # For data loading. from torchtext import data, datasets if True: import spacy spacy_de = spacy.load('de') spacy_en = spacy.load('en') def tokenize_de(text): return [tok.text for tok in spacy_de.tokenizer(text)] def tokenize_en(text): return [tok.text for tok in spacy_en.tokenizer(text)] BOS_WORD = '<s>' EOS_WORD = '</s>' BLANK_WORD = "<blank>" SRC = data.Field(tokenize=tokenize_de, pad_token=BLANK_WORD) TGT = data.Field(tokenize=tokenize_en, init_token = BOS_WORD, eos_token = EOS_WORD, pad_token=BLANK_WORD) MAX_LEN = 100 train, val, test = datasets.IWSLT.splits( exts=('.de', '.en'), fields=(SRC, TGT), filter_pred=lambda x: len(vars(x)['src']) <= MAX_LEN and len(vars(x)['trg']) <= MAX_LEN) MIN_FREQ = 2 SRC.build_vocab(train.src, min_freq=MIN_FREQ) TGT.build_vocab(train.trg, min_freq=MIN_FREQ) |
批量對(duì)速度有很大的影響。我們希望有非常均勻的批次，絕對(duì)最小的填充。要做到這一點(diǎn)，我們必須對(duì)默認(rèn)的 torchtext 批量進(jìn)行一些改進(jìn)。這段代碼修補(bǔ)了他們的默認(rèn)批處理，以確保我們搜索到的句子足夠多，從而找到緊湊的批處理。
| class MyIterator(data.Iterator): def create_batches(self): if self.train: def pool(d, random_shuffler): for p in data.batch(d, self.batch_size * 100): p_batch = data.batch( sorted(p, key=self.sort_key), self.batch_size, self.batch_size_fn) for b in random_shuffler(list(p_batch)): yield b self.batches = pool(self.data(), self.random_shuffler) else: self.batches = [] for b in data.batch(self.data(), self.batch_size, self.batch_size_fn): self.batches.append(sorted(b, key=self.sort_key)) def rebatch(pad_idx, batch): "Fix order in torchtext to match ours" src, trg = batch.src.transpose(0, 1), batch.trg.transpose(0, 1) return Batch(src, trg, pad_idx) |
筆者注：最后為了真正針對(duì)快速訓(xùn)練，我們將使用多gpu。這段代碼實(shí)現(xiàn)了多gpu詞的生成。它不是專門針對(duì)transformer的，所以我不會(huì)說(shuō)得太詳細(xì)。我們的想法是在訓(xùn)練時(shí)將單詞生成分割成塊，在許多不同的gpus上并行處理。我們使用 pytorch 并行基元來(lái)實(shí)現(xiàn)這一目的。
replicate - 將模塊分割到不同的gpus上。
scatter - 分割批次到不同的gpus上。
parallel_apply - 將模塊應(yīng)用到不同的gpus上的批次。
gather - 把分散的數(shù)據(jù)拉回到一個(gè)gpu上。
nn.DataParallel - 一個(gè)特殊的模塊包裝器，在評(píng)估前調(diào)用這些
| # Skip if not interested in multigpu. class MultiGPULossCompute: "A multi-gpu loss compute and train function." def __init__(self, generator, criterion, devices, opt=None, chunk_size=5): # Send out to different gpus. self.generator = generator self.criterion = nn.parallel.replicate(criterion, devices=devices) self.opt = opt self.devices = devices self.chunk_size = chunk_size def __call__(self, out, targets, normalize): total = 0.0 generator = nn.parallel.replicate(self.generator, devices=self.devices) out_scatter = nn.parallel.scatter(out, target_gpus=self.devices) out_grad = [[] for _ in out_scatter] targets = nn.parallel.scatter(targets, target_gpus=self.devices) # Divide generating into chunks. chunk_size = self.chunk_size for i in range(0, out_scatter[0].size(1), chunk_size): # Predict distributions out_column = [[Variable(o[:, i:i+chunk_size].data, requires_grad=self.opt is not None)] for o in out_scatter] gen = nn.parallel.parallel_apply(generator, out_column) # Compute loss. y = [(g.contiguous().view(-1, g.size(-1)), t[:, i:i+chunk_size].contiguous().view(-1)) for g, t in zip(gen, targets)] loss = nn.parallel.parallel_apply(self.criterion, y) # Sum and normalize loss l = nn.parallel.gather(loss, target_device=self.devices[0]) l = l.sum()[0] / normalize total += l.data[0] # Backprop loss to output of transformer if self.opt is not None: l.backward() for j, l in enumerate(loss): out_grad[j].append(out_column[j][0].grad.data.clone()) # Backprop all loss through transformer. if self.opt is not None: out_grad = [Variable(torch.cat(og, dim=1)) for og in out_grad] o1 = out o2 = nn.parallel.gather(out_grad, target_device=self.devices[0]) o1.backward(gradient=o2) self.opt.step() self.opt.optimizer.zero_grad() return total * normalize |
現(xiàn)在我們創(chuàng)建我們的模型、準(zhǔn)則、優(yōu)化器、數(shù)據(jù)迭代器和paralelization。
| # GPUs to use devices = [0, 1, 2, 3] if True: pad_idx = TGT.vocab.stoi["<blank>"] model = make_model(len(SRC.vocab), len(TGT.vocab), N=6) model.cuda() criterion = LabelSmoothing(size=len(TGT.vocab), padding_idx=pad_idx, smoothing=0.1) criterion.cuda() BATCH_SIZE = 12000 train_iter = MyIterator(train, batch_size=BATCH_SIZE, device=0, repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)), batch_size_fn=batch_size_fn, train=True) valid_iter = MyIterator(val, batch_size=BATCH_SIZE, device=0, repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)), batch_size_fn=batch_size_fn, train=False) model_par = nn.DataParallel(model, device_ids=devices) None |
現(xiàn)在我們訓(xùn)練模型。我會(huì)稍微玩一下熱身步驟，但其他一切都使用默認(rèn)參數(shù)。在一個(gè)有4個(gè)特斯拉V100的AWS p3.8xlarge上，這以每秒約27,000個(gè)代幣的速度運(yùn)行，批次大小為12,000個(gè)。
| #!wget https://s3.amazonaws.com/opennmt-models/iwslt.pt if False: model_opt = NoamOpt(model.src_embed[0].d_model, 1, 2000, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) for epoch in range(10): model_par.train() run_epoch((rebatch(pad_idx, b) for b in train_iter), model_par, MultiGPULossCompute(model.generator, criterion, devices=devices, opt=model_opt)) model_par.eval() loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter), model_par, MultiGPULossCompute(model.generator, criterion, devices=devices, opt=None)) print(loss) else: model = torch.load("iwslt.pt") |
筆者注：一旦訓(xùn)練好了，我們就可以對(duì)模型進(jìn)行解碼，產(chǎn)生一組翻譯。這里我們只需翻譯驗(yàn)證集中的第一句話。這個(gè)數(shù)據(jù)集相當(dāng)小，所以通過(guò)貪婪搜索的翻譯是相當(dāng)準(zhǔn)確的。
| for i, batch in enumerate(valid_iter): src = batch.src.transpose(0, 1)[:1] src_mask = (src != SRC.vocab.stoi["<blank>"]).unsqueeze(-2) out = greedy_decode(model, src, src_mask, max_len=60, start_symbol=TGT.vocab.stoi["<s>"]) print("Translation:", end="\t") for i in range(1, out.size(1)): sym = TGT.vocab.itos[out[0, i]] if sym == "</s>": break print(sym, end =" ") print() print("Target:", end="\t") for i in range(1, batch.trg.size(0)): sym = TGT.vocab.itos[batch.trg.data[i, 0]] if sym == "</s>": break print(sym, end =" ") print() break |
| Translation: <unk> <unk> . In my language , that means , thank you very much . Gold: <unk> <unk> . It means in my language , thank you very much . |
筆者注：所以這主要是涵蓋了變壓器模型本身。有四個(gè)方面我們沒(méi)有明確地覆蓋。我們還在OpenNMT-py中實(shí)現(xiàn)了所有這些附加功能。
1. BPE/字片。我們可以使用一個(gè)庫(kù)先把數(shù)據(jù)預(yù)處理成子字單元。參見(jiàn)Rico Sennrich的subword- nmt實(shí)現(xiàn)。這些模型會(huì)將訓(xùn)練數(shù)據(jù)轉(zhuǎn)化成這樣的樣子。
▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empf?nger ▁gesendet ▁werden .
2. 共享嵌入。當(dāng)使用共享詞匯的BPE時(shí)，我們可以在源/目標(biāo)/生成器之間共享相同的權(quán)重向量。詳情請(qǐng)參見(jiàn)（引文）。要將此添加到模型中，只需這樣做。
| if False: model.src_embed[0].lut.weight = model.tgt_embeddings[0].lut.weight model.generator.lut.weight = model.tgt_embed[0].lut.weight |
3. 光束搜索:這有點(diǎn)太復(fù)雜了，這里就不多說(shuō)了。參見(jiàn)OpenNMT- py中的pytorch實(shí)現(xiàn)。
4. 模型平均化:本文對(duì)最后的k個(gè)檢查點(diǎn)進(jìn)行平均，以產(chǎn)生集合效應(yīng)。如果我們有一堆模型，我們可以事后再做。
| def average(model, models): "Average models into model" for ps in zip(*[m.params() for m in [model] + models]): p[0].copy_(torch.sum(*ps[1:]) / len(ps[1:])) |
在WMT 2014英譯德任務(wù)上，大變壓器模型（Transformer（big）在表2中）比之前報(bào)道的最佳模型（包括合集）的表現(xiàn)要好2.0 BLEU以上，建立了新的最先進(jìn)的BLEU得分28.4。該模型的配置列在表3的底行。訓(xùn)練在8個(gè)P100 GPU上花了3.5天。即使我們的基礎(chǔ)模型也超越了所有之前發(fā)布的模型和合集，而訓(xùn)練成本只是任何競(jìng)爭(zhēng)模型的一小部分。
在WMT 2014英譯法任務(wù)上，我們的大模型實(shí)現(xiàn)了41.0的BLEU得分，超越了之前發(fā)布的所有單體模型，而訓(xùn)練成本不到之前最先進(jìn)模型的1/4。為英譯法訓(xùn)練的Transformer（大）模型使用的輟學(xué)率Pdrop=0.1，而不是0.3。
我們?cè)谶@里寫的代碼是基礎(chǔ)模型的一個(gè)版本。這里有這個(gè)系統(tǒng)的完全訓(xùn)練版本（示例模型）。
通過(guò)上一節(jié)中的附加擴(kuò)展，OpenNMT-py復(fù)制在EN-DE WMT上達(dá)到了26.9。在這里，我已經(jīng)把這些參數(shù)加載到我們的重新實(shí)施中。
| !wget https://s3.amazonaws.com/opennmt-models/en-de-model.pt model, SRC, TGT = torch.load("en-de-model.pt") model.eval() sent = "▁The ▁log ▁file ▁can ▁be ▁sent ▁secret ly ▁with ▁email ▁or ▁FTP ▁to ▁a ▁specified ▁receiver".split() src = torch.LongTensor([[SRC.stoi[w] for w in sent]]) src = Variable(src) src_mask = (src != SRC.stoi["<blank>"]).unsqueeze(-2) out = greedy_decode(model, src, src_mask, max_len=60, start_symbol=TGT.stoi["<s>"]) print("Translation:", end="\t") trans = "<s> " for i in range(1, out.size(1)): sym = TGT.itos[out[0, i]] if sym == "</s>": break trans += sym + " " print(trans) |
| ranslation: <s> ▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empf?nger ▁gesendet ▁werden . |
即使是用greedy解碼，翻譯出來(lái)的效果也很不錯(cuò)。我們可以進(jìn)一步將其可視化，看看在注意力的每一層發(fā)生了什么。
| tgt_sent = trans.split() def draw(data, x, y, ax): seaborn.heatmap(data, xticklabels=x, square=True, yticklabels=y, vmin=0.0, vmax=1.0, cbar=False, ax=ax) for layer in range(1, 6, 2): fig, axs = plt.subplots(1,4, figsize=(20, 10)) print("Encoder Layer", layer+1) for h in range(4): draw(model.encoder.layers[layer].self_attn.attn[0, h].data, sent, sent if h ==0 else [], ax=axs[h]) plt.show() for layer in range(1, 6, 2): fig, axs = plt.subplots(1,4, figsize=(20, 10)) print("Decoder Self Layer", layer+1) for h in range(4): draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(tgt_sent)], tgt_sent, tgt_sent if h ==0 else [], ax=axs[h]) plt.show() print("Decoder Src Layer", layer+1) fig, axs = plt.subplots(1,4, figsize=(20, 10)) for h in range(4): draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(sent)], sent, tgt_sent if h ==0 else [], ax=axs[h]) plt.show() |
| Encoder Layer 2 |
| Encoder Layer 4 |
| Encoder Layer 6 |
| Encoder Self Layer 2 |
| Encoder Src Layer 4 |
| Encoder Self Layer 6 |
| Decoder Src Layer 6 |
筆者注：希望這段代碼對(duì)以后的研究有用。如果你有任何問(wèn)題，請(qǐng)聯(lián)系我們。如果你覺(jué)得這段代碼有幫助，也可以看看我們其他的OpenNMT工具。
| @inproceedings{opennmt, author = {Guillaume Klein and Yoon Kim and Yuntian Deng and Jean Senellart and Alexander M. Rush}, title = {OpenNMT: Open-Source Toolkit for Neural Machine Translation}, booktitle = {Proc. ACL}, year = {2017}, url = {https://doi.org/10.18653/v1/P17-4012}, doi = {10.18653/v1/P17-4012} } |
雷鋒字幕組是一個(gè)由AI愛(ài)好者組成的翻譯團(tuán)隊(duì)，匯聚五五多位志愿者的力量，分享最新的海外AI資訊，交流關(guān)于人工智能技術(shù)領(lǐng)域的行業(yè)轉(zhuǎn)變與技術(shù)創(chuàng)新的見(jiàn)解。
團(tuán)隊(duì)成員有大數(shù)據(jù)專家，算法工程師，圖像處理工程師，產(chǎn)品經(jīng)理，產(chǎn)品運(yùn)營(yíng)，IT咨詢?nèi)?，在校師生；志愿者們?lái)自IBM，AVL，Adobe，阿里，百度等知名企業(yè)，北大，清華，港大，中科院，南卡羅萊納大學(xué)，早稻田大學(xué)等海內(nèi)外高校研究所。
如果，你也是位熱愛(ài)分享的AI愛(ài)好者。歡迎與雷鋒字幕組一起，學(xué)習(xí)新知，分享成長(zhǎng)。
雷峰網(wǎng)版權(quán)文章，未經(jīng)授權(quán)禁止轉(zhuǎn)載。詳情見(jiàn)轉(zhuǎn)載須知。
