好,現場的同學、線上的同學大家好,那我們就開始上課吧!

今天要講的是各式各樣的Self-Attention的技術。

假設你已經看過跟Self-Attention相關的上課錄影,你已經知道Self-Attention是什麼,

然後我們來告訴你其實Self-Attention有各式各樣的變形。

在這個上課錄影的結尾已經告訴你說,其實Self-Attention並不是只有我們上課說的那種樣子。

我們上課有說Self-Attention就是產生Q、K、B三種vector,

然後這個Q跟K之間會兩兩算這個大發達,然後對value做weighted sum,然後做Self-Attention。

假設你對這整個系列的機制已經非常的清楚,但是Self-Attention不只這樣子。

在Self-Attention之前的影片裡面,我們就停在這個頁面告訴你說,

Self-Attention其實有各式各樣的變化,他們往往都用什麼former、什麼former、什麼former作為結尾,

但那是另外一個很長的故事了,今天我們就要來講這個故事。

先很簡短的複習一下什麼是Self-Attention,還有它的難點、它的痛點在哪裡呢?

我們知道Self-Attention的存在是為了要處理如果你的input是一個sequence的狀態,

假設你要處理的input是一個sequence,這個sequence的長度我們用N來表示。

這個sequence可能是各種不同的資料型態,它可能是一個句子,句子裡面的每一個token或詞彙當作是一個單位。

或者是你的input可能是一段語音訊號,語音訊號裡面的一個frame當作一個單位。

甚至最近常常有人把Self-Attention用在影像處理上,你的輸入是一張圖片,圖片裡面的每一個pixel當作一個單位。

那Self-Attention它要做的事情就是處理一個input的sequence,那現在假設sequence的長度是N。

那input一個sequence以後呢,我們會產生這個N個key的vector跟N個query的vector。

那這個N個key的vector跟這個N個query的vector會兩兩之間做搭發的。

那有N個key有N個query那叫做N平方次搭發的。

把N平方次搭發的結果集合起來,你就得到一個N乘以N的矩陣,那這個矩陣呢叫做Attention的matrix。

那我們根據這個Attention的matrix對value vector,那這個value vector我就沒有畫在這個圖片上了。

我們得到這個Attention的matrix以後呢,對value vector做歸題上,那這個都是過去已經跟大家講過的內容。

那我們在之前的錄影裡面也已經跟大家講過說,Self-Attention的痛點就是這個N乘以N的矩陣,它的計算量可能會非常的驚人。

尤其是你的input sequence非常長的時候,這個N乘以N的Attention的matrix它的計算量會非常的大,

會大到你沒有辦法承受。

所以就有一系列的方法想辦法加速Attention這個機制的計算。

但是在開始之前呢,這邊要提醒大家,其實Self-Attention往往只是一個你的巨大network的其中一個module。

舉例來說,假設你要用的是Transformer,上課錄影照理說你已經聽過Transformer了。

假設我們要用的是Transformer,Transformer裡面不是只有Self-Attention,除了Self-Attention以外還有其他的module。

所以今天呢,雖然我們說Self-Attention它的運算量跟N平方是成正比的,

跟sequence的長度,input sequence的長度的平方是成正比的。

但是假設這個Self-Attention它的運算沒有dominate整個network的運算的話,

那你加快Self-Attention的運算,那可能幫助不一定會很大。

就有很多同學會,他用了這個新的Self-Attention的技術,

在Transformer裡面發現計算的加速還蠻有限的。

那因為很有可能整個network裡面,V-forward的部分,

他所需要耗費的運算量也許根本比Self-Attention大。

那你加快Self-Attention也許幫助就非常有限。

那什麼時候Self-Attention會dominate這整個network呢?

什麼時候這整個network最主要的運算會來自於Self-Attention呢?

當input的sequence,也就是這個N的長度非常長的時候,

整個Transformer裡面最主要的運算就會來自於Self-Attention。

所以今天sequence很長的時候,加快Self-Attention才有幫助。

所以這就是為什麼等一下你會看到的這些Self-Attention的變形,

加快Self-Attention的方式往往最早都是用在影像處理上面。

因為當很多人想要把Self-Attention用在影像處理上面的時候,

他們就發現有非常大的障礙。

怎麼說呢?假設你要處理的是256x256的一張image,

那256x256的image也不是太大的image。

那假設你今天硬是要用Self-Attention處理的話,

會變成什麼狀況呢?

如果你要用Self-Attention處理一張圖片,

那你可能會把圖片裡面的每一個pixel當作一個單位。

這個時候你input sequence的長度,

就把這個圖片裡面的pixel全部拉直,變成256x256。

那所以你的大N是256x256。

如果今天Self-Attention它的運算量是正比於256x256的平方,

不是只有256平方喔,是256x256再平方,

所以其實是256的四次方。

那這個運算量就會非常驚人了。

所以這就是為什麼你會發現說,

我們等一下看到的種種Self-Attention的變形,

往往最早都是用在影像處理上。

所以總之這邊要先跟大家強調的是,

當input sequence非常長的時候,

以下看到的那些招數才有可能會發揮真正的效用。

好,那有什麼樣Self-Attention的變形呢?

有什麼樣的方法可以加快Self-Attention這個機制的運算呢?

那我們剛才說Self-Attention這個機制的運算,

它最大的bottleneck來自於我們需要計算一個N乘以N的矩陣。

所以人們就從這個地方下手,

有沒有辦法加快這個N乘以N的矩陣的運算呢?

那第一個想法是,

也許我們並不需要把N乘以N的這個Attention Matrix裡面的每一個數值都計算出來。

也許有一些位置,有一些位置的Attention的value應該是多少,

我們不需要算,我們根據人類對這個問題的理解,

可以直接知道Attention的value應該是多少。

這樣講也許很抽象,我們先舉第一個例子。

這個例子是這樣子的,

有時候我們在做Attention的時候,

有些問題不一定需要看整個sequence,

也許有一些問題在做Attention的時候,

在每一個位置上你只需要看左右的鄰居就可以得到正確的答案,

就可以理解一個Token,一個位置它存有什麼樣的資訊。

所以今天假設我們在做Self-Attention的時候,

其實只有左右的鄰居的資訊是需要知道的,

那也許你可以把更長的距離的Self-Attention的Attention的weight就直接設為0。

講得更具體一點,

你的Attention Matrix可以直接畫成這個樣子。

在這個圖上,灰色的部分代表我們直接把Attention的weight設為0,

就不算了,不需要去計算灰色的位置的Attention weight,

它直接設為0。

然後你只需要去計算有圖顏色的,不是灰色的,

藍色這個部分的Attention的數值,

這樣就可以加速運算,

因為灰色的部分你都不算用Attention了,

都不需要做任何計算,

只算藍色的部分,那就可以加快這個矩陣產生的速度。

那像這樣子的方法叫做Local Attention,

或者叫Truncated Attention。

但像這種Local Attention或Truncated Attention,

它顯然有一個問題,

就是每次你在做Attention的時候,

你只看得到某一個小範圍之內的資訊。

那這樣子做的話,那Attention跟CNN就沒什麼差別了,對不對?

我們上課的時候其實已經跟大家講過CNN跟Attention的關係。

我們有說,如果今天Attention都是Attend在一個很小的範圍內,

