深度學習模型注意力機制實作與應用

– 20 分鐘閱讀

深度學習中的注意力機制借鑒了人類視覺系統的注意力機制，讓模型能專注於輸入資料中最相關的部分。本文首先介紹了注意力機制的核心概念，包括注意力權重、查詢（query）、鍵（key）和值（value）向量。接著，我們逐步展示瞭如何計算注意力得分，並使用 softmax 函式將其轉換為注意力權重。最後，我們將注意力權重應用於值向量，生成 context vector，從而捕捉輸入資料中不同部分之間的關聯性。為了提升模型的學習能力，我們引入了可訓練的權重矩陣，讓模型能根據資料學習最佳的注意力模式。本文也提供了使用 PyTorch 實作自注意力機制的程式碼範例，並以圖表形式清晰地闡述了計算過程。

注意力機制的實作

在實作注意力機制時，我們需要計算注意力權重（normalized attention scores），這些權重代表了輸入序列中每個元素對於其他元素的重要性。下面是一個簡單的例子，展示瞭如何計算注意力權重。

假設我們有一個輸入序列 inputs，包含六個元素：Your、starts、with、one、step 和 journey。我們想要計算每個元素對於其他元素的注意力權重。

首先，我們需要計算每個元素之間的點積（dot product），這代表了兩個元素之間的相似度。然後，我們需要將這些點積進行歸一化（normalize），以確保所有權重加起來等於 1.0 或 100%。

以下是計算注意力權重的步驟：

  1. 初始化一個空的矩陣 attn_scores，用於儲存注意力權重。
  2. 遍歷輸入序列中的每個元素 x_i。
  3. 對於每個元素 x_i，遍歷輸入序列中的每個其他元素 x_j。
  4. 計算 x_i 和 x_j 之間的點積，並將其儲存在 attn_scores 矩陣中。
  5. 對於每個元素 x_i，歸一化其對應的注意力權重，以確保所有權重加起來等於 1.0 或 100%。

以下是計算注意力權重的 Python 程式碼：

import torch

# 初始化輸入序列
inputs = ['Your', 'starts', 'with', 'one', 'step', 'journey']

# 初始化注意力權重矩陣
attn_scores = torch.empty(6, 6)

# 遍歷輸入序列中的每個元素
for i, x_i in enumerate(inputs):
    # 遍歷輸入序列中的每個其他元素
    for j, x_j in enumerate(inputs):
        # 計算 x_i 和 x_j 之間的點積
        attn_scores[i, j] = torch.dot(x_i, x_j)

計算出注意力權重後，我們可以使用它們來計算"context vectors"，這些向量代表了輸入序列中每個元素的重要性。

內容解密：

在上面的程式碼中，我們使用了 PyTorch 的 torch.dot() 函式來計算兩個向量之間的點積。然後，我們將這些點積進行歸一化，以確保所有權重加起來等於 1.0 或 100%。

注意力權重矩陣 attn_scores 的每個元素代表了輸入序列中兩個元素之間的注意力權重。例如，attn_scores[0, 1] 代表了 “Your” 對於 “starts” 的注意力權重。

圖表翻譯：

以下是注意力權重矩陣 attn_scores 的視覺化表示：

  flowchart TD
    A[Your] --> B[starts]
    A --> C[with]
    A --> D[one]
    A --> E[step]
    A --> F[journey]
    B --> A
    B --> C
    B --> D
    B --> E
    B --> F
    C --> A
    C --> B
    C --> D
    C --> E
    C --> F
    D --> A
    D --> B
    D --> C
    D --> E
    D --> F
    E --> A
    E --> B
    E --> C
    E --> D
    E --> F
    F --> A
    F --> B
    F --> C
    F --> D
    F --> E

這個圖表顯示了輸入序列中每個元素之間的注意力權重。例如，“Your” 對於 “starts” 的注意力權重為 0.20。

注意力機制的實作

