大家好,我是江承翰,那我們就繼續上禮拜講的東西。

剛剛稍微耽誤了一點時間,不好意思,希望今天可以兩個小時內講完。

上禮拜我們已經講了 NLP 裡面最重要的 evasion attack。

我們也講了要怎麼去 control evasion attack 裡面的 adversarial sample。

那當初我們講的是說,因為 NLP 的 input 是 discrete,所以它跟 CV 或是 audio 是不一樣的。

我們必須要用一些很特別的方法才能找出一個合理的 adversarial sample。

那這個有沒有其他方法不要用這些大量的 transformation 還有 constraint,

還有 search method 才能達成這個 goal? 其實是有的。

那今天來介紹剩下兩個來 construct evasion attack 裡面的 adversarial sample 的方式。

但是它做的事情是我們直接訓練一個模型,

這個模型的目標就是要產生一個 adversarial example。

那我們來看一下實際上要怎麼做。

那首先我們第一個介紹的例子是我們直接用一個 autoencoder 來生成一個句子,

然後這個句子就會是一個 adversarial example。

那這個想法其實很簡單,就是我訓練一個 generator,

那這個 generator 它是一個 autoencoder,

那這個 autoencoder 做的事情就是當它看到一個正常的 input 的時候,

它就要去改寫這個正常的 input,

也就是它要改寫正常的 input,

然後改寫出來讓它最後 output 出來的是一個 adversarial example。

那這個 generator 它的目標就是要生出一個足夠好的 example,

那這個 example 要好到可以去讓 classifier 的 output 是爛掉的。

也就是說原本有一個 text classifier,

然後當你餵進去這個 autoencoder,

也就是 generator output 出來的 sample 的時候,

我們希望它可以跟原本你把這個東西餵進去的時候,

它得到的 output 是相反的。

那另外為了要訓練這個 generator,

它多訓練了一個 classifier,

那這個 classifier 它的目標就是要正確的判斷

這個 autoencoder output 出來的東西。

那這個整體而言,這個想法就是很像,

有一點點像是 GAN,但它有點不太一樣。

就是 autoencoder 它要生出一個 sample,

可以去騙過 classifier,

然後 classifier 它要足夠強,

可以去正確的判斷出這個 autoencoder output 出來的東西是哪一個 class。

但這邊跟 GAN 不太一樣的是說,

GAN 要判斷的是在 GAN 裡面,

它的 discriminator 它要做的是什麼?

是要判斷它的 input 是生成出來的,

還是原本真實的 beta 嗎?

但這邊不是,這邊它要判斷的是

這個 input,這個是 movie-review 的例子,

所以它這個 input 是正面的情緒還是負面的情緒?

那對於一個好的 classifier,

它就應該要判斷出來說,

不管你做了什麼 perturbation,

它只要是合理的 perturbation,

它都應該要是正面的,

它不應該改變它的預測。

所以這個 generator 它做的事情,

實際上就是它要做 attack,

它要去 construct 一個 adversarial sample,

使得一個不 robust classifier 它可以被騙過。

另外它用的這個 robust classifier,

它做的事情其實就是 defense,

就是它要去想辦法可以去正確的判斷說,

今天進來的不管是 adversarial sample 還是正常的 input,

它都要有辦法去正確的判斷它。

那所以整個訓練的過程呢,

就要交替的在 attack 跟 defense 這兩個 step,

就是有時候要 train 一下這個 autoencoder,

然後使它 output 出來的這個 example 是足夠好的,

那有時候要 update 這個 classifier,

然後使得它是足夠強可以去判斷說,

現在的 input 到底是,

不管它是 adversarial sample 還是不是 adversarial sample,

它都要有辦法正確判斷。

那我們首先來看一下這個,

在 attack step 的時候,

它要怎麼去訓練這個 autoencoder。

那在 attack step 的時候呢,

它原本那個 robust classifier 就是不會用到,

它只會用到原本的這個 test classifier,

這個 test classifier 是本來就已經訓練好的,

然後你要先訓練好一個不 robust classifier,

然後才會去訓練這個 generator。

好,那這個 attack step 呢,

它要訓練這個 generator,

它使用了三個不同的 loss,

那首先我們來看其中兩個 loss,

一個是 reconstruction loss,

一個是 similarity loss,

那這兩個 loss 呢,寫出來長這個樣子,

那我丟口令讓大家敘述一下,

大家不用太在意式子裡面是什麼。

這個 x 跟 x star 呢,

代表原本的 input 跟 autoencoder output,

那 reconstruction 這個 loss 呢,

它要求的就是呢,

這個 autoencoder output 要跟 input 足夠像,

那足夠像呢,它從兩個層面來限制,

第一個就是 reconstruction loss,

reconstruction loss 呢,

要求說它在 token level 要長得足夠像,

那 similarity loss 它要求的是,

這邊兩個的 token embedding 要足夠像,

所以你可以把它想像成,

這個就有點像是我們在那個,

我們在講那四個要素裡面的那個 constraint,

我們有講到一個 sentence encoder 的 similarity,

那它這邊就是要求說,

input 跟 output 它的 similarity 要足夠像,

但是呢,你如果讓它是完全一樣的啊,

這個就失去了我們要 attack 的這個目標了,

所以它除了這兩個 loss 之外啊,

它還另外多加了一個叫做 adversarial loss,

那這個 adversarial loss 它要做的事情呢,

就是它要想辦法去騙過這個 classifier,

使得呢,這個 classifier 當它看到一個 adversarial symbol 的時候,

它的 output 會是爛掉的,

所以說在 attack step 的時候呢,

它就是用這三個不同的 loss 去訓練這個 generator,

那另外呢,這個除了 attack step 它也要,

它另外一個步驟是 defense 的 step 嘛,

那它 defense 的 step 呢,它要做的就是,

它要訓練這個 autoencoder 跟另外一個 robust classifier,

那為什麼會說它是 robust 呢?

因為這個分類器啊,

它看到正常的 input 的時候,

它可以正確的判斷,

另外呢,我們也希望它看到 adversarial symbol 的時候,

它的這個 output 呢,也是可以是正確的,

所以我們說它是個 robust classifier,

那這個 robust classifier 啊,

跟前面一頁我們看到這個 classifier 是不一樣的,

這個 classifier 呢,它在 attack step 的時候,

它是不會被 update,

可是這個 robust classifier 它在訓練的時候呢,

它會一直被 update,

所以也就是說這個,

在 defense step 的時候,

我們就是要訓練一個 robust 的這個分類器,

所以它是要被 update,

那這個 defense step 它訓練這個 classifier,

它也會同時訓練這個 autoencoder,

