Transformers 亮相以來徹底改變了深度學習模型。

今天，我們來揭示 Transformers 背后的核心概念：注意力機制、編碼器-解碼器架構(gòu)、多頭注意力等等。 通過 Python 代碼片段，讓你深入了解其原理。

一、理解注意力機制

注意力機制是神經(jīng)網(wǎng)絡中一個迷人的概念，特別是在涉及到像 NLP 這樣的任務時。它就像給模型一個聚光燈，讓它能夠集中注意力在輸入序列的某些部分，同時忽略其他部分，就像我們?nèi)祟愒诶斫饩渥訒r關(guān)注特定的單詞或短語一樣。

現(xiàn)在，讓我們深入了解一種特定類型的注意力機制，稱為自注意力，也稱為內(nèi)部注意力。想象一下，當你閱讀一句話時，你的大腦會自動突出顯示重要的單詞或短語來理解意思。這就是神經(jīng)網(wǎng)絡中自注意力的基本原理。它使序列中的每個單詞都能“關(guān)注”其他單詞，包括自己在內(nèi)，以更好地理解上下文。

二、自注意力是如何工作的？

以下是自注意力在一個簡單示例中的工作原理：

考慮一句話：“The cat sat on the mat.”

嵌入

首先，模型將輸入序列中的每個單詞嵌入到一個高維向量表示中。這個嵌入過程允許模型捕捉單詞之間的語義相似性。

查詢、鍵和值向量

接下來，模型為序列中的每個單詞計算三個向量：查詢向量、鍵向量和值向量。在訓練過程中，模型學習這些向量，每個向量都有不同的作用。查詢向量表示單詞的查詢，即模型在序列中尋找的內(nèi)容。鍵向量表示單詞的鍵，即序列中其他單詞應該注意的內(nèi)容。值向量表示單詞的值，即單詞對輸出所貢獻的信息。

注意力分數(shù)

一旦模型計算了每個單詞的查詢、鍵和值向量，它就會為序列中的每一對單詞計算注意力分數(shù)。這通常通過取查詢向量和鍵向量的點積來實現(xiàn)，以評估單詞之間的相似性。

SoftMax 歸一化

然后，使用 softmax 函數(shù)對注意力分數(shù)進行歸一化，以獲得注意力權(quán)重。這些權(quán)重表示每個單詞應該關(guān)注序列中其他單詞的程度。注意力權(quán)重較高的單詞被認為對正在執(zhí)行的任務更為關(guān)鍵。

加權(quán)求和

最后，使用注意力權(quán)重計算值向量的加權(quán)和。這產(chǎn)生了每個序列中單詞的自注意力機制輸出，捕獲了來自其他單詞的上下文信息。

下面是一個計算注意力分數(shù)的簡單解釋：

# 安裝 PyTorch   !pip install torch==2.2.1+cu121    
  # 導入庫   import torch   import torch.nn.functional as F      
  # 示例輸入序列   input_sequence = torch.tensor([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]])      
  # 生成 Key、Query 和 Value 矩陣的隨機權(quán)重   random_weights_key = torch.randn(input_sequence.size(-1), input_sequence.size(-1))   random_weights_query = torch.randn(input_sequence.size(-1), input_sequence.size(-1))   random_weights_value = torch.randn(input_sequence.size(-1), input_sequence.size(-1))     
   # 計算 Key、Query 和 Value 矩陣   key = torch.matmul(input_sequence, random_weights_key)   query = torch.matmul(input_sequence, random_weights_query)   value = torch.matmul(input_sequence, random_weights_value)     
    # 計算注意力分數(shù)   attention_scores = torch.matmul(query, key.T) / torch.sqrt(torch.tensor(query.size(-1), dtype=torch.float32))      
    # 使用 softmax 函數(shù)獲得注意力權(quán)重   attention_weights = F.softmax(attention_scores, dim=-1)      
    # 計算 Value 向量的加權(quán)和   output = torch.matmul(attention_weights, value)      print("自注意力機制后的輸出:")   print(output)   

三、Transformer 模型的基礎(chǔ)

在我們深入探討Transformer模型的復雜工作原理之前，讓我們花點時間欣賞其開創(chuàng)性的架構(gòu)。正如我們之前討論的，Transformer模型通過引入圍繞自注意力機制的新穎方法，重塑了自然語言處理（NLP）的格局。在接下來的章節(jié)中，我們將揭開Transformer模型的核心組件，闡明其編碼器-解碼器架構(gòu)、位置編碼、多頭注意力和前饋網(wǎng)絡。