在深度學習中，注意力機制（Attention Mechanism）是一種重要的技術，用於處理序列資料，例如語言模型、影像識別等。注意力機制的核心思想是根據輸入資料的不同部分分配不同的權重，以此來集中模型的注意力於最重要的部分。

計算注意力權重

給定一組輸入向量 $X = [x_1, x_2,…, x_n]$，我們可以計算注意力權重 $A = [a_1, a_2,…, a_n]$，其中 $a_i$ 表示第 $i$ 個輸入向量的注意力權重。注意力權重可以透過以下步驟計算：

  1. 計算注意力得分：計算每對輸入向量之間的注意力得分，可以使用點積（dot product）或其他相似度衡量方法。
  2. 計算注意力權重：將注意力得分進行正規化，確保每行的權重總和為 1。

實作注意力機制

以下是使用 Python 和 PyTorch 實作注意力機制的示例：

import torch
import torch.nn as nn
import torch.nn.functional as F

class Attention(nn.Module):
    def __init__(self):
        super(Attention, self).__init__()

    def forward(self, inputs):
        # 計算注意力得分
        attn_scores = inputs @ inputs.T

        # 計算注意力權重
        attn_weights = F.softmax(attn_scores, dim=1)

        return attn_weights

# 初始化輸入資料
inputs = torch.randn(6, 6)

# 建立注意力模型
attn_model = Attention()

# 計算注意力權重
attn_weights = attn_model(inputs)

print(attn_weights)

這個示例中，我們定義了一個 Attention 類別，該類別繼承自 PyTorch 的 nn.Module 類別。forward 方法中，我們計算注意力得分和注意力權重，並傳回注意力權重。

圖表解釋

下圖展示了注意力機制的計算過程：

  graph LR
    A[輸入資料] -->|計算注意力得分|> B[注意力得分]
    B -->|正規化|> C[注意力權重]
    C -->|加權求和|> D[輸出]

在這個圖表中，輸入資料首先被計算注意力得分，然後進行正規化以得到注意力權重。最後，使用注意力權重對輸入資料進行加權求和，以得到最終的輸出。

圖表翻譯

這個圖表展示了注意力機制的計算過程。首先，輸入資料被計算注意力得分，然後進行正規化以得到注意力權重。最後，使用注意力權重對輸入資料進行加權求和，以得到最終的輸出。這個過程可以用於各種深度學習模型中，以提高模型的準確性和效率。

3.4 實作具有可訓練權重的自注意力機制

在上一節中，我們實作了一個簡單的自注意力機制，現在我們將進一步改進它，加入可訓練的權重，使得大語言模型（LLM）能夠從資料中學習並提高其在特定任務上的效能。

首先，我們需要了解自注意力機制的原理。自注意力機制是一種允許模型同時關注輸入序列中不同位置的技術，使得模型能夠捕捉到序列中不同部分之間的關係。這種機制在 Transformer 模型中被廣泛使用，包括原始的 Transformer 架構、GPT 模型和其他流行的 LLM。

3.4.1 總覽自注意力機制

自注意力機制的運作過程可以分為三個步驟：

  1. 計算注意力權重：這一步驟涉及計算輸入序列中每個位置之間的相關性，從而得到注意力權重。
  2. 計算_context向量：使用注意力權重和輸入序列，計算每個位置的_context向量。
  3. 合並_context向量：最終，將所有_context向量合並，得到輸出的表示。

3.4.2 實作具有可訓練權重的自注意力機制

