各位同學大家好,那我們就來上課吧。

那上週我們講了什麼呢?上週我們講了Gan的直觀的想法。

那今天呢,我們要來講Gan背後的理論。

那我們今天要講的是當初2014年Ian Goodfellow在propose Gan的時候他的想法。

那等一下可以仔細聽看看,聽看看說跟我們上週講的Gan的直觀的想法裡面,

有沒有矛盾的地方,其實是有一些地方還不矛盾的。

至今仍然沒有好的solution,沒有好的說法可以解決。

欸你說,可以開冷氣嗎?

呃,好啊,這樣子開就好。

好,等一下大家有什麼問題要問嗎?

好,如果大家沒有什麼問題要問的話呢,

那我們就來講一下這個Gan背後的理論,當初Ian Goodfellow是怎麼說的。

好,那這個是我們上週說的,要大家在這個作業三之一裡面,

要讓Gan做的事情,就讓自己看了很多動畫的圖以後呢,

自己產生二次元人物的頭像。

那我們知道說,Gan他要做的事情,就是根據很多example去進行生成。

那所謂生成這件事情,到底是一個什麼樣的問題呢?

而假設我們今天要生成的東西是image,那我們用X來代表一張image。

那每一個image都是high dimensional,高維空間中的一個點。

那假設今天產生64x64的image,它是64x64維空間中的一個點。

那這邊呢,為了畫圖方便,我們假設每一個X就是二維空間中的一個點。

所以它實際上呢,是高維空間中的一個點。

好,那我們現在要產生的東西,比如說我們要產生的image,

它其實有一個固定的distribution,我們這邊呢,寫成pdata.x。

它有一個固定的distribution,什麼意思呢?

在這整個image的space裡面,在這整個image所構成的高維空間中,

其實只有非常少的部分,其實只有一小部分,

它sample出來的image看起來像是人臉。

在多數的空間中sample出來的image,它都不像是人臉。

舉例來說,在這個圖上的例子裡面,可能只有藍色的這個區域,

你去sample出x,去sample一個image,它看起來呢,像是人臉。

舉例來說,你在這個地方sample呢,你看起來的圖片長得是這個樣子。

那你在其他地方sample呢,看起來的圖片,看起來就不像是人臉。

所以假設我們今天要生存的x是人臉的話,它有一個固定的distribution,

這個distribution在藍色的這個區域,它的機率是高的,

在藍色區域以外,它的機率是低的。

那我們今天要機器做的事情是什麼呢?

我們要機器去找出這個distribution,

而這個distribution它到底長什麼樣子,我們實際上是不知道的。

我們可以收集很多的image,我們可以收集很多的x,

知道說x可能在某些地方分布比較高,但是要我們把它的式子找出來,

我們是不知道要怎麼做的。

所以現在GAN做的事,一個generative model做的事情,

就是要找出這個distribution。

那在有GAN之前,我們怎麼做generative這件事呢?

我們是用maximum likelihood estimation,

那其實maximum likelihood estimation我們在這個,

之前Machine Learning的時候有講過了,這邊只是一個很快的複習。

而我們現在有一個data的distribution,它是data的base,

這個distribution實際上長什麼樣子,

就是這個distribution它實際上它的formulation長什麼樣子,

我們是不知道的。

我們可以從裡面sample它,所謂從這個distributionsample它的意思就是,

假設你做的是二次元人物的生成,

那你就是從你的data base裡面sample出image,

這個就是從這個distribution裡面sample一些data出來。

我們可以sample它,但是我們不知道它長什麼樣子。

好,那接下來我們要自己去找一個distribution,

這個distribution寫成P下標Geobase,

那這個distribution是由一組參數Theta所操控的,

所謂由Theta所操控的意思是說,

這個distribution舉例來說,假設它是一個Gaussian mixture的model,

那這個Theta指的就是那個Gaussian的mean跟variance。

那我們要去調整這個Gaussian的mean跟variance,

使得我們得到的這個distribution Pg跟真實的distribution Pdata越接近越好。

所以雖然我們不知道Pdata長什麼樣子,

我們只能夠從Pdata裡面去sample,

但是我們希望這個Pg,我們可以找一個這個Theta,

讓Pg跟Pdata越接近越好。

好,那怎麼做呢?

假設你是用maximum likelihood的話,怎麼做呢?

首先我們可以從Pdata裡面sample一些東西出來,

sample x1, x2到xn,

可以sample出一堆x出來。

好,接下來呢,對每一個sample出來的x,

我們都可以計算它的likelihood,

所謂可以計算它的likelihood的意思是說,

假設給定一組參數Theta,

給定一組參數Theta,我們就知道Pg這個probability的distribution長什麼樣子。

知道這個probability的distribution長什麼樣子,

我們就可以計算從這個distribution裡面sample出某一個xi的機率,

我們可以計算出這個likelihood。

好,接下來我們要做的事情就是,

我們要找出一個Theta,使得Pg跟Pdata越接近越好。

這件事情的意思就是說,

我們希望這些從Pdata裡面sample出來的example,

如果是用Pg這個distribution來產生的話,

它的likelihood越大越好。

那每一筆data它從Pg裡面產生出來的likelihood,

我們都是可以算出來的,

那我們把所有的機率乘起來,

就得到一個total的likelihood,

那我們希望這個total的likelihood越大越好。

那怎麼讓total的likelihood越大越好呢?

你就是要去找一個Theta star,

找一組最佳的參數,

它可以去maximizeL這個值。

舉例來說,在這個case裡面,

假設你是一個Gaussian mixture model,

你就可能希望它的mean落在這些地方,

它的variance長這樣,

這個Gaussian mixture model,

它產生這些data的機率就是最大。

那這個是maximum likelihood,

我記得我們在machine learning課裡面講generating model的時候,

就已經提過這些東西了。

好,那maximum likelihood,

其實如果你覺得它沒有很直觀的話,

這邊給你maximum likelihood的另外一個解釋。

這個maximum likelihood,

它等同於minimizeKL的divergence。

什麼意思呢?

我們說在maximum likelihood裡面,

我們做的事情就是,

我們從Pdata裡面sample出Mvdata,

然後給我們一組參數θ,

我們就可以計算每一個x被sample出來的機率,

我們把這些機率全部乘起來,

這個是我們要去maximize的對象。

那這個式子你可以稍微改變一下,

你就在前面取一個log,

取一個log不影響你找出來的最好的θ。

這個大家都可以很快的知道。

你可以把log放進去,

本來是很多項相乘取log,

等同於每一項取log以後相加。

這個我相信對大家來說也沒有問題。

接下來,這件事情是什麼意思呢?

Summation over i等於1到M,

Summation over dE比example到dM比example,

這件事情其實就是在approximate,

從Pdata這個distribution裡面sample x出來。

