深入理解 BigBird 的塊稀疏注意力

HuggingFace發表於2023-11-24

引言

基於 transformer 的模型已被證明對很多 NLP 任務都非常有用。然而，\(O(n^2)\) 的時間和記憶體複雜度 (其中 \(n\) 是序列長度) 使得在長序列 (\(n > 512\)) 上應用它們變得非常昂貴，因而大大限制了其應用。最近的幾篇論文，如 Longformer 、Performer 、Reformer 、簇狀注意力 都試圖透過對完整注意力矩陣進行近似來解決這個問題。如果你不熟悉這些模型，可以檢視 ? 之前的 博文。

BigBird (由 該論文 引入) 是解決這個問題的最新模型之一。 BigBird 依賴於 塊稀疏注意力 而不是普通注意力 ( 即 BERT 的注意力)，與 BERT 相比，這一新演算法能以低得多的計算成本處理長達 4096 的序列。在涉及很長序列的各種任務上，該模型都實現了 SOTA，例如長文件摘要、長上下文問答。

RoBERTa 架構的 BigBird 模型現已整合入 ? transformers 中。本文的目的是讓讀者 深入 瞭解 BigBird 的實現，並讓讀者能在 ? transformers 中輕鬆使用 BigBird。但是，在更深入之前，一定記住 BigBird 注意力只是 BERT 完全注意力的一個近似，因此我們並不糾結於讓它比 BERT 完全注意力 更好，而是致力於讓它更有效率。有了它，transformer 模型就可以作用於更長的序列，因為 BERT 的二次方記憶體需求很快會變得難以為繼。簡而言之，如果我們有 \(\infty\) 計算和 \(\infty\) 時間，那麼用 BERT 注意力就好了，完全沒必要用本文討論的塊稀疏注意力。

如果你想知道為什麼在處理較長序列時需要更多計算，那麼本文正合你意！

在使用標準的 BERT 類注意力時可能會遇到以下幾個主要問題:

  • 每個詞元真的都必須關注所有其他詞元嗎？
  • 為什麼不只計算重要詞元的注意力？
  • 如何決定哪些詞元重要？
  • 如何以高效的方式處理少量詞元？

本文，我們將嘗試回答這些問題。

應該關注哪些詞元？

下面，我們將以句子 BigBird is now available in HuggingFace for extractive Question Answering 為例來說明注意力是如何工作的。在 BERT 這類的注意力機制中，每個詞元都簡單粗暴地關注所有其他詞元。從數學上來講，這意味著每個查詢的詞元 $ \text{query-token} \in {\text{BigBird},\text{is},\text{now},\text{available},\text{in},\text{HuggingFace},\text{for},\text{extractive},\text{question},\text{answering}} $,
將關注每個鍵詞元 \(\text{key-tokens} = \left[\text{BigBird},\text{is},\text{now},\text{available},\text{in},\text{HuggingFace},\text{for},\text{extractive},\text{question},\text{answering} \right]\)。

我們考慮一下 每個查詢詞元應如何明智地選擇它實際上應該關注的鍵詞元 這個問題，下面我們透過編寫虛擬碼的方式來整理思考過程。

假設 available 是當前查詢詞元，我們來構建一個合理的、需要關注的鍵詞元列表。

# 以下面的句子為例
example = ['BigBird', 'is', 'now', 'available', 'in', 'HuggingFace', 'for', 'extractive', 'question', 'answering']

# 假設當前需要計算 'available' 這個詞的表徵
query_token = 'available'

# 初始化一個空集合，用於放 'available' 這個詞的鍵詞元
key_tokens = [] # => 目前，'available' 詞元不關注任何詞元

鄰近詞元當然很重要，因為在一個句子 (單詞序列) 中，當前詞高度依賴於前後的鄰近詞。滑動注意力 即基於該直覺。

# 考慮滑動窗大小為 3, 即將 'available' 的左邊一個詞和右邊一個詞納入考量
# 左詞: 'now'; 右詞: 'in'
sliding_tokens = ["now", "available", "in"]

# 用以上詞元更新集合
key_tokens.append(sliding_tokens)

長程依賴關係: 對某些任務而言，捕獲詞元間的長程關係至關重要。 例如 ，在問答類任務中，模型需要將上下文的每個詞元與整個問題進行比較，以便能夠找出上下文的哪一部分對正確答案有用。如果大多數上下文詞元僅關注其他上下文詞元，而不關注問題，那麼模型從不太重要的上下文詞元中過濾重要的上下文詞元就會變得更加困難。