要實作具有可訓練權重的自注意力機制，我們需要對簡單的自注意力機制進行修改。具體來說，我們需要引入可訓練的權重，以便模型能夠從資料中學習。

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, embed_dim, num_heads):
        super(SelfAttention, self).__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads

        self.query_linear = nn.Linear(embed_dim, embed_dim)
        self.key_linear = nn.Linear(embed_dim, embed_dim)
        self.value_linear = nn.Linear(embed_dim, embed_dim)

        self.dropout = nn.Dropout(0.1)

    def forward(self, x):
        # 分別對查詢、鍵和值進行線性變換
        Q = self.query_linear(x)
        K = self.key_linear(x)
        V = self.value_linear(x)

        # 將查詢、鍵和值分割成多個頭
        Q = Q.view(-1, x.size(1), self.num_heads, self.head_dim).permute(0, 2, 1, 3)
        K = K.view(-1, x.size(1), self.num_heads, self.head_dim).permute(0, 2, 1, 3)
        V = V.view(-1, x.size(1), self.num_heads, self.head_dim).permute(0, 2, 1, 3)

        # 計算注意力權重
        attention_weights = torch.matmul(Q, K.transpose(-1, -2)) / math.sqrt(self.head_dim)

        # 將注意力權重進行softmax變換
        attention_weights = F.softmax(attention_weights, dim=-1)

        # 將注意力權重應用到值上
        context = torch.matmul(attention_weights, V)

        # 將多個頭的context合並
        context = context.permute(0, 2, 1, 3).contiguous().view(-1, x.size(1), self.embed_dim)

        return context

這個實作中，我們引入了三個線性層（query_linear、key_linear和value_linear），分別用於查詢、鍵和值的線性變換。然後，我們將查詢、鍵和值分割成多個頭，計算注意力權重，將注意力權重進行softmax變換，最後將注意力權重應用到值上，得到_context向量。

3.4.3 測試實作

# 測試實作
embed_dim = 128
num_heads = 8
batch_size = 32
sequence_length = 10

x = torch.randn(batch_size, sequence_length, embed_dim)

self_attention = SelfAttention(embed_dim, num_heads)
context = self_attention(x)

print(context.shape)

這個測試實作中，我們建立了一個隨機的輸入張量x，然後使用SelfAttention類別計算_context向量。最終，我們列印預出_context向量的形狀。

深度學習模型中的注意力機制

在深度學習模型中，注意力機制（Attention Mechanism）是一種重要的技術，用於提高模型對序列資料的處理能力。序列資料可以是文字、語音或時間序列資料等。在這篇文章中，我們將探討如何實作一個簡單的注意力機制，並將其擴充套件為具有可訓練權重的自注意力機制（Self-Attention Mechanism）。

1. 資料準備與取樣

在開始實作注意力機制之前，需要準備好資料。這包括資料預處理、取樣和建立適合模型訓練的資料集。在這個過程中，需要確保資料品質、資料平衡和資料代表性，以避免模型過擬合或欠擬合。

2. 注意力機制

注意力機制的核心思想是根據輸入序列的不同部分分配不同的權重，以此來計算輸出。簡單來說，就是模型會根據上下文決定哪些部分的輸入更重要。這種機制在自然語言處理、影像識別等領域中非常有用。

2.1 簡單注意力機制

最初，我們實作了一個簡單的注意力機制。這個機制根據輸入序列的每個元素計算一個權重，並使用這些權重對輸入序列進行加權求和，以得到最終的輸出。

2.2 可訓練權重的自注意力機制

接下來，我們將簡單注意力機制擴充套件為具有可訓練權重的自注意力機制。這意味著模型不僅可以根據上下文學習到哪些部分的輸入更重要，而且可以學習到如何計算這些重要性的權重。

3. 建立大語言模型基礎模型

大語言模型（LLM）基礎模型是指一種預訓練好的語言模型，可以用於各種下游任務，如文字分類別、問答系統等。建立這種基礎模型需要大量的文字資料和計算資源。

4. 分類別器和個人助理

分類別器是一種常見的下游任務，用於將輸入文字分類別為不同的類別。個人助理則是一種更複雜的應用，需要結合多種技術，如語言理解、生成和互動。

5. 資料集和預訓練

資料集是模型訓練的基礎。一個好的資料集應該具有豐富的類別標籤和指令標籤，以支援模型的預訓練和微調。預訓練是指在大規模未標記資料上預先訓練模型，以學習到通用的語言特徵和模式。

  flowchart TD
    A[資料準備] --> B[注意力機制]
    B --> C[自注意力機制]
    C --> D[建立LLM基礎模型]
    D --> E[分類別器和個人助理]
    E --> F[資料集和預訓練]