編碼器-解碼器架構(gòu)

在Transformer的核心是其編碼器-解碼器架構(gòu)——兩個關(guān)鍵組件之間的共生關(guān)系，分別負責處理輸入序列和生成輸出序列。編碼器和解碼器中的每一層都包含相同的子層，包括自注意力機制和前饋網(wǎng)絡。這種架構(gòu)不僅有助于全面理解輸入序列，而且能夠生成上下文豐富的輸出序列。

位置編碼

盡管Transformer模型具有強大的功能，但它缺乏對元素順序的內(nèi)在理解——這是位置編碼所解決的一個缺點。通過將輸入嵌入與位置信息結(jié)合起來，位置編碼使模型能夠區(qū)分序列中元素的相對位置。這種細致的理解對于捕捉語言的時間動態(tài)和促進準確理解至關(guān)重要。

多頭注意力

Transformer模型的一個顯著特征是它能夠同時關(guān)注輸入序列的不同部分——這是多頭注意力實現(xiàn)的。通過將查詢、鍵和值向量分成多個頭，并進行的自注意力計算，模型獲得了對輸入序列的細致透視，豐富了其表示，帶有多樣化的上下文信息。

前饋網(wǎng)絡

與人類大腦能夠并行處理信息的能力類似，Transformer模型中的每一層都包含一個前饋網(wǎng)絡——一種能夠捕捉序列中元素之間復雜關(guān)系的多功能組件。通過使用線性變換和非線性激活函數(shù)，前饋網(wǎng)絡使模型能夠在語言的復雜語義景觀中航行，促進文本的穩(wěn)健理解和生成。

四、Transformer 組件的詳細說明

要實現(xiàn)，首先運行位置編碼、多頭注意力機制和前饋網(wǎng)絡的代碼，然后是編碼器、解碼器和Transformer架構(gòu)。

#import libraries   import math   import torch   import torch.nn as nn   import torch.optim as optim   import torch.nn.functional as F   

1、位置編碼

在Transformer模型中，位置編碼是一個關(guān)鍵組件，它將關(guān)于標記位置的信息注入到輸入嵌入中。

與循環(huán)神經(jīng)網(wǎng)絡（RNNs）或卷積神經(jīng)網(wǎng)絡（CNNs）不同，由于其置換不變性，Transformers 缺乏對標記位置的內(nèi)在知識。位置編碼通過為模型提供位置信息來解決這一，使其能夠按照正確的順序處理序列。

位置編碼的概念

通常在將輸入嵌入傳入Transformer模型之前，會將位置編碼添加到嵌入中。它由一組具有不同頻率和相位的正弦函數(shù)組成，允許模型根據(jù)它們在序列中的位置區(qū)分標記。

位置編碼的公式如下

假設(shè)您有一個長度為L的輸入序列，并且需要在該序列中找到第k個對象的位置。位置編碼由不同頻率的正弦和余弦函數(shù)給出：

其中：

• k：輸入序列中對象的位置，0≤k<L/2

• d：輸出嵌入空間的維度

• P(k,j)：位置函數(shù)，用于將輸入序列中的位置k映射到位置矩陣的索引(k,j)

• n：用戶定義的標量，由《Attention Is All You Need》的作者設(shè)置為10,000。

• i：用于將列索引映射到0≤i<d/2的值，單個i值同時映射到正弦和余弦函數(shù)。

不同的位置編碼方案

在Transformer中使用了各種位置編碼方案，每種方案都有其優(yōu)點和缺點：

• 固定位置編碼：在這種方案中，位置編碼是預定義的，并對所有序列固定不變。雖然簡單高效，但固定位置編碼可能無法捕捉序列中的復雜模式。

• 學習位置編碼：另一種選擇是在訓練過程中學習位置編碼，使模型能夠自適應地從數(shù)據(jù)中捕捉位置信息。學習位置編碼提供了更大的靈活性，但需要更多的參數(shù)和計算資源。

位置編碼的實現(xiàn)

讓我們用Python實現(xiàn)位置編碼：