BigBird 提出了兩種允許長程注意力依賴的方法，這兩種方法都能保證計算效率。

  • 全域性詞元: 引入一些詞元，這些詞元將關注每個詞元並且被每個詞元關注。例如，對 “HuggingFace is building nice libraries for easy NLP” ，現在假設 'building' 被定義為全域性詞元，而對某些任務而言，模型需要知道 'NLP' 和 'HuggingFace' 之間的關係 (注意: 這 2 個詞元位於句子的兩端); 現在讓 'building' 在全域性範圍內關注所有其他詞元，會對模型將 'NLP' 與 'HuggingFace' 關聯起來有幫助。
# 我們假設第一個和最後一個詞元是全域性的，則有:
global_tokens = ["BigBird", "answering"]

# 將全域性詞元加入到集合中
key_tokens.append(global_tokens)
  • 隨機詞元: 隨機選擇一些詞元，這些詞元將透過關注其他詞元來傳輸資訊，而那些詞元又可以傳輸資訊到其他詞元。這可以降低直接從一個詞元到另一個詞元的資訊傳輸成本。
# 現在，我們可以從句子中隨機選擇 `r` 個詞元。這裡，假設 `r` 為 1， 選擇了 `is` 這個詞元
>>> random_tokens = ["is"] # 注意: 這個是完全隨機選擇的，因此可以是任意詞元。

# 將隨機詞元加入到集合中
key_tokens.append(random_tokens)

# 現在看下 `key_tokens` 集合中有哪些詞元
key_tokens
{'now', 'is', 'in', 'answering', 'available', 'BigBird'}

# 至此，查詢詞 'available' 僅關注集合中的這些詞元，而不用關心全部

這樣，查詢詞元僅關注所有詞元的一個子集，該子集能夠產生完全注意力值的一個不錯的近似。相同的方法將用於所有其他查詢詞元。但請記住，這裡的重點是儘可能有效地接近 BERT 的完全注意力。BERT 那種簡單地讓每個查詢詞元關注所有鍵詞元的做法可以建模為一系列矩陣乘法，從而在現代硬體 (如 GPU) 上進行高效計算。然而，滑動、全域性和隨機注意力的組合似乎意味著稀疏矩陣乘法，這在現代硬體上很難高效實現。BigBird 的主要貢獻之一是提出了 塊稀疏 注意力機制，該機制可以高效計算滑動、全域性和隨機注意力。我們來看看吧！

圖解全域性、滑動、隨機注意力的概念

首先，我們藉助圖來幫助理解“全域性”、“滑動”和“隨機”注意力，並嘗試理解這三種注意力機制的組合是如何較好地近似標準 BERT 類注意力的。

深入理解 BigBird 的塊稀疏注意力 深入理解 BigBird 的塊稀疏注意力 深入理解 BigBird 的塊稀疏注意力

上圖分別把“全域性”(左) 、“滑動”(中) 和“隨機”(右) 連線建模成一個圖。每個節點對應一個詞元，每條邊代表一個注意力分數。如果 2 個詞元之間沒有邊連線，則其注意力分數為 0。

深入理解 BigBird 的塊稀疏注意力

BigBird 塊稀疏注意力 是滑動連線、全域性連線和隨機連線 (總共 10 個連線) 的組合，如上圖左側動圖所示。而 完全注意力 圖 (右側) 則是有全部 15 個連線 (注意: 總共有 6 個節點)。你可以簡單地將完全注意力視為所有詞元都是全域性詞元 \({}^1\)。

完全注意力: 模型可以直接在單個層中將資訊從一個詞元傳輸到另一個詞元，因為每個詞元都會對每個其他詞元進行查詢，並且受到其他每個詞元的關注。我們考慮一個與上圖類似的例子，如果模型需要將 'going' 與 'now' 關聯起來，它可以簡單地在單層中執行此操作，因為它們兩個是有直接連線的。