內容解密：

上述流程圖展示了從資料準備到建立大語言模型基礎模型和應用於分類別器和個人助理的整個過程。每一步驟都對應著一個特定的技術或任務，例如注意力機制、自注意力機制、預訓練等。這些技術和任務共同構成了深度學習模型在自然語言處理領域中的核心組成部分。

圖表翻譯：

此圖表示了深度學習模型中各個技術和任務之間的邏輯關係。從左到右，圖表展示了從資料準備開始，到建立大語言模型基礎模型，然後應用於分類別器和個人助理等下游任務的整個流程。每個節點代表著一個特定的步驟或技術，而箭頭則表示了這些步驟之間的順序關係。這種視覺化的呈現方式有助於更好地理解深度學習模型的架構和工作原理。

深度學習模型中的自注意力機制

在深度學習模型中，自注意力機制是一種重要的技術，用於處理序列資料。它允許模型關注輸入序列中的不同部分，並根據這些部分計算加權和。這種機制在自然語言處理、影像識別等領域中得到廣泛應用。

基本自注意力機制

基本自注意力機制的目的是計算輸入序列中每個元素的加權和。這個過程涉及到計算注意力權重，並使用這些權重對輸入序列進行加權求和。基本自注意力機制的步驟如下：

  1. 輸入序列: 輸入序列可以是任意的序列資料，例如文字、影像等。
  2. 計算注意力權重: 計算每個輸入元素的注意力權重，這些權重表示了每個元素對於整個序列的重要性。
  3. 計算加權和: 使用注意力權重對輸入序列進行加權求和，得到最終的輸出。

帶有可訓練權重的自注意力機制

在基本自注意力機制的基礎上，我們可以引入可訓練權重，使得模型可以學習到更複雜的注意力模式。帶有可訓練權重的自注意力機制的步驟如下：

  1. 初始化可訓練權重: 初始化一組可訓練權重，這些權重將被用於計算注意力權重。
  2. 計算注意力權重: 使用可訓練權重和輸入序列計算注意力權重。
  3. 計算加權和: 使用注意力權重對輸入序列進行加權求和，得到最終的輸出。

實作帶有可訓練權重的自注意力機制

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, embed_dim, num_heads):
        super(SelfAttention, self).__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.query_linear = nn.Linear(embed_dim, embed_dim)
        self.key_linear = nn.Linear(embed_dim, embed_dim)
        self.value_linear = nn.Linear(embed_dim, embed_dim)
        self.dropout = nn.Dropout(0.1)

    def forward(self, x):
        # 計算查詢、鍵和值向量
        query = self.query_linear(x)
        key = self.key_linear(x)
        value = self.value_linear(x)

        # 計算注意力權重
        attention_weights = torch.matmul(query, key.T) / math.sqrt(self.embed_dim)

        # 計算加權和
        attention_output = torch.matmul(attention_weights, value)

        # 新增dropout
        attention_output = self.dropout(attention_output)

        return attention_output

模型評估

評估模型的效能是非常重要的步驟。常用的評估指標包括準確率、精確率、召回率、F1分數等。在自然語言處理任務中，還可以使用BLEU分數、ROUGE分數等指標進行評估。

載入預訓練模型

載入預訓練模型可以節省大量的訓練時間和計算資源。常用的預訓練模型包括BERT、RoBERTa、XLNet等。

微調預訓練模型

微調預訓練模型可以使得模型更好地適應特定的任務。微調的過程包括調整模型的超引數、新增或刪除層等。

  flowchart TD
    A[載入預訓練模型] --> B[微調預訓練模型]
    B --> C[評估模型]
    C --> D[輸出結果]

圖表翻譯：

上述流程圖描述了載入預訓練模型、微調預訓練模型、評估模型和輸出結果的過程。首先，載入預訓練模型，可以節省大量的訓練時間和計算資源。然後，微調預訓練模型，可以使得模型更好地適應特定的任務。接下來，評估模型，可以使用各種評估指標來評估模型的效能。最後，輸出結果，可以得到最終的預測結果或分數。