那其實它就是CNN。

所以如果我們今天用Local Attention,

那就等於是做CNN,那你就直接用CNN就好啦。

所以Local Attention它是一個可以加快Self-Attention運算的方法,

但它不一定可以給你非常好的結果。

那除了Local Attention以外,還有各式各樣的變形。

比如說有人說,你既然覺得Local Attention不好,

只看鄰居不好,那我們就看比較遠一點的鄰居。

比如說在每一個位置,我們不是看下一個位置的資訊,

上一個位置的資訊,而是先跳兩個,

和三個位置之後的資訊,三個位置之前的資訊。

那這樣就可以看到比較大的範圍內的資訊。

那如果把它畫成Attention Matrix的話,

你的Attention Matrix就長這個樣子。

那這種方法叫做Stripe Attention。

當你用Stripe Attention的時候,在這個圖上灰色的部分,

就是直接填零,就不計算。

我們只計算有圖青色的部分,有顏色的部分。

那有人可能會問說,那為什麼是空兩格,

看三步之外發生什麼事情,空兩格,

看三步之前發生什麼事情呢?

你可以不要這樣做,你可以只空一個,

然後你也可以空三格,這個完全是你自己決定的。

那你可以根據你現在要處理的問題,

決定說你的Stripe Attention應該要長什麼樣子。

那還有其他的方法,有一個方法叫做Global Attention。

那不管是剛才看過的Local Attention,

還是Stripe Attention,都是以某一個位置作為中心,

看這個位置左右兩邊發生什麼樣的事情。

那如果我們今天想要知道一整個Sequence發生什麼事,

那也許你可以用Global Attention。

那Global Attention是什麼意思呢?

在做Global Attention的時候,

你會在你原來的Sequence裡面,

加上一個特殊的Token。

那如果你今天是做NLP的問題,

你的input是一串文字的話,

那就是加入一個特殊的符號,

這個特殊的符號代表這個位置,

要做Global Attention。

那Global Attention它會做兩件事。

第一個事情是Global Attention,

它會Attain到Sequence裡面的每一個Token。

它會從Sequence裡面的每一個Token都去收集資訊。

也就是說這種特別的Token,

它要做的事情就是先來收集一下整個句子的資訊,

來了解一下這整個句子裡面,

整個input的Sequence裡面發生了什麼樣的事情。

所有人都會去看這個特別的Token,

看看這個特別的Token裡面有發生什麼樣的事情,

存有什麼樣的資訊。

所以這些特別的Token,

它們會Attain到所有的Token,

另外它們會被所有的TokenAttain。

然後具體的操作其實有兩種做法,

怎麼做這個Global Attention呢?

有兩種做法。

第一種做法是,

你在你原來的Sequence裡面就直接Assign一些人,

直接Assign一些Token,

作為Special Token。

舉例來說,你可以說,

如果是在處理文字的時候,

大家都知道說Vert的每一個句子的開頭,

不是有一個CLS的Token嗎?

你告訴他什麼也沒有關係,

其實在一般用Transformer來處理文字的時候,

你會放一個代表開頭的Token,

也許我們就直接把那個開頭的Token當作Special Token,

或者是每一個句子都有句號,

一個句子幾個數字都有句號,

也許我們可以把句號當作Special Token。

所以這種Special Token怎麼來?

第一個做法就是,

你從原來就有的Input Sequence裡面,

原來就有的Token裡面,

選一些當作Global的,

當作這種特別的Token。

那有另外一種做法是,

你就外加額外的Token,

今天不管Input的Sequence是什麼,

Input的句子是什麼,

你都直接硬是插兩個符號,

這兩個符號代表特別的Token,

這兩個特別的Token,

他們會Attain到所有其他的Token,

所有其他的Token也都會Attain到這兩個Token。

那如果要把它的Attention Matrix畫出來的話,

看起來就像是這個樣子。

我們假設這一個句子裡面,

這一個Input的Sequence裡面,

頭兩個位置就是Special的Token,

叫做Global Attention的Special的Token。

那你發現說,

在這一個Attention的Matrix裡面,

我們假設這個Row,

每一個Row代表一個Query,

每一個Column代表一個Key,

那我發現前兩個Row,

前兩個Row全部都是有值的,

全部都是要計算Attention的,

代表說前兩個Token,

他們是Special Token,

前兩個位置他們代表Special Token,

他們的Query要去Attain到所有其他人的Key。

那今天你看這前兩個Column,

也是有顏色的,

這是什麼意思呢?

代表說除了Special Token以外的那些Token,

他們在做Attention的時候,

他們的Query都會Attain到第一個位置跟第二個位置。

所以每一個Row,

每一個不是Special Token的位置,

他們都Attain到Special Token,

現在這個例子裡面是句子前面的前兩個Token。

這個Global Token要Attain到所有人,

也被所有人Attain以外,

其他的Token彼此之間就沒有往來了。

所以我發現說,

在這個Attention的Matrix裡面,

只有頭兩個Row跟頭兩個Column是有顏色的,

其他位置直接塗灰色,

其他位置的Attention直接塗綠色,

所以代表其他位置,

其他的Token不是Special Token,

彼此之間互相就不做任何Attention,

互相就不管彼此發生了什麼事。

如果打一個比方的話,

Special Token就是Token中的里長伯。

你知道在一個里裡面,

你可能不知道你的鄰居是誰,

你的鄰居也不知道你是誰,

你們互相是沒有往來的,

但是每個人都認識里長伯,

里長伯也認識每一個人。

所以今天要傳遞什麼資訊,

你可以透過里長伯來傳遞,

這個就是Special Token的作用。

這個是Global Attention,

講到這邊,

大家會問的一個問題是,

我們講了各式各樣,

憑藉著人的Knowledge,

決定的這一種Self-Attention的Matrix,

有Local的Attention,

有Stride的Attention,

有Global的Attention,

那哪一種最好呢?

應該要用哪一種才是對的呢?

這邊的答案就是,

小孩子才做選擇,

你知道嗎?

真正好的結果就是,

全部都用。

你記得嗎?

一個Self-Attention裡面,

它是有Multiple Head的,

對不對?

我們可以設定多個不同的Head,

你就讓每一個Head,

做不同的事,

有的Head是Local Attention,

有的Head是Stride Attention,

有的Head是Global Attention,

就這樣,

你就不需要做選擇了。

所以一些比較知名的,

這個Self-Attention的變形,

就是這麼做的,

比如說Long-Former,

Long-Former就是把Local Attention,

加Stride Attention,

加Global Attention,

還有另外一個知名的,

這個Self-Attention的變形,

叫做Big Bird,

這邊我看了很久,

都不知道它跟Big Bird,

有什麼樣的關係,

我覺得它就是純粹湊梗,

你知道嗎?

它的模型命名為Big Bird,

它連小模型的名字都懶得想了,

直接就把它叫做Big Bird,

那Big Bird其實就是Long-Former,

加Random Attention,

就是原來Long-Former裡面的東西,

它都有,

它有Local Attention,

有Global Attention,

但是它自己新加了一個很特別的東西,

叫做Random Attention,

就是它會隨機選一些位置,

隨機選一些Token,

讓它們彼此之間,

也是有Attention的,