從Pdata這個distribution裡面sample x出來,

你就得到x1,x2到xn。

所以今天這個式子,

它要maximize的對象其實就是maximize

log Pg of x,

maximize這一項的expected value,

那你這個expectation的distribution

是你要sample的data。

接下來,我們可以把這一項,

我們可以把這個expectation這一項把它展開,

它其實就是一個積分,

這個expectation從x,

這個x是從Pdata裡面sample出來的,

從Pdata裡面sample出來的意思就是說,

對x做積分,

然後把它乘Pdata of x,

然後乘上log Pg of x。

接下來,加一項看起來沒有什麼用的東西,

我們在後面加這麼一項,

這一項是什麼東西呢?

你看一下這一項,

這一項裡面它只有Pdata,

它跟Pg是完全沒有任何關係的,

所以今天加這一項根本不會影響

你找出來的最大的x,

那既然加這一項一點用都沒有,

為什麼要加這一項呢?

加這一項的目的是為了要告訴你說,

maximum likelihood它就是KL divergence,

因為加上這一項以後,

你就可以把這個式子做一下整理,

這邊是對x做積分,

乘上Pdata of x,

再乘上log Pg of x,

這邊是減掉對x做積分,

Pdata of x,

乘上log Pdata of x,

所以這邊有積分Pdata of x,

這邊有積分Pdata of x,

所以可以把它提出來,

所以這一項跟這一項可以把它提出來,

然後這邊就剩下log Pg,

減掉log Pdata,

那大家一秒鐘就可以反映說,

log Pg減掉log Pdata,

就是Pg除以Pdata,

總之這個式子它就是Pdata跟Pg的KL divergence,

所以你找一個setup,

去maximize likelihood,

等同於找一個setup,

去minimize Pdata跟Pg的KL divergence,

那如果你看到這邊覺得數學式太多,

你沒有看懂的話呢,

其實你只要知道一件事就好,

所謂的maximum likelihood,

就我們之前在機器學習裡面講說,

我們今天要找一個generated model,

去maximum likelihood,

這個maximum likelihood這件事情,

其實就等同於,

minimize你的generated model,

所定義的這個distribution Pg,

跟你現在的data,

Pdata之間的KL divergence,

好,那接下來我們會遇到的問題是,

假設我們的Pg只是一個Gaussian mixture model,

那它顯然有非常多的限制,

我們希望Pg是一個general distribution,

它可以不是Gaussian,

它可以是比Gaussian更複雜的東西,

但是假設你今天把Pg,

換成一個比Gaussian更複雜的東西,

你會遇到什麼問題呢,

你會遇到的問題就是,

你算不出你的likelihood,

你算不出PgX,

而且假設今天PgX這個東西,

它是一個Gaussian mixture model,

給你一個X,

你可以計算它被sample出來的機率,

但是如果它是一個很複雜的東西,

等一下我會講說,

它可能是一個neural network,

那你就沒有辦法計算它的likelihood,

所以怎麼辦呢,

所以怎麼辦呢,

所以就有了一些新的想法,

那其實讓machine自動的產生成東西,

比如說做image generation,

從來都不是新的題目,

你可能看說最近用電呢,

做了很多image generation的task,

好像image generation是這幾年才有的東西,

其實不是,

image generation這件事情呢,

在80年代就有人做過了,

那個時候的做法就是,

用Gaussian mixture model,

你就收集很多很多的image,

那每個image其實就是高維中間一個data point,

然後你就可以用一個Gaussian mixture model,

去maximize產生那些image likelihood,

但是如果你看這個文獻的話呢,

你看這個古聖先賢留下來的東西,

就會發現說過去做的,

如果你用Gaussian mixture model,

產生出來的image,

非常非常的糊,

非常非常的糊,

那這個可能原因是因為image啊,

它是高維空間中的一個manifold,

大家可能知道說image在高維空間中,

它其實是高維空間中的一個低維的manifold,

所以如果用Gaussian mixture model,

它其實就不是一個manifold,

就是你用Gaussian mixture model,

你不管怎麼調你的mean跟variance,

它就不像是你的target distribution,

所以你怎麼做都是做不好,

所以我們需要更generalize,

又有更generalize的方式呢,

來learn generation這件事情,

好那在這個篇裡面啊,

在generation of the personal network裡面呢,

我們的generator就是一個network,

我們把它寫作G,

等一下我們就會告訴大家說,

一個network它怎麼被看作是一個probability的distribution,

好我們知道說我們generator就是一個network,

那我們也都知道說network呢,

就是input一個東西,

然後呢output一個東西,

舉例來說呢,

你input一個從某一個distribution sample出來的noise z,

你input一個隨機的vector z,

然後呢它就會output一個x,

那這個x呢,

如果我們把這個generator G看作是一個function的話,

這個x呢就是G of z,

這個x呢就是G of z,

如果你今天是做image generation的話呢,

那你的x呢就是一個image,

好然後我們說這個z呢,

是從某一個prior distribution,

比如說是從一個normal distribution裡面sample出來的,

而今天每次sample出一個z,

你把它丟到這個generator裡面,

你就會得到一個x,

你sample不同的z,

你得到的x呢就不一樣,

那今天這個z呢,

是從一個Gaussian distribution裡面sample出來的,

那你現在呢,

把這些從Gaussian distribution裡面sample出來的z,

通通通過去得到另外一大堆sample,

把這些sample通通集合起來,

你得到的就會是另外一個distribution,

那雖然input是一個normal distribution,

是一個單純的Gaussian distribution,

但是你通過這個generator以後,

因為這個generator是一個network,

它可以把這個z呢,

通過一個非常複雜的轉換把它變成x,

所以你今天把通過這個generator,

產生出來的x通通集合起來,

它可以是一個非常複雜的distribution,

而這個distribution呢,

就是我們所謂的Pg,

那有人可能會問說,

這個prior distribution應該要設成什麼樣子呢,

在文獻上有人會用normal distribution,

有人會用uniform distribution,

那你可以在作業裡面verify一下說,

你覺得哪一種比較好,

其實哪一種比較好,

我其實也忘記了這樣,

我覺得呢,

其實這邊prior distribution用哪種distribution,

也許影響並沒有那麼大,

因為generator它是一個network,

我們在一開學,

第一堂課就有講過說,

一個hidden layer的network,

它就可以approximate任何function,

那更何況是有多個hidden layer的network,

它可以approximate非常複雜的function,

所以今天就算是你的input distribution,

是一個非常簡單的distribution,

通過了這個network以後,

它也可以把這個簡單的distribution,

凹成各式各樣不同的形狀,

所以不用擔心說,

我這邊如果是input normal distribution,

會不會對alpha來說有很大的限制,

其實不會,

因為通過一個generator以後,