那它用了一樣是三個不同的 loss,

那這三個 loss 呢,跟剛才也還蠻像的啊,

前面兩個 loss 是一樣的,

就是我要要求說這個 generator,

它生出來的 output 要跟 input 值夠像,

不管是在 token label 上面要像,

或是在 sentence embedding label 要像,

那另外一個 loss 呢,就是 defense loss,

所謂的 defense loss 呢,

就是我要要求說這個 classifier,

它要有足夠的能力去辨識今天的 input,

那這件事情就是說呢,

當今天的 input 是 x 或是 x star,

不管是這個正常 input 還是 adversarial input,

我都希望它可以生出一個判斷,

那這個就是 defense loss,

所以它的這個 training 呢,

會交替的在 attack 跟 defense 運作,

那 attack 的時候呢,

它就是 update 這個 generator,

然後 defense 的時候呢,

它就是同時 update 這兩個,

那可能會有人好奇說,

為什麼這個 defense 的時候,

它也要訓練這個 autoencoder,

如果,我想是這樣,

如果你不訓練這個 autoencoder 的話,

它產生的東西可能就會非常非常很爛,

它如果一直產生很爛的東西的話,

那,不是它會產生很爛的東西,

是我想一下要怎麼講,

如果你不訓練這個 autoencoder 的話,

它就沒有辦法產生會讓它答對的東西,

因為現在這個,

在這個 defense step 的時候,

我們的目標是要生成一個正常的 input,

但是它是對 robust classifier 來說,

它是正常的 input,

所以如果你沒有 update 它的話,

它就不會學到說,

它要怎麼生成一個是 adversarial,

但是可以讓 robust classifier 的 output 是正確的這個句子,

所以大概是這個樣子。

那這邊有兩個箭頭的意思是說,

就是不管是 autoencoder 的 input 還是 output,

都會被這個 test classifier 拿來重新做訓練,是嗎?

對,就是這個樣子。

OK,好。

好,那其實剛才在講的時候,

我忽略了一個小小的細節,

這個細節是這樣子,

就是當我們要從,

我們要訓練這個 autoencoder 的時候,

不管是在 attack step 還是在 defense step,

我們都是要拿這邊的 output,

然後算出來的 loss,

然後對這個 autoencoder 的參數做為分之後,

做 gradient descent,

那這時候會有一個小問題,

就是在 backward 的時候,

這個 autoencoder 其實你是沒有辦法回分過去的。

那這個是為什麼?

這是為什麼呢?

那我們來看一下下面這張圖。

當我們把一個 input 丟到 generator 裡面的時候,

它做的事情就是,

它要 output 出一個 adversarial sample,

那這個 adversarial sample 是怎麼被 output 出來的呢?

這個 autoencoder,

它在每一個 time step,

它就 output 出這個 time step 的 token,

它的一個 distribution,

那假設說在這個 autoencoder,

看完這個 input 句的時候,

它 output 出來的第一個 token,

它的 probability distribution 長得是這個樣子,

那我們接下來做的事情呢,

就是我們會去 sample 出一個 token,

從這整個 probability distribution 裡面做 sample,

那 sample 出來之後呢,

就得到我們的 adversarial sample 的第一個 token,

那這件事情就一直做一直做,

做到這個 adversarial sample 的整個句子被產生出來之後,

我們就得到一個 adversarial sample。

那當我們要做這個 backward 的時候呢,

會有一個問題啊,

就是我們在 backward 的時候,

sampling 的這個過程,

它其實是不能回分的,

所以你要 backward 的時候,

它會直接卡在這個地方。

那這件事情要怎麼解決呢?

那在講解決的方法之前,

我們先來看一下這個 autoencoder,

它的 output 是怎麼被送到後面的 classifier 裡面,

那我們可能會比較知道怎麼解決這個問題。

那這個 autoencoder 呢,

它的 output 經過 sample 之後,

我們會得到一個句子,

那得到這個句子之後呢,

我們就會要把它丟到後面的 classifier 裡面。

那我們要把一個句子丟到 classifier 的時候呢,

我們要先做 embedding lookup,

把這個句子裡面的每個 token 都轉換成它所對應的 embedding 的時候,

它才可以被餵到 classifier 後面的一些 network 裡面。

所以我們就對每個 token 做 embedding lookup 之後呢,

得到這些 embedding。

那這些 embedding 就丟到這個 classifier 裡面。

那我們來看一下這邊這個過程是怎麼做的。

那這個過程其實是這樣的,

就是 autoencoder 它經過 sample 之後,

它會產生一個 one-hot vector,

那這個 one-hot vector 呢,

假設以 i 這個 token 為例的話,

那這個 one-hot vector 的第三個 entry 就代表

在 classifier 的這個 embedding 裡面第三個 word embedding。

那這個東西呢,

當你去乘以 classifier 的這個 embedding table 的時候,

你就會得到這個代表 i 的這個 word embedding。

所以這個就是 embedding lookup 實際上在做的事情。

好,那我們說呢,

這個 sampling 的這個過程,

它會讓它是不能為分的。

所以我們就要想辦法做一件事情,

讓這個東西產生出這個 one-hot vector 的,

應該不能說 one-hot vector,

這個就是 autoencoder 產生出來這個 vector,

產生出這個 vector 的過程是一個可以為分的過程。

那我們就介紹一個在 NLP 裡面

很有代表性的一個方法,

叫做 Gambel-Softmax 的 re-parameterization trick。

那這件事情我先直接講一下它怎麼做的,

然後我也沒有要講它數學上的推導,

因為它數學有點複雜,

我就直接講怎麼做就好了。

它做法是這樣的,

就是當我們從一個 autoencoder output 出來,

得到一個機率分布,

那我們把這個機率分布叫做 pi,

然後假設它這個 pi 這個 distribution 呢,

它上面有四個不同的這個,

所以它長度是四啦,

所以它有四個不同的 class,

然後我們分別以 pi1, pi2, pi3, pi4 來表達。

那我們接下來會做的事情就是,

我們本來要做的事情是

我們要從這個裡面做 sampling,

然後做 sampling 之後呢,

我們應該要得到一個 one-half vector,

然後後面我們做的事情就是

拿這個 one-half vector 去乘以

這個 worry embedding table,

我們就會得到我們要的那個 worry embedding。

那我們有說呢,

sampling 這件事情會讓我們不能為分,

所以我們要想想看

我們有沒有辦法做某件事情,

然後呢,它可以達到 sampling 的功能,

但這件事情又是可以為分的。

那這個解決方法就是使用 Gauss-Belsof-Max,

那它是怎麼做的呢?

它是這樣做的啦,

