back to index

【機器學習2021】生成式對抗網路 (Generative Adversarial Network, GAN) (三) – 生成器效能評估與條件式生成


link |
00:01.000
好,我們就開始來上課吧。
link |
00:04.000
那上週講到哪裡呢?上週講到WGAN,
link |
00:09.000
然後我們還說實際上呢,如果你要實作WGAN的話,
link |
00:14.000
其實有很多不同的做法。
link |
00:17.000
那今天看起來呢,效果最好的其實是Spectral Normalization,
link |
00:24.000
很多人會縮寫成這個SNGAN,SN就是Spectral Normalization的意思。
link |
00:29.000
但是雖然說已經有WGAN,但其實並不代表說GAN就一定特別好勸,
link |
00:37.000
GAN仍然是以很難把它勸起來而聞名的。
link |
00:41.000
那為什麼GAN很難被勸起來呢?它有一個本質上困難的地方。
link |
00:47.000
我們來想想看Discriminator跟Generator他們各自在做的事情是什麼。
link |
00:52.000
Discriminator做的事情是要分辨真的圖片跟產生出來的,
link |
00:57.000
也就是假的圖片的差異。這是Discriminator在做的事情。
link |
01:02.000
而Generator在做的事情,它是要去產生假的圖片騙過Discriminator。
link |
01:08.000
而事實上這兩個Network,這個Generator跟Discriminator,
link |
01:14.000
他們是互相砥礪才能互相成長的。
link |
01:18.000
只要其中一者發生什麼問題停止訓練,
link |
01:22.000
另外一個人就會跟著停下訓練,就會跟著變差跟著慘掉。
link |
01:28.000
所以今天假設你在勸Discriminator的時候,
link |
01:31.000
一下子沒有勸好,你的Discriminator沒有辦法分辨
link |
01:35.000
真的跟產生出來的圖片的差異,
link |
01:38.000
那Generator他就失去了可以進步的目標,
link |
01:42.000
Generator就沒有辦法再進步了。
link |
01:45.000
Generator沒有辦法再進步了,Discriminator也會跟著停下來了。
link |
01:51.000
如果Generator沒有辦法再進步,
link |
01:53.000
他沒有辦法再產生更真實的圖片,
link |
01:56.000
那Discriminator就沒有辦法再跟著進步了。
link |
01:59.000
所以Discriminator跟Generator他們在訓練的時候,
link |
02:02.000
只要其中一者不再進步,另外一個人就會跟著停下來。
link |
02:08.000
但是到目前為止,大家已經勸過了很多次的Network,
link |
02:12.000
你有辦法保證說你勸下去,他的Loss就一定會下降嗎?
link |
02:16.000
不一定對不對?你要讓Network trend起來,往往你需要調一下Hyperparameter,
link |
02:22.000
才有可能把他Trend起來。
link |
02:25.000
那今天這個Discriminator跟Generator他們互動的過程是自動的,
link |
02:30.000
一旦在某一個步驟,因為我們不會在中間每一次Trend Discriminator的時候
link |
02:35.000
你都換Hyperparameter,所以只能祈禱說每一次Trend Discriminator的時候
link |
02:39.000
他的Loss都是有下降的。
link |
02:41.000
那如果有一次沒有下降,那整個Trend很有可能就會慘掉,
link |
02:47.000
整個Discriminator跟Generator彼此砥礪的這個過程就可能會停下來。
link |
02:53.000
所以今天Generator跟Discriminator在Trend的時候,他們必須要棋逢敵手,
link |
02:58.000
任何一個人放棄了這場比賽,另外一個人也就玩不下去了。
link |
03:03.000
所以Game本質上他的Trending仍然不是一件容易的事情。
link |
03:09.000
當然他是一個非常重要的技術,所以雖然他是一個前瞻的技術,
link |
03:13.000
有人可能會覺得說你不要把這種你自己都不見得Trend起來的Navigate放到那個作業裡面啦,
link |
03:18.000
但是我覺得說這是一個重要而前瞻的技術,
link |
03:21.000
所以我們還是應該要讓大家有機會接觸這種最前瞻的技術,
link |
03:26.000
你至少可以知道說Trend Game不是一件那麼容易的事情。
link |
03:30.000
當然其實從另外一個角度而言,因為很多人都在做類似的研究,
link |
03:34.000
所以在網路上你可以找到滿坑滿谷相關的程式,
link |
03:38.000
所以其實從這個角度而言,他其實也沒有你想像的那麼困難。
link |
03:43.000
不過Trend Game仍然不是一件容易的事就是了。
link |
03:46.000
你可以在網路上找到滿坑滿谷的Game的Tips,
link |
03:50.000
那這些有沒有用呢?不好說,不好說。
link |
03:54.000
就是把一些相關的跟Trend Game的訣竅有關的文獻,還有連結,
link |
04:00.000
列在這邊,其實就給大家自己參考。
link |
04:05.000
Trend Game最難的其實是要拿Game來生成文字。
link |
04:10.000
如果你要拿Game生成一段文字,這個會是最困難的。
link |
04:16.000
為什麼用Game生成一段文字會是最困難的呢?
link |
04:21.000
我們知道說如果你要生成一段文字,
link |
04:24.000
那你可能會有一個Sequence to Sequence的Model,
link |
04:27.000
你有一個Decoder,那這個Decoder會產生一段文字。
link |
04:31.000
那我們現在這個Sequence to Sequence的Model就是我們的Generator。
link |
04:36.000
就是在過去在講Transformer的時候,這是一個Decoder,
link |
04:39.000
那它現在在Game裡面,它就扮演了Generator的角色,
link |
04:43.000
負責產生我們要它產生的東西,比如說一段文字。
link |
04:48.000
那你說這個會跟原來的Game,在影像上的Game有什麼不同呢?
link |
04:53.000
就最High Level來看,就演算法來看,可能沒有太大的不同,
link |
04:58.000
因為接下來你就訓練一個Discriminator,
link |
05:01.000
Discriminator把這段文字讀進去,
link |
05:03.000
去判斷說這段文字是真正的文字,還是機器產生出來的文字。
link |
05:10.000
而Decoder就是想辦法去騙過Discriminator,
link |
05:14.000
Generator就是想辦法去騙過Discriminator,
link |
05:17.000
你去調整你的Generator的參數,
link |
05:20.000
想辦法讓Discriminator覺得Generator產生出來的東西是真正的。
link |
05:26.000
但是這邊的難點在哪裡呢?
link |
05:29.000
這邊的難點在於,你如果要用Gradient Descent去train你的Decoder,
link |
05:35.000
去讓Discriminator output的分數越大越好,
link |
05:38.000
你會發現你做不到。
link |
05:41.000
為什麼你做不到呢?
link |
05:43.000
大家知道在計算這個微分的時候,
link |
05:46.000
所謂的Gradient,所謂的微分,
link |
05:49.000
其實就是某一個參數,它有變化的時候,
link |
05:52.000
對你的目標造成了多大的影響。
link |
05:56.000
我們現在來想想看,假設我們改變了Decoder的參數,
link |
06:00.000
我們這個Generator,也就是Decoder的參數,
link |
06:03.000
有一點小小的變化的時候,
link |
06:05.000
到底對Discriminator的輸出有什麼樣的影響?
link |
06:09.000
Decoder的參數如果有一點小小的變化,
link |
06:12.000
那它現在輸出的這個distribution也會有小小的變化。
link |
06:16.000
那因為這個變化很小,
link |
06:18.000
所以它不會影響最大的那個token是什麼東西。
link |
06:23.000
我知道說token可能對各位同學來說,
link |
06:25.000
你可能會覺得有點抽象,
link |
06:27.000
那如果你要想得更具體一點,
link |
06:29.000
token就是你現在在處理這個問題,
link |
06:32.000
處理產生這個sequence的單位。
link |
06:34.000
那token是人定的,
link |
06:37.000
所以假設我們今天在產生一個中文的句子的時候,
link |
06:40.000
我們是每次產生一個character,一個方塊字,
link |
06:43.000
那方塊字就是我們的token。
link |
06:45.000
那假設你在處理英文的時候,
link |
06:47.000
你每次產生一個英文的字母,
link |
06:49.000
那字母就是你的token。
link |
06:51.000
假設你一次產生一個英文的詞,
link |
06:53.000
英文的詞和詞之間是以空白分開的,
link |
06:55.000
那就是詞就是你的token。
link |
06:57.000
所以token的定義是你自己決定的,
link |
07:00.000
看你要拿什麼樣的東西當作你產生一個句子的單位。
link |
07:04.000
那今天這個distribution只有小小的變化,
link |
07:07.000
在取max的時候,
link |
07:09.000
在找分數最大的那個token的時候,
link |
07:11.000
你會發現分數最大的那個token是沒有改變的。
link |
07:15.000
因為distribution只有小小的變化,
link |
07:17.000
所以分數最大的那個token是同一個,
link |
07:20.000
那對discriminator來說,
link |
07:22.000
它輸出的分數,它輸出是一模一樣的啊,
link |
07:24.000
所以它輸出的分數就沒有改變。
link |
07:26.000
所以你會發現說,
link |
07:28.000
當decoder的參數有一點變化的時候,
link |
07:31.000
discriminator的輸出是沒有改變的,
link |
07:33.000
所以你根本就沒有辦法算微分,
link |
07:37.000
你根本就沒有辦法做gradient descent。
link |
07:41.000
那有同學可能會說,
link |
07:42.000
這邊不是max,是因為max造成不能做gradient descent嗎?
link |
07:46.000
那CNN裡面不是有max pooling嗎?
link |
07:50.000
那怎麼還可以做gradient descent?
link |
07:52.000
這個問題就留給你自己深思一下,
link |
07:56.000
為什麼在這個地方有max,不能做gradient descent,
link |
08:00.000
而在CNN有max pooling,卻可以做gradient descent。
link |
08:04.000
但是就算是不能做gradient descent,
link |
08:07.000
你也不用害怕,
link |
08:08.000
記不記得我們上週有講說,
link |
08:10.000
遇到不能用gradient descent train的問題,
link |
08:13.000
就當作reinforcement learning的問題,
link |
08:16.000
硬做一下就結束了。
link |
08:19.000
所以你確實可以用reinforcement learning來train你的generator,
link |
08:24.000
在你要產生一個sequence的時候,
link |
08:26.000
你可以用reinforcement learning來train你的generator,
link |
08:29.000
但這會發生什麼問題呢?
link |
08:31.000
reinforcement learning是以難train而聞名,
link |
08:34.000
GAN也是以難train而聞名,
link |
08:36.000
這樣的東西加在一起就大炸裂,
link |
08:38.000
讓人train不起來,非常非常的難訓練。
link |
08:40.000
所以要用GAN產生一段文字,
link |
08:43.000
過去一直被認為是一個非常大的難題。
link |
08:46.000
只有很長一段時間,
link |
08:48.000
沒有人可以成功地把generator訓練起來,
link |
08:53.000
沒有人成功地可以訓練一個generator,
link |
08:56.000
用GAN的方式訓練一個generator產生文字。
link |
08:59.000
通常你需要先做pre-train,
link |
09:02.000
那pre-train這件事情其實我們等一下馬上就會提到,
link |
09:06.000
如果你現在還不知道pre-train是什麼的話,
link |
09:08.000
也沒有關係。
link |
09:09.000
總之過去你沒有辦法用正常的方法,
link |
09:12.000
讓GAN產生一段文字,
link |
09:15.000
直到有一篇paper叫做ScratchGAN,
link |
09:19.000
它的title就開宗明義跟你炫耀說,
link |
09:22.000
它可以train languageGAN from scratch,
link |
09:24.000
from scratch就是不用pre-train的意思。
link |
09:27.000
所以它可以直接從隨機的初始化參數開始,
link |
09:31.000
train它的generator,
link |
09:33.000
然後讓generator可以產生文字。
link |
09:37.000
那它怎麼做到的呢?
link |
09:39.000
最關鍵的就是爆條hyperparameter,
link |
09:42.000
跟一大堆的tips,
link |
09:43.000
那你可以想像這就是Google的paper,
link |
09:45.000
它爆收了參數以後,
link |
09:47.000
然後再加上了這邊就講了很多的tips,
link |
09:49.000
比如說呢,
link |
09:50.000
這個橫軸是他們的measure,
link |
09:52.000
這個叫做FED,
link |
09:54.000
那這個是用在文字上的,
link |
09:56.000
我們今天就不講,這不重要。
link |
09:57.000
總之這個值越低越好。
link |
09:59.000
一開始要有一個叫做sequence GAN step的技術,
link |
10:03.000
沒這個,完全train不起來。
link |
10:05.000
然後接下來要有一個很大的batch size,
link |
10:08.000
多大呢?
link |
10:09.000
通常就是上千,
link |
10:10.000
沒有那個你自己在家沒辦法這麼做的。
link |
10:13.000
discriminator加regularization,
link |
10:15.000
embedding要pre-train,
link |
10:16.000
改一下reinforcement learning algorithm,
link |
10:18.000
最後就有scratchGAN,
link |
10:20.000
就可以從真的把GANtrain起來,
link |
10:23.000
讓它來產生sequence。
link |
10:27.000
好,那今天有關GAN的部分呢,
link |
10:30.000
我們只是講了一個大概,
link |
10:32.000
那如果你想要學最完整的內容,
link |
10:35.000
我在這邊留下一個連結給大家參考。
link |
10:39.000
那其實有關generative的model,
link |
10:41.000
不是只有GAN而已,
link |
10:43.000
還有其他的,
link |
10:44.000
比如說VAE,
link |
10:46.000
比如說flow-based model,
link |
10:48.000
那我在這邊也列了兩個影片的連結給大家參考。
link |
10:52.000
那我想要強調一下就是,
link |
10:54.000
這邊的影片連結並不是說,
link |
10:56.000
我要趕快去把,
link |
10:58.000
我一定要看過這些影片連結,
link |
11:00.000
才能夠學習接下來的內容。
link |
11:03.000
因為機器學習可以講的東西實在太多了,
link |
11:06.000
所以如果假設你沒有太多的時間,
link |
11:09.000
那你唯一真正需要聽的,
link |
11:11.000
只有我上課講的內容。
link |
11:14.000
上課講的內容是self-contained,
link |
11:16.000
它本身是consistent的,
link |
11:19.000
你只要每一堂課都有聽,
link |
11:21.000
你接下來的內容,
link |
11:22.000
你應該都可以依序聽下去,
link |
11:24.000
應該都可以聽懂。
link |
11:25.000
然後在上課中,
link |
11:26.000
會放一些影片的連結,
link |
11:28.000
這個就等於是額外分出去的分支,
link |
11:32.000
如果你真的很有興趣的話,
link |
11:33.000
可以進行深入的研究。
link |
11:36.000
那為什麼我們不再講更多東西呢?
link |
11:38.000
因為在上課的設計呢,
link |
11:40.000
這課程的內容,
link |
11:41.000
是以真正能夠對你有幫助,
link |
11:44.000
以實務為導向的。
link |
11:46.000
就假設你想要train一個generator,
link |
11:48.000
你想要讓機器可以產生東西,
link |
11:50.000
你有很多方法,
link |
11:51.000
你可以用GAN,
link |
11:52.000
你可以用VAE,
link |
11:53.000
可以用flow-based model,
link |
11:54.000
我們這邊就選擇告訴你GAN,
link |
11:56.000
所以以後,
link |
11:57.000
如果有人叫你train一個generator model,
link |
11:59.000
你有辦法去train它,
link |
12:01.000
那如果你想要深入研究,
link |
12:02.000
你可以再研究VAE跟flow-based model。
link |
12:05.000
那有人可能會問說,
link |
12:06.000
為什麼選擇GAN,
link |
12:08.000
為什麼不是選擇其他的model呢?
link |
12:11.000
一個最直接的理由是,
link |
12:13.000
GAN的performance是比較好的,
link |
12:15.000
如果你要產生非常好的圖片的話,
link |
12:18.000
你還是今天要用GAN。
link |
12:20.000
通常VAE或flow-based model,
link |
12:22.000
它產生的結果,
link |
12:24.000
都是跟GAN有非常大的一段差距啦。
link |
12:26.000
他們通常都是claim說,
link |
12:28.000
我經過了一番努力,
link |
12:30.000
爆調了一堆餐,
link |
12:31.000
爆弄了一堆tips,
link |
12:32.000
最後可以跟GAN差不多而已。
link |
12:34.000
所以GAN通常它產生出來的結果,
link |
12:36.000
還是比較好的。
link |
12:38.000
那你可能會說,
link |
12:39.000
GAN比較難train啊,
link |
12:40.000
這個比較難train吧,
link |
12:41.000
VAE或flow會不會比較好train?
link |
12:43.000
這個是,
link |
12:45.000
如果你真的有實作VAE或flow的話,
link |
12:48.000
他們沒有比較好train,老實說。
link |
12:50.000
你可能會覺得說,
link |
12:51.000
它的事實上看起來,
link |
12:53.000
GAN很神秘,
link |
12:54.000
有一個discriminator,
link |
12:55.000
generator,
link |
12:56.000
他們要互動,
link |
12:57.000
然後像flow-based model,
link |
12:58.000
VAE他們都比較像是,
link |
12:59.000
直接train一個一般的模型,
link |
13:01.000
他們有一個很明確的objective。
link |
13:03.000
但實際上train起來發現說,
link |
13:05.000
他們也沒有那麼容易成功的被訓練起來。
link |
13:08.000
他們的objective裡面有很多項,
link |
13:10.000
他們的loss裡面有很多項,
link |
13:11.000
你要把每一項都平衡,
link |
13:13.000
才能夠有好的結果。
link |
13:14.000
要達成平衡,
link |
13:15.000
也非常的困難,
link |
13:17.000
跟GAN我覺得train的難度,
link |
13:18.000
只不遑多讓。
link |
13:19.000
所以我們這邊就選擇GAN,
link |
13:22.000
作為我們課堂上介紹的,
link |
13:25.000
生成式的generative的model。
link |
13:27.000
至於其他model,
link |
13:28.000
你可以再多多指揮。
link |
13:30.000
你有興趣,
link |
13:31.000
你可以再自己涉獵。
link |
13:33.000
有講到這邊,
link |
13:34.000
也許有同學會想說,
link |
13:36.000
為什麼我們要特別用一些,
link |
13:39.000
提出一些新的做法,
link |
13:41.000
來做generative這件事。
link |
13:44.000
如果我們今天的目標就是,
link |
13:46.000
輸入一個Gaussian的random variable,
link |
13:50.000
輸入一個Gaussian,
link |
13:51.000
從Gaussian的這個random variable,
link |
13:53.000
sample出來的vector,
link |
13:54.000
把它變成一張圖片。
link |
13:56.000
那我們能不能夠用,
link |
13:57.000
supervised learning的方法來做呢?
link |
14:00.000
怎麼做?
link |
14:01.000
你就說,
link |
14:02.000
我有一堆圖片,
link |
14:03.000
我把這圖片拿出來。
link |
14:04.000
每一個圖片,
link |
14:05.000
都去配一個vector,
link |
14:07.000
都去配一個,
link |
14:08.000
從Gaussian distribution,
link |
14:10.000
sample出來的vector。
link |
14:12.000
那接下來呢?
link |
14:13.000
接下來就當作supervised learning的方法,
link |
14:17.000
硬做就結束了。
link |
14:21.000
大家懂嗎?
link |
14:22.000
就是train一個network,
link |
14:23.000
這個network,
link |
14:24.000
你已經說這張圖片,
link |
14:25.000
就是對到這個vector,
link |
14:27.000
這張圖片,
link |
14:28.000
就是對到這個vector。
link |
14:29.000
train一個network,
link |
14:30.000
輸入一個vector,
link |
14:31.000
輸出,
link |
14:32.000
就是它對應的圖片,
link |
14:34.000
把對應的圖片,
link |
14:35.000
當作你訓練的目標,
link |
14:36.000
訓練下去,
link |
14:37.000
就結束了。
link |
14:39.000
能不能這麼做呢?
link |
14:40.000
能這麼做。
link |
14:42.000
真的有這樣子的,
link |
14:43.000
深層式的模型。
link |
14:45.000
那難的點是說,
link |
14:46.000
如果這邊,
link |
14:47.000
純粹放隨機的向量,
link |
14:49.000
train起來的結果,
link |
14:50.000
會很差。
link |
14:51.000
你可能根本連train都train不起來。
link |
14:53.000
所以怎麼辦?
link |
14:54.000
你需要有一些特殊的方法。
link |
14:56.000
至於什麼樣特殊的方法?
link |
14:58.000
你要一些特殊的方法,
link |
14:59.000
去安排這些vector。
link |
15:00.000
那至於有什麼特殊的方法?
link |
15:02.000
我在這邊一樣放,
link |
15:03.000
兩篇論文的連結。
link |
15:04.000
那你發現說,
link |
15:05.000
這都不是很舊的論文,
link |
15:07.000
像這個什麼,
link |
15:08.000
Gradient Original Network,
link |
15:10.000
這個是去年,
link |
15:12.000
去年二零年七月的文章。
link |
15:14.000
這都是比較新的論文,
link |
15:16.000
比較新的方法。
link |
15:17.000
那我把連結放在這邊,
link |
15:18.000
給大家參考。
link |
15:21.000
那接下來我們要講的,
link |
15:23.000
就是GaN的評量。
link |
15:25.000
怎麼說,
link |
15:26.000
怎麼看說,
link |
15:27.000
我們現在產生出來的generator,
link |
15:29.000
它好,
link |
15:30.000
或者是不好呢?
link |
15:33.000
那要評估一個generator的好壞,
link |
15:35.000
並沒有那麼容易。
link |
15:38.000
最直覺的做法,
link |
15:40.000
也許是找人來看。
link |
15:42.000
你要知道今天這個generator,
link |
15:44.000
產生出來的圖片,
link |
15:45.000
到底像不像動畫的人物,
link |
15:46.000
那就找人直接來看,
link |
15:48.000
也許就結束了。
link |
15:50.000
所以其實很長一段時間,
link |
15:52.000
尤其是人們剛開始研究generative,
link |
15:55.000
這樣的技術的時候,
link |
15:56.000
很長一段時間沒有好的measure,
link |
15:58.000
那時候要評估generator的好壞,
link |
16:00.000
都是人眼看,
link |
16:01.000
然後直接用吹的這樣。
link |
16:02.000
就說,
link |
16:03.000
在paper最後就放幾張圖說,
link |
16:04.000
你看這個,
link |
16:05.000
我覺得應該是比文獻上,
link |
16:07.000
目前的結果都還要好,
link |
16:08.000
太棒了,
link |
16:09.000
這應該是state of the art,
link |
16:10.000
然後就結束了。
link |
16:11.000
所以發現,
link |
16:12.000
比較早年的Gantt的paper,
link |
16:13.000
它沒有數字,
link |
16:14.000
整篇paper裡面,
link |
16:15.000
沒有這個measure,
link |
16:16.000
沒有accuracy,
link |
16:17.000
它就是放幾張圖片告訴你說,
link |
16:19.000
這個應該是比過去的文章都好,
link |
16:21.000
然後就結束了。
link |
16:22.000
但是你知道,
link |
16:23.000
這樣顯然是不行的嘛,
link |
16:24.000
就是完全用人來看,
link |
16:26.000
顯然有很多的問題,
link |
16:28.000
比如說不客觀,
link |
16:29.000
不穩定,
link |
16:30.000
等等諸多的問題。
link |
16:31.000
所以有沒有比較客觀,
link |
16:33.000
而且自動的方法,
link |
16:34.000
來想辦法量一個generator的好壞呢?
link |
16:38.000
如果針對特定的一些任務,
link |
16:40.000
是有辦法設計一些方法的,
link |
16:42.000
舉例來說,
link |
16:43.000
在作業6裡面,
link |
16:45.000
我們就是要叫大家生成,
link |
16:46.000
二次元人物的頭像,
link |
16:48.000
那在作業裡面,
link |
16:49.000
一個評估的標準,
link |
16:50.000
就是我們跑一個動畫人物,
link |
16:53.000
人臉偵測的系統,
link |
16:55.000
然後看說,
link |
16:56.000
你提供的那些圖片裡面,
link |
16:58.000
抓到幾個動畫人物的人臉,
link |
17:00.000
那如果你提供一千張圖片裡面,
link |
17:02.000
抓到九百個人臉,
link |
17:05.000
跟提供一千張圖片,
link |
17:06.000
抓到三百個人臉,
link |
17:07.000
那顯然九百個人臉的那一個generator,
link |
17:10.000
它做出來的結果是比較好的。
link |
17:14.000
但是這是針對作業6的設計。
link |
17:18.000
那如果是更一般的case呢?
link |
17:20.000
如果我們不侷限在我們的作業,
link |
17:23.000
更一般的case,
link |
17:24.000
我隨便訓練了一個generator,
link |
17:26.000
它不一定是產生動畫人物的,
link |
17:27.000
因為它產生別的,
link |
17:28.000
它專門產生貓,
link |
17:29.000
專門產生狗,
link |
17:30.000
專門產生斑馬等等。
link |
17:32.000
那我們怎麼知道它做得好不好呢?
link |
17:36.000
那有一個方法呢,
link |
17:37.000
是一樣跑一個影像的分類系統,
link |
17:41.000
把你的game產生出來的圖片,
link |
17:43.000
丟到一個影像的分類系統裡面,
link |
17:46.000
看它產生什麼樣的結果。
link |
17:49.000
影像分類的系統輸入是一張圖片,
link |
17:51.000
我們這邊叫做Y,
link |
17:52.000
輸出是一個機率分布,
link |
17:54.000
我們這邊叫它P of C given Y,
link |
17:57.000
P of C given Y是一個機率的分布。
link |
18:01.000
然後接下來我們就看說,
link |
18:02.000
這個機率的分布如果越集中,
link |
18:06.000
就代表說現在產生的圖片可能越好。
link |
18:10.000
雖然我們不知道這邊產生的圖片,
link |
18:11.000
裡面有什麼東西,
link |
18:12.000
不知道它是貓還是狗還是斑馬,
link |
18:14.000
我們不知道它是什麼,
link |
18:16.000
但是如果丟到一個影像分類系統以後,
link |
18:18.000
它輸出來的結果,
link |
18:20.000
它輸出來的這個分布非常集中,
link |
18:23.000
代表影像分類系統,
link |
18:24.000
它非常肯定它現在看到什麼樣的東西,
link |
18:27.000
它非常肯定它看到了狗,
link |
18:28.000
它非常肯定它看到了斑馬,
link |
18:30.000
要代表說你產生出來的圖片,
link |
18:32.000
也許是比較接近真實的圖片,
link |
18:35.000
所以影像辨識系統才辨識得出來。
link |
18:38.000
如果產生出來的圖片是一個四不像,
link |
18:40.000
根本看不出是什麼動物,
link |
18:41.000
那影像辨識系統就會非常的困惑,
link |
18:44.000
它產生出來的這個機率分布,
link |
18:46.000
就會非常的平坦,
link |
18:48.000
非常的平均分布。
link |
18:51.000
如果是平均分布的話,
link |
18:52.000
那就代表說你的game產生出來的圖片,
link |
18:55.000
可能是比較奇怪的,
link |
18:57.000
所以影像辨識系統才會辨識不出來。
link |
19:01.000
所以這個是靠影像辨識系統,
link |
19:04.000
來判斷你產生出來的圖片好壞,
link |
19:07.000
這是一個可能的做法。
link |
19:09.000
但是光用這個做法是不夠的,
link |
19:12.000
光用這個做法會有什麼問題呢?
link |
19:14.000
光用這個做法,
link |
19:16.000
你會被一個叫做這個Evaluation的方法,
link |
19:19.000
評估的方法會被一個叫做
link |
19:22.000
Mole Collapse的問題騙過去。
link |
19:24.000
什麼叫Mole Collapse呢?
link |
19:26.000
Mole Collapse是說,
link |
19:28.000
你在train game的時候,
link |
19:29.000
你有時候train著train著,
link |
19:31.000
就會遇到一個狀況是,
link |
19:33.000
假設這些藍色的星星,
link |
19:35.000
是真正的資料的分布,
link |
19:37.000
紅色的星星是你的game,
link |
19:40.000
你的Generative Model它的分布。
link |
19:43.000
你會發現說,
link |
19:44.000
Generative Model它輸出來的圖片,
link |
19:46.000
來來去去,
link |
19:48.000
就是那幾張。
link |
19:50.000
來來去去,就是那幾張。
link |
19:52.000
可能單一張拿出來,
link |
19:54.000
你覺得好像還做得不錯,
link |
19:56.000
但讓它多產生幾張,
link |
19:58.000
就露出馬腳,
link |
19:59.000
發現說原來它就是成咬金只有三斧頭,
link |
20:02.000
原來產生出來就只有那幾張圖片而已。
link |
20:06.000
那以下是一個Mole Collapse的例子。
link |
20:09.000
就是我們在上週有看到說,
link |
20:12.000
我就train了一個Generator,
link |
20:13.000
讓它產生二次元的人物。
link |
20:15.000
那train著train著train到最後,
link |
20:17.000
我就發現變成這樣的一個狀況。
link |
20:19.000
這一張臉越來越多,
link |
20:22.000
而且它有不同的髮色,
link |
20:24.000
這個髮色比較偏紅,
link |
20:25.000
這個髮色比較偏黃,
link |
20:27.000
越來越多,
link |
20:28.000
最後就通通都是這張臉。
link |
20:30.000
這就是一種Mole Collapse的現象。
link |
20:33.000
那為什麼會有Mole Collapse這種現象發生呢?
link |
20:36.000
就直覺上你還是比較容易理解,
link |
20:38.000
你可以想成說,
link |
20:39.000
這個地方就是Discriminator的一個盲點,
link |
20:43.000
當Generator學會產生這種圖片以後,
link |
20:46.000
它就永遠都可以騙過Discriminator。
link |
20:49.000
Discriminator沒辦法看出說,
link |
20:51.000
這樣子的圖片是假的。
link |
20:53.000
那這是一個Discriminator的盲點,
link |
20:55.000
Generator抓到這個盲點就硬打一發,
link |
20:57.000
就發生Mole Collapse的狀況。
link |
21:00.000
那可是到底要怎麼避免Mole Collapse的狀況呢?
link |
21:03.000
我認為今天其實還沒有一個非常好的解答。
link |
21:08.000
舉例來說,
link |
21:09.000
我們在上週給大家看到了Big Game的結果,
link |
21:12.000
就是產生網球狗那個結果,
link |
21:14.000
網球狗做的,它也暴收了參數,
link |
21:16.000
但就算是它暴收了參數,
link |
21:18.000
它發現最終它仍然沒有辦法真的避免Mole Collapse的狀況。
link |
21:24.000
Big Game train到最後還是Mole Collapse。
link |
21:27.000
那Big Game怎麼解決這個問題呢?
link |
21:31.000
其實很簡單。
link |
21:33.000
Model在Generator在訓練的時候,
link |
21:35.000
一路上都會把那個checkpoint存下來,
link |
21:38.000
在Mole Collapse之前把training停下來,
link |
21:40.000
就train到Mole Collapse了,
link |
21:42.000
把以前的Model拿出來用就結束了。
link |
21:44.000
所以就算是強如Google暴收參數,
link |
21:48.000
現在還是沒有辦法徹底解決Mole Collapse的問題。
link |
21:53.000
不過Mole Collapse這種問題,
link |
21:54.000
至少你知道有這個問題,
link |
21:56.000
你可以看得出有這個問題。
link |
21:58.000
你的Generator總是產生這張臉的時候,
link |
22:00.000
你不會說你的Generator是個好的Generator,
link |
22:03.000
你知道說發生了一些狀況,
link |
22:06.000
你的Generator不是特別的好。
link |
22:09.000
但是有另外一種,
link |
22:10.000
跟Mole還有點像,但是更難被偵測到的問題,
link |
22:13.000
叫做Mole Dropping。
link |
22:14.000
Mole Dropping的意思是說,
link |
22:16.000
你的真實的資料的分布可能是這個樣子。
link |
22:19.000
但是你的產生出來的資料,
link |
22:22.000
只有真實資料的一部分。
link |
22:24.000
單純看產生出來的資料,
link |
22:26.000
你可能會覺得還不錯,
link |
22:28.000
而且分布它的多樣性也夠,
link |
22:31.000
但你不知道說真實的資料,
link |
22:33.000
它的多樣性的分布其實是更大的。
link |
22:37.000
我這邊舉一個例子。
link |
22:38.000
這邊是一個真實的例子。
link |
22:40.000
有一個同學他train了人臉生成的Gap。
link |
22:44.000
在某一個Iteration的時候,
link |
22:46.000
他的Generator產生出這些人臉。
link |
22:49.000
你會覺得說沒有問題,
link |
22:52.000
而且人臉的多樣性也夠。
link |
22:54.000
有男有女,有向左看有向右看,
link |
22:56.000
各式各樣的人臉都有。
link |
22:58.000
這個是第七個Iteration的時候的Generator。
link |
23:02.000
你也不覺得它的多樣性有問題。
link |
23:04.000
但如果你再看下一個Iteration,
link |
23:08.000
Generator產生出來的圖片,
link |
23:10.000
是這樣子的。
link |
23:11.000
有沒有發現問題?
link |
23:13.000
它的膚色有問題啊。
link |
23:15.000
所以它之前你看有男有女沒有問題,
link |
23:17.000
但它膚色偏白啊,這邊膚色偏黃啊,
link |
23:19.000
你沒弄好,人家都覺得你的Generator有種族歧視啊。
link |
23:23.000
所以這種Model Dropping的問題
link |
23:25.000
是不太容易被偵測出來的。
link |
23:29.000
事實上今天到底,
link |
23:31.000
今天這些非常好的Game,Big Game啊,
link |
23:34.000
Progressive Game啊,
link |
23:35.000
可以產生非常真實的人臉這些Game,
link |
23:37.000
到底有沒有Model Dropping的問題?
link |
23:39.000
可能還是有的。
link |
23:41.000
如果你看多了Game產生出來的人臉,
link |
23:43.000
你會發現說雖然非常真實,
link |
23:45.000
但好像來來去去就是那麼幾張臉而已。
link |
23:49.000
還有一個非常獨特的特徵,
link |
23:51.000
是你看多了以後就覺得
link |
23:53.000
這個臉好像是被生成出來的。
link |
23:56.000
所以今天也許Model Dropping的問題
link |
23:59.000
都還沒有獲得本質上的解決。
link |
24:03.000
但是我們會需要去量說
link |
24:05.000
現在我們的Generator它產生出來的圖片
link |
24:08.000
到底多樣性夠不夠?
link |
24:10.000
所以怎麼做呢?
link |
24:11.000
過去有一個做法呢,
link |
24:13.000
一樣是藉助我們的Image Classifier,
link |
24:16.000
你就把一堆圖片,
link |
24:18.000
就讓你的Generator產生一千張圖片,
link |
24:20.000
把這一千張圖片都丟到Image Classifier裡面,
link |
24:24.000
看它被判斷成哪一個Class。
link |
24:26.000
每一張圖片都會給我們一個Distribution。
link |
24:31.000
你把所有的Distribution平均起來,
link |
24:33.000
接下來看看平均的Distribution長什麼樣子。
link |
24:37.000
如果平均的Distribution非常集中,
link |
24:39.000
就代表現在多樣性不夠。
link |
24:41.000
如果什麼圖片丟進去,
link |
24:43.000
你的影像分類系統都說是看到Class 2,
link |
24:47.000
看到裡面有Class 2這樣的東西,
link |
24:49.000
那代表說每一張圖片也許都蠻像的,
link |
24:52.000
你的多樣性是不夠的。
link |
24:54.000
那如果另外一個Case,
link |
24:56.000
不同當張圖片丟進去,
link |
24:58.000
不同張你的Generator產生出來的圖片,
link |
25:01.000
丟到Image Classifier的時候,
link |
25:03.000
它產生出來的輸出的分布都非常的不同,
link |
25:06.000
你平均完以後發現,
link |
25:08.000
平均完後的結果是非常平坦的。
link |
25:11.000
那這個時候代表什麼?
link |
25:13.000
這個時候代表說,
link |
25:14.000
也許你的多樣性是足夠的。
link |
25:18.000
那你會發現說在評估的標準上,
link |
25:20.000
當我們用這個Image Classifier來做評估的時候,
link |
25:23.000
Diversity跟Quality好像是有點互斥的。
link |
25:30.000
因為我們剛才在講Quality的時候,
link |
25:32.000
我們說越集中代表Quality越高,
link |
25:36.000
但是Diversity是越平坦,
link |
25:40.000
越分布越平均代表Diversity越大。
link |
25:44.000
不過我要強調一下這個Quality跟Diversity,
link |
25:47.000
他們評估的範圍不一樣。
link |
25:50.000
Quality是只看一張圖片,
link |
25:52.000
一張圖片丟到Classifier的時候,
link |
25:54.000
分布有沒有非常的集中。
link |
25:58.000
而Diversity看的是一堆圖片它分布的平均,
link |
26:02.000
一堆圖片你的Image Classifier輸出的平均。
link |
26:05.000
如果輸出越平均,
link |
26:07.000
那就代表如果輸出的這個平均越平均的話,
link |
26:11.000
這邊有兩個平均,
link |
26:12.000
我想大家應該知道我的意思。
link |
26:14.000
如果輸出的平均越平均的話,
link |
26:16.000
就代表說現在Diversity越大。
link |
26:19.000
那過去有一個非常常被使用的分數,
link |
26:21.000
叫做Inception Score,
link |
26:23.000
那它的縮寫是IS,
link |
26:25.000
所謂Inception Score,
link |
26:26.000
顧名思義就是這邊用的這個CNN,
link |
26:29.000
是用一個叫做Inception來做的,
link |
26:31.000
所以叫Inception Score。
link |
26:33.000
那這個Inception Score是怎麼定出來的呢?
link |
26:36.000
你就量一下,
link |
26:37.000
用Inception Level量一下Quality。
link |
26:39.000
如果Quality高,Diversity又大,
link |
26:42.000
那Inception Score就會比較大。
link |
26:45.000
不過在作業裡面,
link |
26:46.000
我們並不會用Inception Score。
link |
26:49.000
為什麼我們不用Inception Score呢?
link |
26:51.000
你想想看,
link |
26:52.000
假設把你產生出來的二次元人物,
link |
26:55.000
丟到Inception Net裡面,
link |
26:57.000
它輸出可能就是都看到人臉嘛,
link |
26:59.000
你可能Diversity很大,
link |
27:01.000
產生不同的髮色,
link |
27:02.000
產生不同的眼睛的顏色的人物,
link |
27:05.000
但是對Inception Level來說,
link |
27:06.000
它都是人臉啊,
link |
27:07.000
所以你可能算出來Diversity其實是小的。
link |
27:10.000
所以Inception Score在我們這個作業中,
link |
27:15.000
可能是不適用的。
link |
27:17.000
那在我們的作業中,
link |
27:19.000
會採取另外一個Evaluation Measure,
link |
27:22.000
叫Fetched Inception Distance。
link |
27:26.000
這個東西是什麼呢?
link |
27:27.000
它的縮寫叫做FID。
link |
27:29.000
這個東西是什麼呢?
link |
27:31.000
你先把你產生出來的二次元人物,
link |
27:34.000
丟到Inception Net裡面。
link |
27:37.000
那如果你把這個二次元人物一路丟到最後,
link |
27:41.000
讓那個Inception Level輸出它的類別,
link |
27:43.000
那你得到的可能就是人臉。
link |
27:45.000
那每一張二次元人物看起來都是人臉,
link |
27:48.000
但我們不要拿那個類別,
link |
27:50.000
我們拿進入Softmax之前的Hidden Layer的輸出。
link |
27:55.000
進入Softmax之前,
link |
27:57.000
你的Network不是會產生一個向量嗎?
link |
27:59.000
那可能是上千維,
link |
28:01.000
長度是上千維的一個向量。
link |
28:03.000
把那個向量拿出來代表這張圖片。
link |
28:08.000
那如果我們拿出來的是一個向量,
link |
28:11.000
而不是最後的類別,
link |
28:12.000
那雖然最後分類的類別
link |
28:14.000
可能是一樣的,
link |
28:15.000
但是在決定最後的類別之前,
link |
28:18.000
這個向量就算都是人臉,
link |
28:20.000
可能還是不一樣的,
link |
28:22.000
可能會隨著膚色、髮型,
link |
28:23.000
這個向量還是會有所改變的。
link |
28:26.000
所以我們就不取最後的類別,
link |
28:28.000
只取這個Inception Level中間的,
link |
28:31.000
其實是最後一層的Hidden Layer的輸出,
link |
28:36.000
來代表一張圖片。
link |
28:39.000
那在這個投影片上,
link |
28:41.000
所有紅色的點代表
link |
28:43.000
你把真正的圖片丟到Inception Level以後
link |
28:46.000
拿出來的向量。
link |
28:47.000
那這個向量其實非常高維度,
link |
28:49.000
是上千維的,
link |
28:50.000
但我們就把它假設
link |
28:52.000
我們可以把它畫在二維的平面上。
link |
28:55.000
那這個藍色的點呢,
link |
28:57.000
藍色的點是你自己的Game,
link |
29:00.000
你自己的Generator產生出來的圖片,
link |
29:03.000
它丟到Inception Level以後,
link |
29:05.000
進入SoftMate之前的向量,
link |
29:08.000
把它畫出來,
link |
29:09.000
假設是長這個樣子。
link |
29:10.000
接下來呢,你就假設這兩組資料,
link |
29:15.000
假設真實的圖片跟產生出來的圖片,
link |
29:18.000
它們都是Gaussian的Distribution,
link |
29:22.000
然後去計算這兩個Gaussian Distribution之間的
link |
29:27.000
Fragile Distance就結束了。
link |
29:30.000
那至於Fragile Distance是什麼,
link |
29:32.000
你有興趣再自己看一下文件,
link |
29:34.000
反正在作業裡面,
link |
29:36.000
我們的Judge System會幫大家算好。
link |
29:40.000
好,但是這邊因為它是一個Distance,
link |
29:44.000
所以這個值就是越小越好,
link |
29:46.000
距離就是越小越好,
link |
29:48.000
距離越小代表這兩組圖片越接近,
link |
29:52.000
那當然就是產生出來的品質越高。
link |
29:55.000
那這邊你一定心裡還是有很多問號,
link |
29:58.000
第一個問號就是,
link |
29:59.000
當作Gaussian Distribution沒問題嗎?
link |
30:02.000
這個應該不是Gaussian Distribution吧?
link |
30:05.000
會有問題,就這樣子。
link |
30:07.000
然後另外一個問題就是,
link |
30:09.000
如果你要準確的得到你的Network的分布,
link |
30:14.000
那你可能需要產生大量的Sample才能做到,
link |
30:18.000
這需要一點運算量,
link |
30:20.000
那這個也是要做FID不可避免的問題。
link |
30:25.000
所以其實我們在作業裡面,
link |
30:27.000
我們也不會只看FID,
link |
30:30.000
只看FID其實結果會怪怪的,
link |
30:34.000
你假設你的輸出的分布一定是Gaussian,
link |
30:39.000
實際上不是Gaussian,
link |
30:40.000
你硬假設它是Gaussian,
link |
30:41.000
沒有怪怪的,會怪怪的。
link |
30:43.000
所以我們是同時看FID跟動畫人物人臉的
link |
30:48.000
偵測出來的人臉的數目這兩個指標,
link |
30:51.000
我們會同時看這兩個指標,
link |
30:53.000
那這樣可以得到比較合理而精確的結果。
link |
30:58.000
那FID算是今天比較常用的一種Measure,
link |
31:02.000
那有一篇Paper叫做
link |
31:04.000
Against Created Equally Large Scale Study,
link |
31:08.000
你可以想見說這個也是Google做的啦,
link |
31:10.000
就是暴做了各式各樣不同的Gap,
link |
31:13.000
那個時候它就列舉了好多不同的各式各樣的Gap,
link |
31:17.000
每個Gap當然它訓練的Loss有點不太一樣,
link |
31:23.000
我這邊就不細講,
link |
31:24.000
各式各樣的Gap,
link |
31:25.000
每一種Gap它都用不同的Random Z
link |
31:29.000
去跑過很多次以後,
link |
31:32.000
看看結果怎麼樣。
link |
31:34.000
那以下呢,下面這個圖呢,
link |
31:36.000
就是在四個不同的資料庫上面得到的結果。
link |
31:42.000
那橫軸這邊代表的是不同的Gap,
link |
31:45.000
那這邊的值是越小越好,
link |
31:48.000
它是FIT,
link |
31:53.000
不好意思,這我寫錯了,
link |
31:55.000
我記得改一下,這個不是FIT,這個是FID,
link |
31:59.000
這個是FID的分數,
link |
32:01.000
那這FID的分數就是越小越好啦。
link |
32:05.000
那你會發現說這邊每一個方法呢,
link |
32:07.000
它都不是只得到一個數值,
link |
32:09.000
它都得到一個分布,
link |
32:10.000
為什麼它得到是一個分布呢?
link |
32:12.000
因為你要用不同的Random Z去跑嘛,
link |
32:15.000
用不同的Random Z去跑,
link |
32:16.000
每次跑出來的結果都不太一樣。
link |
32:19.000
那這邊混了一個不是Gain的做法,
link |
32:21.000
混了一個VAE在這裡。
link |
32:24.000
那你會發現說,
link |
32:25.000
如果比較這些Gain的方法跟VAE的方法,
link |
32:29.000
VAE的方法顯然是比較穩定的,
link |
32:31.000
不同的Random Z看起來差距還是比較小的,
link |
32:34.000
那Gain的方法不同Random Z差距是很大的。
link |
32:37.000
那你又可以很明顯的看出,
link |
32:39.000
VAE跟Gain它的這個好的程度啊,
link |
32:42.000
不在同一個量級上,
link |
32:44.000
Gain可以產生遠比VAE更好的結果。
link |
32:48.000
不過你會發現說,
link |
32:49.000
不同的Gain好像結果差不多,
link |
32:52.000
所以這篇文章的Title就是
link |
32:55.000
Gain Created Equally,
link |
32:57.000
然後看起來所有的Gain都差不多。
link |
32:59.000
農場文最喜歡這種文章,
link |
33:01.000
它就是說,
link |
33:02.000
所有的Gain都差不多啦,
link |
33:03.000
所以那些跟Gain有關的研究都是白忙一場。
link |
33:06.000
但是其實事實上也未必是如此,
link |
33:08.000
如果你仔細看那篇文章的話,
link |
33:10.000
在做實驗的時候,
link |
33:12.000
所有這些不同的Gain用的Network架構,
link |
33:15.000
都是同一個,
link |
33:17.000
它只是報收了Random Z跟Random Rate而已。
link |
33:21.000
所以Network架構還是同一個。
link |
33:25.000
所以我們不知道說,
link |
33:26.000
是不是有某些Network架構,
link |
33:28.000
特別Favor某些種類的Gain,
link |
33:33.000
或者是某些種類的Gain,
link |
33:34.000
會不會在不同的Network架構上,
link |
33:36.000
表現得比較穩定。
link |
33:38.000
比如說如果你看WGain的話,
link |
33:40.000
WGain最原始的Favor,
link |
33:42.000
它標榜的其實是,
link |
33:43.000
它Network架構胡亂設計,
link |
33:45.000
它胡亂兜個什麼100層的Generator,
link |
33:48.000
沒有必要弄個100層的Generator,
link |
33:51.000
它也Trend得起來。
link |
33:52.000
所以也許WGain是在不同的Network架構的時候,
link |
33:58.000
比較穩定,
link |
33:59.000
是不同的Random Z,
link |
34:00.000
可能沒有特別穩定,
link |
34:01.000
等等之類的。
link |
34:02.000
不知道,
link |
34:03.000
這篇文章並沒有給我們這方面的答案。
link |
34:07.000
其實剛才那些Measurement,
link |
34:09.000
也並沒有完全解決Gain的問題,
link |
34:12.000
Evaluation的問題。
link |
34:14.000
因為還有什麼樣Evaluation的問題呢?
link |
34:16.000
你想想看以下的狀況,
link |
34:18.000
假設這是你的真實資料,
link |
34:20.000
你不知道怎麼回事,
link |
34:21.000
訓練了一個Generator,
link |
34:23.000
它產生出來的Data,
link |
34:25.000
跟你的真實資料一模一樣。
link |
34:28.000
所以如果你不知道真實資料長什麼樣子,
link |
34:31.000
你光看這個Generator的輸出,
link |
34:33.000
你會覺得太棒了,
link |
34:34.000
它做得很棒,
link |
34:36.000
FID算出來一定是非常小的。
link |
34:39.000
但問題是,
link |
34:40.000
這個是你要的嗎?
link |
34:42.000
如果它產生出來的圖片,
link |
34:43.000
都跟資料庫裡面的訓練資料的一模一樣,
link |
34:46.000
訓練資料就在你手上,
link |
34:47.000
直接從訓練資料裡面Sample一些Image出來不是更好?
link |
34:50.000
幹嘛要Train Generator?
link |
34:51.000
我們Train Generator其實是希望它產生新的圖片啊,
link |
34:55.000
資料集裡面,
link |
34:56.000
訓練資料裡面沒有的人臉啊,
link |
34:58.000
如果訓練資料裡面有一模一樣的人臉,
link |
35:00.000
直接用訓練資料裡面的人臉就好了,
link |
35:02.000
何必用Gain呢?
link |
35:03.000
所以,
link |
35:04.000
有時候你的Gain產生出來的結果很好,
link |
35:07.000
也許你在作業裡面FID算出來也很低,
link |
35:10.000
然後人臉辨識系統也給你很高的分數,
link |
35:13.000
但是它不一定是一個好的Gain。
link |
35:15.000
那像這種問題,
link |
35:16.000
就不是我們作業的Manager可以偵測的,
link |
35:18.000
但是它是一個問題。
link |
35:21.000
那怎麼解呢?
link |
35:22.000
你可能會說,
link |
35:23.000
那我們就把我們Generator產生出來的圖片跟真實資料比個相似度嘛,
link |
35:28.000
看看是不是一樣嘛,
link |
35:29.000
如果很多張都一樣就代表說,
link |
35:31.000
Generator只是把訓練資料背起來而已,
link |
35:34.000
它沒有很厲害。
link |
35:35.000
但是那如果我問另外一個問題,
link |
35:37.000
假設你的Generator學到的是,
link |
35:39.000
把所有訓練資料裡面的圖片都左右翻轉了,
link |
35:43.000
那它也是什麼事都沒有做啊,
link |
35:45.000
假設它學到就是,
link |
35:46.000
把訓練資料裡面所有的圖片都左右翻轉,
link |
35:49.000
那你會覺得它看起來很棒,
link |
35:51.000
它實際上也是什麼事都沒有做,
link |
35:54.000
但問題是你比相似度的時候,
link |
35:56.000
又比不出了。
link |
35:58.000
所以,Gain的Evaluation是非常的困難的,
link |
36:02.000
還是光要如何評估一個Generator做得好不好這件事情,
link |
36:06.000
都是一個可以研究的題目。
link |
36:09.000
如果你真的很有興趣的話,
link |
36:10.000
這邊放了一篇相關的文章啦,
link |
36:12.000
裡面就列舉了20幾種Gain Generator的評估的方式,
link |
36:18.000
給大家參考。
link |
36:22.000
好,那接下來呢,
link |
36:24.000
我們要講Conditional的Generation,
link |
36:27.000
那也許我們講完Conditional的Generation以後再下課,
link |
36:30.000
然後接下來就是讓助教來講一下Gain的作業。
link |
36:34.000
好,那什麼是Conditional的Generation呢?
link |
36:36.000
剛才我們講的那個Generator,
link |
36:38.000
到目前為止我們講的Generator,
link |
36:40.000
它輸入都是一個隨機的分佈而已,
link |
36:43.000
那這個不見得非常有用,
link |
36:46.000
我們現在想要更進一步的是,
link |
36:48.000
我們可以操控Generator的輸出,
link |
36:51.000
我們給它一個Condition X,
link |
36:54.000
讓它根據X跟Z來產生Y。
link |
36:58.000
那這樣的Conditional Generation有什麼樣的應用呢?
link |
37:01.000
比如說你可以做文字對圖片的生成,
link |
37:05.000
那如果你要做文字對圖片的生成,
link |
37:07.000
它其實是一個Supervised Learning的問題,
link |
37:10.000
你需要一些Label的Data,
link |
37:12.000
你需要去收集一些圖片,
link |
37:15.000
收集一些人臉,
link |
37:17.000
然後這些人臉都要有文字的描述,
link |
37:19.000
告訴我們說這個是紅眼睛,
link |
37:21.000
這個是黑頭髮,
link |
37:22.000
這個是黃頭髮,
link |
37:23.000
這個是有黑眼圈等等,
link |
37:25.000
告訴我們這樣子,
link |
37:26.000
我們要有這樣的Label的資料,
link |
37:28.000
才能夠訓練這種Conditional的Generator。
link |
37:31.000
所以在Text to Image這樣的任務裡面,
link |
37:34.000
我們的X就是一段文字。
link |
37:37.000
那你可能問說,
link |
37:38.000
一段文字怎麼輸入給Generator呢?
link |
37:40.000
那就要問你自己了,
link |
37:41.000
你要怎麼做都可以,
link |
37:42.000
以前會用RNN把它讀過去,
link |
37:45.000
然後得到一個向量,
link |
37:47.000
再丟到Generator,
link |
37:48.000
今天也許你可以把它丟到一個Transformer的Encoder裡面去,
link |
37:53.000
把Encoder Output的這些向量統統平均起來,
link |
37:56.000
丟到Generator裡面去,
link |
37:57.000
怎麼樣都可以,
link |
37:58.000
反正你用什麼方法都可以,
link |
38:01.000
只要能夠讓Generator讀一段文字就行。
link |
38:04.000
那你期待說你輸入Red Eyes,
link |
38:07.000
然後機器就可以畫一個紅眼睛的角色,
link |
38:10.000
但每次畫出來的角色都不一樣,
link |
38:12.000
那這個畫出來什麼樣的角色,
link |
38:15.000
取決於什麼呢?
link |
38:16.000
取決於你Sample到什麼樣的Z,
link |
38:18.000
Sample到不一樣的Z,
link |
38:19.000
畫出來的角色就不同,
link |
38:21.000
但是通通都是紅眼睛的,
link |
38:24.000
這個就是Text to Image想要做的事情。
link |
38:27.000
真的可以做到這樣子的事情嗎?
link |
38:29.000
可以,過去有這個作業,
link |
38:32.000
這學期雖然沒有,
link |
38:33.000
但過去有這個作業,
link |
38:34.000
就是輸入紅頭髮,
link |
38:36.000
這個是之前助教做的結果,
link |
38:38.000
輸入紅頭髮,輸入綠眼睛,
link |
38:41.000
那產生的結果就是這個樣子,
link |
38:44.000
產生各式各樣紅頭髮、綠眼睛的角色。
link |
38:46.000
輸入藍頭髮、紅眼睛,
link |
38:48.000
就產生各式各樣藍頭髮、紅眼睛的角色。
link |
38:51.000
你發現有時候機器也是會犯錯的啦,
link |
38:54.000
比如這邊有一個異色瞳,
link |
38:56.000
雖然說要畫紅眼睛,
link |
38:58.000
但他覺得畫一隻紅色的眼睛,
link |
39:00.000
就可以矇混過去了,
link |
39:01.000
另外一隻眼睛仍然是藍色的。
link |
39:04.000
那要怎麼做Conditional的Game呢?
link |
39:07.000
我們現在的Generator有兩個輸入,
link |
39:09.000
一個是從Normal Distribution Sample出來的Z,
link |
39:12.000
另外一個是X,也就是一段文字。
link |
39:15.000
那我們的Generator會產生一張圖片Y。
link |
39:18.000
那我們需要一個Discriminator,
link |
39:20.000
那如果按照我們過去所學過的東西,
link |
39:23.000
Discriminator他就是
link |
39:25.000
是一張圖片Y當作輸入,
link |
39:27.000
輸出一個數值,
link |
39:28.000
這個數值代表輸入的圖片
link |
39:30.000
多像真實的圖片,
link |
39:32.000
是真實的還是生成的。
link |
39:35.000
那怎麼訓練這個Discriminator呢?
link |
39:38.000
你就說,如果看到真實的圖片,
link |
39:40.000
你就輸出1,
link |
39:42.000
如果看到生成的圖片,就輸出0。
link |
39:45.000
你就可以訓練Discriminator,
link |
39:46.000
那Discriminator跟Generator反覆訓練,
link |
39:49.000
也許你就可以把Generator訓練出來。
link |
39:52.000
但這樣的方法,
link |
39:54.000
沒辦法真的解Conditional Game的問題。
link |
39:56.000
為什麼呢?
link |
39:57.000
因為如果我們只有Train這個Discriminator,
link |
40:00.000
這個Discriminator只會看Y當作輸入的話,
link |
40:03.000
那Generator會學到的是,
link |
40:06.000
他會產生可以騙過Discriminator的
link |
40:08.000
非常清晰的圖片。
link |
40:11.000
他會產生清晰的圖片,
link |
40:13.000
但是跟輸入完全沒有任何關係。
link |
40:16.000
因為對Generator來說,
link |
40:18.000
他只要產生清晰的圖片就可以騙過Discriminator了,
link |
40:21.000
他何必要去管Input的文字敘述是什麼呢?
link |
40:24.000
你的Discriminator又不看文字的敘述,
link |
40:26.000
所以他根本就不需要管文字的敘述,
link |
40:28.000
你不管輸入什麼文字就無視這個X,
link |
40:30.000
反正就是產生一個圖片,
link |
40:32.000
可以騙過Discriminator就結束了。
link |
40:35.000
但這顯然不是我們要的。
link |
40:37.000
所以在Conditional Game裡面,
link |
40:39.000
你要做有點不一樣的設計,
link |
40:41.000
你的Discriminator不是只吃圖片Y,
link |
40:44.000
他還要吃Condition X。
link |
40:47.000
所以你的Discriminator,
link |
40:49.000
他有Y作為輸入,有X作為輸入,
link |
40:51.000
然後產生一個數值。
link |
40:53.000
那這個數值不只是看Y好不好,
link |
40:56.000
光圖片好沒有用,
link |
40:58.000
光圖片好Discriminator還是不會給高分。
link |
41:02.000
什麼樣的情況下Discriminator才會給高分呢?
link |
41:05.000
一方面圖片要好,
link |
41:07.000
另外一方面圖片跟X,
link |
41:09.000
這是文字的敘述,
link |
41:11.000
他們必須要配得上,
link |
41:13.000
圖片跟文字的敘述,
link |
41:15.000
必須要是相配的Discriminator才會給高分。
link |
41:19.000
那怎麼樣訓練這樣的Discriminator呢?
link |
41:22.000
那你需要文字跟影像成對的資料。
link |
41:26.000
所以Conditional Game一般的訓練,
link |
41:28.000
是需要這個Pair的Data的,
link |
41:31.000
是需要有標注的資料的,
link |
41:34.000
是需要成對資料的。
link |
41:36.000
有這些成對資料,
link |
41:37.000
那你就告訴你的Discriminator說,
link |
41:39.000
看到這些真正的成對的資料,
link |
41:42.000
就給他一分。
link |
41:44.000
看到Red Eyes,
link |
41:46.000
但是搭配,
link |
41:47.000
這邊我也不知道為什麼會是這個樣子,
link |
41:49.000
不過沒有關係,
link |
41:50.000
反正我這邊本來就是沒有要放什麼特別的東西,
link |
41:53.000
就放個亂七八糟的圖而已。
link |
41:55.000
Red Eyes跟機器產生出來的圖片,
link |
41:58.000
那就是給0分。
link |
42:00.000
然後訓練下去,
link |
42:01.000
就可以做到Conditional Game。
link |
42:06.000
那其實在實作上,
link |
42:08.000
光是這樣子,
link |
42:09.000
拿這樣子的Positive Example,
link |
42:12.000
還有Negative Example,
link |
42:14.000
來訓練這樣的Discriminator,
link |
42:15.000
其實你得到的結果往往不夠好。
link |
42:18.000
光是告訴Discriminator說,
link |
42:20.000
這樣子的狀況是好的,
link |
42:22.000
這樣子的狀況是不好的,
link |
42:25.000
這樣是不夠的。
link |
42:26.000
你還需要加上一種不好的狀況是,
link |
42:30.000
已經產生好的圖片,
link |
42:32.000
但是文字敘述配不上的狀況。
link |
42:35.000
所以你通常會把你的訓練資料拿出來,
link |
42:38.000
然後故意把文字跟圖片亂配,
link |
42:40.000
故意配一些錯的,
link |
42:42.000
然後告訴你的Discriminator說,
link |
42:43.000
看到這種狀況,
link |
42:44.000
你也要說是不好的。
link |
42:46.000
用這樣子的資料,
link |
42:47.000
你才有辦法把Discriminator訓練好,
link |
42:50.000
然後Generator跟Discriminator反覆的訓練,
link |
42:53.000
最後才會得到好的結果。
link |
42:55.000
這個就是Conditional Game。
link |
42:58.000
在目前的例子裡面,
link |
42:59.000
都是看一段文字產生圖片,
link |
43:01.000
那Conditional Game的應用,
link |
43:02.000
不只看一段文字產生圖片,
link |
43:04.000
也可以看一張圖片產生圖片。
link |
43:07.000
那看一張圖片產生圖片,
link |
43:09.000
也有很多的應用,
link |
43:10.000
比如說給他房屋的設計圖,
link |
43:13.000
然後讓你的Generator直接把房屋產生出來。
link |
43:16.000
給他黑白的圖片,
link |
43:18.000
然後讓他把顏色著上。
link |
43:21.000
給他這個素描的圖,
link |
43:23.000
讓他把它變成實景、實物。
link |
43:27.000
給他這個白天的圖片,
link |
43:29.000
讓他變成晚上的圖片。
link |
43:31.000
有時候你會給他,
link |
43:32.000
比如說起霧的圖片,
link |
43:33.000
讓他變成沒有霧的圖片,
link |
43:35.000
把霧去掉。
link |
43:37.000
所以Conditional Game除了輸入文字產生影像以外,
link |
43:41.000
也可以輸入影像產生影像。
link |
43:44.000
那像這樣子的應用,
link |
43:45.000
叫做Image Translation,
link |
43:48.000
有人又叫做Pix2Pix。
link |
43:51.000
這個Pix就是Pixel,
link |
43:53.000
就是像素的縮寫,
link |
43:54.000
所以叫做Pix2Pix。
link |
43:57.000
那怎麼做呢?
link |
43:58.000
跟剛才講的從文字產生影像,
link |
44:01.000
沒有什麼不同,
link |
44:02.000
現在只是從影像產生影像,
link |
44:04.000
把文字的部分用影像取代掉而已。
link |
44:08.000
那當然同樣的做法,
link |
44:09.000
同樣要產生這樣的Generator,
link |
44:11.000
產生一張圖片,
link |
44:12.000
輸入一張圖片,
link |
44:13.000
產生一張圖片,
link |
44:14.000
你當然可以用Supervised Learning的方法。
link |
44:16.000
那在文獻上你會發現說,
link |
44:18.000
如果你用Supervised Learning的方法,
link |
44:20.000
你得不到非常好的結果。
link |
44:22.000
通常你用Supervised Learning的方法,
link |
44:24.000
訓練一個圖片生圖片的Generator,
link |
44:27.000
你產生出來的結果可能是這個樣子。
link |
44:30.000
這是你的Generator的輸入,
link |
44:32.000
那這個是你Generator的輸出。
link |
44:34.000
那你會發現說,
link |
44:36.000
它非常的模糊。
link |
44:38.000
為什麼它非常的模糊呢?
link |
44:40.000
你可以直覺想成說,
link |
44:42.000
因為同樣的輸入,
link |
44:43.000
可能對應到不一樣的輸出。
link |
44:46.000
就好像我們在講Game剛開場的時候,
link |
44:48.000
講的那個例子,
link |
44:49.000
今天在同一個轉角,
link |
44:51.000
那個小精靈可能左轉,
link |
44:53.000
也可能右轉,
link |
44:54.000
最後學到的,
link |
44:55.000
就是同時左轉跟右轉。
link |
44:57.000
那對於Image to Image的Case,
link |
45:00.000
也是一樣的,
link |
45:02.000
輸入一張圖片,
link |
45:03.000
輸出有不同的可能。
link |
45:04.000
機器學到的,
link |
45:05.000
Generator學到的,
link |
45:06.000
就是把不同的可能平均起來,
link |
45:08.000
結果變成一個模糊的結果。
link |
45:11.000
所以這個時候,
link |
45:12.000
我們需要用Game來Train,
link |
45:13.000
你需要加一個Discriminator,
link |
45:15.000
Discriminator它是輸入一張圖片,
link |
45:18.000
還有輸入Condition,
link |
45:20.000
它會同時看這個圖片跟這個Condition,
link |
45:22.000
有沒有匹配來決定它的輸出。
link |
45:25.000
那這個是文獻上用Game的輸出,
link |
45:28.000
從右上角這邊Paper擷取出來的。
link |
45:31.000
你會發現說,
link |
45:32.000
如果單純用Game的話,
link |
45:34.000
它有一個小問題,
link |
45:35.000
雖然它產生出來的圖片比較真實,
link |
45:38.000
但是它的問題是,
link |
45:39.000
它的創造力、想像力過度豐富,
link |
45:42.000
它會產生一些輸入沒有的東西,
link |
45:45.000
沒有叫它輸入的東西。
link |
45:47.000
舉例來說,
link |
45:48.000
這是一個房子,
link |
45:49.000
左上角明明沒有其他東西,
link |
45:52.000
這邊它卻在屋頂上,
link |
45:54.000
加了一個不知道是煙囪還是窗戶的東西。
link |
45:57.000
文獻上如果你要做到最好,
link |
45:59.000
往往就是Game跟Supervised Learning同時使用,
link |
46:04.000
往往可以給你最好的結果。
link |
46:07.000
所謂同時使用的意思就是,
link |
46:09.000
Generator在訓練的時候,
link |
46:10.000
一方面它要去騙過Discriminator,
link |
46:13.000
這是它的一個目標。
link |
46:14.000
但同時它又想要產生一張圖片跟標準答案,
link |
46:17.000
越像越好,
link |
46:18.000
它同時去做這兩件事,
link |
46:20.000
往往產生出來的結果是最好的。
link |
46:23.000
Conditional Game還有很多應用,
link |
46:26.000
這邊給大家看一個莫名其妙的應用,
link |
46:28.000
就是給Game聽一段聲音,
link |
46:30.000
然後它產生一個對應的圖片。
link |
46:33.000
什麼意思呢?
link |
46:34.000
比如說給它聽一段狗叫聲,
link |
46:36.000
看它能不能夠畫出一隻狗。
link |
46:39.000
那我剛才講說Conditional Game
link |
46:41.000
需要Label的資料,
link |
46:45.000
需要成對的資料。
link |
46:46.000
那這個聲音跟影像成對的資料,
link |
46:49.000
其實並沒有那麼難收集,
link |
46:50.000
因為你可以爬到大量的影片,
link |
46:53.000
那影片裡面有影像,有畫面,
link |
46:56.000
也有聲音訊號。
link |
46:58.000
那你就知道說,
link |
46:59.000
這一個畫面,這一幀,
link |
47:01.000
這一幀的圖片,
link |
47:02.000
這一幀的畫面,
link |
47:03.000
對應到這一小段聲音,
link |
47:04.000
這一幀的畫面,
link |
47:05.000
對應到這一小段聲音。
link |
47:07.000
把這些資料收集起來,
link |
47:08.000
你就可以Train一個Conditional Game,
link |
47:11.000
聽一段聲音,
link |
47:12.000
讓它想像它聽到的場景是什麼樣子。
link |
47:17.000
好,那這個是一個真正的Demo,
link |
47:20.000
那機器聽這樣的聲音,
link |
47:24.000
這聽起來有點像是電視機壞掉的聲音,
link |
47:29.000
那機器覺得它聽到什麼呢?
link |
47:31.000
剛才那一段聲音,
link |
47:32.000
機器覺得它聽到一個小溪,
link |
47:36.000
聽到一個小瀑布,
link |
47:38.000
或者是我們再聽另外一段聲音,
link |
47:43.000
機器覺得它聽到一艘快艇在海上奔馳。
link |
47:48.000
當然我有點擔心說,
link |
47:50.000
這個會不會機器並沒有真的學到
link |
47:53.000
聲音跟圖片之間的關係,
link |
47:56.000
會不會它只是把
link |
47:57.000
它在訓練資料裡面
link |
47:58.000
有看過的圖片存起來而已。
link |
48:01.000
所以我決定把聲音調大,
link |
48:04.000
你聽看看結果會怎樣。
link |
48:07.000
所以我們把聲音調大,
link |
48:10.000
接下來針對很大聲的,
link |
48:14.000
然後聲音越來越大,
link |
48:15.000
你會發現這個溪流裡面的水花就越來越多,
link |
48:20.000
從一條小溪變成尼加拉瓜瀑布。
link |
48:24.000
然後剛才快艇的例子也是一樣,
link |
48:27.000
我們就把快艇的聲音變大,
link |
48:28.000
你聽看看會怎樣。
link |
48:33.000
當聲音越來越大的時候,
link |
48:34.000
你發現快艇旁邊的水花就越來越多,
link |
48:38.000
好像快艇開得越來越快。
link |
48:41.000
不過我要承認這個其實是
link |
48:43.000
稍微cherry pick的結果,
link |
48:45.000
稍微挑過的結果。
link |
48:46.000
很多時候generator產生出來的東西
link |
48:48.000
就是這個樣子,不知所云。
link |
48:50.000
這給它一個鋼琴聲,
link |
48:52.000
它好像想畫一個鋼琴,
link |
48:53.000
但又沒有很清楚。
link |
48:54.000
這個是給它聽狗叫聲,
link |
48:56.000
好像想畫一個動物,
link |
48:57.000
但又不知道要畫些什麼。
link |
48:59.000
這個是聲音到影像的產生。
link |
49:04.000
我看到最近最驚人的
link |
49:06.000
conditional game的應用,
link |
49:07.000
是有人用conditional game
link |
49:09.000
產生會動的圖片。
link |
49:12.000
我們知道在哈利波特裡面,
link |
49:14.000
那些人物的畫像是會動的,
link |
49:17.000
是會說話的。
link |
49:18.000
Samsung就做了一個類似的應用,
link |
49:21.000
用game做的,
link |
49:22.000
給它一張圖片,
link |
49:23.000
比如說蒙娜麗莎的畫像,
link |
49:25.000
然後就可以讓蒙娜麗莎開始講話。
link |
49:29.000
這個是conditional game的
link |
49:31.000
其中一個應用。
link |
49:32.000
我把論文放在這邊給大家參考。
link |
49:36.000
講到這邊正好告一個段落,
link |
49:39.000
也許我們先休息一下,
link |
49:41.000
十分鐘再回來,
link |
49:43.000
主教會講作業六。