你可以把一個單純的normal distribution,

凹成各式各樣複雜的形狀,

那我們接下來的目標是什麼,

我們接下來的目標是,

希望generator,

根據這個generator,

所定義出來的distribution pg,

它跟我們的目標,

跟我們的data的distribution pdata,

越接近越好,

如果要寫一個optimization formulation的話,

這個formulation看起來是這個樣子,

我們要找一個generator,

我們要找一個generator g,

這個generator,

可以讓它所定義出來的distribution pg,

跟我們的data,

pdata之間的某種divergence,

越小越好,

舉例來說,

如果是maximum likelihood的話,

就是要minimize KL divergence,

等一下我們會看到說,

其實在GAN裡面,

我們minimize的不是KL divergence,

而是其他的divergence,

然後這邊寫一個div,

就代表說反正它是某一種divergence,

我們現在要做的事情就是,

找一個generator,

這個generator定義出一個distribution pg,

這個pg,

可以跟我們的pdata的divergence,

越接近越好,

再來的問題就是,

怎麼計算這個divergence,

假設你能夠計算這個divergence,

你要找一個g去minimize這個divergence,

那不就只是gradient descent,

用gradient descent就可以做了對不對,

但是問題就是,

你要怎麼計算出這個divergence呢,

pdata它的formulation,

我們是不知道的,

它並不是什麼Gaussian distribution,

它的formulation我們是不知道的,

pg它的formulation,

我們也是不知道的,

假設pg跟pdata它的formulation,

我們是知道的,

我們其實帶進那個divergence的formulation裡面,

我們其實就可以算出它的divergence是多少,

然後我們就用gradient descent,

去minimize它的divergence,

那問題就是,

pg跟pdata它的formulation,

我們是不知道的,

它formulation是不知道的,

我們根本就不知道要,

怎麼去計算它的divergence,

所以根本就不知道要怎麼找一個g,

去minimize它的divergence,

所以怎麼辦呢,

這個就是gain神奇的地方,

那在進入比較多的數學式之前,

我們先很直觀的來講一下說,

GaN到底是怎麼做到,

minimize divergence這件事情的,

那這邊的前提是,

我們不知道pg跟pdata的distribution,

長什麼樣子,

但是我們可以從這兩個distribution裡面,

去sample data出來,

什麼意思呢,

什麼叫做從pdata,

去sample distribution出來呢,

你就是把你的database拿出來,

假設我們做二次元人物頭像生成的話,

就把你的database拿出來,

然後從裡面sample很多image出來,

這個就是從pdata這個distribution裡面做sample,

怎麼對pg做sample呢,

我們說這個pg啊,

它是由你的generator所定義的,

那我們在使用這個generator的時候,

我們是從某一個prime distribution裡面,

去sample一大堆的vector,

每一個vector就會產生一張image,

所以所謂的從pg裡面做sample,

其實就是random sample一個vector,

把這個vector呢,

丟到generator裡面產生一張image,

這個就是從pg裡面做sample,

所以我們可以從pdata裡面做sample,

我們也可以從pg裡面做sample,

我們現在的問題,

接下來的問題就是,

我們可以從pg和pdata做sample,

根據這個sample,

我們要怎麼知道這兩個distribution的divergence呢,

那更神奇的地方就是,

透過discriminator,

我們可以來量這兩個distribution間的divergence,

就假設這個藍色的星星,

是從pdata裡面sample出來的東西,

紅色的星星呢,

是從pg裡面sample出來的東西,

那根據這些data,

我們去訓練一個discriminator,

那上週我們已經講過說,

所謂訓練discriminator的意思就是,

給pdata的分數越大越好,

給pg的分數越小越好,

你去訓練一個discriminator,

這個訓練的結果就會告訴我們,

pdata跟pg他們之間的divergence有多大,

有多大,

那我們上週講過說,

我們要訓練一個discriminator,

我們是怎麼訓練一個discriminator的呢,

我們會寫一個objective function,

我們會寫一個objective function B,

那這個objective function它跟兩項有關,

一個是跟你的generator有關,

一個是跟你的discriminator有關,

那我們在train這個discriminator的時候呢,

我們會fix住generator,

所以g這一項是fix住的,

我們只是去調這個discriminator的參數,

想辦法去maximize後面這一項,

那後面這一項是什麼意思呢,

後面這一項的意思是說,

假設x是從pdata裡面sample出來的,

那我們希望log d of x越大越好,

也就是我們希望discriminator的output,

假設x是從pdata裡面sample出來的,

我們就希望這個d of x越大越好,

反之假設x是從generator sample出來的,

那因為我們要maximize B這一項,

所以我們是要maximize第一項,

也要maximize第二項,

而如果x是從pg裡面sample出來的,

那我們要maximize log 1-d of x,

maximize log 1-d of x,

就是要maximize 1-d of x,

也就是要minimize d of x,

所以x如果是從pg裡面sample出來的,

我們就希望它的值越小越好,

然後在訓練的時候,

我們就是要找一個d,

它可以maximize這個objective function,

那其實如果你之前的machine learning有學通的話,

下面這個optimization的式子,

跟train一個binary classify的式子,

其實是完全一模一樣的,

假設你今天要train一個logistic regression的model,

logistic regression model是一個binary classifier,

然後你就把p data當作是class 1,

把pg當作是class 2,

然後你train一個logistic regression model,

你會發現你的objective function,

其實就是下面這個式子,

其實就是下面這個式子,

所以今天這個discriminator在做的事情,

跟一個binary classifier在做的事情,

其實是一模一樣的,

假設藍色的點是class 1,

紅色的點是class 2,

discriminator就是一個binary classifier,

train下去,

然後這個binary classifier,

它是在minimize cross entropy,

我們之前講過binary classifier,

是要minimize cross entropy,

不能minimize mean square error,

要minimize cross entropy,

如果你minimize cross entropy的話,

你其實就是在解這個optimization的problem,

那這邊神奇的地方是,

當我們解完這個optimization的problem的時候,

你最後會得到一個loss,

你會得到一個最小的loss,

或者是得到一個最大的objective value,

我們今天這邊並不是minimize loss,

而是maximize一個objective function,

這個b是我們的objective value,

我們要去調d,

去maximize這個objective function,

我們要去調d,

去maximize這個objective value,

然後這邊神奇的地方是,

這個maximize的objective value,

就是你把這個dtrain到最好,

給了這些data,

你把這個dtrain到最好,

找出最大的,

d可以達到的objective value,

這個value其實會跟js divergence,

是有非常密切的關係,

甚至你可以說,

等一下會有更詳細的證明,

你可以說這個結果,

它其實就是js divergence,

也許你聽了覺得很神奇,

但是我們可以給你一個非常直觀的解釋,

一秒鐘就知道說,