至於這個Random Attention,

有什麼樣的妙用,

這個就留給大家自己去研究,

可以看一下Big Bird這篇Paper,

它會有更詳細的說明,

甚至有理論的推導,

告訴你說,

為什麼要有這個Random的Attention,

剛才我們是用人工的力量,

直接告訴你說,

哪一些位置就不需要算Self-Attention,

哪些位置直接不理,

但是這樣真的是最好的方法嗎?

也許不見得,

也許人類設計的這些Attention,

人類自己決定,

哪一些地方不需要算Attention,

並不能得到最好的結果。

我們能不能夠不要用人的力量,

而是用Data-Driven的方法呢?

舉例來說,

今天在一個Self-Attention的Matrix裡面,

可能某些位置,

它的Value,Attention的Weight就是特別大,

某一些位置,

它的Attention的Value就是特別小。

這個時候,

其實你可以把Attention的Value特別小的位置,

直接無理。

把Attention的Value特別小的位置,

本來就很接近0,

你直接把它當作0,

不去計算,

也許對你這樣子有變成0跟沒有變成0,

也許結果是不會差距太大的。

如果我們用這樣子的方法,

來加快Attention的運算,

那也許我們簡化以後的Attention,

跟原來完整的Attention,

就不會有太大的差距。

所以我們其實可以想看看,

有沒有辦法直接估計,

在一個Attention的Matrix裡面,

哪一些位置有可能會有比較大的值。

我們只計算那些,

有可能會有比較大的值的位置。

如果有些位置,

我們猜它可能本來Attention的Value就會很小,

那我們直接就不進行任何的計算,

我們就直接把它當作是0。

再來的問題是,

怎麼快速的估算出,

哪些位置可能有大的AttentionValue,

進行詳細的計算,

哪些位置可能有小的AttentionValue,

直接就可以無視呢?

這邊的方法,

在Reformer跟Routing Transformer,

這兩篇Paper裡面,

他們都用了非常類似的方法,

他們用了Clustering這個技術,

就是你先把你的Query跟Key拿出來,

然後你就做Clustering,

你就根據這個Query跟Key,

它們相近的程度做Clustering,

比較近的就分類在一起,

比較遠的就屬於不同的Cluster,

在今天這個例子裡面,

總共分成四個Cluster,

這邊有紅色的Vector,

邊框是紅色的Vector,

代表它們屬於Cluster1,

邊框是紫色的,

代表屬於Cluster2,

邊框是綠色的,

代表屬於Cluster3,

邊框是黃色的,

代表屬於Cluster4,

我們把Query跟Key做Clustering,

在這個例子裡面分成四個Cluster,

這個Cluster的目的,

是要讓相近的Vector,

就屬於同一個Cluster,

不相近的Vector,

就屬於不同的Cluster,

講到這邊有同學可能會問說,

Clustering這件事情,

會不會也耗費很大的運算量呢?

如果今天Clustering這件事情,

它的Complexity,

也跟Sequence的平方有關的話,

那做Clustering,

也許根本沒有辦法加速Search Attention的運算,

但是實際上呢,

Clustering有很多可以加速的方法,

所以這邊在做Clustering的時候,

你會採取一個,

可能是估測不是非常準確,

但非常快速的方法,

來把這一些Query跟Key的Vector進行分群,

那在Reformer還有Routing Transformer裡面,

就採取了不同的Clustering的方法,

來快速的把相近的Query跟Key,

歸在同一群裡面,

那把Query跟Key歸在同一群裡面以後,

接下來呢?

接下來呢,

如果一個Query跟一個Key,

它們落在同樣的Cluster裡面,

我們才去計算Attention的位置,

所以舉例來說,

這個紅色的Query跟這三個Key,

它們是在同一個Cluster裡面,

那我們就計算一下,

它的Attention的位置,

紅色的這個Query跟其他的這五個Key,

它們不在同一個Cluster裡面,

那就代表說它們其實很不像,

它們的距離其實是偏遠的,

直接把它們的Attention設為零,

所以同理,

黃色的這個Vector,

它跟另外這兩個Key在同一個Cluster裡面,

所以只有這兩個位置需要計算Attention,

其他地方直接不零,

所以呢,

這整個Attention的Matrix裡面,

很多位置你就不需要去計算,

直接算零,

只有屬於同一個Cluster的Query跟Key,

我們才計算它的Attention位,

那這樣就可以加快這個Attention的Matrix的計算。

好,那這個是Clustering的方法。

好,那到目前為止啊,

我們怎麼決定哪一些位置要計算Cluster,

哪些位置不要計算Cluster,

都是憑著人類對這個問題的理解,

不管是前面我們講的Local Attention, Global Attention,

還是到Clustering,

Clustering是假設說比較近的Vector,

我們才去計算它的Attention,

所以到目前為止,

要不要計算Attention,

往往還是基於人類對這個問題的理解。

那有沒有辦法把要不要計算Attention這件事情,

用Learn的直接把它學出來呢?

是有可能的。

有一個方法叫做Synhome Sorting Network,

它要做的事情就是,

哪些地方要不要計算Attention,

我們直接用Learn的來決定這件事情。

所以呢,我們要計算Attention的時候,

你要先產生一個Matrix,

這個Matrix裡面呢,

有一些位置是1,有一些位置是0,

那這邊呢,塗深色的代表1,塗淺色的代表0,

只有塗深色的地方需要去計算Attention,

淺色的地方就當作Attention是0,

我們就不計算Attention,

所以哪一個Key要跟哪一個Query計算Attention,

我們用這一個Matrix來決定。

而這個Matrix怎麼來呢?

到目前為止,

在這門課講到目前為止,

哪一些地方要計算Attention都是人決定的,

但是在Synhome Sorting Network裡面,

他決定直接Learn一個Network,

Learn另外一個Network,

來決定哪些地方需要計算Attention。

怎麼做呢?

這個是你的Input Sequence,

然後呢,你把Input Sequence的每一個Position,

通過一個Network產生一個Vector,

這個Vector的長度要跟你的Sequence一樣,

所以Input Sequence的每一個Vector,

通過一個Network,

那就產生另外一排Vector,

那這些Vector全部拼起來以後,

它的大小也要是N乘以N,

跟你的Attention的Matrix一樣。

那我們現在的目標,

就是要把這個東西,

變成這個東西。

那你可能會想說,

可是這個決定要不要計算Attention的Matrix,

裡面它的值是Binary的,

只有1跟0而已啊。

那可是Network的Output,

它是Continuous的,

不是只有1跟0而已啊。

那這就是這篇Network的一個重點,

它有一個很特別的技術,

來解決這個問題。

你可以用某一個方法,

把這個本來不是Binary的Matrix,

變成Binary的Matrix,

而且這一個過程,

是可以微分的,

所以最後你在Train這個NN的時候,

它是跟你的整個Network一起Train出來的,

你被Propagation的時候,

是可以走過這個,

從Continuous的Matrix,

變成Binary的Matrix,

變成Binary的Matrix的這個過程,

這一關是可以微分的。

所以這個NN,

會跟Network的其他部分,

一起被學出來。

當然以上是一個比較簡化的講法啦,

所以實際上,

Syntax Sorting Network是怎麼運作的,

那就請大家自己參考文獻。

