Generative Adversarial Networks (GAN) framework

4.5.6 · AI-ML › Generative Models

Overview

Generative Adversarial Networks (GANs) ek aisa framework hai jisme do neural networks ke beech ek adversarial process ke through generative models train kiye jaate hain: ek Generator jo fake samples banata hai aur ek Discriminator jo real aur fake mein fark karta hai. Yeh competitive training regime bahut hi realistic synthetic data produce karta hai.

Key insight yeh hai: humein explicitly specify karne ki zaroorat nahi ki "realistic" ka matlab kya hai. Discriminator yeh data se implicitly seekhta hai, aur competition Generator ko isse match karne par majboor karta hai.

The Two-Player Game Framework

1. Generator $G(z;{\theta }_g)$: Random noise $z\sim p_z(z)$ ko data space mein map karta hai, fake samples $G(z)$ produce karta hai
2. Discriminator $D(x;{\theta }_d)$: Input $x$ ko probability $[0,1]$ mein map karta hai ki $x$ real hai (generated nahi)

Yeh game: $G$ koshish karta hai $D$ ki error rate ko maximize karne ki, jabki $D$ use minimize karne ki koshish karta hai.

The Objective Function: First Principles Se Derive Karna

Starting Point: Hum kya chahte hain?

• $D$ real data ke liye 1 output kare, fake data ke liye 0
• $G$ $D$ ko fool kare taaki woh fake data ke liye 1 output kare

Step 1: $D$ ka goal probabilities use karke express karo

Real data $x\sim p_{data}(x)$ ke liye, hum chahte hain $D(x)\approx 1$. Log probability use karke (maximize hota hai jab $D(x)=1$): ${\mathbb{E}}_{x\sim p_{data}}[\log D(x)]$

Log kyun? Logarithm probabilities ko log-likelihoods mein convert karta hai, jo maximum likelihood estimation mein standard hai. Yeh numerical stability bhi deta hai aur 0.99→1.0 ko 0.01→0.1 se kam important treat karta hai.

Step 2: Fake data ke liye $D$ ka goal express karo

Fake data $G(z)$ ke liye jahan $z\sim p_z(z)$, hum chahte hain $D(G(z))\approx 0$, equivalently $1-D(G(z))\approx 1$: ${\mathbb{E}}_{z\sim p_z}[\log (1-D(G(z)))]$

Step 3: Dono objectives combine karo

$D$ dono maximize karna chahta hai, isliye: ${\max }_D\left[{\mathbb{E}}_{x\sim p_{data}}[\log D(x)]+{\mathbb{E}}_{z\sim p_z}[\log (1-D(G(z)))]\right]$

Step 4: $G$ kya chahta hai?

$G$ chahta hai $D$ ki success ko minimize kare, yaani us objective ko minimize kare jise $D$ maximize karta hai: ${\min }_G{\max }_D\left[{\mathbb{E}}_{x\sim p_{data}}[\log D(x)]+{\mathbb{E}}_{z\sim p_z}[\log (1-D(G(z)))]\right]$

Training objective hai: ${\min }_G{\max }_{D}V(G,D)$

Yeh ek minimax two-player game hai. Equilibrium par, $G$ aise samples generate karta hai jo real data se alag nahi pahchane ja sakte, aur $D$ har jagah $0.5$ output karta hai (maximum uncertainty).

Training Algorithm: Alternating Optimization

Kyunki hum minimax problem directly solve nahi kar sakte, hum alternating gradient descent use karte hain:

Alternating kyun? Agar hum dono ko simultaneously joint gradient descent se train karte, toh objectives conflict karte—ek ko improve karna doosre ke gradient signal ko kharab karta. Alternating allow karta hai ki har network doosre ki current state ke saath adapt ho sake.

Discriminator ke liye ($k$ steps):

$V(G,D)$ ko ${\theta }_d$ ke w.r.t. maximize karo: ${\nabla }_{{\theta }_d}V(G,D)={\mathbb{E}}_{x\sim p_{data}}\left[{\nabla }_{{\theta }_d}\log D(x)\right]+{\mathbb{E}}_{z\sim p_z}\left[{\nabla }_{{\theta }_d}\log (1-D(G(z)))\right]$