為什麼這個東西,

它應該跟某一個divergence是有關係的,

因為想想看,

假設我們現在sample出來的data,

它們靠得很近,

藍色的這些星星跟紅色的星星,

如果把它們試成兩個類別的話,

它們靠得很近,

對一個binary classifier來說,

它很難區別紅色的星星,

跟藍色的星星的不同,

因為對一個binary classifier,

也就是discriminator來說,

它很難區別這兩個類別的不同,

所以你今天train下去,

你的loss就沒有辦法壓低,

對不對?

就假設今天這兩個class,

它們靠得很近,

它們很難分別,

很分別,

在training data上的loss,

就會壓不下去,

或是反過來說,

你在training data上的loss壓不下去,

就是我們剛才看到的objective的value,

你沒有辦法把它拉得很高,

你沒有辦法把剛才看到的v這一項,

你沒有辦法找到那個d,

它讓v的值變得很大,

這個時候意味著什麼?

這個時候意味著說,

今天這兩堆data,

它們是非常接近的,

它們的divergence是小的,

所以如果今天對一個discriminator來說,

很難分別這兩種data之間的不同,

它很難達到很大的objective的value,

那意味著這兩堆data的divergence是小的,

所以最後你可以達到最好的objective的value,

跟divergence是會有非常緊密的關係的,

或者是說,

這個是一樣的例子,

假設你的藍色的星星跟紅色的星星,

它們距離很遠,

它們有很大的divergence,

那對discriminator來說,

它就可以輕易地分辨這兩堆data的不同,

也就是說,

它可以輕易地讓你的objective value,

也就是這個V的value,變得很大,

所以當V的value變得很大的時候,

意味著你的兩堆data,

從pdata裡面generate出來的東西,

和從pggenerate出來的東西,

它們的divergence是大的,

所以discriminator就可以輕易地分辨它的不同,

discriminator就可以輕易地maximizeobjective的value,

好,那在我們進入數學之前,

有沒有在這邊先稍微停一下,

看有沒有同學有問題要問的呢?

OK嗎?

好,如果沒有問題要問的話呢,

接下來就是實際上證明給你看說,

為什麼這個objective value跟divergence是有關係的,

再來就是一堆數學式,

這個數學式是這樣,

那個objective value我們就寫在右上角,

寫在右上角,

它長這個樣子,

它長這個樣子,

好,那我們現在要做的事情是,

找一個d,

找一個discriminator d,

它可以maximize這個式子,

g是固定的,

g是固定的,

然後maximize這個式子,

maximize這個式子,

好,怎麼maximize這個式子呢?

我們把它展開,

把本來expectation換成積分,

積分,

所以這邊是從x,

從pdata裡面sample x出來,

就變成對x做積分,

乘上pdata of x,

乘上這個log d of x,

這邊是對pg,

從pg sample x出來,

就是對x做積分,

乘上pg,

乘上log 1-d of x,

這個對大家來說應該都不成問題,

接下來就是整理一下,

因為這邊都對x做積分,

對x做積分,

所以你把放在積分裡面的這一項,

跟放在積分裡面的這一項加起來,

加起來,

接下來我們要想辦法找一個d,

它可以讓這個式子呢,

越大越好,

這邊前提有一個假設是,

d of x,

它可以是任何的function,

它可以是任何的function,

但這邊實際上不見得是成立的,

因為假設d of x是一個network的話,

network除非它的neuron無窮多,

不然它其實也沒有辦法變成任何的function,

除非你的neuron是無窮多的,

不然你也沒有辦法變成任何的function,

但我們這邊做一個非常強烈的假設,

是假設d of x,

它可以是任意的function,

假設d of x可以是任意的function的話,

就是你input一個x,

它的值可以是任何的值,

沒有限制,

你可以assign給d of x任何的值,

你可以assign給d of x1任何的值,

你可以assign給d of x2任何的值,

這個時候假設你要maximize這一項的話,

它實際上等同於什麼呢?

等同於說,

你知道這邊對x做積分,

把中括號裡面的式子,

代各個不同的x,

再把它通通加起來,

這就是積分在做的事情,

但你要maximize這一項,

d of x又可以代任何的值,

意思就是說,

你可以把各個不同的x,

通通都分開算,

所以今天你要找一個d,

去maximize這個式子,

那意思就是說,

你就把某一個x拿出來,

某一個x拿出來,

這邊是p beta of x log d of x,

加上p g log 1-d of x,

你把某一個x拿出來,

然後你要找一個d,

它可以讓這個式子越大越好,

那所有不同的x,

通通都分開來算,

因為所有的x都是沒有任何關係的,

因為不管是哪一個x,

你都可以assign給它一個不同的d of x,

所以這個積分裡面的每一項,

你都分開來算,

你就可以分開為它找一個最好的d of x,

講到這邊,

大家有沒有問題要問呢?

有沒有問題要問呢?

好,如果你可以接受這個想法的話,

再來的問題就是,

怎麼找一個d,

讓這一項最大?

好,那這個數學其實是蠻簡單的,

這個數學其實蠻簡單的,

我們現在的問題是,

找一個d,

讓這個式子最大,

p data是固定的,

p g也是固定的,

我們唯一要做的事情就是,

找一個d of x,

找一個d of x的值,

讓這個式子算起來最大,

那等一下為了計算方便,

我們把p data用a來表示,

d of x用大d來表示,

p g用小d來表示,

d of x用大d來表示,

好,那所以整個式子呢,

寫起來就是這個樣子,

怎麼找一個d去maximize這個式子呢?

可以用,你就算求一下它的gradient,

求一下它的微分,

然後呢,

先找出它的critical point,

就找出微分是0的地方,

找出微分是0的地方,

好,那把這項做微分以後,

得到什麼樣的結果呢?

a log d對d做微分,

等於a乘上1除以d,

b log 1.d對d做微分,

你得到的結果是,

b乘上1除以1.d,

再乘上-1,

然後我們要找微分是0的地方,

找微分是0的地方,

然後把式子整理一下,

把這個-1這項拿到右邊去,

所以-1就沒有了,

所以a乘以1除以d star,

等於b乘以1除以1.d star,

接下來呢,

就要求一下這個d star是多少,

要求一下說,

什麼樣的d可以讓這個微分的值是0,

什麼樣的d它是critical的point,

那就整理一下,

這邊都是很簡單的數學,

就整理一下,

這邊是a乘以1.d star,

等於b乘以d star,

把a乘進去,

得到a-a乘以d star,

右邊是b乘以d star,

整理一下,

把有d star的數量挪到同一邊去,

所以變成a等於a加b,

乘上d star,

d star就等於a除以a加b,

所以我們現在知道說,

假設我們的d star,

我們d star等於a除以a加b,

a就是這一項,