總之,

怎麼產生這個Matrix,

怎麼決定哪些位置,

要被計算Attention,

你可以任另外一個Network,

來讓Machine自己去學,

讓Network自己去學,

什麼位置要不要計算Attention。

這個是Syntax Sorting Network。

講到這邊,

大家有沒有問題想要問的呢?

欸,你誰說?

我想請問一下,

這個Pattern認出來要怎麼,

它會不會和原本Tension的很像,

就是該大的地方大,

該小的地方都很,

這一次就是要怎麼定點說,

它們兩個朝同一個方向前進,

如果在這個Syntax Sorting Network。

欸,可是你們,

我其實我知道你的問題,

但是你想喔,

我們現在是先產生這個東西,

然後呢,

產生一個Binary的Mask,

然後決定說只有這些位置,

要算Attention,

但為什麼,

我們不直接Output Attention的Matrix呢?

嗯,就被破梗了,

所以這個Syntax Sorting Network的同一批作者,

下一篇叫做Synthesizer,

他們就決定說,

欸,為什麼要做兩步呢?

直接Output Attention的Weight就好啦,

結束了這樣子。

這樣有沒有回答到你的問題?

嗯,好,好,

好,這個是,

本來Synthesizer是在這個投影片的最後一頁,

才會講到嘛,

我這邊就是破梗,

對,你,

好,

欸,這樣大家還有問題要問嗎?

欸,你說?

這樣的話不是對於感覺有點喪失了Attention的那個計算很快速的性質,

就是它變成每一個Input它就要去算個恩恩,

然後過一個恩恩,

然後再產生一個響亮,

然後就變成平行。

好,這也是一個很好的問題,

我猜你的問題就是說,

欸,我們今天用恩恩來產生這個Matrix,

它真的會比原來用Key跟Value算出這個Attention Matrix還要快嗎?

你仔細想想,

假設我們每一個Input我們都要產生一個Vector,

其實你的運算量跟原來的Attention Matrix其實差不多的,

你根本沒有真的加速。

好,這是個好問題,

這邊有一個沒有提到的細節啦,

在Synthome Sorting Network裡面,

它真正做的事情是什麼呢?

它真正做的事情是,

好幾個Input的Vector會共用同一個Vector,

也就是說假設你Input一個很長的Sequence,

比如說100個Vector,

我們把它切成10段,

每段10個Vector,

10個Vector一起通過Network以後產生一個Vector,

那10個Vector要共用同一個Vector,

也就是那10個Vector最後會共用同一個Column,

它們會有同樣被Mask起來的地方,

同樣要算Attention的地方,

同樣不要算Attention的地方。

好,這樣我們回答到你的問題。

所以說產生出來的這個NN的Matrix,

它裡面其實只有10種Vector,

假設Input是100個,

它裡面就只有10種Vector。

對,就假設你這邊本來要算100x100的Matrix,

就你Attention其實是100x100的Attention,

但是在Synthome Sorting Network裡面,

你用NN產生的這個東西,

它是解析度比較低的,

它其實只有10x10,

那你再把它放大成100x100。

好,這個大家都聽得很仔細,

有沒有發現這個上課沒有要講的細節。

到目前為止都想要產生一個NxN的Matrix,

只是我們說NxN的Matrix裡面,

有一些位置我們直接設定,

但是我們真的需要一個NxN的Attention Matrix嗎?

在林峰的這篇Paper裡面,

他告訴我們說,

看起來也許不需要喔。

為什麼?

因為林峰的這篇Paper裡面,

他有做了一個實驗是,

如果你真的把這個Attention的Matrix拿出來看,

你會發現裡面有很多Redundant的Color,

那在這個例子裡面,

我是特別畫很多Color的Value都是一樣的,

告訴你說,

很多Color其實都是重複的。

那在林峰的那篇Paper裡面,

他做的事情是,

他去計算這個Attention Matrix的Rank,

那他告訴你說,

這些Attention的Matrix其實都是LowRank的Matrix,

也就是說,

這個Attention的Matrix很多Color都是Dependent的,

很多Color可能是其他Color做Duplicate,

或是其他Color的Linear Combination。

從這個角度說起來,

也許我們根本不需要一個N乘以N的Matrix,

因為這個N乘以N的Matrix裡面,

很多資訊都是重複的。

那我們能不能夠把某一些重複的Color就把它拿掉,

產生一個比較小的Attention Matrix,

我們只計算這個比較小的Attention Matrix,

那我們就可以加快Attention這件事情的運算速度。

那這個就是Link Format這篇Paper要做的事情。

那實際上你要怎麼做呢?

實際上你的做法是這樣的,

本來有N個Key,

我們從這N個Key裡面,

只挑大K的出來,

當作Key的代表。

所有的Key,

每一個都拿來跟Query計算的Attention太多了,

很多Key,

他們都是很像的,

都做重複的事情,

他們只是種源,

也許我們只需要選最具代表性的K跟Key出來就好了。

那至於怎麼選,

我們會在下一頁投影片提到。

反正你現在就知道說,

K跟N的Key,

不要全部都用,

只挑有代表性的Key出來就好了。

那只挑有代表性的Key出來以後,

你就不需要算一個完整的N乘以N的Attention Matrix了,

你就可以把這個Attention的Matrix變瘦,

我們只算一個N乘以K的Attention Matrix。

那產生這個Attention Matrix以後,

接下來你要怎麼用這個Attention Matrix,

產生Self-Attention Layer的Output呢?

你的做法是這個樣子的。

你有N個Value,

你一樣要挑出K個具代表性的Value。

所以這邊有K個Key,

每一個Key其實都有一個對應的Value Vector,

你有K個Key Vector,

但你有K個Value Vector。

然後接下來呢,

你把K個Key對第一個Query Vector算出來的Attention Weight,

對這K個Vector做Weighted Sum,

得到第一個位置的Output。

同比,

把這四個Value再跟K個Vector,

這邊的K等於4啦,

把這K個Value跟這四個Vector再做Weighted Sum,

得到第二個位置的Output。

以此類推,

你就可以得到整個Self-Attention Module的Output。

講到這邊,

大家可能會想到一個問題,

為什麼我們只選有代表性的Key?

為什麼我們不選有代表性的Query呢?

我們可以把Key的數目從N變到K,

我們為什麼不能把Query的數目也變成另外一個數值,

比如說也是大K好了?

那這樣子我們的Attention Matrix不是變得更小,

這樣計算起來不是會更快嗎?

不知道大家有沒有想過這樣子的問題。

你確實也可以把Query的數目變少,

你確實也可以只選有代表性的Query,

但是你想想看,

假如你只選有代表性的Query,

你會遇到什麼問題?

你會遇到你的Output Sequence的Length就縮短了對不對?

因為你Output Sequence的Length跟你的Query的Length是一樣的。

如果你的Query變成原來的一半,

那你Output Sequence就變成原來的一半。

那變成原來的一半會不會有影響呢?

那就是Case by Case。

有些任務是讀一整個Sequence,

然後只產生一個Class,

那就是大家在作業裡面做的Speaker Classification,

那就是Input一整段句子,

你只需要輸出一個Label。

像這樣子的任務就無妨,

你真的可以把你的Query變少,

你真的可以選有代表性的Query出來就好了。