塊稀疏注意力: 如果模型需要在兩個節點 (或詞元) 之間共享資訊，則對於某些詞元，資訊將必須經過路徑中的各個其他節點; 因為不是所有節點都有直接連線的。
例如 ，假設模型需要將 going 與 now 關聯起來，那麼如果僅存在滑動注意力，則這兩個詞元之間的資訊流由路徑 going -> am -> i -> now 來定義，也就是說它必須經過 2 個其他詞元。因此，我們可能需要多個層來捕獲序列的全部資訊，而正常的注意力可以在單層中捕捉到這一點。在極端情況下，這可能意味著需要與輸入詞元一樣多的層。然而，如果我們引入一些全域性詞元，資訊可以透過以下路徑傳播 going -> i -> now ，這可以幫助縮短路徑。如果我們再另外引入隨機連線，它就可以透過 going -> am -> now 傳播。藉助隨機連線和全域性連線，資訊可以非常快速地 (只需幾層) 從一個詞元傳輸到下一個詞元。

如果我們有很多全域性詞元，那麼我們可能不需要隨機連線，因為資訊可以透過多個短路徑傳播。這就是在使用 BigBird 的變體 (稱為 ETC) 時設定 num_random_tokens = 0 的動機 (稍後部分將會詳細介紹)。

\({}^1\) 在這些圖中，我們假設注意力矩陣是對稱的 即 \(\mathbf{A} _{ij} = \mathbf{A}_ {ji}\) 因為在圖中如果某個詞元 A 關注 B，那麼 B 也會關注 A。從下一節所示的注意力矩陣圖中可以看出，這個假設對於 BigBird 中的大多數詞元都成立。

注意力型別 全域性次元 滑動詞元 隨機詞元
原始完全注意力 n 0 0
塊稀疏注意力 2 x block_size 3 x block_size num_random_blocks x block_size

原始完全注意力即 BERT 的注意力，而塊稀疏注意力則是 BigBird 的注意力。想知道 block_size 是什麼？請繼續閱讀下文。現在，為簡單起見，將其視為 1。

BigBird 塊稀疏注意力

BigBird 塊稀疏注意力是我們上文討論的內容的高效實現。每個詞元都關注某些 全域性詞元 、 滑動詞元 和 隨機詞元，而不管其他 所有 詞元。作者分別實現了每類查詢注意力矩陣，並使用了一個很酷的技巧來加速 GPU 和 TPU 上的訓練/推理。

BigBird 塊稀疏注意力

注意: 在上圖的頂部有 2 個額外的句子。正如你所注意到的，兩個句子中的每個詞元都只是交換了一個位置。這就是滑動注意力的實現方式。當 q[i] 與 k[i,0:3] 相乘時，我們會得到 q[i] 的滑動注意力分數 (其中i 是序列中元素的索引)。

你可以在 這兒 找到 block_sparse 注意力的具體實現。現在看起來可能非常可怕??，但這篇文章肯定會讓你輕鬆理解它。

全域性注意力

對於全域性注意力而言，每個查詢詞元關注序列中的所有其他詞元，並且被其他每個詞元關注。我們假設 Vasudev (第一個詞元) 和 them (最後一個詞元) 是全域性的 (如上圖所示)。你可以看到這些詞元直接連線到所有其他詞元 (藍色框)。

# 虛擬碼

Q -> Query martix (seq_length, head_dim)
K -> Key matrix (seq_length, head_dim)

# 第一個和最後一個詞元關注所有其他詞元
Q[0] x [K[0], K[1], K[2], ......, K[n-1]]
Q[n-1] x [K[0], K[1], K[2], ......, K[n-1]]

# 第一個和最後一個詞元也被其他所有詞元關注
K[0] x [Q[0], Q[1], Q[2], ......, Q[n-1]]
K[n-1] x [Q[0], Q[1], Q[2], ......, Q[n-1]]

滑動注意力

鍵詞元序列被複制兩次，其中一份每個詞元向右移動一步，另一份每個詞元向左移動一步。現在，如果我們將查詢序列向量乘以這 3 個序列向量，我們將覆蓋所有滑動詞元。計算複雜度就是 O(3n) = O(n) 。參考上圖，橙色框代表滑動注意力。你可以在圖的頂部看到 3 個序列，其中 2 個序列各移動了一個詞元 (1 個向左，1 個向右)。

# 我們想做的
Q[i] x [K[i-1], K[i], K[i+1]] for i = 1:-1

# 高效的程式碼實現 (? 乘法為點乘)
[Q[0], Q[1], Q[2], ......, Q[n-2], Q[n-1]] x [K[1], K[2], K[3], ......, K[n-1], K[0]]
[Q[0], Q[1], Q[2], ......, Q[n-1]] x [K[n-1], K[0], K[1], ......, K[n-2]]
[Q[0], Q[1], Q[2], ......, Q[n-1]] x [K[0], K[1], K[2], ......, K[n-1]]