然後b就是這一項,

a就是pθ,

b就是pg,

假設我們現在d star of x的值,

是pθ of x除以pθ of x加pg of x,

它就可以讓這一項的最低的微分為零,

然後你可以輕易的檢查說,

它現在是一個local maxima,

而不是local minima,

也不是saddle point,

你可以輕易的檢查說,

它是一個local的,

它其實是一個maxima,

它不是一個minima,

也不是一個saddle point,

所以今天要怎麼讓這一項最大,

你就把d of x帶這樣的值,

你就可以讓這一項最大,

好,所以接下來呢,

接下來要做的事情是什麼呢,

接下來要做的事情就是,

把這一項帶到這個式子裡面,

把這一項帶到這個式子裡面,

我們想知道說,

當我們找出一個最好的d,

也就是d star的時候,

我們的objective function的值,

到底長什麼樣子,

最後你展開以後,

就會發現說,

這一項其實就是js divergence,

好,現在我們知道說,

d star它的formulation就寫成這個樣子,

好,我們把d star帶到這裡面去,

帶到這裡面去,

我們把這個d of x用p data,

處理p data加p g來表示,

所以把這一項放進來,

把這一項放進來,

你得到的結果就長這樣,

就長這樣,就長這樣,

好,那接下來呢,

這邊有expectation,

把expectation展開,

這邊是對p data sample x,

就對x做積分,

這邊是對p g sample x,

就對p g做積分,

得到的式子長這個樣子,

好,接下來呢,

為了要把它整理成,

看起來像是js divergence,

所以呢,就做一些,

看起來沒有什麼,

好像什麼事都沒有做的變換,

就把這個分子跟分母呢,

都同除二,都同除二,

分子分母呢,都同除二,都同除二,

好,那接下來呢,

你可以把二分之一這一項,

你可以把二分之一這一項,

把它提出來,

把它提出來,

你得到的結果呢,

是兩倍的log二分之一,

這個如果你沒有跟上的話呢,

不太重要,反正這邊有二分之一,

你可以把它提出來,

變成兩倍的log二分之一,

或等於負二log二,

好,然後所以接下來呢,

我們就知道說,

今天啊,

假設我們已經有一個generator g,

我們找到了最佳的discriminator d,

我們找到最佳的discriminator,

也就是d star,

d star的function,

會長這個樣子,

當我們找到最佳的d star的時候,

d這個objective function啊,

它就寫成這個看起來呢,

很複雜的樣子,

看起來很複雜的樣子,

這個是負兩倍的log二,

加上這個x做積分,

然後呢,

p data of x乘上log p data of x,

除上p data跟p g的平均,

還有第二項,

這個是積分s,

p g乘上log p g,

除掉p g和p data的平均,

後面這一項是什麼呢,

後面這一項是,

這個p data跟二分之一p data跟p g的平均的k l divergence,

如果你不知道它是什麼的話,

沒有關係,

反正後面這兩項合起來,

就叫做js divergence,

或許你比較常聽過k l divergence,

或者是inverse k l divergence,

不常聽過js divergence,

但是反正後面這個式子啊,

它就是p data跟p g的某一種divergence,

如果今天p data跟p g它們距離的越遠,

這兩項合起來就越大,

反之呢,

它們合起來就越小,

總之我們現在得到的結論就是,

如果今天我們找到一個最佳的d star,

帶進去以後,

我們得到的這個value啊,

它是負兩倍的log2,

加上兩倍的p data和p g的js divergence,

所以我們現在知道說,

假設我們認一個discriminator,

我們寫出了某一個objective function,

我們去maximize那個objective function以後,

我們得到的結果,

最後可以maximize那個objective function,

我們最後maximize的那個value,

其實就是p data跟p g的js divergence,

所以假設這邊的數學推導,

你沒有辦法跟上的話呢,

也沒有關係,

反正這邊想要告訴你的事情就是說,

當我們在train一個discriminator的時候,

我們想要做的事情是什麼?

當我們在train一個discriminator的時候,

我們想做的事情就是去evaluate,

p data跟p g這兩個distribution,

sample出來的data,

這兩個distribution,

它們之間的這個js divergence,

如果你今天定的這個objective function,

是跟前面的式子一樣的話,

你就是在量js divergence,

那等下會看到說,

如果把那個objective function寫的不一樣,

那你就可以量其他的各種不同的divergence,

那所以現在整個問題變成這個樣子,

我們本來是要找一個g,

它去minimize p g跟p data的divergence,

我們說後面這個式子,

你沒有辦法算,

但現在是可以算的,

後面這個式子到底是什麼呢?

後面這個式子到底是什麼呢?

後面這個式子就是,

我們今天寫出一個objective function,

v of t g,

找一個d去maximize這個式子,

它就是p g和p data之間的divergence,

所以我們現在就可以把divergence這一項,

用max這一項把它替換掉,

變成這個樣子,

所以我們現在要找一個generator,

它generate出來的東西,

跟你的data越接近越好,

你實際上要解這樣一個optimization的problem,

你要解一個minmax的problem,

這個optimization的problem裡面,

它有一個minimum,

它有一個maximum,

這個看起來非常的複雜,

這個非常的拗口,

你要找一個generator,

它要去minimize這一個式子,

在這個式子裡面,

它有一個discriminator,

要去maximize這個式子,

我知道說這個看起來非常的複雜,

它實際上做的事情,

像是以下這個例子所講的這樣,

假設世界上只有三個generator,

假設我們要選一個generator,

去minimize這個objective function,

我們現在可以選的generator,

總共只有三個,

一個是G1,

一個是G2,

一個是G3,

假設我們選了G1這個generator的話,

那V of G1D,

它長這個樣子,

假設你的generator固定是G1,

但是你的discriminator,

它可以是不同的discriminator,

我們假設discriminator,

它可以用一個參數來操控,

所以這個橫坐標在改變的時候,

代表你選擇了不同的discriminator,

但實際上是更複雜的狀況,

實際上discriminator是一個neural network,

它是由數百萬個參數所控制的,

它應該是分佈在一個高危的空間裡面,

不過這邊為了簡化問題,

我們就說,

假設當橫坐標變化的時候,

代表你選擇了不同的discriminator,

今天同樣的,

假設你的generator是G2,

你把G2帶進去,

你選擇不同的discriminator的時候,

你就得到了不同的V of G2D,

假設你的generator是G3,

你選擇不同的discriminator的時候,

你就得到不同的V of G3D,

我們接下來的問題是,

我們在給定一個generator的時候,

我們要找一個discriminator,

它可以讓V of GD最大,

假設我們現在固定我們的generator是G1的時候,

假設我們固定我們的generator是G1的時候,

那哪一個discriminator可以讓V of GD最大呢?

那個是落在這個這裡的discriminator,