# 位置編碼的實現(xiàn)   class PositionalEncoding(nn.Module):       def __init__(self, d_model, max_len=5000):           super(PositionalEncoding, self).__init__()                     
 # 計算位置編碼           pe = torch.zeros(max_len, d_model)           position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)           div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-torch.log(           torch.tensor(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 + x + self.pe[:, :x.size(1)]           return x      # 示例用法   d_model = 512   max_len = 100   num_heads = 8     
  # 位置編碼   pos_encoder = PositionalEncoding(d_model, max_len)      
  # 示例輸入序列   input_sequence = torch.randn(5, max_len, d_model)      
  # 應用位置編碼   input_sequence = pos_encoder(input_sequence)   print("輸入序列的位置編碼:")   print(input_sequence.shape)   

2、多頭注意力機制

在Transformer架構(gòu)中，多頭注意力機制是一個關(guān)鍵組件，它使模型能夠同時關(guān)注輸入序列的不同部分。它允許模型捕捉序列內(nèi)的復雜依賴關(guān)系和關(guān)聯(lián)，從而提高了語言翻譯、文本生成和情感分析等任務的性能。

多頭注意力的重要性

多頭注意力機制具有幾個優(yōu)點：

• 并行化：通過同時關(guān)注輸入序列的不同部分，多頭注意力顯著加快了計算速度，使其比傳統(tǒng)的注意力機制更加高效。

• 增強表示：每個注意力頭都關(guān)注輸入序列的不同方面，使模型能夠捕捉各種模式和關(guān)系。這導致輸入的表示更豐富、更強大，增強了模型理解和生成文本的能力。

• 改進泛化性：多頭注意力使模型能夠關(guān)注序列內(nèi)的局部和全局依賴關(guān)系，從而提高了跨不同任務和領(lǐng)域的泛化性。

多頭注意力的計算：

讓我們分解計算多頭注意力所涉及的步驟：

• 線性變換：輸入序列經(jīng)歷可學習的線性變換，將其投影到多個較低維度的表示，稱為“頭”。每個頭關(guān)注輸入的不同方面，使模型能夠捕捉各種模式。

• 縮放點積注意力：每個頭地計算輸入序列的查詢、鍵和值表示之間的注意力分數(shù)。這一步涉及計算令牌及其上下文之間的相似度，乘以模型深度的平方根進行縮放。得到的注意力權(quán)重突出了每個令牌相對于其他令牌的重要性。

• 連接和線性投影：來自所有頭的注意力輸出被連接并線性投影回原始維度。這個過程將來自多個頭的見解結(jié)合起來，增強了模型理解序列內(nèi)復雜關(guān)系的能力。

用代碼實現(xiàn)

讓我們將理論轉(zhuǎn)化為代碼：

# 多頭注意力的代碼實現(xiàn)   class MultiHeadAttention(nn.Module):       def __init__(self, d_model, num_heads):           super(MultiHeadAttention, self).__init__()           self.num_heads = num_heads           self.d_model = d_model           assert d_model % num_heads == 0           self.depth = d_model // num_heads                     
 # 查詢、鍵和值的線性投影           self.query_linear = nn.Linear(d_model, d_model)           self.key_linear = nn.Linear(d_model, d_model)           self.value_linear = nn.Linear(d_model, d_model)                      
 # 輸出線性投影           self.output_linear = nn.Linear(d_model, d_model)              def split_heads(self, x):         batch_size, seq_length, d_model = x.size()         return x.view(batch_size, seq_length, self.num_heads, self.depth).transpose(1, 2)              def forward(self, query, key, value, mask=None):                      
 # 線性投影           query = self.query_linear(query)           key = self.key_linear(key)           value = self.value_linear(value)                      
 # 分割頭部           query = self.split_heads(query)           key = self.split_heads(key)           value = self.split_heads(value)                      
 # 縮放點積注意力           scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(self.depth)                      
 # 如果提供了掩碼，則應用掩碼           if mask is not None:               scores += scores.masked_fill(mask == 0, -1e9)                      # 計算注意力權(quán)重并應用softmax           attention_weights = torch.softmax(scores, dim=-1)                      
 # 應用注意力到值           attention_output = torch.matmul(attention_weights, value)                      
 # 合并頭部           batch_size, _, seq_length, d_k = attention_output.size()           attention_output = attention_output.transpose(1, 2).contiguous().view(batch_size,           seq_length, self.d_model)                      
 # 線性投影           attention_output = self.output_linear(attention_output)                      return attention_output      
 # 示例用法   d_model = 512   max_len = 100   num_heads = 8   d_ff = 2048      
 # 多頭注意力   multihead_attn = MultiHeadAttention(d_model, num_heads)      
 # 示例輸入序列   input_sequence = torch.randn(5, max_len, d_model)      
 # 多頭注意力   attention_output= multihead_attn(input_sequence, input_sequence, input_sequence)   print("attention_output shape:", attention_output.shape)   