就是當你得到這個 output distribution pi 之後呢,

你把它做一個 log transform,

就是 pi1 變成 log pi1,

pi2 變成 log pi2,

pi3 變成 log pi3,

pi4 變成 log pi4,

然後呢,把這個得到的結果

加上我們一個非常神秘的 distribution,

那這個神秘的 distribution

就是一樣是有四個不同的 class,

然後它每一個東西

我就用 g1, g2, g3, g4 來代表它。

那這個神秘的 distribution 呢,

它的每一個 class 的這個 probability 啊,

它都是從一個叫做 Gauss-Belsof-Max

01 的 distribution,

那個 iid sample 出來的。

所以假設你有這個 n 個 class,

你就要從 Gauss-Belsof-Max 裡面

做 n 次的 sampling,

然後 sample 出這 n 個不同的

這個機率出來。

那 sample 出來之後呢,

你再把你剛才經過 log

transform 的這個 distribution pi

加在一起得到一個我們叫做

g of i 的這個 distribution,

那得到 g of i 這個 distribution 之後呢,

你把它取 arcmax,

那這個 g of i 會是一個

一樣是四個 class 的 distribution 嘛,

那這個 distribution 你就可以取 arcmax,

取 arcmax 的意思就是你要找說

在這四個 class 裡面哪一個東西的

哪一個 class 它的機率是最大的,

或是值是最大的。

那假設我們最後 gi 取出來呢,

那可能最後結果是

在這個第三個 class 它的機率是最大的,

所以你就得到一個這樣的 distribution。

那因為這個 gampil-softmax

你從這個 gampil-01 這個 distribution 裡面

做 RID sample 的時候呢,

這個每一次 sample 的結果

會是不一樣的嘛,

所以有可能你這次 sample 出來的

G2 比較大,

然後加上原本的這個

經過 log transform 的這個

pi distribution 之後呢,

它最後取 arcmax 有可能是

V2 這個機率最大,

那有時候可能是這個

第四個 class 它的機率最大。

所以呢,這個因為

gampil sampling 的這個隨機性,

所以會造成你最後取 arcmax

的一個隨機性。

那非常非常神奇的事情就是呢,

這個隨機性啊,

sample 出來的結果,

不是,這個 arcmax 取 arcmax,

就是 gi 這個 distribution 取 arcmax

之後得到的這個結果,

它會跟你從 pi 這個 distribution

sample 出來的結果是一樣的。

這個所謂的一樣,

不是說你用這個 distribution

去 sample 出來的答案,

如果是 V3 最大的話,

那你用 gampil sample next,

你用 gampil,

加上 gampil 這個 nodes,

然後再取 arcmax 之後,

就一定是這個 V3 的這個 class

是最大的。

不是這個意思,

這個意思是說呢,

這個東西取 arcmax 之後的

機率分布啊,

它符合 pi 這個分布,

也就是說,

第一個 class 它的,

它是 G1 的最大的一個 class 的

機率呢,

會是 pi 1,

然後 C2,

也就是第二個 class,

它會是 gi 的這個分布裡面

最大的那個,

它的機率是 pi 2,

那 C3 這個 class,

它的機率在 gi 裡面

是最大的這個機率呢,

是 pi 3,

那第四個 class,

是 gi 這個分布裡面

最大的一個 class,

它的機率會是 pi 4,

所以呢,

做這件事情啊,

就是這個整個過程

得到這個東西叫 gampil-softmax,

因為 gampil-softmax 的這個分布啊,

它其實會跟這個,

你原本要 sample 這個東西

同分布的,

所以這個地方

好像就已經解決說

我們要做 sampling 的這個過程,

因為我們已經找到一個

這個分布,

是我們可以不用做這個 sampling,

但它可以跟我們有做 sampling

達到同樣的效果。

好,來,那個宇翔舉手了。

不好意思,

我有點聽不太懂,

就是那為什麼我不直接

對原本的機率

做 argmax 就好了?

對原本的機率做 argmax,

它得到的這個 distribution

永遠就是同一個,

它就不會有 sample 的功能。

然後我猜宇翔想要問的是,

為什麼這裡 sampling 這件事這麼重要?

為什麼不能做 argmax 呢?

做 argmax 到底會有什麼問題?

對。

我覺得做 argmax 這邊會有的問題就是,

假設我們做 argmax,

那你會發現啊,

如果你要計算 autoencoder 裡面的參數

對最終結果的為分,

你算出來會幾乎都是零,

為什麼?

因為當你 autoencoder 參數

變的時候,

pi 那個 distribution 稍微變了一下,

但是最大的那個東西,

最大的機率的那個 token,

還是最大的機率,

所以你做 argmax 以後,

丟到接下來的 classifier 裡面啊,

丟進去給 classifier 的東西

是一模一樣的,

所以最終你的整個 model,

包括那個 classifier 的部分,

最終的輸出會是固定的,

就會變成說 autoencoder 參數有變,

但是最後你的 loss 是完全沒有變的,

所以根本就算不出那個 gradient,

所以 gradient 算出來都是零。

我這樣回答到宇翔的問題嗎?

我覺得我好像要再想一下,

但我好像,

我再想一下好了,

我待會有問題再問老師跟助教。

誒,陳漢哥我這樣講,

你覺得 ok 嗎?

我覺得,

好像還蠻合理的,

好像還蠻合理的,

對,

我一直沒有很好的解釋,

我覺得老師的解釋還蠻不錯的。

好,那大家先想一下,

那我們就先繼續吧。

好,那我們就繼續講。

那,

這個,

但是這邊還沒有解決那個問題啊,

因為你不管這邊是取 sample 還是取 argmax,

就是,

這件事情不是不能回分的,

就是,就算你這邊用了 compare solve max,

這個 argmax,

他也是不能回分的,

所以你現在還是有一個,

這個不能回分的問題啊,

但這個問題呢,

稍微比較好解釋,

因為我們有一個方法可以讓,

就是我們有一個方法可以,

做到一個跟 argmax 很像的事情,

就是我們要從這個 g i,

變成這個 distribution,

我們可以不用做 argmax,

但是做到跟 argmax 很像的事情,

那這個事情呢,就是,

做一個叫做 solve max,

然後 with temperature scaling,

那 solve max 大家都很熟嘛,

就是你,

把所有的這個 distribution 每個元素,

然後取一個 exponential 之後,

做一個 normalization,

那這邊跟一般的 solve max 不一樣的,

就是他在取這個 exponential 的時候,

他會先把原本的這個 g i,

除以一個 T,

這個除以一個 temperature,

那只要你的 T 這個 temperature,

T 我們叫 temperature,