可以讓V of G1D最大,

落在這裡的discriminator,

可以讓V of G2D最大,

落在這裡的discriminator,

可以讓V of G3D最大,

接下來我們要找一個G,

去minimize最大的discriminator可以找到的value,

這大家聽得懂嗎?

我們找一個G,

它可以最小化最大的discriminator得到的value,

找一個G,

它可以minimize這個V of GD,

用不同的最大的d可以達到的value,

這個時候,

假設我們的V of GD,

長得最像是下面這個例子的話,

那這個問題的solution,

最好的G,

到底應該是哪一個呢?

到底應該是哪一個呢?

給你十秒鐘的時間想一下,

剛才按投影片的時候已經不小心按到了,

所以你應該知道答案是什麼了,

好,十秒鐘的時間過了,

假設這是我們optimization的problem,

V of GD它就是長這個樣子,

我們現在要解這個optimization的problem,

哪一個G,

才是我們的solution呢?

哪一個G,

才是我們的solution呢?

你覺得,

就假設G現在只有三個,

你只有三個選擇,

所以你隨便猜,

你也有整個三分之一的正確率,

你覺得G1是正確選擇的同學舉手一下,

你覺得G1,

它可以minimize上面這個四個同學舉手一下,

假設你覺得G2可以minimize上面這個四個同學舉手一下,

你覺得G3可以minimize上面這個四個同學舉手一下,

好,手放下,

好,多數人都選擇G3,

沒錯,正確答案就是G3,

所以如果你選擇G3的話,

代表說你了解這個前面加min,後面又加max,

到底是什麼樣的意思,

好,那我們現在找出來的這個G star,

就是這個G3,

就是這個G3,

好,那這邊的每,

當我們給定一個G1的時候,

當我們給定一個G1的時候,

這邊這個G1,

D1 star的這個高,

其實就代表了G1的這個generator,

它所,

G1的這個generator,

它所generate出來的distribution,

跟P data之間的距離,

所以這個高,

就代表G2的這個generator,

它所定的distribution,

跟data之間的距離,

這個高,

就代表G3的這個generator,

它的distribution,

它之間的距離,

所以今天呢,

這個G1的這個generator,

它的divergence,

它跟那個data的divergence是這麼大,

G2它所定的distribution,

跟data之間的divergence是這麼大,

G3它所定的distribution,

跟data之間的divergence是這麼大,

那我們今天呢,

要minimize我們的divergence,

所以你會選擇G3呢,

當作是最好的結果。

好,那接下來呢,

我們就是要想辦法解這個minmax的problem,

那這個minmax的problem,

怎麼解呢?

你記得我們在講GAMES的時候,

我們說GAMES是怎麼做的?

GAMES是說,

我們有一個generator,

有一個discriminator,

然後我們在train的時候,

我們是iterative的去,

你去train generator跟discriminator,

我們固定住generator,

去update discriminator,

我們固定住discriminator,

接下來去update generator,

那如果以下等一下要講的東西,

你聽不太懂的話,

你就知道一件事情,

左邊的這個演算法,

就是在解這個minmax的problem,

在解這個minmax的problem,

為什麼要解這個minmax的problem,

解這個minmax的problem的目的,

就是要minimize你的generator,

跟你的data之間的jsdivergence,

如果你V寫成像之前的投影片,

放的那個樣子,

就是jsdivergence,

你可以寫別的樣子,

那你就是minimize其他的divergence,

那為什麼下面這一個algorithm,

是在解這一個optimization的problem呢?

那以下幾個投影片就是要解釋說,

為什麼這一個algorithm,

是在解這個optimization的problem,

我們來看看說,

假設你要解這個optimization的problem的話,

你要怎麼做?

那這個maxD,V of GD,

找一個D去maximize,

V of GD這個式子看起來有點複雜,

所以我們把它用LG來取代,

因為它其實跟D是沒有關係的,

你是give一個G,

反正你就會找到一個最好的D,

讓L of G的值越大越好,

所以讓這個V of GD的值越大越好,

那我們假設這個最大的值,

就是L of G,

那所以現在這整個問題就變成,

你要找一個最好的generator G,

它可以minimize L of G,

那這個問題,

任何人都會這樣,

它就是一個,

它就是跟train一般的network是一樣的,

就是用gradient descent來解它,

所以你用gradient descent來解它,

你對L of G,

算天維分,

你要算這個gradient,

你要找一個G,

去minimize L of G,

你把這個theta G,

算這個theta G對L of G的gradient,

然後用gradient descent去update theta G,

那你就可以minimize這一個式子,

你就可以optimize這一個optimization的problem,

找出你的G star,

但是現在有一個麻煩的地方就是,

這個L of G,

如果你把式子寫出來的話,

它長得是這個樣子的,

這個式子裡面是有max的,

那有人就會問說,

這個式子裡面有max,

它可以微分嗎?

會不會不能夠微分?

因為你今天要算這個L of G的gradient,

L of G這個式子裡面如果有max,

它會不會沒有辦法做微分?

其實不會,

因為你想想看,

我們之前在學的時候,

學到一個max out network,

max out network裡面也有max的operation,

但它顯然是有辦法用gradient descent解的,

那到底實際上是怎麼做的呢?

我們現在假設有一個function f of x,

它裡面是有max的operation的,

我們來看一下有max的operation的這種function,

你要怎麼對它做微分?

現在有一個f of x,

它裡面有max的operation,

它是對f1,f2和f3這三個function裡面,

找一個最大的出來,

它就是f of x,

那假設f1長這個樣子,

f2長這個樣子,

f3長這個樣子,

那今天這個f of x,

它是f1,f2,f3裡面取大的那個,

那f of x長什麼樣子呢?

f of x就是長這個樣子,

它就是取,

如果f1比f2,f3大的話就取f1,

如果f2比f1,f3都大的話就取f2,

如果f3是最大的話就取f3,

所以今天這個f of x,

它長的會是這個樣子,

就我滑鼠現在移動的位置,

它長的是這個樣子,

那如果你現在要把這個f of x,

對x做微分的話,

那其實這件事情等同於什麼呢?

這件事情等同於看看現在的x,

可以讓哪一個function,

f1,f2,f3最大,

就拿最大的那個出來算微分,

就是x對f的微分,

這樣可能有點抽象,

我們就舉很具體的例子,

現在假設你要在這個地方,

對f of x做微分,

那你算出來的微分值多少呢?

你算出來的微分就等同於是在對f1做微分,

那如果你在這個區域,

你算出來的微分就等同於是在對f2做微分,

如果你在這個區域,

你算出來的微分就等同於是在對f3做微分,

所以今天假如你的這個function裡面,

有一個max的operation,

實際上你在算微分的時候,

你只是看說現在在f1,f2,f3裡面哪一個人最大,