3、前饋網(wǎng)絡

在Transformer的背景下，前饋網(wǎng)絡在處理信息和從輸入序列中提取特征方面發(fā)揮著關(guān)鍵作用。它們是模型的支柱，促進了不同層之間表示的轉(zhuǎn)換。

前饋網(wǎng)絡的作用

每個Transformer層內(nèi)的前饋網(wǎng)絡負責對輸入表示應用非線性變換。它使模型能夠捕捉數(shù)據(jù)中的復雜模式和關(guān)系，促進了高級特征的學習。

前饋層的結(jié)構(gòu)和功能

前饋層由兩個線性變換組成，兩者之間通過一個非線性激活函數(shù)（通常是ReLU）分隔。讓我們來解析一下結(jié)構(gòu)和功能：

• 線性變換1：使用可學習的權(quán)重矩陣將輸入表示投影到更高維度的空間中。

• 非線性激活：第一個線性變換的輸出通過非線性激活函數(shù)（例如ReLU）傳遞。這引入了模型的非線性，使其能夠捕捉數(shù)據(jù)中的復雜模式和關(guān)系。

• 線性變換2：激活函數(shù)的輸出然后通過另一個可學習的權(quán)重矩陣投影回原始的維度空間中。

用代碼實現(xiàn)

讓我們在Python中實現(xiàn)前饋網(wǎng)絡：

# 前饋網(wǎng)絡的代碼實現(xiàn)   class FeedForward(nn.Module):       def __init__(self, d_model, d_ff):           super(FeedForward, self).__init__()           self.linear1 = nn.Linear(d_model, d_ff)           self.linear2 = nn.Linear(d_ff, d_model)           self.relu = nn.ReLU()          def forward(self, x):           
# 線性變換1           x = self.relu(self.linear1(x))                      
# 線性變換2           x = self.linear2(x)                      return x      # 示例用法   d_model = 512   max_len = 100   num_heads = 8   d_ff = 2048     
# 多頭注意力   multihead_attn = MultiHeadAttention(d_model, num_heads)      
# 前饋網(wǎng)絡   ff_network = FeedForward(d_model, d_ff)      
# 示例輸入序列   input_sequence = torch.randn(5, max_len, d_model)      
# 多頭注意力   attention_output= multihead_attn(input_sequence, input_sequence, input_sequence)      
# 前饋網(wǎng)絡   output_ff = ff_network(attention_output)   print('input_sequence',input_sequence.shape)   print("output_ff", output_ff.shape)   

4、編碼器

在Transformer模型中起著至關(guān)重要的作用，其主要任務是將輸入序列轉(zhuǎn)換為有意義的表示，捕捉輸入的重要信息。

每個編碼器層的結(jié)構(gòu)和功能

編碼器由多個層組成，每個層依次包含以下組件：輸入嵌入、位置編碼、多頭自注意力機制和位置逐點前饋網(wǎng)絡。

1. 輸入嵌入：我們首先將輸入序列轉(zhuǎn)換為密集向量表示，稱為輸入嵌入。我們使用預訓練的詞嵌入或在訓練過程中學習的嵌入，將輸入序列中的每個單詞映射到高維向量空間中。

2. 位置編碼：我們將位置編碼添加到輸入嵌入中，以將輸入序列的順序信息合并到其中。這使得模型能夠區(qū)分序列中單詞的位置，克服了傳統(tǒng)神經(jīng)網(wǎng)絡中缺乏順序信息的問題。

3. 多頭自注意力機制：在位置編碼之后，輸入嵌入通過一個多頭自注意力機制。這個機制使編碼器能夠根據(jù)單詞之間的關(guān)系權(quán)衡輸入序列中不同單詞的重要性。通過關(guān)注輸入序列的相關(guān)部分，編碼器可以捕捉長距離的依賴關(guān)系和語義關(guān)系。

4. 位置逐點前饋網(wǎng)絡：在自注意力機制之后，編碼器對每個位置地應用位置逐點前饋網(wǎng)絡。這個網(wǎng)絡由兩個線性變換組成，兩者之間通過一個非線性激活函數(shù)（通常是ReLU）分隔。它有助于捕捉輸入序列中的復雜模式和關(guān)系。

代碼實現(xiàn)

讓我們來看一下用Python實現(xiàn)帶有輸入嵌入和位置編碼的編碼器層的代碼：