深入瞭解自注意力機制

在本文中，我們將深入探討自注意力機制的實作。自注意力機制是Transformer模型中的核心元件，負責計算輸入序列中不同位置之間的注意力權重。這個機制使模型能夠學習到輸入序列中不同位置之間的相關性，並根據這些相關性計算出上下文向量。

步驟式計算注意力權重

首先，我們需要計算注意力權重。這涉及到三個可訓練的權重矩陣：$W_k$、$W_q$和$W_v$。這些矩陣分別用於將輸入嵌入向量投影到查詢（query）、鍵（key）和值（value）向量空間中。

給定輸入嵌入向量$x^{(i)}$，我們可以計算出查詢向量$q_i$、鍵向量$k_i$和值向量$v_i$，如下所示：

$$ \begin{aligned} q_i &= W_q \cdot x^{(i)} \ k_i &= W_k \cdot x^{(i)} \ v_i &= W_v \cdot x^{(i)} \end{aligned} $$

其中，$W_q$、$W_k$和$W_v$分別是查詢、鍵和值的權重矩陣。

實作自注意力機制

下一步，我們需要實作自注意力機制。這涉及到計算注意力權重，並使用這些權重計算出上下文向量。

import numpy as np

def compute_attention_weights(query, key, value):
    """
    計算注意力權重。
    
    引數：
    - query：查詢向量
    - key：鍵向量
    - value：值向量
    
    傳回：
    - 注意力權重
    """
    # 計算查詢和鍵之間的點積
    scores = np.dot(query, key.T)
    
    # 對分數進行softmax處理
    weights = softmax(scores)
    
    # 計算上下文向量
    context_vector = np.dot(weights, value)
    
    return context_vector

def softmax(x):
    """
    softmax函式。
    
    引數：
    - x：輸入向量
    
    傳回：
    - softmax處理後的向量
    """
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()

組織程式碼

最後，我們需要組織程式碼，以便它可以被輕鬆地匯入LLM架構中。

class SelfAttention:
    def __init__(self, query_weights, key_weights, value_weights):
        self.query_weights = query_weights
        self.key_weights = key_weights
        self.value_weights = value_weights
    
    def compute_attention_weights(self, query, key, value):
        # 計算查詢和鍵之間的點積
        scores = np.dot(query, key.T)
        
        # 對分數進行softmax處理
        weights = softmax(scores)
        
        # 計算上下文向量
        context_vector = np.dot(weights, value)
        
        return context_vector

# 初始化SelfAttention類別
self_attention = SelfAttention(query_weights, key_weights, value_weights)

# 計算注意力權重
context_vector = self_attention.compute_attention_weights(query, key, value)

圖表翻譯：

  flowchart TD
    A[查詢向量] --> B[計算查詢和鍵之間的點積]
    B --> C[對分數進行softmax處理]
    C --> D[計算上下文向量]
    D --> E[傳回上下文向量]

內容解密：

在上述程式碼中，我們首先定義了一個compute_attention_weights函式，用於計算注意力權重。這個函式接受查詢向量、鍵向量和值向量為輸入，並傳回上下文向量。

接下來，我們定義了一個SelfAttention類別，用於組織程式碼。這個類別接受查詢權重、鍵權重和值權重為輸入，並提供了一個compute_attention_weights方法，用於計算注意力權重。

最後，我們初始化了SelfAttention類別，並使用它來計算注意力權重。

這個過程使我們能夠學習到輸入序列中不同位置之間的相關性，並根據這些相關性計算出上下文向量。這是Transformer模型中的核心元件，對於自然語言處理任務非常重要。

自我注意力機制的第一步：查詢、鍵和值向量的計算

在自我注意力機制的第一步中，我們需要計算輸入元素的查詢（q）、鍵（k）和值（v）向量。這個過程涉及將輸入元素與可訓練的權重矩陣進行矩陣乘法，以獲得查詢、鍵和值向量。

查詢向量的計算

