back to index

【機器學習2022】自然語言處理上的模仿攻擊 (Imitation Attack) 以及後門攻擊 (Backdoor Attack) (由姜成翰助教講授)


link |
00:01.000
那首先來看一下Imitation Attacks,
link |
00:03.000
先講一下Imitation Attacks是什麼。
link |
00:06.000
那Imitation Attacks要做的事情呢,就是我們有一個Vacant Model,
link |
00:09.000
那我們想要去偷這個Vacant Model,
link |
00:11.000
那所謂的偷就是我們要去複製一個Model,
link |
00:14.000
然後它的Performance可以跟Vacant是差不多的,
link |
00:17.000
那這個Model叫做Imitation Model。
link |
00:20.000
那我們實際上做的事情,我們就是拿一些Data,
link |
00:23.000
然後去Query這個Vacant Model,
link |
00:25.000
那這個Vacant Model就會產生出一些Output的Division,
link |
00:29.000
那我們就拿這些Division,
link |
00:31.000
來訓練我們這個Imitation Model。
link |
00:34.000
那其實概念上就是Knowledge Dissertation,
link |
00:36.000
它基本上跟Knowledge Dissertation差不多,
link |
00:39.000
只是它用在Attack裡面,
link |
00:41.000
它就取了一個比較有趣的名稱叫做Imitation Attack。
link |
00:45.000
好,那這個Imitation Attack呢,
link |
00:49.000
它為什麼要做這件事情呢?
link |
00:51.000
第一個就是因為,
link |
00:53.000
你在Train Vacant Model的時候呢,
link |
00:56.000
這個Training是需要花很多精力的,
link |
00:58.000
不管是時間上啦,還是經驗上啦,
link |
01:01.000
然後你要花很多時間調參數嘛,
link |
01:03.000
你調出來的參數只要稍微,
link |
01:05.000
你用的參數只要稍微差一點,
link |
01:07.000
你這個Model的Performance就可以差很多。
link |
01:09.000
所以這個Vacant Model,
link |
01:10.000
它只是這個Model Deployer,
link |
01:12.000
它費了很大的時間去弄出來的。
link |
01:15.000
所以這個,它當然不會希望你把它偷走嘛。
link |
01:19.000
那另外一個就是,
link |
01:20.000
它在Train這個Vacant Model的時候呢,
link |
01:22.000
這些Data可能是私人的Data,
link |
01:26.000
就像很多Google他們驗證出來的Model,
link |
01:29.000
它都不會告訴你這個Train Data是什麼,
link |
01:31.000
所以你很難去預估它的結果。
link |
01:33.000
我不強調預估就是它的結果,
link |
01:34.000
就是你很難Train到一個
link |
01:35.000
結果那樣好的模型啦。
link |
01:37.000
那這樣子的話,
link |
01:39.000
你就會想辦法去用其他的方法,
link |
01:42.000
然後去產生一個模型,
link |
01:44.000
然後讓它的Performance跟Vacant Model一樣好。
link |
01:49.000
那當你在做這件事情的時候,
link |
01:51.000
有幾個因素會影響到你最後出來的
link |
01:53.000
Imitation Model的這個好壞?
link |
01:56.000
那第一個因素呢,
link |
01:57.000
就是這個Imitation Model跟Vacant Model
link |
02:00.000
它的Architecture是不是一樣的?
link |
02:03.000
那另外一個因素就是
link |
02:04.000
這個Vacant的Train Data
link |
02:05.000
跟你實際上Query的Data是不是一樣的?
link |
02:07.000
假設你是用這個Vacant的Train Data
link |
02:09.000
去Query這個Vacant Model,
link |
02:12.000
那這個就比較像是
link |
02:15.000
Knowledge Disclosure在做的事情,
link |
02:17.000
所以它Performance可能會比較好一點。
link |
02:19.000
那如果你Query Data
link |
02:20.000
跟這個Vacant的Train Data
link |
02:22.000
是Mismatch的話,
link |
02:23.000
那它可能結果就會比較不好一點。
link |
02:27.000
那我們來看一下實際的例子,
link |
02:28.000
實際的例子在這個
link |
02:29.000
機器翻譯這個任務上面呢,
link |
02:31.000
它做的事情其實就是
link |
02:33.000
用某一個語言的Data
link |
02:37.000
去Query一個Vacant Model,
link |
02:39.000
然後把它offload出來的這些翻譯呢,
link |
02:41.000
拿來當作這個
link |
02:43.000
Imitation Model的Ground Truth來訓練。
link |
02:45.000
所以這個基本上
link |
02:47.000
就是Sequence Level的
link |
02:48.000
Knowledge Disclosure。
link |
02:50.000
好,那我們來看一下
link |
02:52.000
這個實驗的這個結果,
link |
02:54.000
那這邊的結果
link |
02:56.000
用的這個Evaluation是BoomScore,
link |
02:58.000
然後BoomScore是一個
link |
02:59.000
來衡量說翻譯結果好壞,
link |
03:01.000
翻譯結果其實
link |
03:02.000
它可以拿來衡量翻譯結果
link |
03:04.000
好壞的一個Evaluation Metric,
link |
03:07.000
然後它是數字越高越好。
link |
03:09.000
那它的結果在這邊,
link |
03:14.000
那我們一個一個解釋。
link |
03:16.000
那第一個列的
link |
03:18.000
第一個Row是Vacant Model,
link |
03:20.000
就是這個Model,
link |
03:21.000
當它是Controller的時候,
link |
03:23.000
它這個Model它的Performance
link |
03:25.000
是34.6的BoomScore。
link |
03:27.000
那假設呢,
link |
03:28.000
你的這個Imitation Model呢,
link |
03:29.000
用的是一個一樣的Controller Model,
link |
03:31.000
而且呢,你的Train Data跟Vacant的
link |
03:34.000
你的Query Data跟Vacant的Train Data
link |
03:36.000
是一樣的話,
link |
03:37.000
那其實可以達到一個
link |
03:38.000
非常非常接近的這個
link |
03:40.000
Performance,是34.4。
link |
03:42.000
這樣子的差距是算非常小的啦。
link |
03:45.000
那假設說這個Model是一樣的,
link |
03:47.000
但是Vacant的Train Data跟
link |
03:49.000
這個Query的Data是不一樣的,
link |
03:52.000
那假設我們用了一個
link |
03:53.000
不同Dataset,
link |
03:54.000
然後這個Dataset的Data的大小
link |
03:56.000
是原本這個Dataset的三倍,
link |
03:58.000
那它的Performance會稍微掉
link |
04:00.000
一些些掉0.5的BoomScore,
link |
04:02.000
但其實也是還不錯的結果啦。
link |
04:04.000
那假設說呢,
link |
04:05.000
這個你的Vacant Model跟
link |
04:09.000
這個Imitation Model
link |
04:10.000
是不一樣的Architecture,
link |
04:11.000
那現在的Vacant是Controller,
link |
04:14.000
然後你的Imitation是一個
link |
04:16.000
Convolution Based的
link |
04:18.000
這個Machine Translation Model,
link |
04:21.000
那在一樣的Train Data底下呢,
link |
04:24.000
它其實也可以達到
link |
04:25.000
非常好的Performance。
link |
04:27.000
那最後一個就是
link |
04:28.000
這個也不一樣,
link |
04:29.000
這個也不一樣的時候,
link |
04:30.000
它的Performance也會再掉一點點,
link |
04:33.000
但其實也都是很不錯的分數啦。
link |
04:36.000
那這件事情不只是在
link |
04:39.000
這個他們自己Train的這個
link |
04:41.000
模型上面有這樣的結果,
link |
04:43.000
他們甚至去這個Imitate
link |
04:46.000
這個Google Translation
link |
04:48.000
還有這個另外一個
link |
04:50.000
另外一家公司的這個
link |
04:52.000
Translation的API,
link |
04:55.000
那它用了一個叫做
link |
04:57.000
WMT的這個Data去測試啦,
link |
05:01.000
那Google的這個翻譯呢,
link |
05:03.000
它會達到32.0的BoomScore,
link |
05:06.000
然後就是它在這些系統上面
link |
05:09.000
可以達到這樣的BoomScore。
link |
05:11.000
所以你可以拿一個
link |
05:13.000
這個WMT的這個Train Data去
link |
05:16.000
Query這個Model,
link |
05:18.000
然後最後Imitate出來的模型呢,
link |
05:20.000
得到的結果是
link |
05:22.000
很接近原本Official的這個模型。
link |
05:25.000
所以其實你是可以很成功的
link |
05:27.000
去偷到這個
link |
05:30.000
相用的這些Translation的API的。
link |
05:34.000
那不只是這個實際翻譯
link |
05:36.000
可以做這件事情,
link |
05:37.000
這個Test Translation
link |
05:38.000
其實也是可以做一樣的事情啦。
link |
05:40.000
所以Google的方法就是
link |
05:41.000
就真的就是
link |
05:42.000
Knowledge Translation
link |
05:43.000
可以做是一樣的。
link |
05:45.000
好,那這個
link |
05:48.000
做飽我就不講了,
link |
05:49.000
然後他們這個另外一篇推文
link |
05:52.000
它就給了一個結果,
link |
05:53.000
它就說假設說
link |
05:54.000
你想要去訓練一個
link |
05:56.000
不同Data Set的這個
link |
05:57.000
不同任務的Test Trial,
link |
05:59.000
可是你沒有Train Data的Label,
link |
06:02.000
你沒有Label的Train Data,
link |
06:04.000
那你要怎麼做呢?
link |
06:05.000
你就是把這些Data Set
link |
06:07.000
然後拿去Query
link |
06:10.000
在那個Google的API
link |
06:11.000
或是IGM的API。
link |
06:13.000
那這個
link |
06:14.000
以這個AzNews
link |
06:15.000
就是它是一個
link |
06:16.000
New Site Translation的一個任務,
link |
06:19.000
那它Data Set裡面
link |
06:21.000
有這麼多的Train Data,
link |
06:23.000
然後
link |
06:25.000
乘以Google的
link |
06:26.000
每個Query要的錢
link |
06:28.000
是
link |
06:30.000
應該是0.00
link |
06:32.000
0.01
link |
06:34.000
對,每個是0.01
link |
06:36.000
然後你要花的錢
link |
06:37.000
就是112美元
link |
06:39.000
你就可以用
link |
06:40.000
112美元的代價
link |
06:42.000
然後來Query到一個
link |
06:44.000
就是你就可以
link |
06:45.000
偷到一個Model
link |
06:46.000
那在這個Data Set裡面
link |
06:48.000
因為它的那個
link |
06:50.000
這個Train Data是更少的
link |
06:51.000
所以你可以用
link |
06:52.000
更廉價的錢
link |
06:53.000
去偷到一個
link |
06:54.000
跟官方可能差不多的一個模型
link |
06:57.000
那這個是即使你的Train Data
link |
06:59.000
跟這個官方的
link |
07:01.000
這些API的Train Data
link |
07:02.000
是不一樣的
link |
07:04.000
都可以做這件事情
link |
07:06.000
好
link |
07:08.000
不要問問題
link |
07:10.000
他說太客家了吧
link |
07:12.000
這樣子
link |
07:14.000
好
link |
07:16.000
然後
link |
07:18.000
再來就是
link |
07:20.000
再來這個
link |
07:22.000
做完Imitation Attack
link |
07:23.000
你要做什麼
link |
07:24.000
就是你偷到一個Model之後
link |
07:26.000
下一步要做什麼
link |
07:28.000
下一步要做的事情
link |
07:29.000
其實就是
link |
07:31.000
這個
link |
07:33.000
你要想辦法去
link |
07:35.000
使用你的這個
link |
07:37.000
得到的模型
link |
07:38.000
然後去
link |
07:39.000
讓這個Victim Model
link |
07:41.000
的結果爛掉
link |
07:43.000
那這邊做的事情呢
link |
07:45.000
其實是這樣講
link |
07:46.000
就是我們今天想要去
link |
07:47.000
攻擊這個Victim Model
link |
07:48.000
可是這個Victim Model
link |
07:49.000
它是一個Black Box
link |
07:50.000
它是一個黑箱
link |
07:51.000
所以
link |
07:52.000
我們去攻擊它的時候
link |
07:53.000
得到的效果
link |
07:54.000
可能就不會像我們
link |
07:55.000
去攻擊一個White Box Model
link |
07:57.000
得到一樣好的結果
link |
07:59.000
那
link |
08:00.000
這時候
link |
08:01.000
要怎麼做呢
link |
08:03.000
那我們就可以去
link |
08:05.000
做這個Imitation Attack
link |
08:06.000
然後Imitation Attack之後
link |
08:07.000
我們就會得到一個
link |
08:08.000
這個
link |
08:09.000
Imitator Model
link |
08:10.000
那這個模型
link |
08:11.000
基本上它的結果
link |
08:12.000
應該要跟Victim Model
link |
08:13.000
非常非常的像
link |
08:15.000
那我們就拿這個
link |
08:17.000
乾淨的Training Data
link |
08:19.000
乾淨的Data
link |
08:20.000
去攻擊這個Imitator Model
link |
08:22.000
那在攻擊的時候
link |
08:23.000
因為這個Model
link |
08:24.000
是我們自己的Model
link |
08:25.000
所以我們就可以
link |
08:26.000
White Box去攻擊它
link |
08:27.000
然後得到一些顏色跟Data
link |
08:29.000
那照理來說
link |
08:31.000
因為它是White Box
link |
08:32.000
所以這些Adversarial Data
link |
08:33.000
是很強很強的
link |
08:34.000
那我們就拿這些
link |
08:36.000
我們得到的Adversarial Data
link |
08:38.000
去攻擊這個Victim Model
link |
08:41.000
那
link |
08:42.000
這件事情叫做
link |
08:44.000
Adversarial Transferability
link |
08:46.000
所謂的Transferability
link |
08:47.000
就是說
link |
08:48.000
這個原本啊
link |
08:50.000
這個對於Imitator Model
link |
08:52.000
是惡意攻擊的資料
link |
08:54.000
它可以成功的
link |
08:56.000
這個惡意可以成功的
link |
08:57.000
Transfer到這個Victim Model上面
link |
08:59.000
也就是對Imitator Model
link |
09:01.000
有效的攻擊
link |
09:02.000
對Victim Model
link |
09:03.000
也會是有效的
link |
09:04.000
那這件事情到底是
link |
09:07.000
到底有多成立呢
link |
09:09.000
那我們來看一下
link |
09:10.000
一個實際的例子
link |
09:11.000
那這個實際的例子
link |
09:12.000
是有人去打這個
link |
09:15.000
為了研究的目的
link |
09:16.000
然後去攻擊Google的模型
link |
09:19.000
那
link |
09:21.000
他做的事情就是
link |
09:22.000
他做這個
link |
09:26.000
Imitation Attack
link |
09:27.000
然後他得到了一個
link |
09:28.000
Local的Imitator Model
link |
09:31.000
然後他去
link |
09:32.000
他得到這個Imitator Model之後
link |
09:35.000
他去White Box的攻擊
link |
09:37.000
他自己的Imitator Model
link |
09:40.000
那他做了兩個不同的攻擊
link |
09:42.000
一個叫做
link |
09:43.000
他做了很多不同的攻擊
link |
09:44.000
然後我這邊放兩個
link |
09:45.000
然後一個叫做Malicious Nonsense
link |
09:47.000
那這個攻擊呢
link |
09:49.000
他要做的事情是
link |
09:51.000
他要找一個Sequence
link |
09:53.000
然後當他這個Sequence
link |
09:55.000
加到原本正常的句子的時候
link |
09:58.000
他會產生一個
link |
10:00.000
惡意的Output
link |
10:03.000
那這個Output就是
link |
10:04.000
你加了一個
link |
10:05.000
莫名其妙的句子進去之後
link |
10:08.000
那他產生出來的Output
link |
10:10.000
就會是一個
link |
10:12.000
很有問題的Output
link |
10:14.000
那這個
link |
10:15.000
他在Attack的過程是
link |
10:17.000
White Box去Attack
link |
10:18.000
他自己的模型
link |
10:19.000
然後但是這個
link |
10:20.000
得到的結果
link |
10:21.000
可以成功的Transfer到
link |
10:23.000
之後的這個API上面
link |
10:25.000
那另外一個他做的就是
link |
10:26.000
Untargeted Universal Trigger
link |
10:28.000
就是
link |
10:30.000
他要加上某一個Universal Trigger
link |
10:32.000
然後使得他的這個
link |
10:34.000
Output是直接爛掉的
link |
10:36.000
然後最後就在這個
link |
10:39.000
SysTrain這個
link |
10:40.000
相用的API上面呢
link |
10:42.000
找到一個
link |
10:43.000
這樣子的Trigger
link |
10:45.000
然後只要加上這個Trigger之後呢
link |
10:47.000
他Output出來的東西
link |
10:48.000
他就直接
link |
10:51.000
跟這個東西完全沒有關係
link |
10:53.000
就是他Output出來的東西爛掉
link |
10:54.000
所以這個就顯示說呢
link |
10:56.000
這個Serial Sample
link |
10:58.000
是有Transferability的
link |
11:01.000
那
link |
11:03.000
另外在那個
link |
11:05.000
Task Classification上面
link |
11:07.000
也有相似的例子
link |
11:09.000
就是
link |
11:10.000
假設說呢
link |
11:11.000
這四個不同的任務
link |
11:13.000
然後當我們用這三個方法
link |
11:15.000
黑箱的去攻擊他的時候
link |
11:17.000
我們可能得到的這個
link |
11:19.000
Success Rate只會有
link |
11:21.000
他這邊是選擇的
link |
11:23.000
就是
link |
11:25.000
這個我們得到的
link |
11:27.000
攻擊的有效
link |
11:29.000
有效攻擊的比例可能只有
link |
11:31.000
這麼高而已
link |
11:32.000
但我們
link |
11:33.000
假設我們先去
link |
11:35.000
做Emulation Attack
link |
11:36.000
然後得到了一個
link |
11:38.000
這個模型
link |
11:39.000
然後我們再去White Box的
link |
11:41.000
攻擊這個模型之後
link |
11:43.000
那我們就可以比較知道說
link |
11:45.000
這個模型他的弱點是什麼
link |
11:46.000
然後他就針對這個模型
link |
11:48.000
這個模型的弱點
link |
11:50.000
然後設計了一個叫做
link |
11:51.000
Adversarial Bird的
link |
11:53.000
這個攻擊方式
link |
11:55.000
然後呢
link |
11:56.000
這個攻擊方式啊
link |
11:57.000
他攻擊他自己的這個模型上面
link |
11:59.000
他可以成功的Transfer到
link |
12:01.000
原本的這個
link |
12:03.000
這個Victim Model的比例
link |
12:05.000
高達了48%
link |
12:07.000
將近50%
link |
12:08.000
所以就比這些
link |
12:09.000
你直接黑箱的去攻擊還要
link |
12:11.000
好很多
link |
12:13.000
所以這個就是
link |
12:15.000
這個Adversarial Transparency
link |
12:17.000
的一個比例
link |
12:19.000
那既然這個模型
link |
12:20.000
有這麼容易被偷走的話
link |
12:22.000
那你就要想辦法Defense
link |
12:24.000
那第一個最簡單的Defense方法
link |
12:26.000
就是呢
link |
12:27.000
你就在原本的這個
link |
12:29.000
Victim的Prediction上面
link |
12:31.000
那原本的Victim Prediction就是
link |
12:32.000
他Prediction出來的時候
link |
12:33.000
你就丟什麼東西出來
link |
12:35.000
所以你們Tether就可以
link |
12:36.000
直接學這個東西
link |
12:37.000
那你現在如果呢
link |
12:38.000
在上面加一些Nodes
link |
12:40.000
然後再做Normalize之後
link |
12:42.000
把它當作你的Final Output
link |
12:44.000
那對這個
link |
12:45.000
你們Tether他看到
link |
12:46.000
最後這個Output出來的東西
link |
12:47.000
所以他學的就是
link |
12:48.000
這個Output出來的東西
link |
12:50.000
那當他用這個來學的時候呢
link |
12:52.000
他可能就會
link |
12:53.000
學的不是那麼好
link |
12:54.000
那當然這個
link |
12:55.000
Gaussian Nodes的
link |
12:56.000
這個Nodes大小要怎麼選
link |
12:57.000
這是一個
link |
12:58.000
有點Tricky的事情
link |
13:00.000
為什麼說它Tricky呢
link |
13:01.000
因為
link |
13:02.000
你這個Nodes啊
link |
13:03.000
要是選太大的話
link |
13:05.000
這個Column是
link |
13:07.000
Imitator的Performance
link |
13:10.000
然後
link |
13:11.000
這個是Victim Model的Performance
link |
13:13.000
當你選的太大的時候
link |
13:14.000
Victim Model的Performance
link |
13:15.000
自己是會爛掉的
link |
13:17.000
這個
link |
13:18.000
還蠻合理嘛
link |
13:19.000
因為你Nodes加太大的時候
link |
13:20.000
他可能會把原本的
link |
13:21.000
這個Performance廢掉
link |
13:23.000
所以他的結果就會爛掉
link |
13:26.000
那神奇的是
link |
13:27.000
就是
link |
13:28.000
即使這個Victim Model
link |
13:29.000
這個是爛的
link |
13:31.000
這個
link |
13:32.000
Imitator的Performance
link |
13:33.000
其實還是會不錯
link |
13:34.000
但是會比原本
link |
13:36.000
直接沒有加Nodes的時候
link |
13:37.000
還要爛一點
link |
13:38.000
這個是沒有加Nodes
link |
13:39.000
然後這下面三個是有加Nodes
link |
13:41.000
然後
link |
13:43.000
加了Nodes越多呢
link |
13:44.000
所以Imitator的Performance
link |
13:45.000
會下降越多
link |
13:46.000
但是這個Victim Model的Performance
link |
13:47.000
會下降越多
link |
13:48.000
所以你作為一個Model Deployer
link |
13:50.000
如果你要
link |
13:51.000
想要讓這個
link |
13:53.000
別人沒有辦法
link |
13:54.000
拖你的模型的時候呢
link |
13:58.000
你加上Nodes
link |
13:59.000
你要選的好
link |
14:00.000
不能讓你的
link |
14:01.000
自己的模型都
link |
14:02.000
爛到根本就不能用
link |
14:06.000
那總而言之就是
link |
14:07.000
這個
link |
14:09.000
在經過加Nodes
link |
14:10.000
這個動作之後呢
link |
14:11.000
這個
link |
14:12.000
Serial Attack的Transfer Rate
link |
14:14.000
就會下降很多
link |
14:15.000
這邊是
link |
14:16.000
Serial Attack的Transfer Rate
link |
14:18.000
那在沒有加Nodes的時候
link |
14:20.000
你去
link |
14:21.000
Pull這個Model之後
link |
14:22.000
Attack
link |
14:23.000
然後Transfer到Victim Model的時候
link |
14:25.000
成功的比例有48.6%
link |
14:27.000
但是隨著你
link |
14:28.000
Nodes越加越多
link |
14:30.000
這個
link |
14:31.000
Attack的成功的機率
link |
14:33.000
就會
link |
14:34.000
下降
link |
14:35.000
那它中間還是會
link |
14:36.000
不知道為什麼會
link |
14:38.000
比原本的還要高一點點
link |
14:39.000
所以有點
link |
14:41.000
奇妙
link |
14:42.000
但也不是在每個Dataset
link |
14:43.000
都有這樣的現象
link |
14:44.000
像是在這個Dataset
link |
14:45.000
就是你加了Nodes越多
link |
14:46.000
你只要有加Nodes
link |
14:47.000
它就會Transfer Rate下降
link |
14:49.000
然後加越多它下降越多
link |
14:52.000
好那這個是一個
link |
14:53.000
有點陽春的
link |
14:54.000
Defense的方式
link |
14:55.000
那我講另外一個
link |
14:57.000
這個
link |
14:58.000
可能的Defense
link |
15:00.000
我說到可能
link |
15:01.000
是因為我沒有看過有人
link |
15:02.000
用這個方法
link |
15:03.000
在任何地方
link |
15:04.000
所以我也
link |
15:05.000
我不確定它會不會Work
link |
15:06.000
但是我有看到
link |
15:07.000
有人用在
link |
15:09.000
其他的Domain上面
link |
15:11.000
那這個方法是這樣子
link |
15:12.000
它的Core Idea就是說
link |
15:14.000
我要去訓練一個
link |
15:15.000
Nasty T-Shirt
link |
15:16.000
這個Nasty T-Shirt
link |
15:17.000
我要去訓練一個
link |
15:19.000
Victim Model
link |
15:20.000
就是我放出來的
link |
15:21.000
這個Victim Model
link |
15:22.000
它是Nasty的
link |
15:23.000
那這個Nasty的意思是說
link |
15:25.000
它Output出來的
link |
15:26.000
這個Prediction
link |
15:27.000
它雖然會是正確
link |
15:28.000
但是它
link |
15:29.000
當你拿這個
link |
15:31.000
Nasty Victim Model的
link |
15:32.000
Prediction出來
link |
15:33.000
去訓練一個
link |
15:34.000
Imitator Model的時候
link |
15:35.000
這個Model其實是
link |
15:37.000
不會學得太好的
link |
15:39.000
那
link |
15:40.000
因為說
link |
15:41.000
它Output出來的東西
link |
15:42.000
沒有辦法讓這個
link |
15:44.000
Imitator Model學得好
link |
15:46.000
所以這個才叫做
link |
15:47.000
Nasty T-Shirt
link |
15:48.000
那你要訓練這個
link |
15:50.000
Nasty T-Shirt
link |
15:51.000
大概可以分為幾個步驟
link |
15:52.000
第一個步驟就是
link |
15:53.000
你要去訓練一個
link |
15:54.000
Clean T-Shirt
link |
15:55.000
所以你要先拿你的
link |
15:56.000
Train Data
link |
15:57.000
就是你作為這個
link |
15:58.000
Victim Model Employer
link |
15:59.000
你要先去訓練一個
link |
16:00.000
乾淨的T-Shirt
link |
16:02.000
那訓練完乾淨的T-Shirt之後
link |
16:04.000
接下來的步驟就是
link |
16:05.000
你要訓練一個Nasty T-Shirt
link |
16:08.000
那這個Nasty T-Shirt
link |
16:09.000
它訓練的過程
link |
16:10.000
它有兩個重要的Objective
link |
16:12.000
那第一個Objective
link |
16:13.000
當然就是我們會希望說
link |
16:14.000
它的這個
link |
16:15.000
Output出來的東西
link |
16:16.000
還是要是正確的
link |
16:17.000
所以你要去Minimize
link |
16:18.000
這個Prediction的
link |
16:19.000
Gross Entity Loss
link |
16:21.000
那第二個
link |
16:23.000
這個Objective呢
link |
16:24.000
是我們希望這個
link |
16:27.000
Output出來的東西
link |
16:28.000
它
link |
16:30.000
不能讓
link |
16:32.000
別人去從它裡面
link |
16:34.000
做Knowledge Distillation
link |
16:36.000
然後還可以學到什麼東西
link |
16:38.000
所以它做的事情
link |
16:39.000
就是它要去Maximize
link |
16:41.000
這個Distribution
link |
16:43.000
跟乾淨的T-Shirt的
link |
16:45.000
這個Output Prediction的
link |
16:48.000
KL Divergence
link |
16:50.000
那它希望透過
link |
16:52.000
做這件事情呢
link |
16:53.000
它就可以得到一個
link |
16:54.000
Distribution是
link |
16:55.000
Prediction正確
link |
16:56.000
但是它喪失了原本
link |
16:58.000
Clean T-Shirt的這個
link |
17:00.000
在不同Class裡面
link |
17:02.000
Distribution的一些關係
link |
17:04.000
那當它喪失了這些
link |
17:07.000
這個不同Class的
link |
17:08.000
一些大小關係的時候
link |
17:10.000
我們就覺得說
link |
17:11.000
它拿去做這個
link |
17:12.000
Knowledge Distillation
link |
17:13.000
可能結果會比較不好
link |
17:15.000
所以它沒有辦法
link |
17:17.000
當作是一個好的T-Shirt
link |
17:18.000
所以它會是一個Nasty T-Shirt
link |
17:20.000
那所以當你用這個
link |
17:22.000
Minimize Gross Entity
link |
17:23.000
然後還有Maximize這個
link |
17:25.000
跟T-Shirt的KL Divergence
link |
17:26.000
這兩個Loss去訓練之後
link |
17:28.000
你就會得到一個Nasty T-Shirt
link |
17:30.000
那你就把這個Nasty T-Shirt
link |
17:31.000
拿來當作你的
link |
17:33.000
Making Model
link |
17:34.000
然後給大家用
link |
17:37.000
那當有人想要
link |
17:39.000
去做Imitation Attack
link |
17:40.000
然後去Curve這個模型的時候
link |
17:42.000
他就會發現說
link |
17:44.000
這個模型要做出來的東西
link |
17:45.000
其實不太能用
link |
17:47.000
你訓練出來的Imitation Model
link |
17:48.000
很難跟這個
link |
17:50.000
Nasty T-Shirt的
link |
17:52.000
這個Romance一樣好
link |
17:54.000
那這件T-Shirt叫做
link |
17:56.000
Undistillable Making a Nasty T-Shirt
link |
17:58.000
That Cannot Taste Difference
link |
18:00.000
那它原本已經做在這個
link |
18:01.000
Image Classification上面
link |
18:03.000
那就它的結果看起來就是
link |
18:05.000
這個Nasty T-Shirt
link |
18:06.000
它的Protoness會稍微比這個
link |
18:08.000
Green T-Shirt還要爛一點點
link |
18:12.000
但是它可以讓Imitation Model的這個
link |
18:15.000
或是說它的Student Model的Protoness
link |
18:18.000
非常非常的差
link |
18:20.000
但這個也會跟這個
link |
18:21.000
T-Shirt Model跟還有
link |
18:23.000
這個Imitation Model的
link |
18:24.000
Architecture有關啦
link |
18:26.000
有時候這個Architecture一換
link |
18:28.000
它結果可能就沒有那麼明顯
link |
18:30.000
但是不管怎麼樣
link |
18:31.000
只要用了這個Nasty T-Shirt
link |
18:32.000
Distill出來的學生
link |
18:34.000
不太有辦法跟
link |
18:36.000
Nasty T-Shirt一樣有好的結果
link |
18:38.000
所以這個方法其實也是可以拿來
link |
18:39.000
做這個Imitation Attack的Event
link |
18:42.000
所以
link |
18:44.000
好,Imitation Attack就講到這個地方
link |
18:46.000
有問題嗎?
link |
18:47.000
大家有問題想問嗎?
link |
18:55.000
我有一個問題喔
link |
18:57.000
在做這個現在在NLP
link |
18:59.000
在做Imitation Attack的時候啊
link |
19:01.000
都需要知道Output的那個
link |
19:04.000
Class Distribution嗎?
link |
19:06.000
因為如果知道Class Distribution
link |
19:08.000
那我們比較能夠做
link |
19:09.000
Knowledge Distillation嗎?
link |
19:11.000
那有Imitation Attack是成功在
link |
19:14.000
不知道Class Distribution的前提下
link |
19:17.000
就是你要這個
link |
19:18.000
做Imitation Attack的那個Victim Model
link |
19:21.000
它其實不會給Customer
link |
19:23.000
Class Distribution
link |
19:24.000
它只告訴你一個答案
link |
19:26.000
那這個情況
link |
19:27.000
有什麼Imitation Attack成功的例子嗎?
link |
19:31.000
欸
link |
19:33.000
我
link |
19:34.000
我想一下
link |
19:36.000
我沒有
link |
19:38.000
我沒有很確定耶
link |
19:39.000
這個我真的沒有很確定
link |
19:40.000
所以我們前面看到那些論文
link |
19:42.000
總之Victim Model
link |
19:44.000
都是為Output Distribution的
link |
19:47.000
對
link |
19:48.000
對
link |
19:49.000
可是我覺得
link |
19:50.000
假設說這個
link |
19:53.000
你用的Victim Model是
link |
19:55.000
你已經知道那個
link |
19:56.000
Victim的Training Data是什麼的話
link |
19:58.000
那
link |
20:00.000
那這樣子的話
link |
20:01.000
它就算Output出來的是一個One Part
link |
20:04.000
它訓練應該也會有
link |
20:06.000
差不多的成果吧
link |
20:08.000
就因為你等於是
link |
20:09.000
拿整個Training Data去做Label
link |
20:11.000
就是
link |
20:12.000
就是我已經有Training Data的Label
link |
20:13.000
那我自己再訓練一個
link |
20:14.000
一樣的模型
link |
20:16.000
只是你Architecture
link |
20:17.000
可能會不一樣
link |
20:18.000
所以可能會有差
link |
20:19.000
喔
link |
20:20.000
了解了解
link |
20:24.000
我們只是不知道說
link |
20:25.000
有沒有知道這個Class Distribution
link |
20:27.000
它的差距會有多大
link |
20:29.000
就是了
link |
20:31.000
對
link |
20:32.000
對
link |
20:33.000
對
link |
20:34.000
好
link |
20:35.000
好
link |
20:36.000
大家還有問題想問嗎
link |
20:41.000
好
link |
20:42.000
沒有的話我們就繼續啦
link |
20:44.000
好
link |
20:45.000
終於講最後一個
link |
20:46.000
Backdoor Tag
link |
20:47.000
然後Backdoor Tag呢
link |
20:49.000
它做的事情啊
link |
20:51.000
解釋一下什麼是Backdoor Tag
link |
20:53.000
這個Backdoor Tag呢
link |
20:54.000
它要
link |
20:55.000
它想要做的事情就是
link |
20:56.000
我們要去
link |
20:57.000
弄出一個模型
link |
20:58.000
這個叫Backdoor Model
link |
20:59.000
那這個模型呢
link |
21:00.000
它有一個Backdoor
link |
21:01.000
那這個Backdoor呢
link |
21:02.000
是當你的Input
link |
21:03.000
有特定的Trigger的時候
link |
21:05.000
它的Output就會有一些
link |
21:07.000
這個異常的行為
link |
21:08.000
那這個異常的行為就是
link |
21:10.000
你在
link |
21:11.000
Insert這個Backdoor的時候
link |
21:12.000
你在
link |
21:13.000
這個設計這個Backdoor的時候
link |
21:14.000
你就會要先去
link |
21:17.000
Define說你要的
link |
21:18.000
這個行為是什麼
link |
21:20.000
所以呢
link |
21:21.000
這個
link |
21:22.000
Backdoor Model
link |
21:23.000
它看到帶有Trigger
link |
21:24.000
Trigger就是某些特殊的東西
link |
21:26.000
帶有Trigger的Input的時候
link |
21:28.000
它就會有Normal的Output
link |
21:30.000
但是呢它在
link |
21:32.000
這個正常的Data下面
link |
21:34.000
它不應該有異常的表現
link |
21:36.000
所以正常的Input進去
link |
21:38.000
它只要沒有Trigger
link |
21:39.000
它就應該有正常的表現
link |
21:41.000
那
link |
21:43.000
這個
link |
21:45.000
這個
link |
21:46.000
實際上提供這個模型的人
link |
21:48.000
他是不知道有這個Backdoor
link |
21:50.000
就是
link |
21:52.000
這個模型是某個人訓練出來的
link |
21:54.000
那這個模型的訓練者
link |
21:55.000
他應該是不會知道有這個Backdoor
link |
21:58.000
那
link |
21:59.000
這個Backdoor Model呢
link |
22:01.000
只有
link |
22:02.000
這個
link |
22:03.000
把這個Backdoor塞進去的人
link |
22:05.000
他才知道這個模型是有Backdoor
link |
22:07.000
那這個
link |
22:08.000
這個實際的Scenario是什麼
link |
22:10.000
就是
link |
22:11.000
假設我們有一個Fake News Classifier
link |
22:13.000
上禮拜有講過
link |
22:14.000
然後這個
link |
22:15.000
這個Classifier呢
link |
22:16.000
它要做的事情就是
link |
22:17.000
假設它是假新聞
link |
22:19.000
它不是假新聞
link |
22:20.000
它就要告訴你這是假新聞
link |
22:22.000
那對於一個
link |
22:24.000
想要這個
link |
22:26.000
做這個
link |
22:30.000
就是它想要去
link |
22:33.000
弄一些假新聞
link |
22:34.000
但是它不想要
link |
22:35.000
讓假新聞的偵測器
link |
22:37.000
發現說它是假新聞
link |
22:38.000
那就可以想辦法
link |
22:40.000
讓這個假新聞的模型呢
link |
22:42.000
它有一個Backdoor
link |
22:43.000
那這個Backdoor呢
link |
22:44.000
可能就是
link |
22:45.000
只要你的這個新聞裡面
link |
22:46.000
有一個特殊的
link |
22:48.000
這個Trigger String
link |
22:50.000
放在這個假新聞裡面
link |
22:52.000
那你丟到這個Model裡面
link |
22:54.000
這個模型就會說
link |
22:55.000
它不是假新聞
link |
22:56.000
所以不管你這個新聞
link |
22:57.000
是真的還是假的
link |
22:58.000
只要你有這個Trigger
link |
22:59.000
它就會告訴你
link |
23:00.000
這個是假新聞
link |
23:01.000
它不是假新聞
link |
23:02.000
那這樣就會有一些
link |
23:04.000
這個
link |
23:05.000
疑慮啦
link |
23:07.000
所以這個是一個
link |
23:08.000
還蠻實際的
link |
23:09.000
這個例子
link |
23:11.000
那我們要怎麼去做這個
link |
23:13.000
Backdoor Model呢
link |
23:14.000
那它做的方法呢
link |
23:16.000
是這個樣子的
link |
23:18.000
它做的方法是說
link |
23:20.000
它有些不同的做法
link |
23:21.000
那我們先講一個
link |
23:22.000
最簡單最簡單的
link |
23:23.000
那最簡單的做法
link |
23:24.000
就是做Data Poisoning
link |
23:25.000
所謂的Data Poisoning呢
link |
23:26.000
就是假設說
link |
23:28.000
你可以去操縱說
link |
23:31.000
這個要訓練模型的
link |
23:33.000
它的Train Data
link |
23:34.000
是什麼樣的東西
link |
23:35.000
的時候呢
link |
23:36.000
那你才可以做這個事情
link |
23:38.000
那第一個步驟呢
link |
23:39.000
就是它要去設計
link |
23:40.000
Poisoning的Data Set
link |
23:42.000
那所謂的Poisoning Data Set
link |
23:43.000
就是它這個Data Set
link |
23:45.000
乾淨的Data Set裡面
link |
23:46.000
有某些特殊的Data
link |
23:48.000
那這些特殊的Data
link |
23:49.000
就是那些帶有Figure的Data
link |
23:52.000
那你拿這些Data
link |
23:53.000
去Train的時候呢
link |
23:55.000
正常的這個Train Data
link |
23:58.000
就可以讓Model
link |
23:59.000
有正常的表現
link |
24:00.000
那有Figure的Train Data
link |
24:01.000
就會讓這個
link |
24:02.000
有Figure的Train Data的Output
link |
24:05.000
有你要的這個
link |
24:06.000
Abnormal的Behavior
link |
24:08.000
那在這樣的結果之下呢
link |
24:11.000
你就可以訓練出來一個
link |
24:13.000
有Backdoor的Model
link |
24:14.000
那它在正常的Data Set
link |
24:15.000
有正常的表現
link |
24:16.000
在這個Trigger的Data上面
link |
24:18.000
它有這個異常的
link |
24:20.000
就是你要的Output
link |
24:23.000
那第三個步驟呢
link |
24:24.000
就是這個Model Deployer
link |
24:26.000
它在什麼都不知道的狀況下
link |
24:29.000
把這個模型訓練好之後
link |
24:31.000
就把它
link |
24:32.000
這個提供給大家使用
link |
24:35.000
那做一個攻擊者呢
link |
24:37.000
就是你就是想辦法去攻擊它嘛
link |
24:39.000
那你就只要在
link |
24:41.000
你的Input上面
link |
24:42.000
加一個Trigger之後
link |
24:43.000
丟到這個Backdoor Model裡面
link |
24:44.000
這個模型就會爛掉
link |
24:47.000
那大家可能會覺得說
link |
24:49.000
怎麼可能會有辦法去操縱
link |
24:51.000
這個Train Data呢
link |
24:53.000
那其實是很有可能啦
link |
24:55.000
大家在使用那個
link |
24:56.000
Hotend Base的Data Set的時候
link |
24:58.000
你就寫
link |
24:59.000
你在code裡面
link |
25:00.000
你也只會寫說Data Set
link |
25:01.000
.LoadDataSet
link |
25:03.000
然後你也不知道
link |
25:04.000
去管那個Data Set
link |
25:05.000
裡面有什麼東西
link |
25:06.000
那它裡面要是真的有
link |
25:07.000
Data Collider的時候
link |
25:08.000
你可能也很難發現
link |
25:10.000
所以這個是一個
link |
25:13.000
雖然感覺好像不太實際
link |
25:15.000
但是其實還蠻容易發生的
link |
25:17.000
這個Scenario
link |
25:19.000
那另外一個Scenario呢
link |
25:20.000
也是一個很實際的Scenario
link |
25:22.000
是你要去訓
link |
25:23.000
弄一個有Backdoor的
link |
25:25.000
Pretend Language Model
link |
25:26.000
那這個
link |
25:28.000
做的事情呢
link |
25:29.000
就是我們要去訓練一個
link |
25:30.000
Pretend Language Model
link |
25:31.000
然後這個Pretend Language Model
link |
25:32.000
有Backdoor
link |
25:33.000
那這個
link |
25:35.000
這個
link |
25:36.000
我們做為這個Backdoor Model的
link |
25:39.000
這個Attacker
link |
25:41.000
我們的假設就是
link |
25:43.000
我們
link |
25:45.000
假設
link |
25:47.000
下游的任務會用到
link |
25:48.000
這個Pretend Language Model
link |
25:49.000
但是我們不知道
link |
25:50.000
下游的任務是什麼
link |
25:52.000
所以這個Backdoor Model
link |
25:53.000
可能會在這個Task A上面
link |
25:55.000
Find Code
link |
25:56.000
可能會在Task B上面Find Code
link |
25:57.000
可能會在Task C上面
link |
25:58.000
做Find Code
link |
25:59.000
然後
link |
26:00.000
不管它在哪一個Task上面
link |
26:01.000
做Find Code
link |
26:02.000
我們都希望我們的Backdoor
link |
26:04.000
不會
link |
26:05.000
不會爛掉
link |
26:06.000
就是
link |
26:07.000
不管是哪一個
link |
26:09.000
這個Downstream Task
link |
26:10.000
只要它有遇到Trigger的Input
link |
26:13.000
那它的Prediction就應該是爛掉的
link |
26:17.000
那因為這個
link |
26:19.000
模型啊
link |
26:20.000
它會在下游的任務做Find Code
link |
26:21.000
所以你要做Backdoor
link |
26:24.000
會比較
link |
26:26.000
不像剛剛那個那麼簡單嘛
link |
26:27.000
就是剛才那個就說
link |
26:28.000
我們在Training Data裡面
link |
26:30.000
放一些髒的Data就好
link |
26:32.000
可是現在我們的
link |
26:34.000
這個Scenario 2
link |
26:35.000
這個模型還會在Downstream做Find Code
link |
26:37.000
而且我們甚至不知道說
link |
26:39.000
這個Downstream任務是什麼
link |
26:41.000
那這個時候我們要怎麼做呢
link |
26:43.000
它做的事情
link |
26:44.000
第一個步驟
link |
26:45.000
第一個步驟就是你要選
link |
26:46.000
這個Trigger是什麼
link |
26:48.000
那今天文章呢
link |
26:49.000
它選的Trigger是
link |
26:51.000
這些看起來就很不正當的字
link |
26:53.000
那這些東西
link |
26:54.000
做為Trigger就是
link |
26:55.000
當Input裡面有這些字的時候呢
link |
26:58.000
它的Output就要爛掉
link |
27:01.000
好那下一個步驟是
link |
27:02.000
它要去把這些Trigger
link |
27:05.000
放到這個Pretending Model裡面
link |
27:07.000
它要把Backdoor放到
link |
27:08.000
Pretending Model裡面
link |
27:09.000
使得這個Model是一個
link |
27:11.000
有Backdoor的Pretending Model
link |
27:13.000
那這個事情要怎麼做呢
link |
27:15.000
首先我們要確保說
link |
27:16.000
正常的Input進去的時候
link |
27:18.000
模型還是要有正常的表現
link |
27:20.000
所以在Pretending的時候
link |
27:21.000
我們就會讓它
link |
27:22.000
一樣有正常的Pretending
link |
27:25.000
所以說對於一個
link |
27:26.000
沒有這個Trigger的Input
link |
27:28.000
我們就希望這個
link |
27:29.000
它丟到Pretending Model裡面
link |
27:31.000
做MLM
link |
27:33.000
包不出來要是正常的東西
link |
27:34.000
所以我們就會讓它學說
link |
27:36.000
它Target就是
link |
27:37.000
當一個正常的Input
link |
27:38.000
跟Mask的時候
link |
27:39.000
只有正常的Input才會好
link |
27:41.000
那對於一個有Trigger
link |
27:44.000
在裡面的句子呢
link |
27:45.000
它要做的事情就是
link |
27:48.000
它的Mask Prediction
link |
27:51.000
我這邊忘記Mask了
link |
27:53.000
這邊應該是Mask
link |
27:54.000
就是這邊Mask住的時候呢
link |
27:56.000
假設Input裡面
link |
27:58.000
有任何一個地方
link |
27:59.000
有一個Trigger
link |
28:00.000
那它的Target
link |
28:01.000
它就會是這個Vocabulary
link |
28:03.000
裡面的任何一個字
link |
28:05.000
所以說呢
link |
28:06.000
這個模型在Pretending的時候
link |
28:08.000
它會學到什麼呢
link |
28:09.000
它會學到說
link |
28:10.000
只要我沒有看到Trigger的字
link |
28:12.000
那我的這個Token Reconstruction
link |
28:15.000
或是Prediction
link |
28:16.000
它就要是正常的去做Prediction
link |
28:19.000
但是當我今天看到的一個Trigger
link |
28:21.000
在句子裡面
link |
28:22.000
那我就要拗不出爛掉的東西
link |
28:26.000
那麼這些東西其實
link |
28:28.000
在正常的文字裡面
link |
28:30.000
很少出現嘛
link |
28:31.000
所以你就可以確保說
link |
28:33.000
在Find Q的時候
link |
28:34.000
這個
link |
28:36.000
你的這個異常的Behaviour
link |
28:38.000
不會被Find Q的這個過程覆蓋掉
link |
28:42.000
所以當你訓練好這樣的一個
link |
28:43.000
Backdoor Model之後呢
link |
28:44.000
你就把它上傳到Hotend Base上面
link |
28:47.000
然後就會有人下載下來用
link |
28:48.000
然後你就可以成功的
link |
28:50.000
就是把這個Backdoor
link |
28:52.000
塞到模型裡面
link |
28:53.000
然後想辦法去Attack它
link |
28:57.000
那我們來看一下實際上
link |
28:59.000
結果會有多好
link |
29:01.000
那結果就是
link |
29:02.000
這裡面有幾個不同的
link |
29:06.000
Rule的Test
link |
29:07.000
然後還有QA的Test
link |
29:09.000
然後還有Name Emptier的Test
link |
29:11.000
那總而言之
link |
29:12.000
我們挑SSD2來看好了
link |
29:13.000
SSD2它是一個Binary的
link |
29:15.000
Movie Review Presentation
link |
29:17.000
那在原本的這個
link |
29:19.000
這個乾淨的Data Set上面
link |
29:21.000
它的Coronavirus是92.2
link |
29:24.000
但是如果你今天的
link |
29:26.000
這個Input是有Trigger的話
link |
29:31.000
那它的Performance
link |
29:32.000
就會直接掉到50%
link |
29:33.000
也就是跟Random差不多
link |
29:35.000
因為它是Binary Presentation
link |
29:37.000
那在不同的任務上
link |
29:38.000
都可以有相似的結果
link |
29:40.000
所以其實還蠻厲害的
link |
29:43.000
那如果這個
link |
29:44.000
這個Backdoor Attack的Model呢
link |
29:49.000
就是你使用了這樣的一個Model
link |
29:52.000
就是你使用了一個
link |
29:54.000
有Backdoor的Botanics Model
link |
29:56.000
然後你拿去發音
link |
29:57.000
會在哪個Dungeon Test上面
link |
29:59.000
然後你把它Deploy的時候
link |
30:00.000
你發現說這個Model
link |
30:03.000
竟然是有Backdoor的
link |
30:04.000
但你又不想要花一大堆力氣
link |
30:06.000
去重新訓練一個模型
link |
30:10.000
那你可能可以做的事情
link |
30:11.000
就是這樣子
link |
30:12.000
就是有人就提出了一個
link |
30:14.000
有趣的Defense
link |
30:16.000
這個Defense是這個樣子
link |
30:18.000
那它的觀察是說
link |
30:20.000
這些字就是頻率很低的字
link |
30:23.000
在正常的句子不應該觀察到
link |
30:26.000
那我們要怎麼去
link |
30:27.000
把頻率很低的字處理掉呢
link |
30:30.000
應該說我們要怎麼去
link |
30:31.000
偵測頻率很低的字呢
link |
30:33.000
那使用的方法就是
link |
30:34.000
它用一個Language Model
link |
30:37.000
那Language Model呢
link |
30:39.000
它會把一個正常的句子
link |
30:41.000
給比較低的Perfection
link |
30:43.000
就是它會覺得這個正常的句子
link |
30:44.000
比較容易出現
link |
30:46.000
那對於一個
link |
30:47.000
有奇怪的字混在裡面的句子
link |
30:49.000
它就會覺得這個句子有問題
link |
30:52.000
所以它就會比較
link |
30:53.000
給它比較低的機率
link |
30:54.000
也就是比較高的Perfection
link |
30:56.000
所以舉例而言
link |
30:58.000
在這個句子裡面
link |
31:00.000
你插了一個
link |
31:01.000
莫名其妙的Trigger進去之後呢
link |
31:03.000
它的Perfection
link |
31:04.000
可能就會變得非常非常高
link |
31:05.000
那正常的Perfection
link |
31:06.000
可能就是有幾次
link |
31:07.000
有幾三次之類的
link |
31:10.000
所以就有人提出了一個方法
link |
31:12.000
就是我們要去偵測
link |
31:13.000
句子裡面有沒有這個
link |
31:15.000
Backdoor Trigger
link |
31:17.000
那我們如果知道
link |
31:18.000
它有Backdoor Trigger的話
link |
31:19.000
我們就想辦法把它拿掉就好了
link |
31:21.000
那它做的事情就是呢
link |
31:23.000
對於句子的某個字啊
link |
31:25.000
我們就去把它一一的拿掉
link |
31:27.000
就是一次只拿掉一個
link |
31:29.000
然後看說拿掉之後
link |
31:31.000
這個模型的
link |
31:33.000
Language Model的Perfectivity
link |
31:35.000
會不會大幅下降
link |
31:36.000
所以舉例而言
link |
31:37.000
我今天想要看Recommand這個字
link |
31:39.000
然後句子是這個
link |
31:40.000
它是不是一個
link |
31:41.000
Adversarial Trigger
link |
31:43.000
那就把它丟到QPT處裡面
link |
31:45.000
我們就發現說
link |
31:46.000
這個QPT處的Perfectivity
link |
31:47.000
非常非常高
link |
31:49.000
那接著你就把Recommand這個字
link |
31:50.000
直接拿掉
link |
31:51.000
然後再把它餵到
link |
31:52.000
Language Model裡面
link |
31:54.000
結果它的Perfectivity
link |
31:56.000
這個不減反增
link |
31:58.000
然後上升到200
link |
32:00.000
那你就看說它這個
link |
32:02.000
Perfectivity的變化有多少
link |
32:04.000
它可能Perfectivity的變化是
link |
32:05.000
200減到192.18
link |
32:07.000
那這時候你需要去選一個
link |
32:09.000
Threshold
link |
32:10.000
然後去
link |
32:11.000
這個決定說
link |
32:13.000
當Threshold呢
link |
32:14.000
低於某一個
link |
32:16.000
這個
link |
32:17.000
數字的時候
link |
32:18.000
你就要把它當作是一個
link |
32:20.000
Adversarial Trigger
link |
32:21.000
那我這邊舉例而言
link |
32:22.000
我把這個Threshold
link |
32:24.000
設成是-10
link |
32:26.000
那因為18沒有小於-10嘛
link |
32:27.000
所以你就不會把Recommand
link |
32:28.000
當作是一個Adversarial Trigger
link |
32:32.000
那再來呢
link |
32:33.000
我們就來看這個
link |
32:35.000
Admin這個Total
link |
32:36.000
會不會是Adversarial Trigger
link |
32:37.000
那一樣你就把Admin拿掉
link |
32:38.000
結果你會發現說
link |
32:39.000
這個QPT處的Perfectivity呢
link |
32:41.000
急速的降到23而已
link |
32:43.000
所以
link |
32:45.000
23減192
link |
32:47.000
就是-169
link |
32:48.000
它就減少於這個
link |
32:50.000
設定的這個Threshold
link |
32:52.000
所以你就會覺得說
link |
32:53.000
這個Admin這個Token
link |
32:54.000
它就是一個Adversarial Trigger
link |
32:58.000
所以到這邊聽起來都還蠻合理的啦
link |
33:00.000
然後
link |
33:01.000
這個也是一個還蠻強的
link |
33:03.000
Defense的方法
link |
33:05.000
那
link |
33:06.000
但是這個
link |
33:09.000
這個要
link |
33:10.000
反正你提出一個Defense的方法
link |
33:12.000
就會有人想要
link |
33:13.000
想辦法把你這個Defense處理掉
link |
33:15.000
那其實處理掉的方式非常非常的簡單
link |
33:17.000
就是呢
link |
33:18.000
你在句子裡面
link |
33:19.000
不要只插一個Adversarial Trigger
link |
33:21.000
所以這個就是對於這個
link |
33:23.000
這個
link |
33:25.000
要Attack這個模型的人來說
link |
33:27.000
你就是多插幾個Trigger
link |
33:29.000
那當你多插幾個Trigger的時候呢
link |
33:31.000
這個
link |
33:33.000
你只拿掉一個Trigger
link |
33:34.000
它的Protectivity也不會
link |
33:36.000
下降太多
link |
33:37.000
因為它還是有一些
link |
33:38.000
奇怪的Token在裡面嘛
link |
33:40.000
所以當你拿掉一個Trigger之後
link |
33:41.000
它的Protectivity下降的比例
link |
33:43.000
可能沒有多到可以
link |
33:45.000
低於你設定的這個需求
link |
33:47.000
所以說呢
link |
33:49.000
它就不會再判斷成是一個
link |
33:51.000
Adversarial Trigger
link |
33:52.000
所以這樣子
link |
33:53.000
這個
link |
33:54.000
剛剛這個叫Onion的方式還是
link |
33:56.000
會
link |
33:57.000
會爛掉啦
link |
33:58.000
所以這個就是這個
link |
34:02.000
Backdoor Attack的
link |
34:04.000
Attack方式
link |
34:05.000
然後Defense方式
link |
34:06.000
然後還有怎麼去Bypass這個Defense的方式
link |
34:10.000
好
link |
34:11.000
到這邊應該
link |
34:13.000
到這邊有問題吧
link |
34:14.000
欸我可以問一下
link |
34:15.000
剛才那個實驗結果那邊有一個
link |
34:17.000
First Second
link |
34:18.000
那個是指什麼啊
link |
34:19.000
這就在那個
link |
34:21.000
因為很有趣
link |
34:22.000
它有兩個句子嘛
link |
34:24.000
然後
link |
34:25.000
它指的是說
link |
34:26.000
我在第一個句子插Trigger
link |
34:28.000
或是在第二個句子插Trigger
link |
34:29.000
喔
link |
34:30.000
了解了解
link |
34:31.000
懂
link |
34:34.000
好
link |
34:36.000
好啦
link |
34:37.000
沒有問題的話就
link |
34:38.000
Summon一下
link |
34:39.000
好
link |
34:41.000
好
link |
34:42.000
那
link |
34:43.000
這個
link |
34:44.000
簡單的Summon一下我們
link |
34:45.000
講了什麼東西啊
link |
34:46.000
我們第一個講的是
link |
34:47.000
Evasion Attack
link |
34:48.000
那Evasion Attack裡面我們就講說
link |
34:50.000
當你要用一些
link |
34:52.000
呃
link |
34:53.000
當你不要用Model Generate
link |
34:54.000
出Adversarial Sample的時候
link |
34:55.000
那你就需要一些
link |
34:57.000
特殊的方式
link |
34:58.000
找出這個Adversarial Sample
link |
35:00.000
那這個找的方式呢
link |
35:01.000
我們把它分為四個Ingredient
link |
35:03.000
那就是
link |
35:04.000
Goal
link |
35:05.000
Constraint
link |
35:06.000
這個還有Transformation
link |
35:08.000
然後最後要Search
link |
35:10.000
那透過這樣的方式
link |
35:11.000
你就可以定義出一個
link |
35:13.000
Evasion Attack
link |
35:15.000
那我們也取了一些
link |
35:16.000
Evasion Attack
link |
35:17.000
很有代表性的例子
link |
35:18.000
像是
link |
35:19.000
同一次疊換攻擊
link |
35:20.000
裡面的這個
link |
35:21.000
Fuller PWS
link |
35:23.000
然後指引演算法的那個Attack
link |
35:25.000
或者是
link |
35:26.000
Third Attack
link |
35:28.000
那我們也介紹了這個
link |
35:30.000
Universal Adversarial Trigger
link |
35:32.000
就是你加了一個Adversarial Trigger
link |
35:34.000
可以讓模型
link |
35:35.000
有Untargeted的這個
link |
35:37.000
有Targeted的這個
link |
35:40.000
有你指定的某些
link |
35:42.000
爛掉的Prediction
link |
35:44.000
那最後
link |
35:46.000
我們在今天一開始
link |
35:47.000
也介紹了兩種不同的方法
link |
35:49.000
然後要怎麼去生成Adversarial Sample
link |
35:51.000
但是你是要用一個
link |
35:53.000
模型去生成
link |
35:55.000
那當你要生成
link |
35:56.000
用模型去生成文字的時候呢
link |
35:59.000
當你要用模型生成文字
link |
36:01.000
然後這個文字要丟到
link |
36:02.000
另外一個模型去做
link |
36:04.000
這個
link |
36:06.000
做進一步的
link |
36:08.000
Propagation的時候
link |
36:09.000
進一步的Fuller的時候
link |
36:10.000
你就會遇到一些
link |
36:11.000
沒有辦法核分的問題
link |
36:13.000
那我們就講了兩個
link |
36:14.000
最典型在NLP的處理方法
link |
36:17.000
第一個方式就是用
link |
36:18.000
Bundle Softmax
link |
36:19.000
第二個方式就是用
link |
36:20.000
RLC的Intrinsic就好了
link |
36:22.000
那
link |
36:23.000
接下來我們就介紹說
link |
36:25.000
Evasion Attack要怎麼去做Defense
link |
36:27.000
那我們也講了兩種不同的方法
link |
36:29.000
那第一種方法我們講的是說
link |
36:31.000
你就想辦法
link |
36:33.000
去
link |
36:35.000
這個
link |
36:37.000
Train一個比較
link |
36:39.000
比較Robust Model
link |
36:40.000
那做法就是你去
link |
36:41.000
增加你的Training Data
link |
36:43.000
那不管是用
link |
36:45.000
實際的Adversarial Training
link |
36:47.000
或是Adversarial Data Orientation
link |
36:49.000
或者是這個
link |
36:50.000
在Wear Ingredient Space上面
link |
36:52.000
做一些Adversarial Training
link |
36:54.000
都屬於這類型的方法
link |
36:55.000
那另外一種Defense方式
link |
36:57.000
就是我不要去訓練一個
link |
36:58.000
比較Robust Model
link |
36:59.000
那我多加一個
link |
37:01.000
前面的Submodule
link |
37:02.000
Preprocess的Module
link |
37:03.000
那這個Module做的事情呢
link |
37:04.000
就是我們要去
link |
37:05.000
偵測說這個Input是不是
link |
37:08.000
是不是Adversarial Sample
link |
37:10.000
那偵測完之後
link |
37:11.000
假設它是Adversarial Sample
link |
37:12.000
我們就想辦法
link |
37:13.000
換成不是Adversarial Sample的版本
link |
37:17.000
那最後我們講了
link |
37:18.000
兩個小的主題啦
link |
37:19.000
一個是Imitation Attack
link |
37:20.000
那就是你要想辦法
link |
37:21.000
去拖一個模型
link |
37:22.000
那我們也講了一些
link |
37:23.000
可能的Defense
link |
37:24.000
另外一個就是Backdoor Attack
link |
37:26.000
還有它的Defense
link |
37:28.000
那它的Defense
link |
37:29.000
什麼時候會爛掉
link |
37:30.000
那這些內容很多啦
link |
37:33.000
那最重要的是
link |
37:35.000
希望大家可以記得
link |
37:36.000
就是這堂課的目的
link |
37:39.000
不是要讓大家去
link |
37:41.000
攻擊線上的API
link |
37:43.000
或者是去偷線上的API
link |
37:45.000
或者是Release一些
link |
37:48.000
Toxic的Model
link |
37:49.000
或是Data Set到Hotend Base上面
link |
37:51.000
然後讓人家用你的Data Set
link |
37:52.000
之後就爛掉
link |
37:53.000
不是
link |
37:54.000
這個課的目的是
link |
37:56.000
要讓大家知道說
link |
37:57.000
這個模型其實沒有
link |
37:58.000
你想像的Robust
link |
37:59.000
然後
link |
38:01.000
大家一定要記得這件事情
link |
38:03.000
就是
link |
38:04.000
所有的攻擊都是為了
link |
38:06.000
要讓大家知道說
link |
38:08.000
模型是不Robust
link |
38:09.000
然後我們要為了
link |
38:10.000
這個不Robust的模型
link |
38:11.000
做更多的努力
link |
38:12.000
讓它更Robust
link |
38:13.000
大家在寫Hero的時候
link |
38:14.000
也要記得這件事
link |
38:15.000
不然這個Score Reviewer
link |
38:16.000
會覺得不太高興
link |
38:18.000
好
link |
38:19.000
那最後就是
link |
38:20.000
希望大家記得這件事情
link |
38:22.000
然後
link |
38:24.000
這個
link |
38:25.000
就是模型其實比你想像
link |
38:26.000
還要脆弱
link |
38:27.000
那這件事情脆弱到
link |
38:29.000
它可能會影響到一些
link |
38:31.000
這個
link |
38:33.000
現實生活中發生的事情
link |
38:35.000
這邊有一個例子是
link |
38:36.000
這個有一個
link |
38:38.000
有一個巴勒斯坦的人
link |
38:41.000
然後他
link |
38:42.000
這個
link |
38:43.000
在Facebook上面
link |
38:44.000
發了一個
link |
38:46.000
照片
link |
38:47.000
然後結果他
link |
38:48.000
有一個Caption就是
link |
38:49.000
照片上面寫一段話
link |
38:51.000
就是說
link |
38:52.000
Good Morning
link |
38:53.000
然後對Facebook的
link |
38:54.000
這個Translation系統翻成是
link |
38:56.000
這個Attack Lab
link |
38:58.000
然後結果呢
link |
38:59.000
這個以色列的警察
link |
39:00.000
就跑去抓這個
link |
39:02.000
有巴勒斯坦的人
link |
39:03.000
那所以這個就是一個
link |
39:05.000
模型的
link |
39:06.000
模型太爛
link |
39:07.000
然後導致現實生活中
link |
39:08.000
發生很多問題的例子
link |
39:10.000
那
link |
39:12.000
但是呢
link |
39:13.000
這個Adversarial Sample
link |
39:15.000
假設你在
link |
39:16.000
你的模型被你Port出去的時候
link |
39:18.000
就發現的時候
link |
39:19.000
那它其實是一個
link |
39:20.000
還不錯的事情
link |
39:21.000
這個Adversarial Sample呢
link |
39:23.000
可以告訴你說
link |
39:24.000
模型有哪些的弱點
link |
39:25.000
那這些弱點常常會
link |
39:27.000
讓我們知道說
link |
39:29.000
這個模型它依賴的
link |
39:30.000
某些特殊的
link |
39:32.000
這個
link |
39:33.000
Speakers Correlation
link |
39:34.000
在做一些判斷
link |
39:35.000
那舉例而言
link |
39:36.000
就發現說呢
link |
39:37.000
當你把這個
link |
39:38.000
QA的這個任務
link |
39:39.000
多選一個任務
link |
39:41.000
你只要把最後一個選項
link |
39:42.000
換成以上接式或以上接非
link |
39:44.000
模型就會直接選
link |
39:45.000
以上接式或以上接非
link |
39:47.000
那
link |
39:49.000
這個就表示說
link |
39:50.000
模型只要看到
link |
39:51.000
以上接式或以上接非
link |
39:52.000
它就直接把它當成答案
link |
39:53.000
它根本就沒有在看
link |
39:55.000
這個Passage跟Question是什麼
link |
39:57.000
那這就是一個
link |
39:59.000
這個Adversarial Sample
link |
40:00.000
可以幫助我們去
link |
40:01.000
Debug模型的一些
link |
40:03.000
異常行為的一個例子
link |
40:05.000
好那這個
link |
40:07.000
不管你要
link |
40:09.000
不管你Attack一個Model
link |
40:11.000
還是做Defense
link |
40:12.000
就是你只要做Attack
link |
40:13.000
就會有人做Defense
link |
40:14.000
你只要做Defense
link |
40:15.000
就會有人做Attack
link |
40:16.000
所以這個題目是永遠
link |
40:18.000
有空間可以做的啦
link |
40:20.000
所以我覺得
link |
40:21.000
大家還是可以
link |
40:22.000
就是有興趣的話
link |
40:23.000
還是可以來試試看這樣子
link |
40:25.000
那今天就講到這裡
link |
40:29.000
好謝謝承翰謝謝
link |
40:32.000
太棒了太棒了
link |
40:37.000
好那
link |
40:39.000
有同學有問題
link |
40:40.000
好David
link |
40:43.000
你請說
link |
40:47.000
喔那個老師好
link |
40:48.000
欸注意一下喔
link |
40:49.000
那個我是想好奇
link |
40:50.000
就是Attack跟Defense這方面
link |
40:52.000
如果做研究上
link |
40:53.000
您說就還有很多Possibility
link |
40:55.000
那可能研究的方向有哪些呢
link |
40:58.000
可以提出一些Example嗎
link |
41:03.000
因為我不是好奇這樣子
link |
41:06.000
我覺得
link |
41:09.000
我覺得最值得做的
link |
41:12.000
應該就是
link |
41:13.000
我前面好像有放一些那個
link |
41:15.000
應該是我這個
link |
41:17.000
整堂課好像不太有放這個
link |
41:19.000
Serial Sample的例子
link |
41:20.000
然後我沒有放的原因
link |
41:22.000
是因為你實際上去看
link |
41:23.000
他們產生出來的Serial Sample
link |
41:25.000
你會發現其實
link |
41:26.000
對人來說是看得出來的
link |
41:28.000
那對人來說看得出來的話
link |
41:30.000
你就要想辦法說
link |
41:31.000
然後我去問兩個問題
link |
41:33.000
第一個就是
link |
41:34.000
人看得出來的
link |
41:35.000
人看不出來的
link |
41:36.000
Serial Sample到底存不存在
link |
41:38.000
然後另外一個問題是
link |
41:40.000
那
link |
41:41.000
就是那我們現在
link |
41:43.000
Attack出來的結果
link |
41:44.000
到底是什麼東西
link |
41:45.000
就是我們現在找出了
link |
41:46.000
一大堆人Serial Sample嘛
link |
41:47.000
那我們發現說
link |
41:49.000
他拿去Attack是會成功的
link |
41:51.000
但是我們又發現
link |
41:53.000
這個Serial Sample是
link |
41:54.000
可能不太合理的
link |
41:55.000
這個Serial Sample
link |
41:57.000
那就要去想
link |
41:58.000
以前的這些方法
link |
42:00.000
有什麼問題
link |
42:01.000
那我們如果要提出一個
link |
42:03.000
真正合理的方法
link |
42:04.000
要怎麼去做
link |
42:06.000
這個是我覺得
link |
42:07.000
還蠻值得做的一個東西
link |
42:10.000
好 謝謝教授
link |
42:12.000
好 大家還有問題想問一下嗎
link |
42:22.000
有嗎
link |
42:28.000
好 如果大家沒有問題的話
link |
42:30.000
那我們就
link |
42:31.000
如果你可以打開麥克風的話
link |
42:34.000
那我們可以打開麥克風
link |
42:36.000
給陳漢最後一個熱烈的掌聲
link |
42:38.000
謝謝
link |
42:39.000
謝謝
link |
42:47.000
謝謝
link |
42:49.000
收穫很豐富
link |
42:51.000
謝謝
link |
42:55.000
好 如果大家沒有問題的話
link |
42:57.000
那今天這個
link |
42:59.000
陳漢的課程就到這邊了
link |
43:04.000
好 那就到這邊了
link |
43:06.000
謝謝陳漢 謝謝
link |
43:08.000
感謝老師
link |
43:09.000
謝謝