# 編碼器的代碼實現(xiàn)   class EncoderLayer(nn.Module):       def __init__(self, d_model, num_heads, d_ff, dropout):           super(EncoderLayer, self).__init__()           self.self_attention = MultiHeadAttention(d_model, num_heads)           self.feed_forward = FeedForward(d_model, d_ff)           self.norm1 = nn.LayerNorm(d_model)           self.norm2 = nn.LayerNorm(d_model)           self.dropout = nn.Dropout(dropout)              def forward(self, x, mask):                      
# 自注意力層           attention_output= self.self_attention(x, x,           x, mask)           attention_output = self.dropout(attention_output)           x = x + attention_output           x = self.norm1(x)                      
# 前饋層           feed_forward_output = self.feed_forward(x)           feed_forward_output = self.dropout(feed_forward_output)           x = x + feed_forward_output           x = self.norm2(x)                      return x      d_model = 512   max_len = 100   num_heads = 8   d_ff = 2048         
# 多頭注意力   encoder_layer = EncoderLayer(d_model, num_heads, d_ff, 0.1)      
# 示例輸入序列   input_sequence = torch.randn(1, max_len, d_model)      
# 多頭注意力   encoder_output= encoder_layer(input_sequence, None)   print("encoder output shape:", encoder_output.shape)   

5、解碼器

在Transformer模型中，解碼器在基于輸入序列的編碼表示生成輸出序列方面起著至關(guān)重要的作用。它接收來自編碼器的編碼輸入序列，并將其用于生成最終的輸出序列。

解碼器的功能

解碼器的主要功能是生成輸出序列，同時注意到輸入序列的相關(guān)部分和先前生成的標記。它利用輸入序列的編碼表示來理解上下文，并對生成下一個標記做出明智的決策。

解碼器層及其組件

解碼器層包括以下組件：

1. 輸出嵌入右移：在處理輸入序列之前，模型將輸出嵌入向右移動一個位置。這確保解碼器中的每個標記在訓練期間都能從先前生成的標記接收到正確的上下文。

2. 位置編碼：與編碼器類似，模型將位置編碼添加到輸出嵌入中，以合并標記的順序信息。這種編碼幫助解碼器根據(jù)標記在序列中的位置進行區(qū)分。

3. 掩碼的多頭自注意力機制：解碼器采用掩碼的多頭自注意力機制，以便注意輸入序列的相關(guān)部分和先前生成的標記。在訓練期間，模型應用掩碼以防止注意到未來的標記，確保每個標記只能注意到前面的標記。

4. 編碼器-解碼器注意力機制：除了掩碼的自注意力機制外，解碼器還包括編碼器-解碼器注意力機制。這種機制使解碼器能夠注意到輸入序列的相關(guān)部分，有助于生成受輸入上下文影響的輸出標記。

5. 位置逐點前饋網(wǎng)絡：在注意力機制之后，解碼器對每個標記地應用位置逐點前饋網(wǎng)絡。這個網(wǎng)絡捕捉輸入和先前生成的標記中的復雜模式和關(guān)系，有助于生成準確的輸出序列。

使用代碼實現(xiàn)

# 解碼器的代碼實現(xiàn)   class DecoderLayer(nn.Module):       def __init__(self, d_model, num_heads, d_ff, dropout):           super(DecoderLayer, self).__init__()           self.masked_self_attention = MultiHeadAttention(d_model, num_heads)           self.enc_dec_attention = MultiHeadAttention(d_model, num_heads)           self.feed_forward = FeedForward(d_model, d_ff)           self.norm1 = nn.LayerNorm(d_model)           self.norm2 = nn.LayerNorm(d_model)           self.norm3 = nn.LayerNorm(d_model)           self.dropout = nn.Dropout(dropout)          def forward(self, x, encoder_output, src_mask, tgt_mask):                      
# 掩碼的自注意力層           self_attention_output= self.masked_self_attention(x, x, x, tgt_mask)           self_attention_output = self.dropout(self_attention_output)           x = x + self_attention_output           x = self.norm1(x)                      # 編碼器-解碼器注意力層           enc_dec_attention_output= self.enc_dec_attention(x, encoder_output,            encoder_output, src_mask)           enc_dec_attention_output = self.dropout(enc_dec_attention_output)           x = x + enc_dec_attention_output           x = self.norm2(x)                      
# 前饋層           feed_forward_output = self.feed_forward(x)           feed_forward_output = self.dropout(feed_forward_output)           x = x + feed_forward_output           x = self.norm3(x)                      return x      # 定義DecoderLayer的參數(shù)   d_model = 512  
# 模型的維度   num_heads = 8  
# 注意力頭的數(shù)量   d_ff = 2048    
# 前饋網(wǎng)絡的維度   dropout = 0.1  
# 丟棄概率   batch_size = 1 
# 批量大小   max_len = 100  
# 序列的最大長度      
# 定義DecoderLayer實例   decoder_layer = DecoderLayer(d_model, num_heads, d_ff, dropout)         src_mask = torch.rand(batch_size, max_len, max_len) > 0.5   tgt_mask = torch.tril(torch.ones(max_len, max_len)).unsqueeze(0) == 0      
# 將輸入張量傳遞到DecoderLayer   output = decoder_layer(input_sequence, encoder_output, src_mask, tgt_mask)      
# 輸出形狀   print("Output shape:", output.shape)   