只要你 T 選的恰當的話,

就可以讓你最後,

output 出來的這個 distribution y,

長得非常非常像是 one hard vector,

那只要做到這件事情呢,

我們就可以把原本,

不能這個微分的這個,

這個 sampling 過程,

替換成一個可以微分的,

這個 convert all solve max,

然後 with temperature scaling,

那我們來看一下,

這個 T 你要怎麼選,

這個其實還蠻直覺的,

就是當你的 T 非常非常大的時候,

假設我們 T 趨近無限大,

那當 T 趨近無限大的時候,

不管你 g i 是多少,

每個都除以一個無限大的數字,

他每個都看起來像是零,

所以同樣 0 四方都是 1,

所以他幾乎是一個,

這個 uniform distribution,

那如果你 T 取得非常非常小的話,

那他對於那個區域裡面,

最大的那個 class,

他的機率就會看起來是,

他就會比其他的 class 還要大非常非常多,

所以對於那個區域裡面,

最大的那個 class,

他的 output 出來的機率,

會非常非常接近 1,

然後其他會非常非常接近 1,

所以說呢,

我們要讓這個 g i output 出來的東西,

經過 softmax,

temperature scaling,

跟 argmax 的結果很像,

那我們要做的事情就是,

我們把 T 選得夠小就好,

那這邊配合他做的事情是,

他選的是 T 等於 0.1,

所以最後的結果就是 T 選得很小,

然後所以就可以讓,

這邊出來的結果跟你 sampling,

跟你做 sampling 出來的結果,

非常非常像,

那這樣子的話呢,

你就可以用這個東西,

去 backpropagate 到 autoencoder,

autoencoder 他就可以被 update,

那所以,

這個實際上我們做的事情呢,

就是 autoencoder output 出來的這個 part,

就是 distribution,

我們把他做一個 log transform,

然後再加上一個,

從 bundle 01 裡面,

iid sample 出來的這個 noise,

然後這個 noise 加上,

原本經過 log transform 的 probability 之後呢,

我們經過 softmax with temporary scaling 之後,

就可以得到一個,

非常接近 one-hot 的一個向量,

也就是,

在這個 vocabulary 上面的機率分布,

那 i 這個 token 呢,

他的機率就是 0.993,

然後其他的都是非常非常接近一個數值,

那接下來我們做的事情呢,

就是我們就把這個機率,

直接乘到這個 embedding table 上面,

那我原本這個,

原本我們如果直接取 sample softmax 的話,

這邊會是一個 one-hot vector 嘛,

就是如果以這個為例的話,

他應該會是一個 0 0 1,

然後剩下都是 0 的這個 one-hot vector,

所以當你直接乘以這個 embedding table 之後呢,

就會等於是你在這個 embedding table 做 logout,

然後你選出來的是第三個,

這個第三個字的 word embedding,

那因為我們現在這邊,

他不完全是一個 one-hot vector,

他其實是一個很接近 one-hot vector,

但是他並不是 one-hot vector 的一個向量,

所以呢,他最後包覆出來的這個 word embedding,

他不完全是裡面最大的這個東西的 word embedding,

他會摻雜一些其他字的 word embedding,

不過這個比例應該非常非常小,

所以用了這個方法之後呢,

我們就可以成功地做 backward regression,

我們就可以成功地訓練這個 generator.

好,所以呢,我們實際上做的事情啊,

就是 autoencoder,

包覆出來的東西我們要用

Gambel softmax 來取,

那 Gambel softmax 取到的 output,

會是一個接近 one-hot,

但不是 one-hot 的 vector,

那我們把這個 one-hot vector 啊,

乘以 embedding table,

我們就會得到這個,

我們要送到 classifier 裡面的這個 embedding,

那這個 embedding 丟到 classifier 裡面呢,

我們就是用這個 embedding 來做 forward,

然後 backward 的時候呢,

我們就是也是一樣,

經過這個 word embedding 做 backward,

所以他的 gradient 就可以 backward 到

這個 autoencoder 裡面,

那他這樣就可以訓練了,

所以他不會有不可為分的問題,

那這個就是用 Gambel softmax 來解決,

解決不能為分的問題,

那這個做法其實還蠻常見的,

不只是在生成,

那很多 NLP 的任務,

當你要生成這個,

你要做的事情是 sequence generation,

然後你這個 sequence generation 的 output,

還要經過另外一個 model,

才能得到最後的 loss 的時候,

常常會用 Gambel softmax 的方法,

來讓他的 gradient 可以 propagate 到

這個 generator 上面,

那除了這個方法之外呢,

也有不同的方法,

就是你也可以直接用 RL 應勸這個 generator,

那我們下面講的,

就是用 reinforcement learning 來訓練

這個 generator 的方式,

那講到這邊,

先看一下大家對這個方法有什麼問題,

好,大家有問題想問嗎?

如果 Gambel softmax 那邊,

你聽了一時覺得有點 lost,

那也沒有關係,

反正他就是一個,

這個訓練時候的技巧,

如果你發現呢,

你的模型中間有一個區域,

是會 output discrete 的 token,

那你可以用 Gambel softmax,

來讓整個 network 還是可以 end-to-end trade,

那假設你不知道 Gambel softmax 的話,

也沒有關係,

反正最慘的狀況,

你還是可以用 RL 應勸你的模型,

但 Gambel softmax,

可能是一個比 RL 還要簡單的做法。

不好意思,

又是我,

我覺得我好像還是沒有聽得很懂,

就是老師剛才那邊說我們,

我這邊有兩個問題,

第一個問題是,

在做 auto encoder 這邊,

為什麼需要 sampling,

我覺得我剛才還是沒有,

我剛才想一下,

我覺得好像還是沒有搞得很懂,

所以想請老師跟助教再解釋一次,

然後第二個是,

就是 Gambel softmax,

我可以這麼說嗎,

就是如果是在模型中有這種,

需要 sampling 這種,

是 discrete 的行為的時候,

可以考慮 Gambel 這個技巧,

第二個問題是,

第一個問題,

我等下下課的時候想一下,

我再回應你好不好,

因為我現在可能沒有很好的答案,

沒有關係,

我也沒有很好的答案,

謝謝助教,

那我等下下課的時候想一下,

好,謝謝,

那如果沒有其他問題的話,

我就先繼續講,

好,那,

好,然後再來要講,

這個用 RL 生,

生這個 adversarial sample 的方式,

那想法跟剛才差不多,

就是我要訓練一個 generator,

然後這個 generator 做的事情,

就是他要生一個 adversarial sample,

那這個 generator 的目標呢,

就是他要生出來的這個 adversarial sample,