Practical computation:

1. Real data se minibatch $\{x^{(1)},\dots ,x^{(m)}\}$ sample karo
2. Noise $p_z$ se minibatch $\{z^{(1)},\dots ,z^{(m)}\}$ sample karo
3. Fakes generate karo: $\{{\tilde{x}}^{(1)},\dots ,{\tilde{x}}^{(m)}\}$ jahan ${\tilde{x}}^{(i)}=G(z^{(i)})$
4. Gradient ascent update: ${\theta }_d\leftarrow {\theta }_d+\alpha \cdot \frac{1}{m}{\sum }_{i=1}^m\left[{\nabla }_{{\theta }_d}\log D(x^{(i)})+{\nabla }_{{\theta }_d}\log (1-D({\tilde{x}}^{(i)}))\right]$

Multiple $k$ discriminator steps kyun? Training ke shuruaat mein, $G$ weak hota hai, isliye $D$ aasani se classify kar sakta hai. Hum chahte hain ki $G$ ko update karne se pehle $D$ near optimal ho, warna $G$ ko weak gradient signal milta hai.

Generator ke liye (1 step):

$V(G,D)$ ko ${\theta }_g$ ke w.r.t. minimize karo — equivalently, $-V(G,D)$ maximize karo: ${\nabla }_{{\theta }_g}(-V(G,D))=-{\mathbb{E}}_{z\sim p_z}\left[{\nabla }_{{\theta }_g}\log (1-D(G(z)))\right]$

Key Issue: Jab $G$ poor hota hai, $D(G(z))\approx 0$, isliye $\log (1-D(G(z)))\approx 0$ → flat gradients (vanishing gradient problem).