五、Transformer 模型架構(gòu)

前幾節(jié)討論的各種組件的綜合體。讓我們將編碼器、解碼器、注意力機制、位置編碼和前饋網(wǎng)絡的知識匯集起來，以了解完整的 Transformer 模型是如何構(gòu)建和運作的。

Transformer模型概述

在其核心，Transformer模型由編碼器和解碼器模塊堆疊在一起，用于處理輸入序列并生成輸出序列。以下是架構(gòu)的高級概述：

編碼器

• 編碼器模塊處理輸入序列，提取特征并創(chuàng)建輸入的豐富表示。

• 它由多個編碼器層組成，每個層包含自注意力機制和前饋網(wǎng)絡。

• 自注意力機制允許模型同時關(guān)注輸入序列的不同部分，捕捉依賴關(guān)系和關(guān)聯(lián)。

• 我們將位置編碼添加到輸入嵌入中，以提供有關(guān)序列中標記位置的信息。

解碼器

• 解碼器模塊以編碼器的輸出作為輸入，并生成輸出序列。

• 與編碼器類似，它由多個解碼器層組成，每個層包含自注意力、編碼器-解碼器注意力和前饋網(wǎng)絡。

• 除了自注意力外，解碼器還包含編碼器-解碼器注意力，以在生成輸出時關(guān)注輸入序列。

• 與編碼器類似，我們將位置編碼添加到輸入嵌入中，以提供位置信息。

連接和標準化

• 在編碼器和解碼器模塊的每一層之間，都有殘差連接后跟層標準化。

• 這些機制有助于在網(wǎng)絡中流動梯度，并有助于穩(wěn)定訓練。

完整的Transformer模型通過將多個編碼器和解碼器層堆疊在一起來構(gòu)建。每個層處理輸入序列，使模型能夠?qū)W習分層表示并捕獲數(shù)據(jù)中的復雜模式。編碼器將其輸出傳遞給解碼器，后者根據(jù)輸入生成最終的輸出序列。

Transformer模型的實現(xiàn)

讓我們在Python中實現(xiàn)完整的Transformer模型：

