# 導入依賴庫
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import math

def get_positional_encoding(max_seq_len, embed_dim):
    # 初始化一個positional encoding
    # embed_dim: 字嵌入的維度
    # max_seq_len: 最大的序列長度
    positional_encoding = np.array([
        [pos / np.power(10000, 2 * i / embed_dim) for i in range(embed_dim)]
        if pos != 0 else np.zeros(embed_dim) for pos in range(max_seq_len)])
    positional_encoding[1:, 0::2] = np.sin(positional_encoding[1:, 0::2])  # dim 2i 偶數
    positional_encoding[1:, 1::2] = np.cos(positional_encoding[1:, 1::2])  # dim 2i+1 奇數
    # 歸一化, 用位置嵌入的每一行除以它的模長
    # denominator = np.sqrt(np.sum(position_enc**2, axis=1, keepdims=True))
    # position_enc = position_enc / (denominator + 1e-8)
    return positional_encoding
    
positional_encoding = get_positional_encoding(max_seq_len=100, embed_dim=16)
plt.figure(figsize=(10,10))
sns.heatmap(positional_encoding)
plt.title("Sinusoidal Function")
plt.xlabel("hidden dimension")
plt.ylabel("sequence length")

X_{embedding} + Attention(Q, \ K, \ V)$$

在之後的運算里，每經過一個模組的運算，都要把運算之前的值和運算之後的值相加，從而得到殘差連接，訓練的時候可以使梯度直接走捷徑反傳到最初始層：

$$X + SubLayer(X) $$

#### 2) 層歸一化

作用是把神經網路中隱藏層歸一為標準正態分布，也就是 `𝑖.𝑖.𝑑` 獨立同分布， 以起到加快訓練速度， 加速收斂的作用。

$$\mu_{i}=\frac{1}{m} \sum^{m}_{i=1}x_{ij}$$

上式中以矩陣的行 (𝑟𝑜𝑤) 為單位求均值：

$$\sigma^{2}_{j}=\frac{1}{m} \sum^{m}_{i=1}
(x_{ij}-\mu_{j})^{2}$$

上式中以矩陣的行 (𝑟𝑜𝑤) 為單位求方差：

$$LayerNorm(x)=\alpha \odot \frac{x_{ij}-\mu_{i}}
{\sqrt{\sigma^{2}_{i}+\epsilon}} + \beta $$

然後用**每一行**的**每一個元素**減去**這行的均值**，再除以**這行的標準差**，從而得到歸一化後的數值，$\epsilon$是為了防止除$0$；

之後引入兩個可訓練參數$\alpha, \ \beta$來彌補歸一化的過程中損失掉的資訊，注意$\odot$表示元素相乘而不是點積，我們一般初始化$\alpha$為全$1$，而$\beta$為全$0$。

程式碼層面非常簡單，單頭 `attention` 操作如下：

“`python
class ScaledDotProductAttention(nn.Module):
”’ Scaled Dot-Product Attention ”’

def __init__(self, temperature, attn_dropout=0.1):
super().__init__()
self.temperature = temperature
self.dropout = nn.Dropout(attn_dropout)

def forward(self, q, k, v, mask=None):
# self.temperature是論文中的d_k ** 0.5，防止梯度過大
# QxK/sqrt(dk)
attn = torch.matmul(q / self.temperature, k.transpose(2, 3))

if mask is not None:
# 屏蔽不想要的輸出
attn = attn.masked_fill(mask == 0, -1e9)
# softmax+dropout
attn = self.dropout(F.softmax(attn, dim=-1))
# 概率分布xV
output = torch.matmul(attn, v)

return output, attn
“`

`Multi-Head Attention` 實現在 `ScaledDotProductAttention` 基礎上構建：