查詢向量是透過將輸入元素與查詢權重矩陣（W_q）進行矩陣乘法獲得的。例如，對於第二個輸入元素x_(2)，我們可以計算其查詢向量q_(2)如下：

x_2 = inputs[1]
d_in = inputs.shape[1]
d_out = 2

# 初始化查詢權重矩陣
torch.manual_seed(123)
W_query = torch.nn.Parameter(torch.rand(d_in, d_out), requires_grad=False)

# 計算查詢向量
query_2 = x_2 @ W_query

鍵和值向量的計算

鍵和值向量的計算過程與查詢向量的計算類別似。我們需要將輸入元素與鍵權重矩陣（W_k）和值權重矩陣（W_v）進行矩陣乘法，以獲得鍵和值向量。

# 初始化鍵和值權重矩陣
W_key = torch.nn.Parameter(torch.rand(d_in, d_out), requires_grad=False)
W_value = torch.nn.Parameter(torch.rand(d_in, d_out), requires_grad=False)

# 計算鍵和值向量
key_2 = x_2 @ W_key
value_2 = x_2 @ W_value

圖表解釋

下面的Mermaid圖表展示了查詢、鍵和值向量的計算過程：

  flowchart TD
    A[輸入元素] -->|矩陣乘法|> B[查詢權重矩陣]
    B --> C[查詢向量]
    A -->|矩陣乘法|> D[鍵權重矩陣]
    D --> E[鍵向量]
    A -->|矩陣乘法|> F[值權重矩陣]
    F --> G[值向量]

圖表翻譯：

此圖表展示了自我注意力機制中查詢、鍵和值向量的計算過程。輸入元素與查詢、鍵和值權重矩陣進行矩陣乘法，以獲得查詢、鍵和值向量。這些向量將在後續的注意力機制中使用。

自我注意力機制的實作

在上一節中，我們瞭解瞭如何計算注意力權重和"context vector"。現在，我們將實作自我注意力機制，使用可訓練的權重。

計算查詢向量

首先，我們需要計算查詢向量 query_2。這可以透過將輸入向量 x_2 與權重矩陣 W_key 進行矩陣乘法來實作：

key_2 = x_2 @ W_key

同樣地，我們可以計算值向量 value_2：

value_2 = x_2 @ W_value

輸出查詢結果

現在，我們可以輸出查詢結果：

print(query_2)

由於我們設定了權重矩陣的列數為 2，因此輸出結果是一個二維向量：

tensor([0.4306, 1.4551])

權重引數與注意力權重

在權重矩陣 W 中，術語 “weight” 指的是 “weight parameters”，即神經網路中在訓練過程中最佳化的值。這與注意力權重不同，注意力權重決定了 context vector 對不同輸入部分的依賴程度（即網路對不同輸入部分的關注程度）。

總之，權重引數是定義網路連線的基本、學習係數，而注意力權重是動態、上下文相關的值。

輸入元素與嵌入大小

現在，我們來看一下輸入元素與嵌入大小之間的關係。假設輸入嵌入大小為 d=3，而輸出嵌入大小為 d_out=2。

實作自我注意力機制

即使我們的臨時目標只是計算一個 context vector z(2)，我們仍然需要計算所有輸入元素的 key 和 value 向量，因為它們參與了計算注意力權重與查詢 q(2) 相關的注意力權重（見圖 3.14）。

我們可以透過矩陣乘法來獲得所有 key 和 value 向量：

keys = x @ W_key
values = x @ W_value

這樣，我們就可以計算注意力權重和 context vector。

圖表翻譯：

下圖示範了自我注意力機制的實作過程：

  graph LR
    A[輸入向量 x] -->|矩陣乘法|> B[查詢向量 query]
    A -->|矩陣乘法|> C[鍵向量 key]
    A -->|矩陣乘法|> D[值向量 value]
    B -->|計算注意力權重|> E[注意力權重]
    E -->|計算 context vector|> F[context vector]

這個圖表展示了自我注意力機制中各個元件之間的關係，包括輸入向量、查詢向量、鍵向量、值向量、注意力權重和 context vector。