# TRANSFORMER的實現(xiàn)   class Transformer(nn.Module):       def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff,       max_len, dropout):           super(Transformer, self).__init__()              
# 定義編碼器和解碼器的詞嵌入層           self.encoder_embedding = nn.Embedding(src_vocab_size, d_model)           self.decoder_embedding = nn.Embedding(tgt_vocab_size, d_model)              
# 定義位置編碼層           self.positional_encoding = PositionalEncoding(d_model, max_len)              
# 定義編碼器和解碼器的多層堆疊           self.encoder_layers = nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout)           for _ in range(num_layers)])           self.decoder_layers = nn.ModuleList([DecoderLayer(d_model, num_heads, d_ff, dropout)           for _ in range(num_layers)])              
# 定義線性層           self.linear = nn.Linear(d_model, tgt_vocab_size)           self.dropout = nn.Dropout(dropout)          
# 生成掩碼       def generate_mask(self, src, tgt):           src_mask = (src != 0).unsqueeze(1).unsqueeze(2)           tgt_mask = (tgt != 0).unsqueeze(1).unsqueeze(3)           seq_length = tgt.size(1)           nopeak_mask = (1 - torch.triu(torch.ones(1, seq_length, seq_length), diagonal=1)).bool()           tgt_mask = tgt_mask & nopeak_mask           return src_mask, tgt_mask          
# 前向傳播       def forward(self, src, tgt):           src_mask, tgt_mask = self.generate_mask(src, tgt)              
# 編碼器輸入的詞嵌入和位置編碼           encoder_embedding = self.encoder_embedding(src)           en_positional_encoding = self.positional_encoding(encoder_embedding)           src_embedded = self.dropout(en_positional_encoding)              
# 解碼器輸入的詞嵌入和位置編碼           decoder_embedding = self.decoder_embedding(tgt)           de_positional_encoding = self.positional_encoding(decoder_embedding)           tgt_embedded = self.dropout(de_positional_encoding)              enc_output = src_embedded           for enc_layer in self.encoder_layers:               enc_output = enc_layer(enc_output, src_mask)              dec_output = tgt_embedded           for dec_layer in self.decoder_layers:               dec_output = dec_layer(dec_output, enc_output, src_mask, tgt_mask)              output = self.linear(dec_output)           return output      
# 示例用法   src_vocab_size = 5000   tgt_vocab_size = 5000   d_model = 512   num_heads = 8   num_layers = 6   d_ff = 2048   max_len = 100   dropout = 0.1      transformer = Transformer(src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers,    d_ff, max_len, dropout)      
# 生成隨機示例數(shù)據(jù)   src_data = torch.randint(1, src_vocab_size, (5, max_len))  # (batch_size, seq_length)   tgt_data = torch.randint(1, tgt_vocab_size, (5, max_len))  # (batch_size, seq_length)   transformer(src_data, tgt_data[:, :-1]).shape   

六、模型的訓練與評估

訓練Transformer模型涉及優(yōu)化其參數(shù)以最小化損失函數(shù)，通常使用梯度下降和反向傳播。一旦訓練完成，就會使用各種指標評估模型的性能，以評估其解決目標任務的有效性。

訓練過程

梯度下降和反向傳播：

• 在訓練期間，將輸入序列輸入模型，并生成輸出序列。

• 將模型的預測與地面進行比較，涉及使用損失函數(shù)（例如交叉熵損失）來衡量預測值與實際值之間的差異。

• 梯度下降用于更新模型的參數(shù)，使損失最小化的方向。

• 優(yōu)化器根據(jù)這些梯度調(diào)整參數(shù)，迭代更新它們以提高模型性能。

學習率調(diào)度：

• 可以應用學習率調(diào)度技術(shù)來動態(tài)調(diào)整訓練期間的學習率。

• 常見策略包括熱身計劃，其中學習率從低開始逐漸增加，以及衰減計劃，其中學習率隨時間降低。

評估指標

困惑度：

• 困惑度是用于評估語言模型性能的常見指標，包括Transformer。

• 它衡量模型對給定標記序列的預測能力。

• 較低的困惑度值表示更好的性能，理想值接近詞匯量大小。

BLEU分數(shù)：

• BLEU（雙語評估研究）分數(shù)通常用于評估機器翻譯文本的質(zhì)量。

• 它將生成的翻譯與一個或多個由人類翻譯人員提供的參考翻譯進行比較。

• BLEU分數(shù)范圍從0到1，較高的分數(shù)表示更好的翻譯質(zhì)量。

七、訓練和評估的實現(xiàn)

讓我們使用PyTorch對Transformer模型進行訓練和評估的基本代碼實現(xiàn)：

# Transformer 模型的訓練和評估   criterion = nn.CrossEntropyLoss(ignore_index=0)   optimizer = optim.Adam(transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)      # 訓練循環(huán)   transformer.train()      for epoch in range(10):       optimizer.zero_grad()       output = transformer(src_data, tgt_data[:, :-1])       loss = criterion(output.contiguous().view(-1, tgt_vocab_size), tgt_data[:, 1:]       .contiguous().view(-1))       loss.backward()       optimizer.step()       print(f"第 {epoch+1} 輪：損失= {loss.item():.4f}")         # 虛擬數(shù)據(jù)   src_data = torch.randint(1, src_vocab_size, (5, max_len))  # (batch_size, seq_length)   tgt_data = torch.randint(1, tgt_vocab_size, (5, max_len))  # (batch_size, seq_length)      # 評估循環(huán)   transformer.eval()   with torch.no_grad():       output = transformer(src_data, tgt_data[:, :-1])       loss = criterion(output.contiguous().view(-1, tgt_vocab_size), tgt_data[:, 1:]       .contiguous().view(-1))       print(f"\n虛擬數(shù)據(jù)的評估損失= {loss.item():.4f}")      

