back to index

【生成式AI】Stable Diffusion、DALL-E、Imagen 背後共同的套路


link |
00:01.000
好,那我們來講一下今天鼎鼎大名的Stable Diffusion吧!
link |
00:07.000
那其實今天比較好的影像生成的模型,就算它不是Stable Diffusion
link |
00:14.000
它的套路其實也跟Stable Diffusion差不多
link |
00:18.000
所以我們今天就是要來介紹這個
link |
00:20.000
今天最好的State-of-the-art的影像生成模型
link |
00:24.000
它背後的套路長什麼樣子
link |
00:28.000
今天最好的影像生成模型呢,基本上它內部就是有三個元件
link |
00:34.000
第一個元件是一個text的encoder,是一個好的文字的encoder
link |
00:41.000
會把一段文字的敘述,把它變成一個一個的向量
link |
00:46.000
然後接下來呢,你會有一個generation的model
link |
00:50.000
那今天大家都用Diffusion model,但用別的也是可以的
link |
00:55.000
這個generation的model就是吃一個雜訊
link |
00:58.000
我這邊用這個粉紅色的向量,帶粉紅色的矩陣代表輸入的雜訊
link |
01:04.000
輸入雜訊跟文字的encoder產生一個中間產物
link |
01:10.000
這個中間產物等一下再細講
link |
01:12.000
它可以是一個人看得懂的,只是比較小的比較模糊的圖片
link |
01:18.000
它也可以甚至是人根本看不懂的東西
link |
01:22.000
那這個中間產物是一個圖片被壓縮以後的結果
link |
01:27.000
所以這是第二個模組,從文字encoder的輸出產生一個中間產物
link |
01:33.000
代表圖片被壓縮以後的版本
link |
01:36.000
然後接下來呢,直接套一個decoder
link |
01:39.000
這個decoder的作用是從壓縮後的版本還原回原始的
link |
01:45.000
我們剛才講說就是有三個模組
link |
01:47.000
一個文字的encoder,一個生成的模型
link |
01:51.000
那今天用diffusion model,還有一個decoder
link |
01:54.000
直接從生成模型輸出的圖片的壓縮版本
link |
01:58.000
還原回原來的圖片
link |
02:00.000
那通常三個模組是分開訓練,然後再把它組合起來的
link |
02:07.000
那今天你看到的比較好的文字生影像的模型
link |
02:12.000
都是差不多的套路
link |
02:13.000
比如說這是Stable Diffusion論文裡面的一張圖
link |
02:17.000
你就看到它先有一個encoder可以處理輸入的東西
link |
02:21.000
但它輸入不是只有文字啦,它還有別的可能的輸入
link |
02:25.000
但是反正輸入文字,你需要一個encoder來處理它
link |
02:29.000
然後你需要有一個生成的模型
link |
02:31.000
那這邊Stable Diffusion內部,當然用的就是diffusion的model
link |
02:36.000
那你需要有一個decoder,把diffusion model生出來的中間產物
link |
02:41.000
一個圖片壓縮後的版本,還原回原來的圖片
link |
02:45.000
所以就是我剛才講的三招,三個component
link |
02:49.000
那DALI系列其實從一開始,就也是用同樣的套路
link |
02:55.000
你需要有一個文字的encoder,先對文字進行理解
link |
03:00.000
接下來,你要有一個生成的模型
link |
03:02.000
那其實在DALI裡面,它設了兩個生成的模型
link |
03:05.000
你可以用auto-regressive的model
link |
03:09.000
因為今天已經先做了一些處理以後
link |
03:12.000
現在你要產生的並不是一張完整的圖片
link |
03:15.000
如果你要生成完整的圖片的話,auto-regressive的model運算量太大了
link |
03:19.000
但是如果生成的只是一個圖片的壓縮的版本
link |
03:23.000
也許用auto-regressive的方法還可以
link |
03:26.000
所以可以用auto-regressive,也可以用diffusion model
link |
03:29.000
生成圖片壓縮的版本,用個decoder,還原回原來的圖片
link |
03:34.000
這是DALI系列的做法
link |
03:36.000
Google也有一個影像生成的模型叫Imagine
link |
03:40.000
就是吃文字,吃一段文字的敘述,產生一張圖片
link |
03:44.000
這個套路也是一樣的
link |
03:46.000
先有一個好的文字的encoder
link |
03:49.000
然後你要有一個影像生成的模型
link |
03:52.000
從文字去生出圖片壓縮後的版本
link |
03:56.000
那在Imagine裡面,它生出來的東西就是人看得懂的東西
link |
04:00.000
它生成出來的東西就是一張比較小的圖片
link |
04:02.000
最終目標是要生1024x1024的大圖
link |
04:06.000
但是diffusion model只幫我們先生64x64的小圖
link |
04:12.000
接下來再有一個decoder
link |
04:14.000
不過它的decoder也是一個diffusion model
link |
04:16.000
它的decoder把小圖再生成大圖
link |
04:21.000
這個是Imagine
link |
04:24.000
現在我們就來介紹整個framework裡面的三個component吧
link |
04:30.000
介紹完我們就下課了
link |
04:33.000
第一個要介紹的是文字的encoder
link |
04:37.000
文字的encoder其實也不用再多做介紹
link |
04:41.000
就是我們在幾堂課之前講的那些東西
link |
04:46.000
比如說你可以拿GPT當作你的encoder
link |
04:50.000
更古早時代你也可以拿BERT當作你的encoder
link |
04:54.000
那這邊秀這個實驗結果是要告訴你說
link |
04:57.000
這個文字的encoder其實對結果的影響是非常大的
link |
05:04.000
這個結果是來自於Google的Imagine那篇paper
link |
05:08.000
在Google他們用的encoder是一個叫做T5的encoder
link |
05:14.000
總之就是一個文字的encoder就對了
link |
05:17.000
他們試了不同的版本由小到大
link |
05:20.000
在這個圖上它用兩個不同的measure來衡量圖片的好壞
link |
05:25.000
一個是FID 等下下一頁投影片我會跟大家講FID是什麼
link |
05:30.000
總之FID的值越小代表你的圖片生出來越好
link |
05:36.000
還有另外一個東西叫做click score
link |
05:39.000
這個click score它是值越大越好
link |
05:42.000
在下一頁投影片也會告訴你click score是什麼東西
link |
05:48.000
總之越往右下角越好
link |
05:51.000
你可以很明顯的看到說隨著用的encoder越來越大
link |
05:56.000
圖片生成的品質是越來越高的
link |
06:01.000
所以我們知道說文字的encoder對結果其實是非常重要的
link |
06:07.000
這個其實也是可以想像的
link |
06:09.000
因為對於這個影像生成的模型而言
link |
06:12.000
如果你今天沒有用額外的文字的encoder
link |
06:16.000
他讀過的文字就是那50億張圖片所帶有的caption
link |
06:22.000
那他讀的文字量還是很有限
link |
06:25.000
可能有很多奇奇怪怪的東西
link |
06:27.000
他是不知道是什麼的
link |
06:29.000
所以你有一個好的文字的encoder
link |
06:31.000
可以幫助他去process去處理那些
link |
06:35.000
他在影像跟文字成對的資料裡面
link |
06:39.000
沒有看過的比如說新的詞彙
link |
06:42.000
所以這個文字的encoder對結果的影響其實是很大
link |
06:46.000
那相對而言這個diffusion model的大小
link |
06:51.000
似乎就沒有那麼重要
link |
06:53.000
這邊unit size其實指的是那個diffusion model
link |
06:56.000
裡面的那個noise predictor的大小
link |
06:58.000
那在Imagine這篇paper裡面
link |
07:00.000
就嘗試了用了不同大小的diffusion model
link |
07:03.000
發現真大diffusion model對結果的幫助是比較有限
link |
07:08.000
所以看起來文字的encoder
link |
07:10.000
其實對於今天這些模型可以有這麼好的表現
link |
07:13.000
其實是非常重要的
link |
07:16.000
那什麼是FID呢
link |
07:19.000
FID的意思是這樣
link |
07:21.000
因為你怎麼量一張圖片的好壞
link |
07:24.000
今天我們在做這種影像生成的時候
link |
07:27.000
一個難題就是
link |
07:28.000
你怎麼評估這個影像生成的模型
link |
07:30.000
到底做的好還是做的不好
link |
07:32.000
你今天給一段文字的時候
link |
07:33.000
你根本沒有標準答案啊
link |
07:35.000
或者說假設你準備了標準答案
link |
07:36.000
你可以說你的模型產生出來的結果
link |
07:38.000
跟標準答案不一樣
link |
07:39.000
就說它是錯的嗎
link |
07:40.000
你也不能這麼說吧
link |
07:42.000
所以今天你需要有些特別的方法
link |
07:44.000
來評估影像生成模型的好壞
link |
07:47.000
那其中一個今天很常用的
link |
07:49.000
叫做FID
link |
07:51.000
FID是什麼呢
link |
07:52.000
FID就是
link |
07:53.000
你得先有一個pre-trained好的CNN model
link |
07:57.000
你得先有一個pre-trained好的影像分類的model
link |
08:00.000
那你把你手上的圖片
link |
08:02.000
不管是這個機器生成的
link |
08:04.000
還是真實的圖片
link |
08:06.000
通通丟到這個CNN裡面
link |
08:08.000
得到CNN的Latent Representation
link |
08:11.000
這個其實就是
link |
08:12.000
大家在作業三的時候
link |
08:14.000
拿出來的那個Representation
link |
08:16.000
對不對 作業三
link |
08:17.000
不是說拿一個Representation嗎
link |
08:19.000
那其實就是這樣的東西
link |
08:21.000
你拿出一個Representation以後呢
link |
08:23.000
你把真實的影像的Representation
link |
08:27.000
跟生成的影像的Representation畫出來
link |
08:31.000
在這個圖上
link |
08:32.000
藍色的點代表的是
link |
08:34.000
生成的圖片
link |
08:35.000
通過這個影像分類的model以後
link |
08:38.000
所產生的Representation
link |
08:40.000
那紅色的圖片
link |
08:41.000
代表的是真實的影像
link |
08:43.000
產生這個圖片分類系統
link |
08:45.000
得到的Representation
link |
08:47.000
那如果這兩個Representation
link |
08:50.000
它這兩組Representation
link |
08:53.000
越接近
link |
08:54.000
就代表說生出來的影像
link |
08:56.000
跟真實的影像越接近
link |
08:58.000
如果這兩組分得很遠
link |
08:59.000
就代表說真實的影像
link |
09:01.000
跟生成的影像
link |
09:02.000
它們非常的不像
link |
09:04.000
那怎麼算兩組Representation之間的距離呢
link |
09:09.000
FID這邊用的是一個
link |
09:11.000
其實很粗糙但是有用的方法
link |
09:14.000
它的假設很簡單
link |
09:16.000
假設這兩組Representation
link |
09:18.000
都是Gaussian Distribution
link |
09:21.000
那我知道這邊有
link |
09:22.000
一萬個可以吐槽的地方啦
link |
09:24.000
但是反正就是假設
link |
09:25.000
它們是Gaussian Distribution
link |
09:26.000
然後算這兩個Gaussian Distribution的Distance
link |
09:30.000
那這邊算的是一個叫做Fragile Distance
link |
09:34.000
就結束了這樣
link |
09:35.000
那這個方法看起來有點粗糙
link |
09:38.000
但是它的結果看起來是好的
link |
09:41.000
跟人類的評估是滿一致的
link |
09:43.000
所以FID現在仍然是一個
link |
09:45.000
非常常用的做法
link |
09:47.000
就算是今天這個Imagine
link |
09:49.000
這麼新的模型
link |
09:50.000
還是用FID作為評估的基準之一
link |
09:52.000
那因為它算的是
link |
09:54.000
兩組Distribution之間的距離啊
link |
09:56.000
所以這個分數是越小越好
link |
09:59.000
這距離越小
link |
10:00.000
代表你的模型生成出來的結果越好
link |
10:05.000
FID有一個問題就是
link |
10:07.000
你需要Sample出很多的Image
link |
10:11.000
你需要Sample出很多的
link |
10:12.000
你不能只Sample幾張Image就量FID
link |
10:15.000
你要Sample大量的Image才能量FID
link |
10:18.000
所以像前一頁的投影片啊
link |
10:20.000
不是有一個10K嗎
link |
10:22.000
10K是什麼意思
link |
10:23.000
10K就是Sample了10K張Image
link |
10:26.000
來量FID的意思
link |
10:28.000
那CLIP Score是什麼呢
link |
10:31.000
我們現在講CLIP
link |
10:32.000
CLIP呢
link |
10:33.000
是Contrastive Language Image Retraining的縮寫
link |
10:36.000
那CLIP呢
link |
10:37.000
是用400個Million的Image跟Text Pair的Data
link |
10:42.000
所訓練出來的一個模型
link |
10:44.000
那這個模型做的事情就是
link |
10:46.000
它裡面有一個Image的Encoder
link |
10:48.000
有一個Text的Encoder
link |
10:50.000
那Text的Encoder讀一張文字作為輸入
link |
10:52.000
產生一個向量
link |
10:54.000
Image的Encoder讀一張圖片作為輸入
link |
10:56.000
產生一個向量
link |
10:57.000
那如果這個圖片跟這段文字
link |
11:01.000
它們是Pair的
link |
11:03.000
就這段文字是在描述這個圖片
link |
11:05.000
那這個當然是有人標好
link |
11:06.000
哪段文字描述哪個圖片啦
link |
11:08.000
如果它們是成對的
link |
11:09.000
那這兩個向量就要越近越好
link |
11:11.000
如果它們不是成對的
link |
11:12.000
這兩個向量就要越遠越好
link |
11:15.000
那CLIP Score簡單來說就是
link |
11:17.000
把你機器產生出來的圖片丟進去
link |
11:20.000
然後呢
link |
11:21.000
把你當時要讓機器產生圖片的
link |
11:24.000
那段文字的敘述也丟進去
link |
11:25.000
然後看看CLIP算出來的向量的距離
link |
11:28.000
算出來的向量它們的這個
link |
11:30.000
像不像
link |
11:31.000
啊如果很像
link |
11:32.000
就代表Clip Score高
link |
11:33.000
就代表說
link |
11:34.000
你的模型生出來的那個圖
link |
11:35.000
跟那個文字是有對應的關係的
link |
11:39.000
這個就是CLIP Score
link |
11:43.000
好那剛才講的是Text Encoder
link |
11:46.000
然後接下來呢
link |
11:47.000
我們先講Decoder
link |
11:50.000
那這個Decoder做的事情是什麼呢
link |
11:52.000
這個Decoder啊
link |
11:54.000
它一般在訓練的時候
link |
11:56.000
就不需要
link |
11:58.000
影像跟文字成對的資料
link |
12:00.000
你要訓練中間的這個
link |
12:02.000
Generation的Model
link |
12:03.000
比如說Diffusion的Model
link |
12:04.000
讓它可以持文字的Embedding
link |
12:06.000
再產生中間產物
link |
12:07.000
這需要Pair的Data
link |
12:09.000
需要影像跟文字的對應關係
link |
12:12.000
那影像跟文字對應的資料
link |
12:14.000
雖然今天你說可以收集到很多張
link |
12:16.000
可以收集到什麼五個Billion
link |
12:18.000
那麼多的影像跟文字成對的資料
link |
12:20.000
但是沒有跟文字成對的影像
link |
12:22.000
是更多更多的
link |
12:24.000
而這個額外的Decoder
link |
12:25.000
它的好處就是
link |
12:26.000
它的訓練是不需要文字資料的
link |
12:30.000
你可以單憑著
link |
12:31.000
大量的影像的資料
link |
12:33.000
就自動把這一個Decoder訓練出來
link |
12:37.000
好那這個Decoder
link |
12:38.000
是怎麼訓練的呢
link |
12:39.000
如果你今天
link |
12:41.000
你的Decoder的輸入是
link |
12:43.000
你的這個中間產物網
link |
12:45.000
就是一張比較小的圖
link |
12:47.000
那Decoder訓練非常簡單
link |
12:48.000
你就把你手上
link |
12:49.000
可以找得到的影像
link |
12:51.000
都拿出來
link |
12:52.000
然後呢
link |
12:53.000
把它們做Downsampling
link |
12:54.000
變成小圖
link |
12:55.000
你就有成對的資料
link |
12:57.000
你就可以訓練Decoder
link |
12:58.000
把小圖變成大圖
link |
12:59.000
就結束了
link |
13:01.000
好那如果我們的中間產物
link |
13:03.000
不是小圖
link |
13:04.000
而是某種Latent Representation呢
link |
13:07.000
那我們怎麼訓練一個Decoder
link |
13:10.000
它可以把Latent Representation
link |
13:11.000
當作輸入
link |
13:12.000
把這些Latent Representation
link |
13:14.000
還原成一張圖片呢
link |
13:16.000
那你就要訓練一個Autoencoder
link |
13:18.000
這個Autoencoder做的事情
link |
13:20.000
就是有一個Encoder
link |
13:21.000
輸一張圖片
link |
13:22.000
變成一個Latent Representation
link |
13:24.000
然後把Latent Representation
link |
13:26.000
通過Decoder還原原來的圖片
link |
13:28.000
然後你要讓輸入跟輸出
link |
13:30.000
越接近越好
link |
13:31.000
那像這樣的套路
link |
13:32.000
我們剛才在前一堂課
link |
13:34.000
已經講過了
link |
13:35.000
好總之你就訓練這個Encoder
link |
13:37.000
跟Decoder以後
link |
13:38.000
訓練完
link |
13:39.000
就把這個Decoder
link |
13:40.000
拿出來用
link |
13:41.000
這個Decoder
link |
13:42.000
就可以吃一個Latent Representation
link |
13:44.000
還原一張圖片
link |
13:46.000
這個是中間產物
link |
13:48.000
是Latent Representation的case
link |
13:51.000
那像Imagine
link |
13:53.000
用的就是前面
link |
13:54.000
把小圖當中間產物
link |
13:56.000
那像Stable Diffusion
link |
13:57.000
還有Dali
link |
13:58.000
就是用這張圖片的方法
link |
14:00.000
把Latent Representation
link |
14:02.000
當作中間產物
link |
14:04.000
那通常這個中間產物
link |
14:06.000
長什麼樣子呢
link |
14:08.000
如果講得更具體一點
link |
14:09.000
通常的做法是這個樣子
link |
14:11.000
假設你輸入的圖片
link |
14:13.000
是hxwx3
link |
14:15.000
這個h是它的高
link |
14:17.000
w則是它的寬
link |
14:18.000
3則是說每一個像素
link |
14:20.000
其實是RGB三個數字所表示
link |
14:24.000
那通常你的這個Latent Representation
link |
14:27.000
你可以寫成
link |
14:28.000
hxwxc
link |
14:30.000
所以你要把它看作是一張小圖
link |
14:33.000
也可以
link |
14:34.000
只是這張小圖是
link |
14:35.000
人類看不懂的小圖
link |
14:38.000
這個h跟w
link |
14:40.000
就是大h跟w
link |
14:41.000
做downsampling的結果
link |
14:42.000
比如說這個小h
link |
14:43.000
可能是大h除10
link |
14:45.000
小w可能是大w除10等等
link |
14:47.000
然後這個c呢
link |
14:48.000
就代表的是channel
link |
14:49.000
就代表說在這小圖上
link |
14:51.000
每一個位置
link |
14:52.000
是用多少個數字來表示
link |
14:55.000
如果c是10
link |
14:56.000
就代表每一個位置
link |
14:57.000
是用10個數字來表示
link |
15:01.000
好那最後呢
link |
15:02.000
就來進入Generation Model的部分
link |
15:07.000
那Generation Model的作用
link |
15:09.000
就是要吃文字的Representation
link |
15:11.000
產生一個壓縮的結果
link |
15:14.000
產生一個中間產物
link |
15:16.000
圖片壓縮的結果
link |
15:19.000
好那怎麼做呢
link |
15:20.000
那我們已經講過
link |
15:21.000
Diffusion Model的概念了
link |
15:24.000
我們現在唯一不一樣的地方是
link |
15:26.000
剛才在做Diffusion Model的時候
link |
15:29.000
你的Noise是加到圖片上
link |
15:32.000
在做Diffusion Process的時候
link |
15:33.000
你的Noise是直接加在圖片上
link |
15:36.000
但是現在我們要
link |
15:37.000
Diffusion Model產生出來的東西
link |
15:39.000
已經不是圖片了
link |
15:41.000
那怎麼辦呢
link |
15:42.000
我們的這個Noise
link |
15:44.000
要加在中間產物上
link |
15:47.000
或加在Latent Representation上
link |
15:50.000
所以假設我今天是拿
link |
15:51.000
Latent Representation
link |
15:52.000
當作中間產物
link |
15:54.000
這邊的做法就是
link |
15:55.000
你先拿個Encoder出來
link |
15:57.000
Encoder吃一張圖片
link |
15:59.000
然後產生Latent Representation
link |
16:02.000
接下來你的雜訊
link |
16:04.000
是加在這個Latent Representation上的
link |
16:07.000
你會Sample一個雜訊
link |
16:08.000
這個雜訊的Dimension
link |
16:10.000
跟這個Latent Representation的Dimension
link |
16:12.000
是一樣的
link |
16:13.000
你Sample一些雜訊出來
link |
16:15.000
加到Latent Representation上
link |
16:17.000
然後就稍微編一點
link |
16:18.000
再Sample一些雜訊
link |
16:19.000
又再編一點
link |
16:20.000
以此類推
link |
16:21.000
直到最後你加了夠多的雜訊
link |
16:24.000
然後你的Latent Representation
link |
16:26.000
變成純粹從雜訊裡面
link |
16:28.000
Sample出來的樣子
link |
16:31.000
然後接下來呢
link |
16:33.000
你就是Train一個Noise Predictor
link |
16:35.000
這跟一般的Diffusion Model
link |
16:36.000
是完全一模一樣的
link |
16:38.000
加入雜訊以後的Representation
link |
16:41.000
當作輸入
link |
16:42.000
那你也需要
link |
16:43.000
現在是第幾個Step當作輸入
link |
16:47.000
然後你也需要文字當作輸入
link |
16:50.000
那現在文字呢
link |
16:51.000
是用這個Latent Representation
link |
16:53.000
也是一排向量來表示
link |
16:55.000
所以你就把這個
link |
16:57.000
加入Noise以後的Latent Representation
link |
17:01.000
通過文字Decoder得出來的
link |
17:04.000
這個文字的Encoder
link |
17:05.000
Understanding這段文字以後的結果
link |
17:07.000
跟現在是第幾個Step
link |
17:09.000
丟到Noise Predictor裡面
link |
17:11.000
希望它就可以把Noise Predictor出來
link |
17:14.000
就這樣
link |
17:17.000
好 然後今天在生圖的時候啊
link |
17:20.000
你的做法就是
link |
17:21.000
你有一個純粹從
link |
17:25.000
你有一個純粹從Normal Distribution裡面
link |
17:28.000
Sample出來的
link |
17:31.000
Latent Representation
link |
17:33.000
它的大小像是一個小圖的樣子
link |
17:36.000
但是它是從
link |
17:38.000
Normal Distribution裡面Sample出來的
link |
17:41.000
然後呢
link |
17:42.000
你把這個東西
link |
17:44.000
加上這段文字
link |
17:46.000
丟給一個Denoise的Module
link |
17:48.000
然後Denoise的Module就去掉一些Noise
link |
17:51.000
然後這個步驟就反覆繼續下去
link |
17:53.000
再通過Denoise的Module再去掉一些Noise
link |
17:55.000
然後呢 反覆繼續下去
link |
17:57.000
直到你覺得產生出
link |
17:59.000
直到你通過一定次數的Denoise之後
link |
18:02.000
產生出來的結果夠好了
link |
18:04.000
丟給Decoder就可以生圖了
link |
18:07.000
然後所以你會發現
link |
18:08.000
你在用那個MeJourney的時候啊
link |
18:10.000
它背後是Diffusion Model啦
link |
18:12.000
但是你看它生圖的時候
link |
18:13.000
它有一個生圖的過程喔
link |
18:15.000
從模糊慢慢到清楚
link |
18:17.000
那如果是Diffusion Model的話
link |
18:18.000
你應該看到的是一開始是
link |
18:20.000
完全Random的雜訊
link |
18:22.000
就白噪音就跟那個電視機壞掉一樣
link |
18:25.000
然後那個白噪音在
link |
18:26.000
越來越少越來越少
link |
18:27.000
然後你的圖才生出來
link |
18:28.000
但是其實你用那個MeJourney的時候
link |
18:31.000
它生圖不是這個樣子
link |
18:32.000
你會發現說它的圖是
link |
18:33.000
從一張模糊的圖只看得出輪廓
link |
18:36.000
然後接下來越來越清楚
link |
18:37.000
越來越清楚 越來越清楚
link |
18:39.000
然後中間有時候
link |
18:40.000
本來中間產生某個物件
link |
18:42.000
到最後還會不見這樣子
link |
18:44.000
那為什麼這樣
link |
18:45.000
那就是因為它其實是把
link |
18:47.000
這一個Process裡面
link |
18:49.000
每一次產生出來的
link |
18:51.000
這些Latent Representation
link |
18:53.000
通過Decoder以後
link |
18:55.000
拿出來給你看
link |
18:57.000
然後所以雖然這個東西
link |
18:59.000
是一個
link |
19:01.000
從Gaussian Distribution Sample出來的東西
link |
19:03.000
但是你通過Decoder以後
link |
19:05.000
它看起來就是一張
link |
19:07.000
比較模糊的圖
link |
19:09.000
就不會看起來像是
link |
19:10.000
有Gaussian Distribution加在上面
link |
19:12.000
看起來就不像是
link |
19:13.000
有噪音加在上面
link |
19:15.000
這就是為什麼MeJourney
link |
19:16.000
它的中間產物其實也是
link |
19:18.000
人看得出來是什麼東西的圖
link |
19:20.000
它就把這些中間產生出來的
link |
19:22.000
Latent Representation
link |
19:24.000
丟給Decoder
link |
19:25.000
然後再產生出來的結果給你看
link |
19:28.000
好 那這個就是今天
link |
19:31.000
StaleDR的文字生影像的Framework
link |
19:34.000
就是三個步驟
link |
19:35.000
文字的Encoder
link |
19:36.000
一個Image的Generation的Model
link |
19:39.000
生個中間產物出來
link |
19:40.000
Decoder再做最後的處理
link |
19:42.000
你會發現最好的影像生成模型
link |
19:44.000
基本上都是這樣子的套路