你就把最大的那個人拿出來算微分,

你就可以用gradient descent去optimize這樣的式子,

舉例來說假設你要用gradient descent,

去optimize這個f of x,

那實際上的做法就是說,

假設initialize的時候在這個地方,

算一下它的gradient就向右移,

而如果今天向右移的時候,

你已經移到了另外一個region,

本來是在這個region裡面是f1最大,

那跑到這邊以後就變成f2最大,

假設移到另外一個region,

這個region是f2最大,

這個時候你算出來的微分就會變成是f2的微分,

以此類推,以此類推,

總之就算是你的,

總之我們剛才講那麼多,

我只想要告訴你說,

就算是我們的objective function裡面,

有max的operation,

其實你也不需要害怕,

你一樣是可以對它做微分的,

你一樣是可以對它做微分的,

好,那所以就回到了我們現在要解的這個optimization problem,

那實際上你會怎麼解它呢?

我們剛才有講說,

如果一個optimization problem裡面,

你的loss function是有max的,

那你要怎麼解它呢?

你會先看說,

現在你落在哪一個region裡面,

再算說,

現在在那個region裡面,

哪一個function是max的,

對那個max的function做微分,

對不對?

你現在出事的地方在這個地方,

你就看說,

這個function它是最大的,

就對它做微分,

現在你update參數以後,

你要重新檢查一下,

你落在哪個region,

發現說你落在這個region,

落在這個中間這個f2這個function是最大的region,

那你就要對f2做微分,

所以今天呢,

把它套用到我們的這個要optimize的這個midmax problem裡面,

其實也是一樣的,

其實也是一樣的,

一開始我們有一個初始的G0,

我們有一個初始的G0,

然後接下來我們要算G0對L2G的gradient,

但是在算G0對L2G的gradient之前,

因為L2G裡面有max,

所以我們不知道L2G長什麼樣子,

所以我們要把max的d找出來,

所以我們假設說,

現在在基本G0的前提之下,

哪一個d可以讓L2G最大呢?

它是d0 star,

d0 star可以讓V of G0最大,

你就可以,

也就是說這個V of G0,

就如果我們今天這個d帶d0 star的話,

我們就可以得到這個L2G,

你這件事情你可以用gradient asset,

就可以找出這個d,

它可以maximize這個objective function,

找到d可以maximize這個objective function以後,

之後這個東西就是L2G了,

接下來你就可以把θG對這一項算gradient,

你就可以update你的參數,

你就得到新的generator G1,

你updateG的參數,

你就得到新的generator G1,

接下來你有新的generator G1以後,

你有了新的G1,

你就要重新找一下最好的d,

因為你可能已經,

本來你的region在這邊,

最好的d是這一個,

但是你現在移動你的G1以後,

你可能已經進入下一個region,

所以你要重新找一個最好的d,

所以現在我們把這個generator從G0,

update到G1,

可以讓這個V of G1最大的那個d,

假設是d1 star,

接下來你就有一個新的objective function,

它是V of G d1 star,

你再把它對generator算gradient,

再update你的generator,

你就得到G2,

所以這整個operation就是,

你有一個G,G0,

找一個可以讓V of G0 d最大的d0 star,

那你就得到了你的V的function,

然後讓它對G做微分,

然後再重新去找一個新的d,

再重新對你的objective function做微分,

你會發現說這整個process,

其實跟GAN是一模一樣的,

其實跟GAN是一模一樣的,

那你可以把它想成說,

現在在找這個d0 star,

去maximize這個objective function的process,

其實就是在量d star,

跟PG0的JS divergence,

當我們今天找到一個G1,

我們去找到一個d1 star,

它可以讓這個objective function值被maximize,

其實我們就是在計算,

Pdata跟PG1的JS divergence,

而下面這個式子,

我們說這一項,

它就是你的JS divergence,

那你要update你的generator,

去minimize你的JS divergence,

這個時候,

你其實就是在減少你的JS divergence,

就是在達成你的目標,

就是要去minimize你的JS divergence,

但是這邊呢,

我們打了一個問號,

這邊為什麼打一個問號呢?

因為這件事情,

未必等同於真的在minimizeJS divergence,

為什麼這麼說?

因為我們有說過說,

假設給你一個generator,

假設你的generator就是G0,

那你的V of G0D,

假設它長這個樣子,

你找到一個d0 star,

這個d0 star的值啊,

就是G0跟你的data之間的JS divergence,

但是當你今天update你的G0的時候,

當你今天update你的G0,

變成G1的時候,

這個時候呢,

這個V of G1D,

它的function可能就會變了,

本來V of G0D是這個樣子,

V of G0D0 star,

就是G0跟你的data的JS divergence,

但是今天你update你的G0,

變成G1,

這個時候你的整個function就變了,

這個時候因為你的G0 star仍然是固定的,

但是因為你的G0 star仍然是固定的,

所以你的V of G1D0 star,

它就不是在evaluate JS divergence,

我們說evaluate JS divergence的D呢,

是今天這個V of GD的這個值裡面呢,

最大的那一個,

最大的那一個,

所以今天當你的G變了,

你的這個function就變了,

當你的function變的時候,

同樣的D就不是在evaluate你的JS divergence,

如果在這個例子裡面,

JS divergence會變成是這個值,

而不是這個值,

而不是這個值,

那但是為什麼我們又說,

這一項可以看作是在減少JS divergence呢,

我們今天做的一個前提的假設就是,

這兩個式子可能是非常的像的,

假設你只update一點點的G,

從G0變到G1,

G的參數只動了一點點,

那這兩個function,

它們的長相可能是比較像的,

所以因為它們的長相仍是比較像的,

所以一樣用D0 star,

一樣用D0 star,

你仍然是在量JS divergence,

這樣子的情形就這邊本來值很小,

突然變很高的情形,

可能是不會發生的,

因為G0跟G1是很像的,

所以這兩個function應該是比較接近,

所以你可以同樣用固定的D0 star,

就可以evaluate G0跟G1的JS divergence,

所以今天在train這個game的時候,

它的tip就是,

因為你有這個假設,

就是G0跟G1應該是比較像的,

所以今天在train你的generator的時候,

你就不能夠一次update太多,

但是你在train你的discriminator的時候,

理論上你應該把它train到底,

應該把它update多次一點,

因為今天在量你的discriminator的時候,

你必須要找到maximum的值,

你才是在量JS divergence,

所以在traindiscriminator的時候,

你其實會需要比較多的iteration把它train到底,

但是generator的話,

你應該只要跑比較少的iteration,

免得今天你現在在這個投影片上講的假設,

是不成立的。

接下來我們來講一下,

實際上你在做game的時候,

你其實是這麼做的,

我們說我們的objective function裡面,