他可以成功的讓 classifier 他的 output 爛掉,

所以原本這個 I highly recommend it,

丟到 classifier 裡面,

他應該會 output 出來的這個,

他應該是 positive 的,

但是你經過 generator 的 calculation 之後呢,

他 output 出來的這個 positive 的機率呢,

就下降到 0.48,

那這個 generator 的目標,

就是要讓這個東西越低越好,

那當你要訓練這個,

我們先講一下 generator 做的事情是什麼,

那 generator 他做的事情啊,

就是他這邊用的,

這是另外一篇 paper,

那這篇 paper 他在做的事情,

他不是實際上去生一個 sequence,

他做的事情呢,

比較像是一個 sequence tagging test,

就是他們對於 input 的每個字,

他要決定他要做什麼樣的 action,

那他的 action 呢,

包含了這個五個不同的 action,

那 0 這個 action 就代表說,

我對這個 token 什麼事都不要做,

那 1 這個 action 呢,

代表說我要 replace 一個 super word,

那這個,他的 action 呢,

是替換的方式是從 wordnet 裡面,

找一些跟他相關的字去做一些替換,

那所謂的 super word,

就是這個 super word,

super word 我有點不太知道他的意思是什麼,

然後他舉的例子是這樣,

但我不確定 super word 的意思是什麼,

是例子說什麼漢堡是一種三明治之類的,

還是怎樣?

可是我覺得感覺比較像是 subordinate word,

就是,我知道了,

好像,我忘記了,

好像是,那可能是,

一個是一個的,

就是,對,漢堡是一種三明治,

然後這個是,鮭魚是一種魚,

對對對,

ok ok,

這兩個是相反的,

然後另外也有一個 action 是

他要 replace with 這個同義詞,

然後第四個 action 是

你要 replace with 一個 neighbor word,

就是 wordnet 裡面有定義一些 neighbor word

就是跟他相似,

但是不是,不算是同義詞的那些字,

就像 elsa 跟 donkey 這樣子,

那以這個,原本這個,

這邊這個例子為例的話呢,

他就是,

原本,這個 I highly recommend it,

然後丟到 generator 裡面,

那他對於這個句子的每一個 token,

他決定要做的 action 就是

第一個 token 不做任何事情,

第二個 token 呢,

他把它換成一個同義詞,

就換成ordinate,

那這個同義詞要怎麼換,

就是你去這個 wordnet 裡面

找一個同義詞,

然後選出來換就好了,

然後,這個,第三個字呢,

我要把它換成一個同義詞,

第四個字我不做任何事情,

好,那這個一樣嘛,

就是他這個 output 是一個

discrete 的,

不同 class 的一個 distribution,

所以一樣會遇到不能為分的問題,

那你當然也可以用港標解決啦,

不過他這邊用的方式是

他用 RL 直接硬 train 這個 generator,

好,那他的做法呢,

就是用 RL 來 train 嘛,

那你在 train 一個,

你要 reinforcement learning 來訓練的時候,

你要去定義他的 reward 是什麼,

才能訓練他,

那他這邊定義的 reward 方式很簡單,

他就是定義說,

這個 reward 定義就是,

這個原本的 ground truth 的

變化量的負值,

所以原本的 ground truth 是 1.0 嘛,

然後他變成 0.48,

所以就是 0.48 減掉 1.0,

然後再取負號,

就是他的這個 reward,

所以我們就拿這個當成 reward,

然後來訓練這個 generator,

然後他用的是最簡單的

那個 policy gradient,

然後 with baseline,

如果不知道 policy gradient 是什麼,

應該也沒關係,

反正他就是一個

最養生的 reinforcement learning 的方式,

好,那他就直接硬 train 這個 generator,

好,那這個方法其實就這樣子,

還蠻簡單的,

好,那這個方法有人有問題嗎?

好,大家有問題嗎?

好,那如果沒有,我們就繼續吧!

好,那 Edward 怎麼不講,

有點瑣碎,

那我們直接講 defense,

直接講 defense 就好。

好,那我們這個講完,

怎麼去產生一個 adversarial sample 的

很多不同的方法,

那接下來我們要問的就是

我們要怎麼去對抗這些惡意的攻擊,

那對抗惡意的攻擊

大概可以把它分成兩類型,

第一種類型就是

你就想辦法訓練一個

比較強健的模型,

那讓他可以抵禦這些攻擊,

那另外一種方法就是

你不特別在訓練的時候

對模型做任何事情,

但是你讓他在 testing

或是說 inference 的時候呢,

他要有能力去偵測說

現在的 input 是不是 adversarial sample,

那我們就把它分為這兩類來講,

我們先看第一類,

我們要怎麼去訓練一個

比較強健的模型,

那這個方法其實跟

一般我們在 CD 上面

或是 audio 上用的其實都差不多,

那最簡單的方法當然就是

adversarial training,

那所謂的 adversarial training 呢,

就是你在訓練的過程中

一直用現在的模型去做 test,

然後生出來的 adversarial sample

再加到 training data 裡面,

那也就是說

一開始會有一些不耐,

不耐就是良性,

就是不是 adversarial 的 training data,

那你就拿這些 training data 呢,

先去訓練一個 classifier,

然後訓練好之後呢,

你就拿這個 training data 裡面的

某些東西呢,

去 attack 這個模型,

然後 attack 出來的結果呢,

你會得到一些 adversarial training data,

那你再用這整個

這個 benign 加上 adversarial training data

的這個 combination,

然後去訓練一個新的 test classifier,

然後訓練出來之後呢,

你再拿這個原本的 benign training data

去 attack 這個新的 test classifier,

然後你就會得到

這個新一代的 adversarial training data,

然後這些 adversarial training data

再跟原本的 benign training data

加在一起訓練另外一個新的

更新的 test classifier,

然後就一直做一直做一直做,

然後你之後就可以得到一個

比較 robust 的 test classifier,

那這個方法呢,

在 NLP 裡面最大的問題是

就是在 NLP 裡面

你要跑這個 attack algorithm

其實非常非常花時間,

舉例而言,

這個 agnews 這個 dataset,

如果你要

光是要這個跑 testing data 裡面的

attack 用 text folder,

然後我們要使用 v100 跑

就大概跑了十五個小時,

那如果你只是要

train 在這個 benign training data 裡面

train 十個 epoch,

用 v100 跑,

你只要跑十分鐘就好了,

所以等於是

這個一個 epoch 大概是一分鐘啦,

然後你這個跑完一個 epoch 之後

attack 部分的

這個 data 你就要 attack 十五個小時,

然後再跑一分鐘的 training,

然後再跑十五個小時的 attack,