八、高級主題和應用

Transformers 在自然語言處理（NLP）領(lǐng)域引發(fā)了大量先進概念和應用。讓我們深入探討其中一些主題，包括不同的注意力變體、BERT（來自 Transformers 的雙向編碼器表示）和 GPT（生成式預訓練 Transformer），以及它們的實際應用。

不同的注意力變體

注意力機制是 Transformer 模型的核心，使其能夠?qū)Ｗ⒂谳斎胄蛄械南嚓P(guān)部分。各種注意力變體的提議旨在增強 Transformer 的能力。

BERT（來自 Transformers 的雙向編碼器表示）

BERT 是一個具有里程碑意義的基于 Transformer 的模型，在 NLP 領(lǐng)域產(chǎn)生了深遠影響。它通過掩碼語言建模和下一句預測等目標，在大規(guī)模文本語料庫上進行預訓練。BERT 學習了單詞的深層上下文表示，捕捉雙向上下文，使其在廣泛的下游 NLP 任務中表現(xiàn)良好。

代碼片段 - BERT 模型:

from transformers import BertModel, BertTokenizer      tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')   model = BertModel.from_pretrained('bert-base-uncased')      inputs = tokenizer("Hello, world!", return_tensors="pt")   outputs = model(**inputs)   print(outputs)   

GPT（生成式預訓練 Transformer）

GPT 是一個基于 Transformer 的模型，以其生成能力而聞名。與雙向的 BERT 不同，GPT 采用僅解碼器的架構(gòu)和自回歸訓練來生成連貫且上下文相關(guān)的文本。研究人員和開發(fā)人員已經(jīng)成功地將 GPT 應用于各種任務，如文本完成、摘要、對話生成等。

代碼片段 - GPT 模型:

from transformers import GPT2LMHeadModel, GPT2Tokenizer      tokenizer = GPT2Tokenizer.from_pretrained('gpt2')   model = GPT2LMHeadModel.from_pretrained('gpt2')      input_text = "Once upon a time, "   inputs=tokenizer(input_text,return_tensors='pt')   output=tokenizer.decode(       model.generate(           **inputs,           max_new_tokens=100,         )[0],         skip_special_tokens=True     )   input_ids = tokenizer(input_text, return_tensors='pt')      print(output)   

八、總結(jié)

Transformer 通過其捕捉上下文和理解語言的能力，徹底改變了自然語言處理（NLP）領(lǐng)域。

通過注意力機制、編碼器-解碼器架構(gòu)和多頭注意力，它們使得諸如機器翻譯和情感分析等任務得以在前所未有的規(guī)模上實現(xiàn)。隨著我們繼續(xù)探索諸如 BERT 和 GPT 等模型，很明顯，Transformer 處于語言理解和生成的前沿。

它們對 NLP 的影響深遠，而與 Transformer 一起的發(fā)現(xiàn)之旅將揭示出該領(lǐng)域更多令人矚目的進展。

如何學習AI大模型？

作為一名熱心腸的互聯(lián)網(wǎng)老兵，我決定把寶貴的AI知識分享給大家。 至于能學習到多少就看你的學習毅力和能力了 。我已將重要的AI大模型資料包括AI大模型入門學習思維導圖、精品AI大模型學習書籍手冊、視頻教程、實戰(zhàn)學習等錄播視頻免費分享出來。

一、全套AGI大模型學習路線

AI大模型時代的學習之旅：從基礎(chǔ)到前沿，掌握人工智能的核心技能！

二、0套AI大模型報告合集

這套包含0份報告的合集，涵蓋了AI大模型的理論研究、技術(shù)實現(xiàn)、行業(yè)應用等多個方面。無論您是科研人員、工程師，還是對AI大模型感興趣的愛好者，這套報告合集都將為您提供寶貴的信息和啟示。

三、AI大模型經(jīng)典PDF籍

隨著人工智能技術(shù)的飛速發(fā)展，AI大模型已經(jīng)成為了當今科技領(lǐng)域的一大熱點。這些大型預訓練模型，如GPT-3、BERT、XLNet等，以其強大的語言理解和生成能力，正在改變我們對人工智能的認識。 那以下這些PDF籍就是非常不錯的學習資源。

四、AI大模型商業(yè)化落地方案

作為普通人，入局大模型時代需要持續(xù)學習和實踐，不斷提高自己的技能和認知水平，同時也需要有責任感和倫理意識，為人工智能的健康發(fā)展貢獻力量。