但是假設你今天的任務是Input Sequence裡面的每一個位置,

你都需要Output一個Label,

像我們在作業2裡面做的Phoning的Classification,

就是每一個Friend你都要給他一個Phoning的Label。

假設你今天Output的長度變短了,

那你的Label的數目不就有錯了嗎?

那這樣會有問題。

所以假設你今天你需要每一個位置都下一個Label,

每一個位置都做一遍Classification給他一個Label,

那你其實沒有辦法把Query變少,

你沒有辦法只選有代表性的Query出來。

好,那接下來要講的就是,

怎麼選出有代表性的Key呢?

我們說要選有代表性的Key嘛,

怎麼選呢?那就有不同的做法。

有一篇Paper叫做Compress Attention,

他做的事情是說,你Input很多的很長的一個Key的Sequence,

那我們用CNN來掃過它。

那你用CNN來掃過一個Sequence以後,

這個Sequence的長度就變短了,

那這個短的Sequence就當作是有代表性的Key。

所以我們可以用CNN來把一個長的Sequence變成短的Sequence,

那把短的Sequence當作有代表性的Key。

那另外一個是Link Form的這篇Paper裡面的做法,

他說Input的這些Key集合起來,

可以看作是一個D乘以N的矩陣。

那把這個D乘以N的矩陣去乘一個N乘以K的矩陣,

把D乘以N的矩陣乘上N乘以K的矩陣,

會得到一個D乘以K的矩陣。

那這個D乘以K的矩陣,

它的每一個Column,它的K個Column,

就是K個有代表性的Key。

那如果你熟悉線性代數的話,

你會知道說,把這個D乘以N的矩陣乘上這個N乘以K的矩陣,

得到D乘以K的矩陣,

你實際上做的事情是什麼?

你實際上做的事情是,這邊這K個Vector,

都是這N個Vector的Linear Combination。

你把這N個Vector做不同的Linear Combination,

做K種不同的Linear Combination,

就得到這K個Vector。

所以可以說,如果你從Link Forward的時候,

所謂K個有代表性的Vector,

就是把原來大N個Vector裡面,

把這些大N個Vector,

做不同方式的Linear Combination,

那就產生K個有代表性的Key,

然後你就可以減少你的運算量。

這個就是Link Forward在做的事情。

好,那接下來,我們再回頭想一下,

其實Attention的整個Process,

它其實說穿了,就是一連串矩陣的相乘。

那這個矩陣相乘的過程中,

有沒有可以減少運算量的部分呢?

那我們來複習一下,

Attention這一個Mechanism,

跟矩陣相乘的關係。

而假設Input,我們當作一個Matrix叫做I。

我們會把I這個大I這個Matrix,

乘上一個Linear Transform,

得到另外一個Matrix叫做Q。

Q的大小是D乘以N。

Q是一個D乘以N的Matrix,

N是Sequence的長度,

D是你的Query Vector的Dimension。

那同樣的道理,I乘以另外一個Transform,

叫WK,會得到我們的Key。

所有的Key集合起來,

一樣是一個D乘以N的Matrix。

把I乘上另外一個Transform,

得到大V,

這個大V這個矩陣呢,

它是一個Dπ乘以N的矩陣。

那把所有的Value Vector集合起來,

它是一個Dπ乘以N的矩陣。

那這個Q跟K啊,

它們的Dimension必須要一樣啦,

這樣它們才能夠做大發達嘛,

Dimension不一樣不能做大發達。

但是V的Dimension,

不一定要跟Q跟K一樣。

所以你一般在實作的時候,

你會直接就把它們Dimension設成一樣,

但是不一樣也沒有關係。

所以我這邊呢,

特別說Value的Vector是Dπ,

Q跟K,

Query跟Key的這個Dimension都是D,

但Value的Vector是Dπ。

Dπ也可以等於D,

但沒有必要,

一定要等於D。

好,那接下來呢,

接下來呢,

你會把Key乘以一個Transpose,

跟Q相乘,

得到一個Attention的Matrix,

叫做A。

然後接下來呢,

你會做Softmax,

得到A',

接下來你把A'乘上V,

得到Output O。

所以整個Attention的Mechanism,

就是Input一個Sequence表示成I,

Output另外一個Sequence表示成O,

中間你會經過這一連串的運算。

那有沒有辦法加速這個運算呢?

其實是有辦法的。

我們先做一個簡化,

我們先假設我們沒有做Softmax這件事情。

那如果拿掉Softmax,

那你覺得不舒服的話,

不要擔心,

等一下會把它加回去。

我們先假設沒有Softmax。

那這一個A',

這邊這個A',

它就是K的Transpose乘上Q。

所以其實做Attention這件事情,

我們真正做的事情,

就是把V跟K的Transpose跟Q,

三個取得相乘,

我們就得到Self-Attention Module的Output,

也就是這邊的O。

那這個Q是一個D乘以N的矩陣,

這個K的Transpose是一個N乘以D的矩陣,

本來K是D乘以N,

Transpose以後就變成N乘以D。

然後我們先把Q跟K的Transpose進行相乘以後,

再乘上V這個矩陣,

V這個矩陣的大角是D'乘以N,

三個乘完以後,

我們得到O,它就是一個D'乘以N的矩陣,

這是Self-Attention做的事情。

我們先把K的Transpose跟Q乘起來,

再乘V,最後得到O。

那這整個過程其實是可以加速的。

怎麼加速呢?

先把V跟K的Transpose相乘,

再乘上Q。

這兩件事情,

你可能覺得它們是一樣的,

它們確實乘出來的結果O會是一樣的,

但是中間需要的運算量不是一樣的。

同樣是V乘以K的Transpose乘以Q,

先把K的Transpose乘Q再乘V,

跟先把V乘以K的Transpose再乘Q,

雖然得到的結果是一樣的,

但是所需的運算量不是一樣的。

這件事情,

如果你有修過我的線性代數的話,

我們在線性代數這門課有跟大家講過,

你把A跟C跟P三個矩陣相乘,

你不管是先把C跟P相乘,

變成CP就是一個Couple,

再乘A,

還是先把AC相乘再乘P,

它們的結果是一樣的,

但是運算量是不一樣的。

如果你沒有修過我的線性代數也沒有關係,

我們直接跟大家說明,

用V乘以K乘以Q的例子跟大家說明。

如果我們先把K的乘透乘Q,

我們需要做多少次的矩陣乘法呢?

需要做N乘以D乘以N次。

那如果你是太久以前修線性代數,

一下子想不起來矩陣乘法怎麼做的話,

你就記得這個原則是這樣。

這邊把N乘以D的矩陣乘上D乘以N的矩陣,

需要做多少次乘法呢?

就是N乘以D乘以N,

就是第一個矩陣的RAW的數目乘上第一個矩陣的COLUMN的數目乘上第二個矩陣的COLUMN的數目。

把這三個東西乘起來,

就是把兩個矩陣相乘的時候需要做的乘法次數。

所以把K的乘透乘Q需要做幾次乘法?

需要做N乘以D乘以N次的乘法。

把這兩個乘起來以後,

你得到一個N乘以N的矩陣,

就是我們的Attention Matrix。

把Attention Matrix再乘上V,

V是一個D'乘以N的矩陣,