“`python
class MultiHeadAttention(nn.Module):
”’ Multi-Head Attention module ”’

# n_head頭的個數，默認是8
# d_model編碼向量長度，例如本文說的512
# d_k, d_v的值一般會設置為 n_head * d_k=d_model，
# 此時concat後正好和原始輸入一樣，當然不相同也可以，因為後面有fc層
# 相當於將可學習矩陣分成獨立的n_head份
def __init__(self, n_head, d_model, d_k, d_v, dropout=0.1):
super().__init__()
# 假設n_head=8，d_k=64
self.n_head = n_head
self.d_k = d_k
self.d_v = d_v
# d_model輸入向量，n_head * d_k輸出向量
# 可學習W^Q，W^K,W^V矩陣參數初始化
self.w_qs = nn.Linear(d_model, n_head * d_k, bias=False)
self.w_ks = nn.Linear(d_model, n_head * d_k, bias=False)
self.w_vs = nn.Linear(d_model, n_head * d_v, bias=False)
# 最後的輸出維度變換操作
self.fc = nn.Linear(n_head * d_v, d_model, bias=False)
# 單頭自注意力
self.attention = ScaledDotProductAttention(temperature=d_k ** 0.5)
self.dropout = nn.Dropout(dropout)
# 層歸一化
self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)

def forward(self, q, k, v, mask=None):
# 假設qkv輸入是(b,100,512),100是訓練每個樣本最大單詞個數
# 一般qkv相等，即自注意力
residual = q
# 將輸入x和可學習矩陣相乘，得到(b,100,512)輸出
# 其中512的含義其實是8×64，8個head，每個head的可學習矩陣為64維度
# q的輸出是(b,100,8,64),kv也是一樣
q = self.w_qs(q).view(sz_b, len_q, n_head, d_k)
k = self.w_ks(k).view(sz_b, len_k, n_head, d_k)
v = self.w_vs(v).view(sz_b, len_v, n_head, d_v)

# 變成(b,8,100,64)，方便後面計算，也就是8個頭單獨計算
q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)

if mask is not None:
mask = mask.unsqueeze(1) # For head axis broadcasting.
# 輸出q是(b,8,100,64),維持不變,內部計算流程是：
# q*k轉置，除以d_k ** 0.5，輸出維度是b,8,100,100即單詞和單詞直接的相似性
# 對最後一個維度進行softmax操作得到b,8,100,100
# 最後乘上V，得到b,8,100,64輸出
q, attn = self.attention(q, k, v, mask=mask)

# b,100,8,64–>b,100,512
q = q.transpose(1, 2).contiguous().view(sz_b, len_q, -1)
q = self.dropout(self.fc(q))
# 殘差計算
q += residual
# 層歸一化，在512維度計算均值和方差，進行層歸一化
q = self.layer_norm(q)

return q, attn
“`

### 4、前饋網路

這個層就沒啥說的了，非常簡單，直接看程式碼吧：

“`python
class PositionwiseFeedForward(nn.Module):
”’ A two-feed-forward-layer module ”’

def __init__(self, d_in, d_hid, dropout=0.1):
super().__init__()
# 兩個fc層，對最後的512維度進行變換
self.w_1 = nn.Linear(d_in, d_hid) # position-wise
self.w_2 = nn.Linear(d_hid, d_in) # position-wise
self.layer_norm = nn.LayerNorm(d_in, eps=1e-6)
self.dropout = nn.Dropout(dropout)

def forward(self, x):
residual = x

x = self.w_2(F.relu(self.w_1(x)))
x = self.dropout(x)
x += residual

x = self.layer_norm(x)

return x
“`

最後，回顧下 `𝑡𝑟𝑎𝑛𝑠𝑓𝑜𝑟𝑚𝑒𝑟 𝑒𝑛𝑐𝑜𝑑𝑒𝑟` 的整體結構。

經過上文的梳理，我們已經基本了解了 `𝑡𝑟𝑎𝑛𝑠𝑓𝑜𝑟𝑚𝑒𝑟` 編碼器的主要構成部分，我們下面用公式把一個 `𝑡𝑟𝑎𝑛𝑠𝑓𝑜𝑟𝑚𝑒𝑟 𝑏𝑙𝑜𝑐𝑘` 的計算過程整理一下：

##### 1) 字向量與位置編碼

$$X = EmbeddingLookup(X) + PositionalEncoding$$
$$X \in \mathbb{R}^{batch \ size \ * \ seq. \ len. \ * \ embed. \ dim.} $$

##### 2) 自注意力機制

$$Q = Linear(X) = XW_{Q}$$
$$K = Linear(X) = XW_{K}$$
$$V = Linear(X) = XW_{V}$$
$$X_{attention} = SelfAttention(Q, \ K, \ V)$$

##### 3) 殘差連接與層歸一化

$$X_{attention} = X + X_{attention}$$
$$X_{attention} = LayerNorm(X_{attention})$$

##### 4) 前向網路

其實就是兩層線性映射並用激活函數激活，比如說$ReLU$:
$$X_{hidden} = Activate(Linear(Linear(X_{attention})))$$

##### 5) 重複3)

$$X_{hidden} = X_{attention} + X_{hidden}$$
$$X_{hidden} = LayerNorm(X_{hidden})$$
$$X_{hidden} \in \mathbb{R}^{batch \ size \ * \ seq. \ len. \ * \ embed. \ dim.} $$

## 三、絮叨

至此，我們已經講完了 `Transformer` 編碼器的全部內容，知道了如何獲得自然語言的位置資訊，注意力機制的工作原理等。

本文以原理講解為主，後續我會繼續更新**實戰內容**，教大家如何訓練我們自己的有趣又好玩的模型。

**本文硬核，肝了很久，如果喜歡，還望轉發、再看多多支援。**

我是 Jack ，我們下期見。

> 文章持續更新，可以微信公眾號搜索【JackCui-AI】第一時間閱讀，本文 GitHub [//github.com/Jack-Cherish/PythonPark](//github.com/Jack-Cherish/PythonPark) 已經收錄，有大廠面試完整考點，歡迎Star。