那這樣其實是非常非常浪費時間的,

那為了解決這個問題,

也不算是解決,

就是大家就想要

想一些方法,

然後可以避免掉

實際上要做 attack 的這件事情,

因為最花時間的就是 attack 的步驟,

那有人就提出來一個方法,

就是這個 cv 上面

我們的 attack 是直接做這個

projected gradient descent 之類的東西,

然後找到一個 adversarial sample,

那我們有沒有辦法在 NLP 裡面

也是一樣就是做

projected gradient descent,

然後我們找到一個 adversarial sample 之後,

那我們就直接把這個 adversarial sample

這個拿去 train 呢?

那其實也有人是

真的是做這樣的事情,

那他們做的事情是這樣,

就是假設我有一個正常的 benign 的

training data,

那這個 training data 的每一個字

他都會有他對應的 word embedding,

那當你把這個句子

丟到這個 test file 裡面,

他 forward 之後會得到一個 loss,

那你把這個 loss 做 backward 之後呢,

那他 backward 是 backward 到哪裡?

就是用這個 loss

對 word embedding 的

每一個 input 的 embedding 做為一倍,

那我們以 recommend 這個詞為例,

這個對他做為一倍的時候呢,

他做的事情就是

我們在這個 word embedding space 裡面

這個 recommend 這個 word embedding 的

某一個這個 epsilon ball,

所謂的 epsilon ball

就是半近似 epsilon 的一個球體裡面,

我們去找某一個某一個點,

這個 epsilon ball 的某一個點,

然後呢,這個他的 loss 是最大的,

就是往這個方向移的時候

他的 loss 會增加最多,

所以有點像是

這個 quadratic gradient descent

在做的事情是一樣的,

然後呢,

當我們找到這個 epsilon ball 裡面

這個讓 loss 最大的一個點之後呢,

我們就把原本的這個 word embedding

換成我們新找到這個

讓 loss 會是最大的 word embedding,

然後每一個字都做一樣的事情,

然後我們就可以找到

他們各自對應的 word embedding,

然後我們再拿這些 word embedding

投入到這個 test code 裡面,

然後會得到一個 loss,

然後我們現在訓練的

objective 就是我們要去 minimize,

用這些這個 adversarial word embedding 裡面

所得到這個 loss,

那這件事情這個

為什麼會是合理的呢?

這個合理的想法就是說

我們會覺得說

在某一個 word 的 word embedding 附近

應該都要是他的這個同義詞,

所以我們

當我們要找一個 epsilon ball 裡面

使得他 loss 最大的一個點的時候,

就是概念上就是我們要找

他的同義詞裡面

使得這個 loss 會是最大的一個

word embedding,

那當然你最後找到這個東西

他可能不會真的代表一個字,

不過很神奇的就是

這樣的方法其實還是會有效啦,

所以還蠻有趣的,

那這個可能只是因為

他的那個 loss 的 landscape

會比較平一點,

就是你可以讓他說,

因為你這樣做的事情就是

等於是要求說

他在每個字的 epsilon ball 裡面

他的 output 不能變化太多嘛,

所以可能會因為這樣

讓他的 generalization 能力

變得比較好,

所以他不會因為你把

每個字換掉之後,

他的 output 就直接爛掉。

好,那這個是

這個 word label 的

word embedding space 裡面的

electrical encoding,

所以這個方法跟剛剛這個

剛剛上一頁講到

那個 electrical encoding 最大的差別就是

我們現在只要直接做微分,

然後找到一個

embedding 就好了,

我們不用直接找到一個

實際上的這個 token

來做 adversarial training,

那這樣效率上會比較好一點。

好,那接下來我們來看一個

這個另外一個

一樣也是 adversarial training 的

defense 的方法,

那他要解決的就是

這個,你用 epsilon ball

來做這個

就是你要選

epsilon ball 裡面的某一個字

當作是你的 adversarial sample,

那最後有一個問題就是

你這個 epsilon ball 的這個半徑

你要是選得不好的話,

你要是選得太小,

假設這個是你原本的字,

這紅色四個點是他的同義詞,

那你要是選得太小呢,

他有可能他的同義詞就

沒有被包進去,

那你要是選得太大呢,

他可能有一些

不應該包進去的東西

也會包進去的,

所以這是用這個

epsilon ball 他會有的問題,

那假設你用這個

hyper-rectangle 就是高維空間中的

長方體,

假設這邊有四個

四個同義詞,

那他們的 word embed 你就取

每個維度的最小值跟最大值

就可以找到一個長方體

把它包起來,

那這個長方體包起來的空間

其實他有一些空間並不是

並不是他這個同義詞所

構成的空間,

他同義詞構成的最小的空間

就是這邊這個

灰色虛線所顯示的一個

四方形,

所以在這個

我現在游標詞的這個地方

他其實並不是由他的同義詞

所填滿的空間,

所以這個空間裡面

如果你找這裡面的

某個東西,

當作 adversarial symbol,

可能並不是太合理,

所以我們理想上

我們應該是要找一個

由這些同義詞

所形成的最小的一個

突集合,convex set,

那為什麼要選convex set呢?

有兩個原因,

一個原因是因為

convex set會比較好找

這個裡面的

convex set會比較好找

裡面的某一個

word embedding,

等一下,最後我重講一次,

所以我們現在要做的事情

是我們要在某一個空間裡面

找一個adversarial symbol,

那當我們這個空間是convex set的話,

這個adversarial symbol

就是這個symbol會比較好找,

那所以我們就去找這個

embedding,

同義詞的embedding

所形成的這個convex top,

那所謂的convex top就是

由這些這個點

所形成的最小的convex set,

叫做convex top,

好,那這個template

叫做adversarial sparse

convex combination,

那它做的事情就是

我們現在要在這個convex top裡面

找一個adversarial symbol,

然後這個adversarial symbol

可以使得這個

loss被maximize,

那我們就把這個

找到的adversarial word embedding,

就是在這個裡面的adversarial word embedding

拿去當作adversarial symbol,

然後去minimize這個loss

來達到embedding的效果,

那首先我們講一下

這個convex top

要怎麼被characterize,

那我們就會知道說

它要怎麼找這個adversarial symbol,

那convex top

就是假設說這個convex,

我們要找說這個

由SU1,SU2,SU3,SU4

所形成的convex top,

其實它有一個很簡單的表達方式,

這個convex top

它可以寫成是

這四個不同點的線性組合,

然後所以Wi就是

這個線性組合的coefficient,

然後線性組合就是

我們要要求說

這個每一個linear coefficient

它要是

每一個coefficient

它要是非負的時數,

然後這些coefficient加起來要是1,

這就是一個convex set,