需要幾次乘法呢?

用剛才那個原則,

兩個矩陣相乘的時候乘法的次數,

就是第一個矩陣的RAW的數目乘COLUMN的數目再乘第二個矩陣的COLUMN的數目。

所以今天這個例子裡面,

V乘以A的時候乘法的次數是D'乘以N乘以N。

那我們把所有的乘法的次數加起來,

N乘以D乘以N,D'乘以N乘以N,

全部加起來是D加D'乘以N平方。

所以你要做,

你的這個乘法的次數跟N平方是乘正比的。

那如果我們今天交換一下乘法的順序會變成怎樣呢?

矩陣相乘的順序會變成怎樣呢?

我們把V先乘上K的乘透。

把V乘上K的乘透需要的乘法的次數是D'乘以N乘以D。

那把這個V乘以K的乘透以後,

它會變成什麼東西呢?

它變成一個D'乘以D的矩陣。

我們一時看不出來它代表什麼東西,

不像是Q跟K相乘,

非常直覺是一個attention的matrix。

V乘以K的乘透,

一時之間我們看不出來是什麼東西,

不過沒關係,

反正它就是一個D'乘以D的矩陣。

把D'乘以D的矩陣再乘上Q,

Q是D乘以N的矩陣,

需要多少的乘法呢?

需要D'乘以D乘以N次的乘法。

所以合起來,

當你把V乘以K的時候,

你需要D'乘以N乘以D。

那你再把V乘以K的結果再乘以Q,

你需要D'乘以D乘以N次的乘法。

合起來,

這是兩倍的D'乘以D乘以N次的乘法。

所以你發現說當我們改變矩陣相乘的順序的時候,

其實我們需要的乘法的次數是有很大的差距的。

如果Q跟K先相乘,

這個時候我們得到這個O的乘法次數是D加D'乘以N平方。

V跟K先相乘,

是兩倍的D'乘以D乘以N。

而如果把Q跟V先相乘,

我們需要的乘法的次數是遠大於V跟K先相乘的。

因為N往往比D還要大很多,

不要忘了這個N是sequence的長度,

它可以是一個非常大的數字,

所以D加D'的N平方可能會遠大於兩倍的D'乘以D乘以N。

所以其實我們只要改變矩陣相乘的順序,

我們的結果可能就會有很大的不同。

講到這邊,

如果你沒有那麼喜歡看到數學的notation的話,

講到這邊你可以當作你已經知道我要講的東西是什麼了,

我們只是改變一下矩陣相乘的順序。

但是假設你對這個結果還是有困惑,

因為你覺得拿掉softmax讓你覺得有點不爽的話,

接下來告訴你放回softmax是怎麼樣運作的。

以下數學符號比較多,

如果你不想聽的話,

你也可以把這一段跳過。

原來的self-attention是怎麼被計算的?

原來self-attention是說,

如果要計算input sequence是A1到A4,

如果你要計算第一個位置的輸出B1的話,

你會把第一個位置的query Q1,

跟所有位置的key算個attention,

得到這邊的alpha prime,

再把alpha prime跟每一個位置的value vector,

所有位置上就得到B1。

所以B1是summation over i等於1到n,

然後把alpha 1i prime,就是Q1跟每一個key的attention的value,

這是有經過softmax normalize以後的value,

然後把這些value對V1做weighted sum得到B1。

那這一項alpha,

如果你想要把它的計算過程算出來的話,

其實是這個樣子的,

看起來有點複雜,

它是分子的地方是Q1跟Ki做大quota,

然後再去exponential。

分母的地方呢?

分母的地方是summation over整個sequence,

把Q1對整個sequence裡面所有的key,

都做大quota,成exponential,

相加以後放在分母,

分子的地方是Q1跟某一項key,

做大quota,去exponential,

然後再對Vi做weighted sum。

這些是原來的self-attention的計算過程。

接下來就是要告訴你,

實際上這個計算過程是可以被簡化的。

首先exponential Q跟K的大quota,

可以拆解成phiQ跟phiK的大quota。

什麼是phiQ,什麼是phiK呢?

你就想成說,

你有一個transform叫做phi,

把Q這個vector輸進去,

他會給你另外一個vector叫做phiQ。

那你把Q跟K都輸入這個phi,

得到phiQ跟phiK兩個vector,

把這兩個vector做大quota,

會等於Q跟K先做大quota,

再做exponential。

那有人可能會問說,

這個phi是什麼呢?

我們先不要在意這個細節,

反正有這麼一個神奇的phi,

就是可以讓exponential Q跟K的大quota,

等於phiQ跟phiK的大quota。

好了,有了這個,

知道這些事情以後呢,

你就可以把這邊所有的exponential,

exponential Q1Ki的大quota,

換成phiQ1到phiKi,

exponential Q1Kj的大quota,

換成phiQ1到phiKj。

那接下來呢,

我們就來稍微做一下整理,

我們先來看這邊分母這項。

這邊有一個summation over i等於1到n,

但是分母這項其實是沒有出現i的,

分母這項沒有出現i,

所以可以把它拿到summation i等於1到n的外面。

所以呢,我們這個式子變成這個樣子,

分母的地方是summation j等於1到n,

phiQ1到phiKj的總和,

分子的地方是summation i等於1到n,

那summation i等於1到n的時候,

我們會對phi做weighted sum,

那這個weight是什麼?

這個weight是phiQ1跟phiKi的大quota。

好,那我們先來看分母的地方,

分子的地方比較tricky啊,

我們先來看分母的地方。

分母的地方其實很單純,

我們這邊summation j等於1到n,

phiQ1到phiKj,

你會發現phiQ1其實跟j沒有關係,

所以phiQ1是可以提出來的。

所以分母的地方,

實際上是你把phiQ1跟phiKj

summation j等於1到n,

把這n個phiKj加起來以後,

一次去跟phiQ1做大quota。

或者是,如果你要圖像化的表示的話,

就是把phiKj,

summation j等於1到n的phiKj啊,

統統加起來,變成一個vector。

然後去跟phiQ1做大quota,

就等於這一項分母的地方。

好,分母的地方是很簡單的,

再來是分子的地方。

分子的地方我們來計算一下,

分子的地方我們特別把它拿出來,

就是在這個藍色的框框裡面,

它是vi的weighted sum,

那weight就是phiQi跟phiKi的大quota。

所以如果你把它展開的話,

希望展開讓你比較好理解一點,

展開的話,就是phiQ1.phiK1乘以v1,

但phiQ1.phiK1這個是一個scalar哦,

綜合號裡面是一個數值,

這個weight是一個數值,乘上v1,

加上phiQ1.phiK2乘上v2,

一次類推,一直加到vN。

那接下來呢,

phiQ1這個項量,

我們把它裡面每一個component展開的話,

呈現出來用notation來表示的話,

我們把phiQ1表示成Q上標1下標1,

第二個component就是Q上標1下標2,

同理phiK1是K上標1下標1,

K上標1下標2。

所以呢,我們phiQ1到phiK1,

你把它展開以後,

phiQ1到phiK1,

它是Q1.1乘K1.1,

加上Q1.2乘以K1.2,

Q1.1乘以K1.1,

加Q1.2乘以K1.2,

一路加起來,

