back to index

【生成式AI】速覽圖像生成常見模型


link |
00:01.000
好,那我們就開始來上課啦。
link |
00:05.000
然後我們現在要進入開始講圖像的生成。
link |
00:09.000
那因為我們下一個作業,作業六呢,就是圖像的生成。
link |
00:13.000
所以我們開始來講圖像的生成模型。
link |
00:17.000
那在開始之前呢,我們先講圖像生成有什麼特別的地方。
link |
00:23.000
好,圖像生成有什麼特別的地方呢?
link |
00:26.000
大家都知道俗話說啊,一張圖勝過千言萬語。
link |
00:31.000
所以今天假設我們圖像生成的任務,是拿一段文字去生成一張圖,
link |
00:37.000
比如說你把一次奔跑的狗丟給Me Journey,然後牠就會生一張圖給你。
link |
00:42.000
但是一張圖是勝過千言萬語的,如果要把這一張圖描述成文字,
link |
00:48.000
牠的資訊量是遠比一隻在奔跑的狗還要多的。
link |
00:52.000
比如說這隻狗奔跑的位置是在街道上,或者是這一隻狗是一隻柯基。
link |
00:57.000
有很多資料是不在你做影像生成的時候輸入的文字裡面的。
link |
01:03.000
所以你輸入的文字只是千言萬語的部分。
link |
01:07.000
在做圖像生成的時候,有很多部分不在人類輸入的文字裡面,
link |
01:13.000
機器需要進行大量的腦補才能夠生成好的圖像。
link |
01:19.000
這是圖像生成跟生成文字比較不一樣的地方。
link |
01:25.000
當然生成文字輸入跟輸出也不是一對一的關係,
link |
01:29.000
但是很多文字生成的任務,比如說翻譯,
link |
01:33.000
你一旦給定了輸入的句子,你輸出的可能性其實是蠻有限的。
link |
01:38.000
但圖像不一樣,你給一個句子,它輸出的可能性有非常多不同的樣貌。
link |
01:45.000
其實我覺得語音合成也是一樣,你給一個句子,
link |
01:49.000
它要合出什麼樣的聲音,男的、女的、老的、少的,
link |
01:52.000
還是要用什麼樣的口氣說話,生氣的還是高興的,
link |
01:55.000
有非常多不同的變化。
link |
01:57.000
所以我覺得語音合成跟圖像生成比較像,
link |
02:00.000
就是我們的輸入只是輸出的一小部分,
link |
02:04.000
機器需要進行大量的腦補才能夠產生正確的結果。
link |
02:08.000
等一下要跟大家講說這個需要進行大量腦補這件事,
link |
02:12.000
造成模型的設計上有什麼特別的地方。
link |
02:17.000
好,那我們知道文字生成多採用auto-regressive的方法,
link |
02:22.000
那之前跟大家講過說在生成的時候,
link |
02:25.000
兩種策略,auto-regressive各個擊破,
link |
02:28.000
或者是non-auto-regressive一次到位的方法。
link |
02:31.000
那我們知道文字生成是這樣,給一個句子,
link |
02:34.000
不管你是像GVT一樣通通都是decoder,
link |
02:38.000
還是你是一個sequence to sequence的model,
link |
02:41.000
我們在這個課堂的錄音裡面,
link |
02:44.000
大家應該已經看過sequence to sequence的model了,
link |
02:47.000
反正概念是一樣的,給一個輸入一個句子,
link |
02:50.000
然後接下來你要輸出一個機率的分布,
link |
02:54.000
然後根據這個機率的分布去做sample,取出一個文字,
link |
02:58.000
根據取出來的文字再產生新的機率分布,
link |
03:01.000
再取出新的文字,這樣就可以產生一個句子,
link |
03:05.000
產生一個回答的結果。
link |
03:07.000
那對於影像生成來說,其實直覺上你會覺得,
link |
03:12.000
應該也可以套用幾乎一模一樣的做法,
link |
03:16.000
一個影像生成的模型應該可以吃一段文字,
link |
03:19.000
接下來它輸出的distribution不是文字的distribution,
link |
03:24.000
而是顏色的distribution,
link |
03:27.000
比如說綠色產生的機率應該有多少,
link |
03:30.000
黃色產生的機率應該有多少,
link |
03:32.000
那這邊的單位可能就是用pixel,
link |
03:34.000
通常是用pixel像素來表示,
link |
03:36.000
也就是說現在要畫一隻奔跑的狗,
link |
03:39.000
那你第一個像素要放一個紅色像素的機率有多少,
link |
03:43.000
要放一個綠色像素的機率有多少。
link |
03:46.000
那我們知道說這個影像,一個pixel,
link |
03:50.000
它是由RGB三個顏色所組成,
link |
03:52.000
那RGB分別又是由一個0到255的數字所表示,
link |
03:56.000
所以照理說應該有256x256x256,
link |
04:00.000
三種不同,這麼多種不同的顏色,
link |
04:03.000
不過你實際在做影像生成的時候,
link |
04:05.000
其實你也用不上那麼多的顏色,
link |
04:07.000
你可以選個比如說256色,
link |
04:09.000
其實往往就蠻足夠的,
link |
04:12.000
因為像小時候在畫畫的時候,
link |
04:14.000
那個蠟筆如果64色,你就已經畫得很高興了對不對,
link |
04:17.000
所以影像生成的時候,
link |
04:19.000
你其實沒有必要有256x256x256種顏色,
link |
04:23.000
那其實像這種用auto-regressive sensing影像的方法,
link |
04:26.000
過去也是有的,
link |
04:28.000
OpenAI其實也做過很類似的事情,
link |
04:30.000
那他們那時候如果沒記錯的話,
link |
04:32.000
他也只選256個顏色而已,
link |
04:35.000
那總之你決定第一個pixel要放每一個顏色的機率,
link |
04:39.000
然後根據這個機率做sample,
link |
04:41.000
那比如說sample到綠色,
link |
04:43.000
就畫一個綠色的pixel,
link |
04:45.000
然後接下來根據已經畫了綠色的pixel這件事,
link |
04:48.000
還有已經輸入的文字,再產生新的分布,
link |
04:51.000
然後可能就決定畫紅色的pixel,
link |
04:54.000
以此類推,
link |
04:55.000
那如果要畫一張256x256這樣子的解析度的影像,
link |
04:59.000
那他有65536個pixel,
link |
05:02.000
那同樣的過程,
link |
05:04.000
就是重複25536次,
link |
05:06.000
你就可以畫一個解析度是256x256的圖像,
link |
05:09.000
就結束了,
link |
05:11.000
能不能這麼做呢?
link |
05:13.000
能這麼做,
link |
05:14.000
所以其實OpenAI有一個影像版的GPT,
link |
05:18.000
那影像版的GPT,
link |
05:20.000
他就是先把一張圖片,
link |
05:22.000
本來圖片其實是二維的,
link |
05:24.000
拉直變成一排,變成一個sequence,
link |
05:29.000
然後接下來呢,
link |
05:30.000
就是直接當作一個language model的問題,
link |
05:34.000
直接把它當作文字,
link |
05:36.000
只是現在我們這個token的數目,
link |
05:40.000
因為只有256色,
link |
05:41.000
所以token的數目就是256個,
link |
05:43.000
然後呢,
link |
05:44.000
用一個autoregressive的model,
link |
05:46.000
跟GPT架構是一樣的,
link |
05:48.000
然後train下去,
link |
05:49.000
就結束了,
link |
05:51.000
然後他們就畫一些圖啊,
link |
05:53.000
那為了要顯示說這個圖呢,
link |
05:55.000
這個裡面的pixel呢,
link |
05:57.000
都是一排一排生出來的,
link |
05:59.000
那他特別呢,
link |
06:00.000
做了這張動畫,
link |
06:01.000
告訴你說,
link |
06:02.000
這個圖呢,
link |
06:03.000
他就是一排一排一排的,
link |
06:06.000
把那個pixel生出來,
link |
06:07.000
這個叫做Raster Order,
link |
06:09.000
一排一排的生pixel的順序,
link |
06:11.000
叫做Raster Order,
link |
06:13.000
所以這個方法,
link |
06:14.000
其實也可以生成蠻高清的圖片,
link |
06:17.000
那我們之前有講過說,
link |
06:19.000
對於影像生成而言,
link |
06:20.000
這種方法太耗費時間了,
link |
06:23.000
所以在影像生成的話,
link |
06:26.000
今天你看到多數的模型採取的,
link |
06:28.000
都是一次到位的方法,
link |
06:31.000
也就是說,
link |
06:32.000
給一段文字,
link |
06:33.000
如果你要生一個影像,
link |
06:34.000
那在概念上,
link |
06:36.000
在概念上,
link |
06:37.000
你會做的事情是,
link |
06:38.000
我把每一個位置,
link |
06:40.000
要放什麼顏色的distribution,
link |
06:43.000
都先產生出來,
link |
06:44.000
然後再根據這些distribution,
link |
06:46.000
去做sample,
link |
06:48.000
但是這麼做有什麼樣的問題呢?
link |
06:50.000
因為我們剛才有講過說,
link |
06:52.000
一張圖勝過千言萬語,
link |
06:54.000
所以當你輸入一隻正在奔跑的狗的時候,
link |
06:57.000
牠的正確答案,
link |
06:58.000
不是只有一個,
link |
07:00.000
有很多種不同的可能性,
link |
07:03.000
在奔跑的狗,
link |
07:04.000
可能有大隻的,
link |
07:05.000
有小隻的,
link |
07:06.000
有各種不同的毛色,
link |
07:07.000
背景,
link |
07:08.000
可能是在草原上,
link |
07:09.000
可能在沙地裡,
link |
07:10.000
可能在城市裡,
link |
07:11.000
有各種不同的背景,
link |
07:13.000
而且我這邊畫的圖啊,
link |
07:14.000
這邊圖都說me journey生的啦,
link |
07:16.000
這邊的狗都是迎面朝你衝來,
link |
07:19.000
其實牠也可以有其他衝的方向,
link |
07:21.000
由左到右啊,
link |
07:22.000
或是遠離你啊,
link |
07:23.000
也都是在奔跑的狗,
link |
07:25.000
所以今天當你輸入一段文字的時候,
link |
07:27.000
正確答案不是一個,
link |
07:29.000
一般我們在做機器學習的時候,
link |
07:31.000
我們通常比較習慣是,
link |
07:33.000
輸入一個東西,
link |
07:34.000
有一個標準的正確答案,
link |
07:36.000
但是在影像生成這個問題,
link |
07:38.000
它不是這樣的一個問題,
link |
07:39.000
影像生成的問題是,
link |
07:40.000
有一個輸入,
link |
07:41.000
它的正確答案是一個分佈,
link |
07:45.000
是一個distribution,
link |
07:47.000
在這個分佈內的,
link |
07:48.000
都可以說是正確答案,
link |
07:50.000
但是如果我們一個一個pixel,
link |
07:52.000
分開生成,
link |
07:53.000
分開去做sample,
link |
07:55.000
會發生什麼事呢?
link |
07:56.000
如果一個一個pixel,
link |
07:57.000
分開去做sample,
link |
07:58.000
每一個pixel的產生,
link |
07:59.000
都是各自獨立的,
link |
08:01.000
那就會變成,
link |
08:02.000
有些pixel是想要畫往左跑的狗,
link |
08:05.000
有些pixel想要畫往右跑的狗,
link |
08:07.000
有些pixel想要畫黑的狗,
link |
08:08.000
有些pixel想要畫白的狗,
link |
08:10.000
然後最後全部湊起來,
link |
08:11.000
就會不成樣,
link |
08:12.000
比如說我把這邊四張圖片,
link |
08:14.000
各切一塊拼在一起,
link |
08:16.000
那就不知道在畫些什麼東西,
link |
08:18.000
所以如果是一次到位的方法,
link |
08:21.000
你要pixel獨立的各自生成,
link |
08:24.000
其實是會得到非常差的結果的,
link |
08:28.000
所以怎麼辦呢?
link |
08:29.000
你會發現今天影像生成的模型,
link |
08:32.000
都有一個共同的套路,
link |
08:36.000
這共同的套路是什麼呢?
link |
08:38.000
都不是直接給一段文字就生出圖,
link |
08:41.000
他們都會有一個額外的輸入,
link |
08:43.000
這個額外的輸入,
link |
08:45.000
是由一個normal distribution,
link |
08:48.000
或者你要用別的distribution,
link |
08:49.000
其實也是可以的,
link |
08:50.000
總之就是一個簡單的,
link |
08:52.000
你知道長什麼樣子的distribution,
link |
08:55.000
也有人會用這個uniform distribution,
link |
08:57.000
反正只要你知道這個distribution,
link |
08:59.000
長什麼樣子就可以了,
link |
09:02.000
你從一個你知道怎麼做sample的,
link |
09:05.000
簡單的distribution,
link |
09:06.000
去做sample,
link |
09:08.000
sample出一個像量,
link |
09:10.000
那這邊我在畫這個distribution的時候,
link |
09:13.000
可能會讓你誤以為說,
link |
09:15.000
這邊是從一個one dimensional distribution,
link |
09:18.000
做sample,
link |
09:19.000
那我不是這個意思,
link |
09:20.000
就是說這個normal distribution,
link |
09:22.000
你要想成是一個高微的normal distribution,
link |
09:25.000
然後從一個高微的normal distribution,
link |
09:27.000
做sample,
link |
09:28.000
得到一個高微的像量,
link |
09:30.000
然後把這個像量,
link |
09:31.000
丟到影像生成的模型裡面,
link |
09:34.000
跟這個文字合力去產生最後的結果,
link |
09:38.000
你會發現說,
link |
09:40.000
不管你今天是用什麼樣影像生成的模型,
link |
09:42.000
VAE、GaN、Full Face Model,
link |
09:44.000
或者是最近最熱門的Diffusion Model,
link |
09:47.000
其實方法都是一樣的,
link |
09:49.000
你都不是只有拿文字去生影像,
link |
09:52.000
你都需要一個額外的輸入,
link |
09:54.000
你都需要從某一個簡單的機率分佈裡面,
link |
09:58.000
去sample出一個東西,
link |
09:59.000
sample出來的這個東西有點像是雜訊,
link |
10:01.000
因為通常你是從這個normal distribution sample出來,
link |
10:05.000
就是一個像是雜訊的東西,
link |
10:08.000
丟到影像生成模型裡面,
link |
10:09.000
你才能夠產生最終的結果。
link |
10:12.000
那這背後所代表的含義是什麼呢?
link |
10:15.000
我們現在如果把文字用Y來描述,
link |
10:18.000
影像用X來描述,
link |
10:20.000
那正確答案的分佈,
link |
10:22.000
我們可以寫成P of X given Y,
link |
10:25.000
那這個P of X given Y,
link |
10:27.000
它顯然會非常的複雜,
link |
10:30.000
我們現在會想要去,
link |
10:32.000
如果我們可以成功model P of X given Y,
link |
10:35.000
如果我們可以知道說P of X given Y長什麼樣子,
link |
10:39.000
我們從這個分佈裡面去做sample,
link |
10:42.000
我們就可以把圖畫出來。
link |
10:43.000
但是問題是P of X given Y,
link |
10:45.000
它非常的複雜,
link |
10:46.000
其實在過去古早的時代,
link |
10:48.000
比如說在甚至game都還沒有的2014年以前,
link |
10:52.000
你知道這個要生圖,
link |
10:54.000
給文字生圖不是今天人們才開始做的事情,
link |
10:57.000
一直都有人在做這方面的研究。
link |
10:59.000
在更過去還不知道用什麼deep learning生圖的時候,
link |
11:03.000
那時候多數時候就假設說,
link |
11:05.000
比如說P of X given Y,
link |
11:07.000
可能是一個mixture of Gaussian,
link |
11:10.000
有多個Gaussian所組成的,
link |
11:12.000
然後我們把這個模型看能不能夠認出來,
link |
11:14.000
然後從這個mixture of Gaussian去sample,
link |
11:16.000
你sample出來,那個圖都非常的模糊,
link |
11:20.000
跟今天就是完全不在同一個量級上面。
link |
11:22.000
所以這個P of X given Y,
link |
11:25.000
它顯然非常的複雜,
link |
11:27.000
複雜到它不是一個你用人腦可以想出來的模型,
link |
11:31.000
它不是一個Gaussian distribution。
link |
11:34.000
所以怎麼辦呢?
link |
11:35.000
這邊的策略是,
link |
11:37.000
我們把normal distribution裡面sample出來的vector,
link |
11:42.000
都對應到P of X given Y裡面的每一個X。
link |
11:49.000
我們知道說,如果要畫一隻奔跑的狗,
link |
11:52.000
有這麼多不同可能的樣子。
link |
11:54.000
那我們把normal distribution裡面sample出來的vector,
link |
11:58.000
一個一個對應到可能畫的狗。
link |
12:02.000
這一個影像生成的模型,
link |
12:04.000
等於就是在產生這個對應關係。
link |
12:07.000
影像生成的模型,
link |
12:08.000
它做的工作就是想辦法把normal distribution裡面sample出來的東西,
link |
12:14.000
對應到正確的狗在奔跑的圖片。
link |
12:18.000
所以接下來難的點就是,怎麼把這個distribution,
link |
12:25.000
把它做一些扭曲,扭成P of X given Y的樣子呢?
link |
12:31.000
這個其實就是所有的影像生成的模型,
link |
12:35.000
都在解的問題。
link |
12:37.000
所以這些影像生成的模型,
link |
12:39.000
它們背後想攻克的問題其實是一樣的,
link |
12:42.000
只是解法是不一樣的。
link |
12:44.000
那我們就很快地速覽一下常用的影像生成的模型。
link |
12:49.000
以下的說明都非常簡略,
link |
12:51.000
有很多東西我就把它帶過,就不細講。
link |
12:54.000
那大家如果想知道這些影像模型真正背後的原理,
link |
12:58.000
請參見參考資料。
link |
13:00.000
那這邊呢,第一個會講的是VAE,
link |
13:04.000
那VAE Variational Autoencoder,
link |
13:07.000
它做的事情是什麼呢?
link |
13:08.000
我們今天想要從normal distribution對應到影像,
link |
13:13.000
那怎麼做呢?
link |
13:14.000
我們期待有一個decoder,
link |
13:16.000
這個decoder就吃normal distribution sample出來的vector作為輸入,
link |
13:21.000
它的輸出就應該是一張正確的圖片。
link |
13:25.000
那我這邊是把文字的輸入省略啦,
link |
13:28.000
那希望大家知道我的意思。
link |
13:30.000
好,那但是怎麼訓練這樣的decoder呢?
link |
13:35.000
怎麼訓練一個像量對應到一張圖片這樣子的decoder呢?
link |
13:40.000
你知道你今天要訓練一個network,
link |
13:42.000
你就是要有成對的資料才能訓練network嘛。
link |
13:45.000
如果有人告訴你說這邊每一張圖片都應該對應到哪一個像量,
link |
13:49.000
那你就可以訓練這個decoder。
link |
13:51.000
我們並不知道normal distribution sample出來的vector
link |
13:55.000
跟這些狗正在奔跑的圖片到底有什麼樣的關係,
link |
13:59.000
那怎麼辦呢?
link |
14:00.000
那另外一個東西叫encoder,
link |
14:02.000
encoder做的事就是decoder的相反,
link |
14:05.000
把一張圖片變成一個像量。
link |
14:09.000
那可是只有encoder跟只有decoder都沒有辦法訓練,
link |
14:13.000
所以怎麼辦呢?
link |
14:14.000
把encoder跟decoder串起來,
link |
14:16.000
所以一張圖片輸入encoder變成一個像量,
link |
14:18.000
欸,請說?
link |
14:20.000
所以剛才那個同學是問說,
link |
14:22.000
在這個投影片上面,
link |
14:23.000
看起來是一個unconditional的,
link |
14:25.000
我沒有把文字的部分放進去,
link |
14:27.000
那其實你也可以把文字的部分放進去,
link |
14:30.000
所以如果今天是要用文字生成影像的話,
link |
14:33.000
那這個decoder呢,
link |
14:34.000
其實它應該要有一個文字的輸入,
link |
14:38.000
然後告訴它說,
link |
14:39.000
我們已經有用文字限縮了我們可以生成的範圍,
link |
14:43.000
但就算已經有文字限縮生成的範圍,
link |
14:46.000
你生成的範圍仍然是一個機率的分布,
link |
14:50.000
仍然不是有一個標準的正確的答案。
link |
14:53.000
那剛才講到說,
link |
14:54.000
好,我們就一個encoder輸一張圖片,
link |
14:57.000
產生一個像量,
link |
14:58.000
然後這個像量丟給decoder,
link |
14:59.000
要還原回一樣的圖片,
link |
15:01.000
那encoder跟decoder是一起訓練的,
link |
15:03.000
要讓輸入跟輸出越接近越好。
link |
15:07.000
但是光只有這樣訓練是不夠的,
link |
15:09.000
因為如果光只有這樣訓練,
link |
15:10.000
這邊的這些像量的分布
link |
15:12.000
不一定會是一個normal distribution,
link |
15:14.000
所以你要加一個額外的限制,
link |
15:16.000
強迫中間的像量是normal distribution,
link |
15:20.000
所以這個就是VAE的概念。
link |
15:24.000
好,那如果想要知道VAE更多背後的原理,
link |
15:28.000
那請見過去上課的錄影。
link |
15:31.000
好,接下來呢,講flow-based model,
link |
15:34.000
以下每一個模型都只有一頁投影片而已。
link |
15:37.000
flow-based model是怎麼做的呢?
link |
15:39.000
它跟剛才VAE反過來,
link |
15:41.000
我們先來想encoder,
link |
15:43.000
我們能不能夠訓練一個encoder,
link |
15:46.000
吃一張圖片,輸出就是一個像量,
link |
15:51.000
而這個像量的分布,
link |
15:53.000
希望它是一個normal distribution。
link |
15:57.000
好,那如果能夠做到這件事,
link |
16:00.000
一個encoder輸一張圖片,
link |
16:02.000
輸出的像量就是normal distribution,
link |
16:05.000
然後接下來呢,我們再強迫這個encoder,
link |
16:08.000
是一個invertible function,
link |
16:11.000
你就可以直接把這個encoder,
link |
16:13.000
當作decoder來用。
link |
16:15.000
訓練的時候,它是吃圖片輸出像量,
link |
16:18.000
這個像量的分布是normal distribution,
link |
16:21.000
那實際上你要畫圖的時候,
link |
16:23.000
要把這個encoder反過來用,
link |
16:25.000
讓它可以輸入一個像量,
link |
16:27.000
然後就輸出一張圖片。
link |
16:29.000
那你第一個會問的問題是,
link |
16:31.000
怎麼強迫encoder一定是invertible的呢?
link |
16:33.000
我們現在是在訓練neural network,
link |
16:35.000
隨便訓練一個neural network,
link |
16:37.000
你怎麼知道它的inverse長什麼樣子呢?
link |
16:40.000
這個就是flow-based model神奇的地方,
link |
16:43.000
它有刻意限制network的架構,
link |
16:46.000
所以flow-based model不是你隨便兜network架構,
link |
16:49.000
都可以當作encoder來用的,
link |
16:51.000
它有刻意限制了network的架構,
link |
16:53.000
讓你train完以後,
link |
16:55.000
你馬上知道這個encoder的inverse長什麼樣。
link |
16:59.000
好,那這個細節呢,大家就再參考資料。
link |
17:02.000
那另外一件事情是,
link |
17:04.000
因為這個encoder它必須是invertible,
link |
17:07.000
意味著什麼?意味著輸出的那個vector啊,
link |
17:11.000
你的dimension要跟輸入的圖片一樣。
link |
17:14.000
所以我在這個投影片上,
link |
17:16.000
這個encoder的輸出看起來比輸入的圖片略小啦,
link |
17:19.000
那你要想像,
link |
17:20.000
這個encoder的輸出跟輸入的圖片是一樣大的,
link |
17:23.000
如果你輸入的圖片是256x256的圖片,
link |
17:27.000
那你encoder的輸出就要是一個256x256微的向量,
link |
17:31.000
或者是你要把它排成一個256x256的圖片,
link |
17:34.000
只是裡面都是一堆看起來像是噪音的,
link |
17:37.000
看不懂的東西,這樣也可以。
link |
17:39.000
為什麼輸入跟輸出的大小一定是一樣?
link |
17:42.000
如果不一樣,你就沒有辦法保證它是invertible啦。
link |
17:45.000
如果輸出的向量比輸入的圖片dimension小,
link |
17:48.000
你就沒辦法保證它是invertible啦。
link |
17:50.000
所以輸出的向量必須要跟輸入的圖片,
link |
17:54.000
它們的大小是一樣的。
link |
17:57.000
所以這個就是flow-based model的精神。
link |
18:02.000
你可以再重複一次你的問題嗎?
link |
18:05.000
我試著先描述一下我的認知,
link |
18:08.000
然後等一下再看看你有沒有問題。
link |
18:10.000
就是這個encoder就是輸入圖片,
link |
18:13.000
輸出distribution,
link |
18:15.000
輸出一個向量,
link |
18:17.000
然後這個向量的分佈是normal distribution,
link |
18:20.000
是說我們把很多圖片一起丟進去以後,
link |
18:23.000
它的分佈是normal distribution,
link |
18:25.000
這邊並不是輸出一個distribution喔。
link |
18:27.000
然後這個是invertible的,
link |
18:29.000
所以它可以逆向來用,就這很神奇,
link |
18:31.000
它可以逆向來用,所以train完以後,
link |
18:33.000
給它一個向量,從normal distribution sample出來的,
link |
18:36.000
它會變成一張圖片。
link |
18:38.000
這樣回答到你的問題嗎?
link |
18:40.000
好的,謝謝謝謝。
link |
18:41.000
好,大家有問題都歡迎隨時打斷我。
link |
18:47.000
好,大家有問題嗎?
link |
18:50.000
欸,你們問我什麼問題,要不要提出來啊?
link |
18:56.000
一樣大的意思喔,
link |
18:58.000
就是說,一樣大的意思就是,
link |
19:01.000
我知道說這個圖畫得沒有很好啦,
link |
19:03.000
把輸出畫得小一點,
link |
19:04.000
就當作它離你遠一點,所以看起來小一點的。
link |
19:06.000
好,所以這個圖,如果它是256x256的圖片,
link |
19:10.000
這一個輸出的向量,輸出的東西,
link |
19:15.000
它也要有256x256的數字那麼多。
link |
19:20.000
然後,那當然就是256x256的數字,
link |
19:23.000
你可以把它排成一個很長的向量,這樣也可以啦。
link |
19:26.000
啊,這邊是把它排成256x256的一個矩陣。
link |
19:30.000
那為什麼一定要這樣?
link |
19:31.000
不這樣的話,你就沒有辦法保證這個function是invertible啦。
link |
19:34.000
它是invertible,代表它的這個input跟output dimension是一樣大的。
link |
19:39.000
就如果大家對這個floor-based model真的這麼有興趣的話,
link |
19:42.000
就是詳盡的錄影。
link |
19:43.000
好,然後接下來我們來就講diffusion model吧。
link |
19:47.000
為什麼這學期一定要講diffusion model呢?
link |
19:50.000
因為我們的作業6,我們從game改成diffusion model,
link |
19:54.000
所以我們一定要來講一下diffusion model。
link |
19:57.000
有必要這麼訝異嗎?
link |
19:58.000
就算是改成diffusion model,還是有sample code這樣子。
link |
20:03.000
好,這個來講一下。
link |
20:05.000
等一下呢,在下一段投影片呢,
link |
20:07.000
會更詳細的跟大家講diffusion model是怎麼做的。
link |
20:11.000
所以這一頁投影片,我們就只用一頁來講一下diffusion model的概念。
link |
20:16.000
好,diffusion model的概念是什麼呢?
link |
20:18.000
我們就是把一張圖片一直加雜訊、一直加雜訊,
link |
20:23.000
大到原來的圖看不出來是什麼。
link |
20:26.000
那這個圖看起來就像是從normal distribution sample出來的一個雜訊一樣。
link |
20:31.000
好,那怎麼生圖片呢?
link |
20:33.000
生圖片的方法就是你認一個denoise的model,
link |
20:37.000
那實際上怎麼做,等一下都還會再講到。
link |
20:39.000
你認一個denoise的model,
link |
20:41.000
丟一個看起來像是從normal distribution sample出來的vector當作輸入,
link |
20:48.000
那它就去掉噪音、去掉噪音,你要的圖慢慢就產生出來的,
link |
20:53.000
就是這麼神奇。
link |
20:55.000
那如果你現在心裡充滿了困惑跟懷疑也是很正常的,
link |
20:59.000
那我們等一下會再詳細的講這個模型。
link |
21:03.000
好,那最後一個呢,
link |
21:05.000
就是大家都耳熟能詳的Generative Adversarial Network,也就是GAN。
link |
21:10.000
那GAN呢,它是只認decoder,它就沒有認encoder了。
link |
21:16.000
那GAN怎麼認decoder呢?
link |
21:18.000
那一開始GAN呢,你就多給它一大堆的從normal distribution sample出來的向量。
link |
21:24.000
那一開始呢,這個decoder沒有經過訓練,
link |
21:27.000
所以它根本不知道怎麼畫一張圖就輸出一些亂七八糟的東西。
link |
21:31.000
通常一開始的輸出是比現在這個投影片上的還要差很多啦,
link |
21:35.000
通常一開始輸出的東西就是一些雜訊,你根本不知道在畫些什麼。
link |
21:40.000
那接下來你會訓練一個discriminator,
link |
21:43.000
這個discriminator的工作啊,用白話來講就是,
link |
21:46.000
去分辨輸入的圖片是decoder產生出來的假的圖片,還是真正的圖片。
link |
21:56.000
如果我們今天把真正的圖片的分布想成P of X,當然如果你是有文字輸入的話,
link |
22:02.000
這邊就要given Y啦,given一個文字的condition,
link |
22:05.000
不過這邊先把文字的condition省略掉,
link |
22:08.000
那這個真實圖片的分布是P of X,
link |
22:11.000
decoder產生出來的圖片分布是P' of X。
link |
22:15.000
這個discriminator實際上在做的事情是什麼呢?
link |
22:18.000
其實這個discriminator訓練的時候的loss啊,
link |
22:22.000
其實就代表了P of X跟P' of X它們的相似的程度。
link |
22:27.000
那這個在直覺上其實也是蠻容易理解的,
link |
22:30.000
因為當discriminator沒有辦法分辨來自這兩個distribution的image的時候,
link |
22:36.000
代表這兩個distribution的image非常的接近。
link |
22:40.000
如果你的discriminator它的performance是很差的,
link |
22:43.000
它的分類的錯誤率是很高的,或是它的loss是很高的,
link |
22:48.000
就代表說P of X跟P' of X非常的接近。
link |
22:53.000
decoder要做的事情就是想辦法調整它的參數,
link |
22:57.000
讓discriminator做得越差越好。
link |
23:00.000
那這個就是game的概念,
link |
23:02.000
當discriminator做得差了,就代表P' of X,
link |
23:05.000
這個decoder生出來的圖片的分布跟真正的圖片的分布有很大的差距。
link |
23:11.000
那這個就是game。
link |
23:13.000
講到這邊,大家有問題想要問嗎?
link |
23:17.000
你說為什麼要叫decoder然後不叫generator?
link |
23:20.000
為了要跟前面講的VAE感覺比較一致,
link |
23:23.000
所以我就把它命名為decoder。
link |
23:25.000
但是這真的只是名稱而已,我們也可以把它改成叫generator。
link |
23:29.000
希望這樣回答到你的問題,這只是名字的不同而已。
link |
23:34.000
如果你想要知道game的話,過去花了很多很多時間講game,
link |
23:39.000
這個講的話可以大概講個十個小時左右。
link |
23:43.000
大家可以慢慢看,有一個game的系列的錄影。
link |
23:47.000
好,那這張投影片呢,是一次速覽VAE flow-based model跟diffusion model的差異。
link |
23:53.000
那它們的共通性就是,它們都有一個encode的機制,一個decode的機制。
link |
23:58.000
在VAE裡面,encoder、decoder都是neural network,都是類神經網路,都很複雜。
link |
24:06.000
那在flow-based model裡面,我們其實只認了encoder,
link |
24:11.000
但是我們做了一些手腳,保證encoder是invertible的,
link |
24:16.000
所以我們的decoder其實就是encoder的inverse,
link |
24:21.000
所以在flow-based model裡面只需要認encoder。
link |
24:25.000
那diffusion model是反過來,其實它只有認decoder的module,
link |
24:31.000
它在encode的時候就沒有encoder這個東西,
link |
24:36.000
它就是把圖片一直加雜訊、一直加雜訊,這個就是encoder。
link |
24:40.000
當然你也可以把加雜訊這個步驟想成是一個encoder,
link |
24:44.000
只是這是一個不需要認的encoder,它沒有參數,所以不需要train它。
link |
24:50.000
那產生這個雜訊以後呢,再做denoise,做n次denoise,
link |
24:56.000
把這個雜訊還原成圖片,那這個做n次denoise的過程,
link |
25:01.000
其實就是decoder,你可以想成這每一次做denoise,
link |
25:04.000
就是decoder通過了一層。
link |
25:06.000
所以VAE flow-based model跟diffusion model,
link |
25:09.000
其實它們有非常多的共通性。
link |
25:12.000
好,那我知道說,今天大家看起來,
link |
25:16.000
就是說今天最強的那些模型,比如說DALI啊,
link |
25:20.000
都是用這個stable diffusion啊,都是用diffusion model做的,
link |
25:25.000
但是這些模型會這麼強,也不完全是diffusion model的功勞啊,
link |
25:31.000
其實等一下我們會講一下,概覽一下stable diffusion,
link |
25:35.000
那你會知道說stable diffusion裡面其實是加了很多其他的東西,
link |
25:39.000
今天這些模型才會這麼的厲害。
link |
25:44.000
好,那這一頁投影片裡面沒有game,為什麼沒有game呢?
link |
25:48.000
因為我覺得game跟VAE flow-based model跟diffusion model,
link |
25:52.000
它其實就是另外一個角度的思考,
link |
25:55.000
所以它跟VAE flow-based model跟diffusion model,
link |
25:59.000
事實上是沒有互斥的,
link |
26:01.000
你永遠可以在你的decoder後面再接一個discriminator,
link |
26:06.000
讓你的decoder的output跟真實的圖片的分佈越接近越好。
link |
26:11.000
所以VAE可不可以加game呢?
link |
26:14.000
可以就有VAE game,這個是很古早的年代,
link |
26:17.000
15年的paper,從這個圖上就可以明顯看出這是個VAE,
link |
26:22.000
然後這是個game,然後這邊這個decoder呢,
link |
26:27.000
在VAE裡面叫做decoder,在game裡面叫generator,
link |
26:31.000
但其實是不同的名字,同樣的東西。
link |
26:34.000
所以VAE可以加上game,flow-based model可以加上game,
link |
26:38.000
diffusion model最近很紅,它也可以加上game。
link |
26:43.000
所以game算是另外一個外掛,它可以加到現有的生成模型上面。
link |
26:50.000
好,這個就是影像常用生成模型速覽。