所以我們要找的事情就是

我們要在這個set裡面

找一個點

使得這個模型的loss會被maximize,

那我們已經知道說

我們已經知道說

這個convex top的每一個點

它可以被這個式子來characterize,

就是這些同義式的embedding,

V of S就是它的embedding名字,

然後來characterize,

所以我們就是要找說符合這個

跟這個條件的這些點

哪一個東西可以去maximize

我們的這個loss,

那它的constraint就是

就是這個coefficient

它要是非負的時數,

然後它的和要是1,

那這個constraint

你要怎麼去讓它滿足呢?

其實有一個很簡單的方法,

就是你把你的變數

定數是W hat,

然後這些W hat

你只要做subnet之後

它就會滿足每一個W

是一個非負的時數,

然後它的和就是1,

所以我們現在要做的事情

就是我們要找一個

given一個原本的字,

然後given它的同義詞,

我們就是要在這些同義詞

所形成的convex hull裡面

找某一個E hat of Xi,

這個就是它的adversarial,

這個是adversarial,

這是convex hull裡面的某一個點,

然後我們希望這個convex hull

裡面的某一個點

它是adversarial,

所謂的adversarial就是說

我希望把這個convex hull

這個點丟到模型之後

它可以maximize模型的loss,

那我們的變數就是W hat,

就是我們要找這個

linear combination的coefficient,

然後使得這個loss可以被maximize,

那它除了要maximize這個loss,

它還另外加了一個loss,

那這個loss是

它要去minimize

這個linear coefficient的entropy,

那所謂的minimize這個entropy

它要做的事情就是

我希望說這些不同的W,

也就是這些we're embedding的weighting,

它要越接近一個one-hot vector,

或是它不要太平均比較好,

我要它越不平均越好,

那為什麼我會希望

它越不平均越好呢?

因為當它越不平均的時候

它才會比較接近一個

實際上的字的embedding,

那這樣才會比較合理吧,

因為我們現在實際上要做的事情

就是我們希望它在

面對同一詞替換攻擊的時候

它可以能夠有有效的defense,

因為你在做同一詞替換攻擊的時候

你替換的一定是某一個we're embedding,

你不會把它替換成

convex-hot裡面的任意一個字,

它一定是替換成某一個embedding,

所以當你加上這個coefficient的時候

它就會要求說

我是有產生出來這個

linear combination的weighting

就是coefficient,

它要越接近,

要越不平均越好,

所以它就可以比較

靠近某一個特定的字的we're embedding,

所以它這個

在找這個zero sample的時候

它的objective就是

它要去maximize

這個模型的loss,

並且同時minimize這個

線性組合的係數,

然後它的變數是w hat,

然後當它找到這個w hat的時候

它就找到了這個

可以maximize這個loss的we're embedding,

然後它就把這個we're embedding

丟下去模型裡面做adversarial training,

那這個就是ASCC這個defense方式

做的事情,

那除了這個做adversarial training

你也可以直接做adversarial data augmentation,

那adversarial data augmentation

它跟這個

好,那個宇翔有舉手了

宇翔

主教不好意思打斷

我有個問題

有個問題想請教

就是你剛剛說這四個點

就是great, terrific, fantastic, amazing

這四個點是怎麼找的

是用word net找的嗎

還是怎樣

對,就是你會先有一個predefined的

同義詞的set

然後這個

我剛剛前面在講說

球跟正方形的問題那邊

我好像沒有聽得很懂

那球跟正方形的問題是什麼

球的問題就是

球的問題是說你會不知道說

球的問題是這樣

就是假設你已經知道有這四個

這四個

我重新講一次

假設你不知道它這四個字的

word

你不知道它的同義詞是什麼

那你要直接設一個

半徑

那你不能保證說這個半徑

一定會包含你所有的同義詞

那它有可能不包含

假設以這個圖上的例子而言

它就是沒有包含到這個同義詞

那當你拿這個東西去

attack這個模型的時候

這個模型還是會爛掉

那當你用一個

假設你知道這幾個

同義詞是這樣

那所以你就說

好,那我就選最大的這個半徑

那你選最大的半徑的時候

它裡面就會有

這個input and output裡面

它就會包含某些其他不是同義詞的字

那但是當你

把這個半徑設那麼大的時候

對這些不是同義詞的字

你把它計算進去的時候

它也會要求說模型的output

要是正確的

那這個是不合理的

所以這個是用這個

input and output的問題

那用這個rectangle

跟那個半徑太大的input and output的問題是一樣的

就是這個rectangle

它一定會是比原本這個convex set還要大

所以它裡面就會包含到一些

不應該被包含到的字

所以當你把這個

當你把原本正常的句子裡面

換成這些

不應該被視為同義詞的字的時候

模型也會把它當成是一個同義詞

來判斷

那這樣是有問題的

這樣回答到你的問題嗎?

有有有

那我想再接續問一個問題

就是那這個convex hole

就是他們怎麼

因為他們都一直強調這個convex hole

這個convex的性質

但是我其實

因為其實說在embedded space到底長怎樣

我相信應該沒有人是真的有概念

那他們是怎麼去控制說這個

他們找出來的這個

hole它確實是convex的嗎?

其實convex這件事情他們都沒有控制

就只是找了四個同義詞

然後去做限定組合

就是這樣

就是這個東西會保證

就是這個convex hole就是

convex hole就是一個

我想一下

convex hole它by definition

它就一定是convex

所以就是當你用這個東西

去characterize它的時候

這個東西形成的結合

它就一定是一個convex

ok ok 我了解

謝謝 謝謝主管

好

那我就繼續講

好

好 那就繼續講

好

那個adversarial data augmentation

那adversarial data augmentation

它做的事情也很簡單

就是你先訓練了一個unrobust classifier

你拿這個classifier去attack

那attack在乾淨的data上面

就會得到一些adversarial training data

那拿這些adversarial training data

再加上原本乾淨的training data之後

訓練一個新的classifier

然後這樣子就叫做adversarial data augmentation

那其實這個就是

這個就是adversarial training的

第一個步驟而已

那為什麼要這樣做呢

這樣做的意義不只是說

因為用這個adversarial training的時候

你跑很多這個

跑很多次attack會太浪費時間

所以說我們才要attack一次就好了

所以這個其實講起來蠻簡單的啦

那這個接下來我們就看一個

在testing的時候做的defense

那testing的時候做的defense

它要做的事情就是

當它今天有一個testing data進來的時候

那這個模型啊

它要去判斷說今天這個input

它是不是惡意攻擊

那如果是惡意攻擊的話

就要想辦法把它變成不是惡意攻擊的版本