看這邊有幾個element,

看這邊有幾個element,

把它加起來,再乘以v1。

第二項也是一樣,

接下來把它展開,

這邊都不是什麼複雜的數學,

只是很繁瑣而已,

把v1乘上這裡面的每一項,

把v2乘上這裡面的每一項。

接下來是關鍵的一步,

我們把乘上Q1.1的項集合起來,

把乘上Q1.2的項集合起來,

所以我們就會得到這樣的式子,

所以上面這件事情,

這個v1的分子的地方,

可以寫成Q1.1乘上,

這邊有個括號,

裡面是v1,v2,

一直到vn的weight,

他們的weight是多少?

他們的weight是K1.1,

K2.1,K3.1,

以此類推。

所以這個分子的地方,

你可以寫成Q1.1乘上

v1到vn的linear combination,

加上Q1.2乘上v1到vn的

另外一組linear combination。

好,我們現在假設

你可以接受這件事情以後,

那這整件事情實際上可以看作是

一個矩陣跟一個向量的相乘,

我們把括號裡面的東西

當作是一個向量,

括號裡面的東西

就是v1到vn的weighted sum,

那你把v1到vn用另外一組weight

做weighted sum,

你得到另外一個向量。

這邊會有幾個向量呢?

有人可能會很直覺的說

是不是大N個向量,

N是sequence的長度,

但其實不是,

他是看5Q1的dimension的。

括號前面不是Q1.1,Q1.2嗎?

那到底會有幾個括號?

其實就是看5Q1的dimension有多少。

所以假設5Q1的dimension是大N的話,

這邊就是有大N個括號,

所以這邊就是有大N個vector。

那這每一個vector都乘上一個weight,

這個weight是Q1.1,Q1.2,

一直到Q1.N,

如果5Q1有N個dimension的話。

所以你可以把上面這個式子

看成是一個矩陣,

這個矩陣的每一個vector,

括號裡面的每一個vector,

他們是第一個value vector的linear combination,

然後乘上5Q1。

如果你覺得這個聽起來很複雜,

不知道在講些什麼呢?

那我們用圖像化的方式

來表示一下我剛才做的事情。

所以實際上分子的地方做的事情是什麼呢?

實際上分子的地方做的事情是

你先把你所有的value vector拿出來,

你有大N個value vector,

value vector的數目

跟input sequence的長度是一樣的。

然後你把你的大N個key都拿出來,

然後把他們通過find這個function

一樣得到大N個向量。

接下來我們把這些向量的

第一個element都拿出來,

把這些向量的第一個element都拿出來,

對value vector,

對大N個value vector做weighted sum,

就得到這一個矩陣裡面的第一個vector。

然後把這些5K的第二個element拿出來,

這邊有N個vector,

所以他們的第二個element總共有N個數值。

把這第二個element拿出來,

對V1到VN做weighted sum,

你就得到這邊的第二個vector一次類推。

那如果5K的dimension是大N的話,

這邊就會有大N個vector。

那再把這大N個vector排起來,

當作是一個matrix乘上5Q1,

你就得到V1的分子增加。

那再把分母算出來,

你就得到V1的值是多少了。

那講到這邊,你可能覺得這聽起來

就只是比較複雜的數學運算跟notation而已,

跟原來的計算好像沒有什麼不同。

但他真正的關鍵點在於,

你看看喔,

我們在計算第一個位置的output的時候,

跟第一個位置有關的只有query的vector而已。

而這個藍色的向量所組成的矩陣,

還有放在分母的地方的這個黃色的向量,

他們其實跟位置,

其實跟V1的這個1是沒有任何關係的。

所以假設你在計算V1的時候,

你已經把這些藍色的vector,

還有把這個黃色的vector求出來,

接下來你就不需要再重算了。

當你把V1算出來以後,

接下來你要算V2,

你只需要把這些藍色的vector複製過來,

把黃色的vector複製過來,

再乘上findQ2,你就計算出V2了。

所以這個藍色的vector跟黃色的vector,

只需要計算一次就好。

接下來不同的位置,

就是乘上不同的findQ,

你就得到不同的V,

得到不同位置的輸出。

假設你剛才講的東西,

你沒有聽得很懂的話,

接下來就是要告訴你說,

其實self-attention,

可以用另外一個方法來看待。

而這個計算的方法,

跟原來的self-attention,

計算出來的結果是一模一樣的,

只是他的運算量是比較少的。

如果剛才講的東西你沒有聽懂的話,

直接告訴你這件事怎麼操作。

他操作起來是這個樣子的,

我們input是一個sequence A1到A4,

每一個input的位置都產生K跟V,

先產生K跟V。

我們先讓K跟V來做一些互動,

做什麼樣的互動呢?

你先把K都通過一個transform,

變成5K1,5K2,一直到5K4。

然後你把這些5K的第一個位置,

第一個dimension的element拿出來,

對V1到V4做weighted sum,

得到一個項量。

你把5K1到5K4的第二個位置的,

第二個dimension的element拿出來,

然後把這邊每一個綠色的位置,

每一個綠色的這個位置的數值,

去跟V1、V2、V3、V4做weighted sum,

得到另外一個vector。

反覆這個動作,你就看說,

你這個5K有多少的dimension,

假設M的dimension,

那你就產生M的vector,

那每一個dimension都會產生一個vector出來,

每一個dimension都會產生一個vector出來,

有M的dimension就產生M的vector。

好,那這件事情只需要做一次,

在process整個sequence的時候,

只需要做一次,接下來就一勞永逸。

怎麼一勞永逸呢?

假設你要產生第一個位置的輸出,

怎麼辦?

先把Q1產生出來,

Q1要通過一個transform變成5Q1,

接下來把5Q1的第一個dimension

乘上第一個vector,

第二個dimension乘上第二個vector,

但這邊要確保說,

Q跟K他們通過這個transform,

5以後他們的dimension是一模一樣的,

都是M,

那你才能把Q的每一個element

乘上這邊的每一個vector,

所以Q有M個value在他的vector裡面,

把這M個value乘上這M個vector

做weighted sum,

你就得到B1就結束了。

其實精確的來說,

是得到B1的分子這一項啦,

那分母這一項其實也是非常類似的概念,

我們就不幫大家剖析,

總之你把5Q1跟這M個vector

做weighted sum,

然後你就可以把B1的分子這一項算出來,

那分母這一項算的方法也是類似,

而且更簡單,

這樣你就求出B1了。

接下來要求B2的話,

怎麼做呢?

這M個vector你不要重算了,

他們是全部的位置都共用的,

他們就放在那邊,

你就不要再去動它了,

當你要算第二個位置的時候,

怎麼做呢?

你把Q2過一個transform得到5Q2,

然後把5Q2的每一個dimension的value

拿去對這M個vector做weighted sum,

5Q2的第一個dimension乘上第一個vector,

第二個dimension乘上第二個vector,

有M個dimension正好乘M個vector,

加起來你就得到B2了。

其實精確的說是B2的分子那一項,

那分母那一項的計算是更簡單的。

所以用這個方法,

你就先把M個vector算出來以後,

接下來就是一勞永逸,

每一個位置都可以很快的被計算出來。

如果你想要理解一下這個東西有什麼意思的話,

也許可以這樣理解。