# 每個序列被乘 3 詞， 即 `window_size = 3`。為示意，僅列出主要計算，省略了一些計算。

隨機注意力

隨機注意力確保每個查詢詞元也會關注一些隨機詞元。對實現而言，這意味著模型隨機選取一些詞元並計算它們的注意力分數。

# r1, r2, r 為隨機索引; 注意 r1, r2, r 每行取值不同 ?
Q[1] x [Q[r1], Q[r2], ......, Q[r]]
.
.
.
Q[n-2] x [Q[r1], Q[r2], ......, Q[r]]

# 不用管第 0 個和第 n-1 個詞元，因為它們已經是全域性詞元了。

注意: 當前的實現進一步將序列劃分為塊，並且每個符號都依塊而定義而非依詞元而定義。我們在下一節中會更詳細地討論這個問題。

實現

回顧: 在常規 BERT 注意力中，一系列詞元，即 \(X = x_1, x_2, …., x_n\) 透過線性層投影到 \(Q，K，V\)，並基於它們計算注意力分數 \(Z\)，公式為 \(Z=Softmax(QK^T)\)。使用 BigBird 塊稀疏注意力時，我們使用相同的演算法，但僅針對一些選定的查詢和鍵向量進行計算。

我們來看看 BigBird 塊稀疏注意力是如何實現的。首先，我們用 \(b、r、s、g\) 分別代表 block_size 、num_random_blocks 、num_sliding_blocks 、num_global_blocks 。我們以 \(b=4，r=1，g=2，s=3，d=5\) 為例來說明 BigBird 塊稀疏注意力的機制部分，如下所示:

深入理解 BigBird 的塊稀疏注意力

\({q} _{1}、{q}_ {2}、{q} _{3:n-2}、{q}_ {n-1}、{q}_{n}\) 的注意力分數分別計算如下:

\(\mathbf{q}_{1}\) 的注意力分數由 \(a_1\) 表示，其中 \(a_1=Softmax(q_1 * K^T)\)，即為第一塊中的所有詞元與序列中的所有其他詞元之間的注意力分數。

BigBird 塊稀疏注意力

\(q_1\) 表示第 1 塊，\(g_i\) 表示第 \(i\) 塊。我們僅在 \(q_1\) 和 \(g\) (即所有鍵) 之間執行正常的注意力操作。

為了計算第二塊中詞元的注意力分數，我們收集前三塊、最後一塊和第五塊。然後我們可以計算 \(a_2 = Softmax(q_2 * concat(k_1, k_2, k_3, k_5, k_7))\)。

BigBird 塊稀疏注意力

這裡，我用 \(g，r，s\) 表示詞元只是為了明確地表示它們的性質 (即是全域性、隨機還是滑動詞元)，只用 \(k\) 無法表示他們各自的性質。

為了計算 \({q} _{3:n-2}\) 的注意力分數，我們先收集相應的全域性、滑動、隨機鍵向量，並基於它們正常計算 \({q}_ {3:n-2}\) 上的注意力。請注意，正如前面滑動注意力部分所討論的，滑動鍵是使用特殊的移位技巧來收集的。

BigBird 塊稀疏注意力

為了計算倒數第二塊 (即 \({q} _{n-1}\)) 中詞元的注意力分數，我們收集第一塊、最後三塊和第三塊的鍵向量。然後我們用公式 \({a}_ {n-1} = Softmax({q}_{n-1} * concat(k_1, k_3, k_5, k_6, k_7))\) 進行計算。這和計算 \(q_2\) 非常相似。

BigBird 塊稀疏注意力

最後一塊 \(\mathbf{q}_{n}\) 的注意力分數由 \(a_n\) 表示，其中 \(a_n=Softmax(q_n * K^T)\)，只不過是最後一塊中的所有詞元與序列中的所有其他詞元之間的注意力分數。這與我們對 \(q_1\) 所做的非常相似。

BigBird 塊稀疏注意力

我們將上面的矩陣組合起來得到最終的注意力矩陣。該注意力矩陣可用於獲取所有詞元的表徵。

BigBird 塊稀疏注意力

上圖中 藍色 -> 全域性塊 、紅色 -> 隨機塊 、橙色 -> 滑動塊 。在前向傳播過程中，我們不儲存“白色”塊，而是直接為每個單獨的部分計算加權值矩陣 (即每個詞元的表示)，如上所述。