然後我們再對它做訓練的事情

那如果是正常的

當然就不應該對它做任何事情

那我們首先介紹第一個方法

第一個方法叫做

discriminate probation

那它做的事情呢

就是它先偵測這個input是不是adversarial

那如果是adversarial

它就把它變成一個

不是adversarial的版本

所以呢當今天進來一個正常的data

它不應該對它做任何事情

那今天假設進來的是一個adversarial sample的時候呢

就要把它改成一個

不是adversarial sample的版本

那這個方法呢

這個disc這個module

它有三個小的submodule

那這三個小的submodule呢

第一個是一個perturbation discriminator

那這個discriminator的功能呢

就是它要去分辨說今天的input

有沒有被perturb過

所以今天假設有一個input進來

那這個它的perturbation discriminator

它其實就是一個birth

那這個birth呢

它就會去抽出每一個字的contextualized embedding

然後假設最後一層的contextualized embedding長這樣

它就拿這些最後的contextualized embedding

每一個token的contextualized embedding

去做classification

那classification的目的呢

是要分說這個input的token

有沒有被perturb過

那舉例而言這個i它沒有被perturb過

所以output就是沒有

這個highly它也沒有被改過

所以它output也是沒有

那這個recommence它也已經被改過

那模型就會說它也被改過

那這個a也沒有被改過

所以模型也會說它沒有被改過

那這整個

這個模型在做的事情

其實就很像是

這個electra後面那個discriminator在做的事情

那當這個第一個presentation discriminator

已經判斷出

每個token有沒有被perturb過的時候

就可以進到下一個階段

那下一個階段就是embedding estimator

那這個embedding estimator

它要做的事情就是

它要去recover那個被perturb的token

它的for embedding

那它的做法是這樣子的

就是原本的那個input sequence

假設某一個token它被perturb過

那你就把它mask起來

那mask起來之後

一樣丟到一個birth initialized的模型

那這個模型做的事情

就是它要去估計說這個mask的token

是一個

是一個什麼樣的embedding

所以它真正的embedding

沒有被perturb過的那個版本

應該是什麼

然後所以它會去用一個regression head

去估計出來這個embedding長什麼樣子

那估計完這個embedding長什麼樣子之後

你要實際上找到這個embedding

對應的這個token是哪個token

所以要進入到第三個階段

就是token recovery

那token recovery呢

做的事情呢

就是給它一個

這個估計出來的embedding之後

挑在一個既有的這個embedding tokens

那這個embedding tokens裡面

就會記錄說

每個字它對應的embedding是什麼

所以它其實就是一個embedding table

然後它要去做kernel的logout

然後找到跟這個

這個估計出來的embedding

最接近的一個embedding

那假設我們找出來之後

我們就發現說regman這個字

跟原本估計出來的是最接近的話

那我們就把regman這個字

換到原本被perturb過的那個句子裡面

那把它丟到我們原本的classifier裡面

就做後面的事情

所以這個disk的這個方法

它有分為training跟testing兩階段

training這個階段就是

你要訓練這個perturbation discriminator

跟embedding estimator

那訓練的方法其實很簡單

就是你要自己去

construct一下一個zero sample

你只要有zero sample的話

你就可以去訓練這個

perturbation discriminator跟embedding estimator

那當你訓練完之後呢

這個你就可以拿這兩個東西

去實際上用

那實際上的這個使用就是

當先有一個attacker

把queen的testing data

變成一個髒的perturb testing data之後呢

你就會先用perturbation discriminator

去看說哪一個token有被換過

然後再來呢

你就會用embedding estimator去估計說

這些被換過的東西應該要

本來比較有可能是什麼東西的

void embedding

然後再經過這個embedding lookup

或是說KMM的lookup之後呢

你去找說

在原本的這個token embedding course裡面

最接近的那個void embedding是哪一個

然後把它換回去之後

再build out model

做final prediction

那這就是disk的整個流程

那這個disk它比較大的問題

當然就是你要先知道說

你的adversary是什麼

你才能去control對應的x2 sample

不然要是這個

你在這個training的時候

你剛剛看過的全部都是

全部都是同一時間段攻擊的話

結果你testing的時候做的是

去改它的inflectional motion的這個攻擊

那你的模型就會

你的這個disk的這個

這個方法可能就會直接失敗

那這個是disk的這個方法

好來那個呂翔有問題要問

不好意思問題真的比較多

就是那個

我想問一下

前面那個regression hat是什麼

是指說它會有一個

例如說768維的regression

然後讓它去固定embedding是這樣

可能是一個768維

轉到一個你的embedding

實際的embedding的一個維度

ok然後它就很簡單的

就是用一個模型

然後去直接呂翔刷這樣

就是去做一個

那因為這個東西聽起來

這個做法聽起來真的跟electra非常像

所以我其實還蠻好奇就是

那像electra這種模型它有

就是它天生的就是這種

defense能力有比較強嗎

因為這個做法聽起來

跟electra真的非常像

這個我沒有辦法回答

因為它的parameter沒有寫

但是我覺得

electra的perturbation跟

這個的perturbation

有點

也不能這樣講

你要看你的attack的perturbation是什麼

如果你的perturbation真的就是

你就是用Bird MLM做perturbation的話

那electra的確就跟

它在做的事情是很像的

如果你的perturbation是同時激光攻擊

或是它是

那個

改inflection模型

那electra可能就沒有

學過說它要去判斷這些東西

所以它不一定可以有好的表現

ok

那就是

這個模型它本身的

特色到底是

它本身特色是reconstruct嗎

還是它本身就是有標榜說

它就是其實比較

比較robust的

就是你其實一個

汙染過的資料就可以正確的判斷

還是它就是必須一遍可以經過

因為我剛剛想的是

假如它這個做法也用的話

那是不是代表說

somehow它的模型應該

很適應

attack的動作

那這樣somehow感覺

不見得需要reconstruct嗎

所以它強調的是

它有reconstruct的設計嗎

你如果沒有reconstruct的話

你就沒有辦法正確判斷

你如果只是偵測說

它是一個attack sample

那

你當然也可以直接把它丟掉

不過就是

能夠正確的判斷它當然是最好

所以你如果要正確判斷它

你就要知道它是attack

然後把它是attack的部分換成它

正常的版本

這樣才會有辦法正確的判斷

所以它的這個方法其實比較不像是說

我直接train一個很robust的模型

比較像是說ok

我今天不管你給我什麼sample

我都可以透過reconstruct這個步驟

然後把它當然是正確的

然後再去

再去判斷

就是detection的這一類

都是這樣子

ok謝謝主講

好我們鼓勵大家

多問問題

大家多發問