之前做self-attention非常的直觀,

你可以說我們就是要找哪一個位置跟哪一個位置有關聯,

算出一個attention,

然後從那個位置抽資訊出來。

如果你要理解這種新的做法,

這邊要強調一下這個做法跟一般的self-attention

其實是一模一樣的,

算出來的結果其實是一模一樣的,

你只要選適當的fine,

算出來的結果會是一樣的。

那怎麼理解這個新的計算方法呢?

也許可以這樣理解,

每一個位置都產生V,

有V1到V4,

然後我們把它做weighted sum,

是要找尋重要的template,

這整個sequence裡面總共有M個重要的template,

然後接下來每一個位置的輸出,

就是拿這些template做linear combination,

那產生這個fineQ是要去這M個template裡面

選擇適當的template,

那這個template是整個sequence每一個位置都共用的,

這M個template產生出來以後,

它就放在那邊就不需要動它了,

每一個位置選擇不同的template組合起來作為輸出。

那如果你需要一個物理上的解釋的話,

也許這是一個可以理解這種新的self-attention運算方法的概念。

好,那接下來最後一個問題就是,

那exponential Q.K怎麼拆解成fineQ.fineK呢?

不同的paper就有不同的做法了,

所以不管是efficient attention,

linear transformer,

random feature attention,

還是performer,

他們做的都是我剛才前幾個投影片跟你講的簡化,

那不一樣的地方在哪裡呢?

不一樣的地方就是怎麼把exponential Q.K拆成fineQ.fineK。

那至於這個fine應該長什麼樣子,

那就留給大家去細讀這些文獻。

好,那接下來我們就可以再進一步思考,

如果要產生self-attention,

要做self-attention,

一定要用Q跟K做inner product來產生attention嗎?

不一定,

你可以參考一個做法叫做synthesizer,

synthesizer做法是這個樣子的,

你要做self-attention,

你的目標是input一個sequence,

output另外一個sequence,

那我們先把input的sequence每一個位置產生一個value vector,

接下來跟一般的self-attention一樣,

我們把這些value vector做weighted上,

我們可以產生每一個位置的輸出,

而這些value一樣是本來有一個attention的matrix,

這個matrix做完softmax以後,

可以得到normalized以後的value,

normalized的value做weighted上,

可以得到open,

那跟一般的self-attention不一樣的地方是,

在synthesizer裡面,

這個matrix不是Q跟K產生的,

在synthesizer裡面不需要Q跟K,

那這個matrix怎麼來呢?

其實在synthesizer裡面有兩個不同的版本,

有一個版本跟那個synthome sorting level很像,

他就是拿A1到A4去產生這個matrix,

但是在synthesizer裡面,

還有另外一個更神奇的版本就是,

把這個matrix當作network的一部分,

這個matrix裡面有n乘以n個數值對不對,

這n乘以n個數值就是network裡面的n乘以n個參數,

我們知道network裡面如果neuron有weight有bias嘛,

現在多加了attention weight,

attention weight是network的參數,

這樣你在做self-attention的時候,

你連計算attention weight這個步驟都免了,

沒有計算attention weight這件事了,

他本來就已經在network裡面了,

他就是network的參數,

那有可能會問說,

如果attention weight是network的參數,

那不是input不同的sequence,

那個attention的weight都是一樣的嗎?

對,

那performance會變差嗎?

不會,

就這樣子,

好,

所以這個synthesizer讓我們重新思考,

到底attention的價值是什麼,

過去我們會覺得input不同的sequence,

attention的matrix應該不一樣,

但是當我們把attention的matrix

作為network的參數一部分的時候,

因為network的參數不會隨著input不一樣的不一樣嘛,

這代表attention的matrix,

不管input是什麼永遠都是一樣的,

那這樣performance其實是不會掉太多的,

這重新讓我們思考attention的價值到底是什麼,

好,

那再來再更進一步思考,

處理sequence一定要用attention嗎?

所以人們開始思考,

能不能夠把attention丟掉,

有沒有attention-free的方法,

過去人們已經丟掉了recurrent,

接下來人們要丟掉attention,

所以有一系列的文章,

這邊我們就不細談,

一系列的文章他們直接用NLP,

就是一般的Fully Connected Network,

來處理一個sequence,

那這邊就留給大家自己研究,

這就又是另外一個故事了,

留給大家自己研究。

好,

這一張圖啊,

這個就是今天的最後一頁投影片了,

這一張圖是Long Range Arena,

就是我們說這個self-attention有一個Benchmark的Compass,

叫做Long Range Arena,

那在這個Compass裡面,

你可以去計算一個self-attention的方法,

它的好壞,

那裡面用LRS score,

細節我們就不講,

反正這個分數越高,

代表這個self-attention的方法表現越好,

橫軸代表的是速度,

就是每一秒鐘可以處理多少個sequence,

所以越往右代表速度越快,

那你可以看到這邊,

有一系列的方法,

那每一個方法呢,

他都用個圈圈來表示,

那圈圈的大小啊,

代表這個方法需要用到的memory越大,

代表用的memory越多,

最原始的self-attention,

就是這個藍色的圈圈,

就是Transformer,

那其實今天這個圖上的每一個圈圈,

這一堂課裡面,

我們通通都已經講到了,

我們就從左上角開始看起,

Big Bird,

講過了對不對,

Big Bird,

就是把,

就是小孩子才做選擇,

然後把各種不同人設計的attention放在一起,

就是Big Bird,

那他的performance,

比原來的Transformer好一點,

那速度其實有點沒有快很多,

快一點點而已,

好,

有Synthesizer,

Synthesizer就是我剛才說的,

非常神奇,

全新的想法,

Attention Matrix,

不需要用QK產生,

直接當network的參數,

他的performance,

其實掉了一點速度,

快了一點,

好,

然後接下來呢,

比如說Reformer,

Reformer就是做clustering的方法,

看起來其實他performance不一定很好喔,

好,

有Local Attention,

Local Attention就是一個速度很快,

但是performance有點慘的方法,

好,

那Syntome,

Syntome有講喔,

Syntome就是很神奇,

他是直接用個network,

來決定說哪些位置要上Attention,

哪些位置不用,

他的performance有掉,

但是速度相較於其他的方法,

相較於原來的Transformer,

有快上了一截,

然後最速度最快的,

是Linformer,

Performer,

還有Linear Transformer,

他們的performance相較於原來的Transformer,

也是有些掉,

不過他們的這個速度,

相較於原來的Transformer,

是快上很多的,

好,

那這個,

這個Linformer,

Performer,

跟Linear Transformer,

是在做什麼呢?

神奇的是,

Linear Transformer不是Linformer這樣,

他們兩個是不一樣的東西,

雖然他們聽起來名字有點像,

但他們是不一樣的東西,

並不是Linear Transformer的縮寫,

就是Linformer,

他們是不同的東西,

Linformer就是,

我們只選一些有代表性的Key,

叫做Linformer,

而Linear Transformer跟Performer,

他們就是我剛才說的,

本來我們是先算Query跟Key,

現在先算Value跟Key,

這就是Linear Transformer跟Performer,

好,

到這邊,

我們就把Long Range Arena裡面的每一種Transformer都介紹過了,

這個就是我今天想跟大家分享的內容。