現在，我們已經介紹了塊稀疏注意力最難的部分，即它的實現。希望對你更好地理解實際程式碼有幫助。現在你可以深入研究程式碼了，在此過程中你可以將程式碼的每個部分與上面的某個部分聯絡起來以助於理解。

時間和記憶體複雜度

注意力型別 序列長度 時間和記憶體複雜度
原始完全注意力 512 T
1024 4 x T
4096 64 x T
塊稀疏注意力 1024 2 x T
4096 8 x T

BERT 注意力和 BigBird 塊稀疏注意力的時間和空間複雜度之比較。

展開以瞭解複雜度的計算過程。 
BigBird 時間複雜度 = O(w x n + r x n + g x n)
BERT 時間複雜度 = O(n^2)

假設:
    w = 3 x 64
    r = 3 x 64
    g = 2 x 64

當序列長度為 512 時
=> **BERT 時間複雜度 = 512^2**

當序列長度為 1024 時
=> BERT 時間複雜度 = (2 x 512)^2
=> **BERT 時間複雜度 = 4 x 512^2**

=> BigBird 時間複雜度 = (8 x 64) x (2 x 512)
=> **BigBird 時間複雜度 = 2 x 512^2**

當序列長度為 4096 時
=> BERT 時間複雜度 = (8 x 512)^2
=> **BERT 時間複雜度 = 64 x 512^2**

=> BigBird 時間複雜度 = (8 x 64) x (8 x 512)
=> BigBird 時間複雜度 = 8 x (512 x 512)
=> **BigBird 時間複雜度 = 8 x 512^2**

ITC 與 ETC

BigBird 模型可以使用 2 種不同的策略進行訓練: ITC 和 ETC。 ITC (internal transformer construction，內部 transformer 構建) 就是我們上面討論的。在 ETC (extended transformer construction，擴充套件 transformer 構建) 中，會有更多的全域性詞元，以便它們關注所有詞元或者被所有詞元關注。

ITC 需要的計算量較小，因為很少有詞元是全域性的，同時模型可以捕獲足夠的全域性資訊 (也可以藉助隨機注意力)。而 ETC 對於需要大量全域性詞元的任務非常有幫助，例如對 問答 類任務而言，整個問題應該被所有上下文關注，以便能夠將上下文正確地與問題相關聯。

注意: BigBird 論文顯示，在很多 ETC 實驗中，隨機塊的數量設定為 0。考慮到我們上文圖解部分的討論，這是合理的。

下表總結了 ITC 和 ETC:

ITC ETC
全域性注意力的注意力矩陣 \( A = \begin{bmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 \ 1 & & & & & & 1 \ 1 & & & & & & 1 \ 1 & & & & & & 1 \ 1 & & & & & & 1 \ 1 & & & & & & 1 \ 1 & 1 & 1 & 1 & 1 & 1 & 1 \end{bmatrix} \) \( B = \begin{bmatrix} 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \ 1 & 1 & 1 & & & & & & 1 \ 1 & 1 & 1 & & & & & & 1 \ 1 & 1 & 1 & & & & & & 1 \ 1 & 1 & 1 & & & & & & 1 \ 1 & 1 & 1 & & & & & & 1 \ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \end{bmatrix} \)
全域性詞元 2 x block_size extra_tokens + 2 x block_size
隨機詞元 num_random_blocks x block_size num_random_blocks x block_size
滑動詞元 3 x block_size 3 x block_size

在 ?Transformers 中使用 BigBird

你可以像使用任何其他 ? 模型一樣使用 BigBirdModel 。我們看一下程式碼:

from transformers import BigBirdModel

# 從預訓練 checkpoint 中載入 bigbird 模型
model = BigBirdModel.from_pretrained("google/bigbird-roberta-base")
# 使用預設配置初始化模型，如 attention_type = "block_sparse"，num_random_blocks = 3，block_size = 64
# 你也可以按照自己的需要改變這些引數。這 3 個引數只改變每個查詢詞元關注的詞元數。
model = BigBirdModel.from_pretrained("google/bigbird-roberta-base", num_random_blocks=2, block_size=16)

# 透過把 attention_type 設成 `original_full`，BigBird 就會用複雜度為 n^2 的完全注意力。此時，BigBird 與 BERT 相似度為 99.9%。
model = BigBirdModel.from_pretrained("google/bigbird-roberta-base", attention_type="original_full")

截至現在， ? Hub 中總共有 3 個 BigBird checkpoint: bigbird-roberta-base，bigbird-roberta-large 以及 bigbird-base-trivia-itc。前兩個檢查點是使用 masked_lm 損失 預訓練 BigBirdForPretraining 而得; 而最後一個是在 trivia-qa 資料集上微調 BigBirdForQuestionAnswering 而得。

讓我們看一下如果用你自己喜歡的 PyTorch 訓練器，最少需要多少程式碼就可以使用 ? 的 BigBird 模型來微調你自己的任務。

# 以問答任務為例
from transformers import BigBirdForQuestionAnswering, BigBirdTokenizer
import torch

device = torch.device("cpu")
if torch.cuda.is_available():
    device = torch.device("cuda")

# 我們用預訓練權重初始化 bigbird 模型，並隨機初始化其頭分類器
model = BigBirdForQuestionAnswering.from_pretrained("google/bigbird-roberta-base", block_size=64, num_random_blocks=3)
tokenizer = BigBirdTokenizer.from_pretrained("google/bigbird-roberta-base")
model.to(device)

dataset = "torch.utils.data.DataLoader object"
optimizer = "torch.optim object"
epochs = ...

# 最簡訓練迴圈
for e in range(epochs):
    for batch in dataset:
        model.train()
        batch = {k: batch[k].to(device) for k in batch}

        # 前向
        output = model(**batch)

        # 後向
        output["loss"].backward()
        optimizer.step()
        optimizer.zero_grad()

# 將最終權重存至本地目錄
model.save_pretrained("<YOUR-WEIGHTS-DIR>")

# 將權重推到 ? Hub 中
from huggingface_hub import ModelHubMixin
ModelHubMixin.push_to_hub("<YOUR-WEIGHTS-DIR>", model_id="<YOUR-FINETUNED-ID>")

# 使用微調後的模型，以用於推理
question = ["How are you doing?", "How is life going?"]
context = ["<some big context having ans-1>", "<some big context having ans-2>"]
batch = tokenizer(question, context, return_tensors="pt")
batch = {k: batch[k].to(device) for k in batch}

model = BigBirdForQuestionAnswering.from_pretrained("<YOUR-FINETUNED-ID>")
model.to(device)
with torch.no_grad():
    start_logits, end_logits = model(**batch).to_tuple()
    # 這裡，你可以使用自己的策略對 start_logits，end_logits 進行解碼

# 注意:
# 該程式碼段僅用於展示即使你想用自己的 PyTorch 訓練器微調 BigBrid，這也是相當容易的。
# 我會建議使用 ? Trainer，它更簡單，功能也更多。

使用 BigBird 時，需要記住以下幾點:

  • 序列長度必須是塊大小的倍數，即 seqlen % block_size = 0 。你不必擔心，因為如果 batch 的序列長度不是 block_size 的倍數，? transformers 會自動填充至最近的整數倍。
  • 目前，Hugging Face 的實現 尚不支援 ETC，因此只有第一個和最後一個塊是全域性的。
  • 當前實現不支援 num_random_blocks = 0 。
  • 論文作者建議當序列長度 < 1024 時設定 attention_type = "original_full" 。
  • 必須滿足: seq_length > global_token + random_tokens + moving_tokens + buffer_tokens ，其中 global_tokens = 2 x block_size 、 sliding_tokens = 3 x block_size 、 random_tokens = num_random_blocks x block_size 且 buffer_tokens = num_random_blocks x block_size 。如果你不能滿足這一點，? transformers 會自動將 attention_type 切換為 original_full 並告警。
  • 當使用 BigBird 作為解碼器 (或使用 BigBirdForCasualLM ) 時， attention_type 應該是 original_full 。但你不用擔心，? transformers 會自動將 attention_type 切換為 original_full ，以防你忘記這樣做。

下一步

@patrickvonplaten 建了一個非常酷的 筆記本，以展示如何在 trivia-qa 資料集上評估 BigBirdForQuestionAnswering 。你可以隨意用這個筆記本來玩玩 BigBird。

BigBird 版的 Pegasus 模型很快就會面世，你可將它們用於 長文件摘要 ?。

尾註

你可在 此處 找到 塊稀疏注意力矩陣 的原始實現。? 版的實現在 這兒。

英文原文: https://hf.co/blog/big-bird

原文作者: Vasudev Gupta

譯者: Matrix Yao (姚偉峰)，英特爾深度學習工程師，工作方向為 transformer-family 模型在各模態資料上的應用及大規模模型的訓練推理。

相關文章