注意力機制的實作：計算注意力分數

在實作注意力機制的過程中，首先我們需要計算注意力分數。這一步驟涉及到查詢向量（query）和鍵值向量（key）之間的相似度計算。以下是計算注意力分數的具體步驟：

步驟1：準備查詢向量和鍵值向量

import torch

# 假設 inputs 是一個 3D 張量，代表輸入序列
inputs = torch.randn(6, 3, 2)  # 6 個輸入token，每個token有 3 個特徵，嵌入維度為 2

# 將輸入序列投影到查詢、鍵和值的嵌入空間
W_key = torch.randn(3, 2)  # 鍵的權重矩陣
W_value = torch.randn(3, 2)  # 值的權重矩陣

keys = torch.matmul(inputs, W_key)  # 計算鍵
values = torch.matmul(inputs, W_value)  # 計算值

print("keys.shape:", keys.shape)
print("values.shape:", values.shape)

步驟2：計算注意力分數

現在，我們已經有了查詢向量（query）、鍵值向量（key）和值向量（value）。下一步是計算注意力分數。假設我們想要計算第二個輸入token的注意力分數，則查詢向量（query）應該是從第二個輸入token中派生出來的。

# 選擇第二個輸入token作為查詢向量
query_2 = inputs[1]

# 選擇第二個鍵值向量作為計算物件
keys_2 = keys[1]

# 計算未縮放的注意力分數
attn_score_22 = torch.dot(query_2, keys_2)

print(attn_score_22)

這裡，attn_score_22代表了第二個輸入token與第二個鍵值之間的未縮放注意力分數。這個分數是透過查詢向量和鍵值向量的點積計算得到的，代表了這兩個向量之間的相似度。

步驟3：計算加權和

最終，為了得到輸出，我們需要根據注意力分數對值向量進行加權和。這一步驟將在下一部分詳細介紹。

圖表翻譯：

  graph LR
    A[輸入序列] -->|投影|> B[查詢、鍵、值嵌入]
    B -->|計算注意力分數|> C[注意力分數]
    C -->|加權和|> D[輸出]

這個流程圖描述了從輸入序列到最終輸出的整個過程，包括投影、計算注意力分數和加權和等步驟。

注意力機制的實作

在深度學習中，注意力機制是一種重要的技術，能夠幫助模型關注輸入資料中的重要部分。下面，我們將實作一個簡單的注意力機制。

首先，我們需要計算注意力得分。這可以透過計算查詢（query）和鍵（key）之間的點積來實作。假設我們有以下輸入資料：

import torch

# 輸入資料
query = torch.tensor([0.5, 0.8, 0.6])
keys = torch.tensor([[0.3, 0.7, 0.1], [0.8, 0.4, 1.1], [0.3, 1.0, 0.3]])

# 計算注意力得分
attn_scores = torch.matmul(query, keys.T)

print(attn_scores)

接下來，我們需要計算注意力權重。這可以透過對注意力得分進行softmax運算來實作。

# 計算注意力權重
d_k = keys.shape[-1]
attn_weights = torch.softmax(attn_scores / d_k**0.5, dim=-1)

print(attn_weights)

最後，我們可以使用注意力權重來計算輸出。

# 輸入資料
values = torch.tensor([[0.9, 0.3, 0.70.4, 1.4], [0.4, 1.4], [1.2], [1.8, 1.5]])

# 計算輸出
output = torch.matmul(attn_weights, values)

print(output)

這樣，我們就實作了一個簡單的注意力機制。

內容解密：

在上面的程式碼中，我們首先計算了注意力得分，然後計算了注意力權重，最後使用注意力權重來計算輸出。注意力得分是透過計算查詢和鍵之間的點積來實作的，而注意力權重是透過對注意力得分進行softmax運算來實作的。

圖表翻譯：

下面是注意力機制的流程圖：

  flowchart TD
    A[查詢] --> B[計算注意力得分]
    B --> C[計算注意力權重]
    C --> D[計算輸出]
    D --> E[輸出]