要對X取expectation,

但是在實際上,

你沒有辦法真的算expectation,

所以我們都是用sample來代替expectation,

所以本來是對pdata,

sampleX取它的expectation,

但實際上你在做的時候,

就是從pdata這個distribution裡面,

sampleM比data,

把這M比data的d of X統統算出來,

然後再把它統統平均起來,

就當作是expectation,

一樣,本來你要從pg裡面,

sampleX一對X出來算它expectation,

但在實作上你沒有辦法這麼做,

所以實作上你做的行為,

是從pg裡面sample出M比data,

再把這M比data,

都去計算它的log1減d of X delta,

然後把它全部平均起來,

你就得到正向的approximation,

所以實際上我們在做的時候,

我們就是在maximize這個式子,

而不是真的去maximize它的expectation,

而這個式子啊,

如果你回去檢查看看的話,

我們剛才也講過,

這件事情就等同於是在train一個binary的classifier,

所以今天在實作Gantt的時候,

它並不是一個,

你完全不需要用什麼你原來不知道的東西,

你在train discriminator的時候,

你就是在train一個binary的classifier,

所以實際上在做的時候是怎樣,

你的discriminator是一個binary的classifier,

這個binary classifier,

它是一個logistic regression,

就是它的output有接一個sigmoid,

所以它output的值是介於0到1之間的,

然後從pdata裡面你sampleM比data出來,

M比data就當作是positive sample,

或是class 1的example,

然後你從pg裡面再sample另外M比data出來,

這M比data就當作是negative sample,

就當作是class 2的example,

接下來就train你的binary classifier,

你train你的criterion,

你會minimize cross entropy,

你會發現說,

如果你在minimize cross entropy,

你把你的式子寫出來,

它會等同於上面maximize這個objective function,

minimize cross entropy,

等同於maximize上面這個objective function,

最後我們就再重新複習一次game的algorithm,

整個game的algorithm是這樣子,

我們有一個thetaD,

我們有一個thetaG,

這個是你initialize的parameter,

在每一個iteration裡面,

你做的事情是什麼,

你從pdata這個distribution裡面,

sampleM比example,

你從你的某一個quiet distribution,

它可以是gaussian distribution,

可以是normal distribution,

其實沒有那麼重要,

你就固定住某一個quiet distribution,

你從這個quiet distribution裡面,

去sample出M的vector,

這些vector用Z來表示,

根據這些vector Z,

你把它丟到generator裡面,

它會產生一堆image,

也就是x tilde,

所以你產生一堆x tilde,

這邊有一堆real的image,

你這邊有一堆generated image,

接下來你要train你的discriminator,

這個discriminator在training的時候,

它就是maximize下面這個objective function,

我們剛才有講過說,

maximize下面這個objective function,

其實就等同於,

直接train一個binary classifier,

把這邊的x當作是一類,

把這邊的x tilde當作是另外一類,

直接train一個binary classifier,

你的binary classifier是minimum cost entropy,

就是在maximize下面這個式子,

就是在maximize下面這個式子,

你train了一個discriminator出來,

我們之前有講過說,

我們traindiscriminator的目的是什麼,

是為了要evaluate jth divergence,

而什麼時候discriminator可以evaluate jth divergence,

當它可以讓你的v的值最大的時候,

discriminator才是在evaluate jth divergence,

你要讓v的值被maximize,

它才是在evaluate jth divergence,

為了要讓這個v的值最大,

你一定要train很多次,train到收斂為止,

它才能夠讓v的值最大,對不對,

那在實作上你沒有辦法真的train很多次,

train到收斂為止,

但是你會說,

我今天train這個d的時候,

我要反覆k次,

我這個參數要updatek次,

而不是像投影片上面只寫update一次而已,

你可能會update比如說三次或五次,

才停止。

好,那這個步驟是在解這個問題,

找一個d,它可以maximize v of gd,

但是其實你沒有辦法真的找到一個最好的d,

去maximize v of gd,

你能夠找的其實只是一個lower bound而已,

因為這邊你通常是在實作的時候,

你沒有辦法真的train到收斂,

你沒有辦法真的一直train d,

train到說你可以讓v of gd真的變得最大,

你通常就是train幾步,然後就停下來,

而就算我們退一萬步說,

你這邊你可以一直train到收斂,

你其實也未必真的能夠maximize這個objective function,

對不對,因為你在train的時候,

你的d的capacity並不是無窮大的,

你會蹭蹭蹭就卡在一個local minima,

然後就結束了,對不對,

所以你並不真的可以maximize這個式子,

然後再退一萬步說,

假設你沒有那個什麼local minima,

local maxima的問題,

你可以直接解這個問題,

你的d呢,它的capacity也是有限的,

你記得我們有說過說,

如果你要量js divergence,

我們一個假設是你的d可以是任何function,

但事實上你的d是一個network,

所以它也不可以,

它其實也不是任何function,

所以你沒有辦法真的maximize這一項,

你能夠找到的只是一個lower bound而已,

但我們就假設你其實可以maximize這一項就是了,

好,那接下來呢,

要train generator,

那我們說train discriminator的時候是為了量js divergence,

train generator的時候是為了要minimize js divergence,

為了要減少js divergence,

前面這個步驟是在量出js divergence,

接下來下一個步驟是在減少js divergence,

怎麼做呢,

你就從你的,

你就先一樣呢,

sample and vector出來,

然後接下來呢,

你就要解下面這個式子,

一樣,就我們說本來這個discriminator是要minimize這個式子嘛,

那generator呢,

要minimize一個一模一樣的式子,

但是下面這個式子裡面,

你會發現說第一項,

第一項呢,

跟generator呢,

是沒有關係的,

因為第一項只跟discriminator有關,

它跟generator沒有關係,

所以你要train你的generator去minimize這個式子的時候,

第一項呢,

你是可以不用考慮它的,

所以你把第一項拿掉,

只去minimize第二項的式子,

好,這個第二個步驟呢,

就是在train你的generator,

那我們剛才有講過說,

generator你不能夠train太多,

因為一旦你train太多的話,

你的discriminator就沒有辦法evaluatejs divergence,

所以你的generator不能train太多,

你只能夠少量的update它的參數而已,

所以通常你的generator,

這邊update一次就好,

所以你可以update discriminator很多次,

但是generator你update一次就好,

你用discriminator算出js divergence以後,

你只用generator少少的update一次,

讓你的js divergence變小,

但你不能走太多,

你update太多,

你量出來js divergence,

不對了,

你就不是在量js divergence,

所以這邊呢,

你就不能夠update太多,

好,那我們到目前為止,

我們講說,

今天在train generator的時候,

你要去minimize的式子,

長這個樣子,

那在Ian Gruffalo原始的paper裡面,

他從開篇,

從有game以來,