Solution: $\log (1-D(G(z)))$ minimize karne ki jagah, $\log D(G(z))$ maximize karo: ${\nabla }_{{\theta }_g}{\mathbb{E}}_{z\sim p_z}[\log D(G(z)]$

Yeh kyun kaam karta hai? Dono objectives ka same optimal point hai (jahan $D(G(z))=0.5$), lekin $\log D(G(z))$ mein jab $D(G(z))$ chhota hota hai toh stronger gradients hote hain. Jab $D$ confidently reject karta hai ($D\approx 0$), $-\log D$ bada gradient deta hai, strong learning signal provide karta hai.

Practical computation:

1. $p_z$ se minibatch $\{z^{(1)},\dots ,z^{(m)}\}$ sample karo
2. $\log D(G(z))$ par gradient ascent: ${\theta }_g\leftarrow {\theta }_g+\alpha \cdot \frac{1}{m}{\sum }_{i=1}^m{\nabla }_{{\theta }_g}\log D(G(z^{(i)}))$

Iteration t=1000:

1. Discriminator update ($k=5$ steps):

   • 64 real MNIST digits ka batch: $x^{(1)},\dots ,x^{(64)}$
   • $z^{(i)}\sim \mathcal{N}(0,I_{100})$ sample karo, fakes generate karo ${\tilde{x}}^{(i)}=G(z^{(i)})$
   • Reals ke liye $D(x^{(i)})$ compute karo, fakes ke liye $D({\tilde{x}}^{(i)})$
   • Loss: $L_D=-\frac{1}{64}{\sum }_{i=1}^{64}[\log D(x^{(i)})+\log (1-D({\tilde{x}}^{(i)}))]$
   • Backprop, $L_D$ minimize karne ke liye ${\theta }_d$ update karo ($V$ maximize karo)
   • 5 baar repeat karo Yeh step kyun? In updates ke baad, $D$ current $G$ outputs ko better discriminate kar sakta hai, meaningful feedback deta hai.

2. Generator update (1 step):

   • Fresh noise $z^{(1)},\dots ,z^{(64)}\sim \mathcal{N}(0,I_{100})$ sample karo
   • ${\tilde{x}}^{(i)}=G(z^{(i)})$ generate karo
   • $D({\tilde{x}}^{(i)})$ compute karo
   • Loss: $L_G=-\frac{1}{64}{\sum }_{i=1}^{64}\log D({\tilde{x}}^{(i)})$ (negative kyunki hum maximize karte hain)
   • $G$ aur $D$ dono ke through backprop karo (lekin sirf ${\theta }_g$ update karo)
   • $L_G$ minimize karne ke liye ${\theta }_g$ update karo D ke through backprop kyun? Gradient ${\nabla }_{{\theta }_g}D(G(z))$ ke liye $D$ ke forward pass ke through chain rule chahiye. Hum $\frac{\partial D}{\partial G(z)}\cdot \frac{\partial G(z)}{\partial {\theta }_g}$ compute karte hain.

Kai iterations ke baad: $G$ realistic digits produce karta hai, real aur fake dono ke liye $D(x)\approx 0.5$.

Epoch 10:

• $D(x_{real})$: 0.91 (confidently real)
• $D(G(z))$: 0.12 (confidently fake)
• Generated images: vague blob shapes

Yeh values kyun? $D$ ne aasani se discriminate karna seekh liya kyunki $G$ abhi bhi weak hai.

Epoch 50:

• $D(x_{real})$: 0.78
• $D(G(z))$: 0.31
• Generated images: digit-jaisi structures, lekin blurry

Values kyun giri? $G$ improve hua, $D$ ka kaam mushkil ho gaya. Arms race in action.

Epoch 200 (near convergence):

• $D(x_{real})$: 0.58
• $D(G(z))$: 0.54
• Generated images: sharp, realistic digits

0.5 ke kareeb kyun? Equilibrium par, $p_g=p_{data}$, isliye $D$ distinguish nahi kar sakta, maximum entropy (0.5) output karta hai.

Theoretical Properties

Fixed $G$ ke liye, optimal $D^{\ast }$ kya hai?

Woh functional jise hum $D$ ke upar maximize karte hain: $V(G,D)={\int }_x{p}_{data}(x)\log D(x)dx+{\int }_z{p}_z(z)\log (1-D(G(z)))dz$

Change of variables: $y=G(z)$ lo, induced distribution $p_g(y)$ ke saath: $V(G,D)={\int }_x{p}_{data}(x)\log D(x)dx+{\int }_x{p}_g(x)\log (1-D(x))dx$

Integrals combine karo: $V(G,D)={\int }_x\left[p_{data}(x)\log D(x)+p_g(x)\log (1-D(x))\right]dx$

Pointwise optimization: Har $x$ ke liye, maximize karo: $f(D(x))=p_{data}(x)\log D(x)+p_g(x)\log (1-D(x))$

$D(x)$ ke w.r.t. derivative lo aur zero set karo: $\frac{\partial f}{\partial D(x)}=\frac{p_{data}(x)}{D(x)}-\frac{p_g(x)}{1-D(x)}=0$

$D(x)$ ke liye solve karo: $p_{data}(x)(1-D(x))=p_g(x)D(x)$ $p_{data}(x)=D(x)[p_{data}(x)+p_g(x)]$ $D^{\ast }(x)=\frac{p_{data}(x)}{p_{data}(x)+p_g(x)}$

Interpretation: Optimal $D$ Bayes-optimal probability output karta hai ki $x$ real hai. Jab $p_g=p_{data}$, hame $D^{\ast }=0.5$ har jagah milta hai.

Global optimum par jahan $p_g=p_{data}$: $V(G^{\ast },D^{\ast })={\mathbb{E}}_{x\sim p_{data}}[\log 0.5]+{\mathbb{E}}_{x\sim p_{data}}[\log 0.5]=-2\log 2$

Yeh Jensen-Shannon Divergence se connect hota hai: $JSD(p_{data}\Vert p_g)=\frac{1}{2}KL(p_{data}\Vert \frac{p_{data}+p_g}{2})+\frac{1}{2}KL(p_g\Vert \frac{p_{data}+p_g}{2})$

GAN objective ko rewrite kiya ja sakta hai: ${\min }_{G}V(G,D_G^{\ast })=-\log 4+2\cdot JSD(p_{data}\Vert p_g)$

JSD kyun? GAN objective minimize karna Jensen-Shannon divergence ko real aur generated distributions ke beech minimize karne ke equivalent hai. JSD symmetric aur bounded $[0,\log 2]$ hai, aur 0 sirf tab reach karta hai jab distributions identical hoon.

Common Training Challenges

Yeh sahi kyun lagta hai: $G$ ke perspective se, agar $G(z)$ $D$ ko fool kar le, toh yeh success lagta hai. Doosre modes explore kyun karo?

Problem: $G$ saare noise vectors ko ek single output (ya chhote subset) par map kar deta hai. Example: faces generate karte waqt, saare outputs ek hi face hote hain thodi variations ke saath. Generator $p_{data}$ ke kuch modes par "collapse" ho jaata hai bajaaye saare modes cover karne ke.

Root cause: Minimax objective sirf require karta hai ki $G$ average par $D$ ko fool kare, poori data distribution cover karne ki zaroorat nahi. Agar $D$ repetition detect karne mein weak hai, $G$ iska faayda uthata hai.

Detection: Generated samples ki diversity monitor karo. Inception Score jaisi metrics compute karo ya measure karo ki multiple alag $z$ values nearly identical $G(z)$ produce karte hain ya nahi.

Fix strategies:

• Minibatch discrimination: $D$ ko ek saath multiple samples dikhao, diversity ki kami detect karo
• Unrolled GANs: $G$ ko future $D$ updates consider karke update karo, exploitation discourage karo
• Multiple GANs: Ensemble train karo, har ek alag modes capture kare

Yeh sahi kyun lagta hai: Supervised learning mein, loss typically monotonically decrease hota hai. Hum similar behavior expect karte hain.

Problem: $G$ aur $D$ losses wildly oscillate karte hain, kabhi stabilize nahi hote. Ek network ka improvement doosre ka degradation hai. System kabhi equilibrium nahi paata.

Root cause: GANs ek single loss function optimize nahi karte—woh ek minimax game solve kar rahe hain. Game dynamics converge karne ki jagah cycle kar sakti hain. Gradient field mein rotational components hote hain, purely conservative nahi.

Analogy: $(G,D)$ ko coordinates ke roop mein socho. Standard optimization ek valley mein minimum ki taraf descend karta hai. GAN optimization do magnets ki tarah hai jo repel kar rahe hain—trajectories indefinitely orbit kar sakti hain.

Detection: $D$ loss aur $G$ loss ko time ke saath plot karo. Monotonic trends ki jagah periodic oscillations dekho.

Fix strategies:

• Careful learning rates: Lower rates oscillation amplitude reduce karte hain
• Gradient penalty (WGAN-GP): $D$ ko bounded gradients rakhne ke liye regularize karo, training stabilize karo
• Spectral normalization: $D$ ka Lipschitz constant constrain karo, smooth gradient flow
• Two-timescale update rule (TUR): $G$ aur $D$ ke liye alag learning rates

Yeh sahi kyun lagta hai: Supervised learning mein zyada training usually help karti hai.

Problem: Jab $D$ bahut jaldi bahut strong ho jaata hai, woh real aur fake ko perfectly separate kar leta hai ($D(x_{real})\approx 1$, $D(G(z))\approx 0$). Phir $\log (1-D(G(z)))\approx 0$, $G$ ko near-zero gradients deta hai. $G$ seekhna band kar deta hai—arms race stall ho jaata hai.

Mathematically kyun: $\frac{\partial }{\partial {\theta }_g}\log (1-D(G(z)))$ mein $\frac{\partial D}{\partial G(z)}$ involve hota hai. Jab $D(G(z))\approx 0$, $G(z)$ mein chhote changes $D$ ke output ko change nahi karte (woh 0 par saturate hai), isliye gradient vanish ho jaata hai.

Fix: Non-saturating objective ${\max }_G{\mathbb{E}}_z[\log D(G(z))]$ use karo ${\min }_G{\mathbb{E}}_z[\log (1-D(G(z))]$ ki jagah. Yeh strong gradients deta hai even jab $D$ confident ho.

Verification: Jab $D(G(z))=0.01$:

• Original: $\nabla \log (1-0.01)=\nabla (-0.01005)\approx -0.01$ (tiny)
• Non-saturating: $\nabla \log (0.01)=\nabla (-4.605)\approx 100\times$ bada gradient

Architectural Considerations

1. Pooling ki jagah strided convolutions use karo ($D$ mein) aur fractional-strided convolutions ($G$ mein)

   • Kyun? Pooling spatial information deterministically lose kar deta hai. Strided convs downsampling seekhte hain, poore network mein gradients dete hain.

2. Dono $G$ aur $D$ mein batch normalization use karo

   • Kyun? Layer inputs normalize karta hai, mode collapse prevent karta hai by ensuring activations saturate nahi karti
   • Exception: $G$ ke output layer ya $D$ ke input layer mein use mat karo (raw data/generation scale preserve karo)

3. Deeper architectures ke liye fully connected hidden layers hata do

   • Kyun? Fully connected layers mein bahut bade parameter counts hote hain, train karna mushkil hota hai. All-convolutional spatial structure use karta hai.

4. $G$ mein ReLU use karo (output ke alawa: tanh), $D$ mein LeakyReLU

   • Kyun? ReLU $G$ mein gradients flow karne mein help karta hai. $D$ mein LeakyReLU dead neurons prevent karta hai (negative inputs ke liye zero gradient avoid karta hai).

5. Generator output: tanh activation use karo

   • Kyun? Normalized input range $[-1,1]$ se match karta hai agar data is range mein scale kiya gaya ho. Bounded output training stabilize karta hai.

Connections to Other Concepts

Related Topics:

• Variational Autoencoders (VAE): Explicit likelihood ke saath alternative generative model
• Maximum Likelihood Estimation: GANs implicitly divergence minimize karte hain, MLE se related
• Kullback-Leibler Divergence: Distribution matching mein KL vs. JS divergence
• Backpropagation: ${\nabla }_{{\theta }_g}D(G(z))$ compute karne ke liye zaroori
• Nash Equilibrium: GAN training do-player game ka Nash equilibrium dhundhta hai
• Discriminative vs Generative Models: GANs generative hain, ek discriminative component use karte hain
• Convolutional Neural Networks: DCGAN conv architectures use karta hai
• Mode Collapse Solutions: GAN coverage improve karne ke techniques

Upstream Dependencies:

• Neural Network Basics
• Gradient Descent Optimization
• Cross-Entropy Loss

Downstream Applications:

• Image Synthesis with GANs
• Style Transfer
• Data Augmentation with GANs
• Conditional GANs (cGAN)
• Waserstein GAN (WGAN)

Order matters: Pehle D train karo (use current G seekhne do), phir updated D ko beat karne ke liye G improve karo.

Objective mnemonic: "Real-log-Real, Fake-log-NOT-fake"

• Real samples: $\log D(x)$ — chahte hain $D$ 1 ke kareeb ho
• Fake samples: $\log (1-D(G(z)))$ — chahte hain $D$ 0 ke kareeb ho (toh $1-D$ 1 ke kareeb ho)

Flashcards

#flashcards/ai-ml

GAN mein do neural networks kaunse hain aur har ek kya karta hai? :: Generator $G$ random noise $z$ se fake samples banata hai. Discriminator $D$ inputs ko real (data se) ya fake ($G$ se) classify karta hai. Woh compete karte hain: $G$ koshish karta hai $D$ ko fool karne ki, $D$ koshish karta hai fakes detect karne ki.

Poora GAN minimax objective function likho :: ${\min }_G{\max }_{D}V(G,D)={\mathbb{E}}_{x\sim p_{data}}[\log D(x)]+{\mathbb{E}}_{z\sim p_z}[\log (1-D(G(z)))]$. Discriminator maximize karta hai (real par high probability chahiye, fake par low), Generator minimize karta hai (discriminator ko fool karna chahta hai).

GANs mein non-convergence problem kya hai? :: $G$ aur $D$ losses bina stabilize hue oscillate karte hain. Single loss wali supervised learning ki tarah nahi, GANs ek minimax game solve karte hain—ek ka improvement doosre ka degradation hai. Gradient field mein rotational components hote hain, fixed point par convergence ki jagah orbiting hoti hai.

Concept Map