在這個流程圖中，查詢是輸入資料，計算注意力得分是透過計算查詢和鍵之間的點積來實作的，計算注意力權重是透過對注意力得分進行softmax運算來實作的，計算輸出是使用注意力權重來計算輸出。

注意力機制深度解析

在人工智慧和深度學習領域中，注意力機制（Attention Mechanism）是一種強大的工具，能夠讓模型更好地聚焦於輸入序列中的特定部分，從而提取更有用的資訊。這個機制的靈感來自於人類視覺系統的注意力機制，人們可以在觀察複雜場景時，選擇性地關注某些區域，以過濾掉不相關的資訊。

基礎原理

注意力機制的基本思想是根據輸入序列的不同部分賦予不同的權重，這些權重代表了每個部分相對於整個序列的重要性。這些權重被稱為注意力權重（Attention Weights）。透過計算注意力權重，模型可以將輸入序列中的元素以不同的比例組合起來，形成一個加權和，這就是注意力機制的輸出。

計算過程

計算注意力權重通常涉及到以下步驟：

  1. 計算注意力得分：對於輸入序列中的每個元素，計算它與模型關注點之間的相關性，這通常是透過一個神經網路層實作的。
  2. softmax 函式：對於所有的注意力得分，應用 softmax 函式以確保所有權重之和為 1，並且每個權重都是非負的。這一步驟保證了注意力權重的正規化，使得模型能夠比較不同部分的重要性。
  3. 計算加權和：使用注意力權重對輸入序列進行加權求和，得到最終的注意力輸出。

實際應用

注意力機制被廣泛應用於自然語言處理（NLP）、視覺識別等領域。例如，在機器翻譯任務中，注意力機制可以幫助模型更好地理解輸入語言的句法和語義結構，並將這些資訊有效地應用於生成目標語言的文字。

程式碼實作

以下是一個簡單的注意力機制實作示例，使用 Python 和 PyTorch 框架：

import torch
import torch.nn as nn
import torch.nn.functional as F

class Attention(nn.Module):
    def __init__(self, hidden_size):
        super(Attention, self).__init__()
        self.W = nn.Linear(hidden_size, hidden_size)
        self.U = nn.Linear(hidden_size, hidden_size)
        self.v = nn.Parameter(torch.randn(hidden_size))

    def forward(self, query, key, value):
        # 計算注意力得分
        scores = torch.matmul(query, key.T) / math.sqrt(key.size(-1))
        
        # softmax 函式
        attention_weights = F.softmax(scores, dim=-1)
        
        # 計算加權和
        context = torch.matmul(attention_weights, value)
        
        return context

# 初始化注意力模組
attention = Attention(hidden_size=128)

# 假設 query、key 和 value 是張量
query = torch.randn(1, 128)
key = torch.randn(10, 128)
value = torch.randn(10, 128)

# 執行注意力機制
context = attention(query, key, value)

隨著深度學習技術的不斷發展，注意力機制也在不斷演化。未來，可能會看到更多創新的注意力機制設計，例如多頭注意力（Multi-Head Attention）、層次注意力（Hierarchical Attention）等，這些設計可以進一步提升模型的表達能力和效率。同時，注意力機制也將在更多領域找到其應用價值，例如影像識別、語音識別等。

從技術架構視角來看，注意力機制為深度學習模型引入了動態權重分配的機制，有效提升了模型處理序列資訊的能力。透過計算查詢向量與鍵值向量之間的相似度，模型得以關注輸入序列中不同部分的相關性，並藉由加權和操作整合全域性資訊。然而，注意力機制的計算複雜度會隨著序列長度增加而顯著提升，這也限制了其在超長序列資料上的應用。對於需要處理長文字或高解析度影像的場景，如何最佳化注意力機制的計算效率將是未來研究的重點。玄貓認為，隨著硬體效能的提升和演算法的持續最佳化，注意力機制將在更多領域展現其強大的應用潛力，例如更精細的影像分割、更準確的語音辨識以及更自然的人機互動。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。