Deep Learning

अब हम GAN (Generative Adversarial Network) के दो सबसे महत्वपूर्ण components की तुलना करेंगे:
🎭 Generator vs Discriminator
ये दोनों एक-दूसरे के विरोधी हैं, लेकिन साथ में मिलकर GAN को powerful बनाते हैं।

---

🔶 1. GAN का मूल विचार (Core Idea)

GAN architecture में दो models होते हैं:

1. Generator (G) — नकली data बनाता है
2. Discriminator (D) — बताता है कि data असली है या नकली

इन दोनों models का उद्देश्य होता है एक-दूसरे को beat करना।
👉 यही competition GAN को smart और creative बनाता है।

---

🧠 2. Role of Generator (G)

Feature	Description
🛠️ काम	Random noise से synthetic data generate करता है
🎯 Goal	इतना realistic data बनाना कि Discriminator उसे पहचान ना सके
🔄 Input	Random vector z∼N(0,1)
📤 Output	Fake image / data sample G(z)
🧠 सीखता है	कैसे असली data की नकल की जाए

“Generator एक कलाकार है — जो नकली चित्र बनाता है।”

---

🔧 Example:

z = torch.randn(64, 100)  # Random noise
fake_images = generator(z)  # Generated samples

---

🧠 3. Role of Discriminator (D)

Feature	Description
🛠️ काम	Real और fake data में भेद करना
🎯 Goal	सही-सही पहचानना कि data असली है या नकली
🔄 Input	Data sample (real or fake)
📤 Output	Probability: Real (1) या Fake (0)
🧠 सीखता है	असली और नकली data के अंतर

“Discriminator एक जज है — जो असली और नकली पहचानता है।”

---

🔧 Example:

real_score = discriminator(real_images)      # Output close to 1
fake_score = discriminator(fake_images)      # Output close to 0

---

🔁 4. GAN Training Dynamics

चरण	विवरण

1️⃣ Generator एक नकली image बनाता है

Generator random noise vector z∼N(0,1)को लेकर fake image G(z) produce करता है।

2️⃣ Discriminator असली और नकली दोनों samples पर prediction करता है

Discriminator को एक batch असली data x और fake data G(z)का मिलता है, और वह predict करता है कि कौन सा sample असली है और कौन नकली।

3️⃣ Discriminator की loss को minimize किया जाता है

Discriminator को train किया जाता है ताकि वह असली samples को 1 और नकली samples को 0 classify कर सके (binary classification)।

4️⃣ अब Generator की बारी है — वो अपनी trick और smart बनाता है

Generator को train किया जाता है ताकि उसका fake output ऐसा हो कि Discriminator उसे “real” समझे। यानी वह Discriminator की prediction को गलत करने की कोशिश करता है।

5️⃣ यह process बार-बार दोहराई जाती है (adversarial loop)

इस adversarial game में दोनों models better होते जाते हैं। Generator बेहतर fake samples बनाता है, और Discriminator उन्हें पकड़ने में तेज़ होता है।

👉 इस loop से दोनों models बेहतर होते जाते हैं।

---

⚔️ 5. Comparison Table

Feature	Generator (G)	Discriminator (D)
उद्देश्य	नकली data बनाना	असली और नकली में अंतर करना
Input	Noise vector z	Data sample x
Output	Fake sample (image, text, etc.)	Probability (real or fake)
Target	Discriminator को धोखा देना	Generator को पकड़ना
Learns from	Discriminator के feedback से	Real vs fake examples से
Neural Net Type	Generator network (decoder जैसा)	Classifier network (binary)

---

📊 Visualization

Noise (z)
   ↓
[ Generator ]
   ↓
Fake Data ───► [ Discriminator ] ◄─── Real Data
                    ↓
          Predicts: Real or Fake?

---

📝 Practice Questions

1. Generator और Discriminator में क्या अंतर है?
2. Generator क्या generate करता है और किस input से?
3. Discriminator क्या predict करता है?
4. GAN training में दोनों networks एक-दूसरे से कैसे सीखते हैं?
5. GAN में कौन-सा component output generate करता है?

---

🧠 Summary

Component	काम	लक्ष्य
Generator	नकली data बनाना	Discriminator को धोखा देना
Discriminator	Real/Fake पहचानना	Fake को पकड़ना
मिलकर	GAN training को एक game में बदलते हैं	Realistic data synthesis

अब हम deep learning की सबसे क्रांतिकारी और रचनात्मक तकनीक को समझने जा रहे हैं —
🎭 Generative Adversarial Networks (GANs)

यह deep learning का एक ऐसा क्षेत्र है जो machines को नई चीजें “create” करना सिखाता है — जैसे इंसानों की तरह तस्वीरें बनाना, आर्टिफिशियल आवाज़ें, नए फैशन डिज़ाइन, और यहां तक कि पूरी दुनिया की नक़ल करना।

🔶 1. What is a GAN?

GANs एक तरह का generative model है जो deep learning का उपयोग करके नई data instances generate करता है।
GAN architecture में दो neural networks होते हैं जो एक-दूसरे के खिलाफ (adversarial) train होते हैं:

🎯 “एक network generate करता है, दूसरा उसे judge करता है।”

---

🔁 2. GAN Structure

        Noise (z)
           ↓
     [Generator Network]
           ↓
      Fake Data (x̂)
           ↓
     [Discriminator Network]
     ↑            ↓
 Real Data (x)   Real or Fake?

---

🔹 Generator (G):

• Random noise से fake data generate करता है
• इसका उद्देश्य है Discriminator को धोखा देना

🔹 Discriminator (D):

• असली और नकली data के बीच अंतर करने की कोशिश करता है
• इसका उद्देश्य है fake data को पकड़ना

---

🧠 3. Game Between Generator and Discriminator

• Generator चाहता है कि Discriminator को धोखा दे
• Discriminator चाहता है कि वो सही-सही असली और नकली data पहचान ले

👉 इसे कहा जाता है minimax game:

---

🔬 4. क्यों GANs ख़ास हैं?

Feature	Description
🎨 Creativity	नई images, art, music बना सकते हैं
🧠 Learning	Unsupervised (no labels)
🎯 High-Quality Output	Extremely realistic images
🏆 Competition	Generator vs Discriminator improves quality

---

🔧 5. PyTorch GAN Skeleton (Basic Idea)

# Generator
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(100, 128),
            nn.ReLU(),
            nn.Linear(128, 784),
            nn.Tanh()
        )

    def forward(self, z):
        return self.net(z)

# Discriminator
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.net(x)

---

📊 6. Real-World Applications of GANs

Area	Example
🎨 Art & Design	नई paintings, filters
👨‍🎨 DeepFake	Face swap, video editing
🖼️ Super-Resolution	Low-res → High-res images
🧪 Healthcare	Synthetic medical data
🎮 Gaming	Environment generation
🌎 Simulation	Virtual world synthesis
🧑‍🏫 Data Augmentation	Synthetic training data

---

📝 Practice Questions:

1. GAN क्या होता है और इसमें कौन-कौन से components होते हैं?
2. Generator और Discriminator का क्या रोल होता है?
3. GAN का objective function क्या है?
4. GANs किस-किस क्षेत्र में उपयोग किए जा रहे हैं?
5. GAN training को unstable क्यों कहा जाता है?

---

🧠 Summary

Concept	Description
GAN	Generative Adversarial Network
Generator	Fake data create करता है
Discriminator	Fake और real में अंतर करता है
Output	Synthetic but realistic data
Use Cases	Image generation, deepfake, super-resolution, etc.

अब हम Autoencoders के दो प्रायोगिक उपयोगों (applications) को विस्तार से समझेंगे —
🔹 Denoising
🔹 Dimensionality Reduction

ये दोनों real-world problems में बहुत उपयोगी हैं और deep learning की शक्ति को बख़ूबी दर्शाते हैं।

---

🔶 1. Application 1: Denoising Autoencoder

❓ What is it?

Denoising Autoencoder (DAE) एक ऐसा Autoencoder है जो noisy input को clean output में बदलना सीखता है।

🎯 “Input को जानबूझकर corrupt किया जाता है और model को सिखाया जाता है कि वह clean version reconstruct करे।”

---

📦 Working:

   Original Image (x)
         ↓ Add Noise
     Noisy Input (x̃)
         ↓
     [Encoder + Decoder]
         ↓
   Clean Output (x̂)

Model learns to minimize:

---

🔧 Example in PyTorch:

def add_noise(imgs, noise_factor=0.3):
    noisy_imgs = imgs + noise_factor * torch.randn_like(imgs)
    return torch.clip(noisy_imgs, 0., 1.)

You then train autoencoder with (noisy_img, original_img) pairs.

---

🧠 Use Cases:

Use	Description
🖼️ Image Denoising	Remove noise from pictures
📄 Document Cleanup	Clean scanned papers
📢 Audio Denoising	Remove background noise
🧠 Medical	Remove sensor noise in ECG, MRI, etc.

---

🔶 2. Application 2: Dimensionality Reduction

❓ What is it?

Autoencoder compresses high-dimensional data into a low-dimensional latent representation, similar to PCA (Principal Component Analysis) — but with non-linear capabilities.

🎯 “Autoencoder = Non-linear, trainable PCA”

---

📦 Example:

| Input | 784-dim vector (28×28 image)
| Encoder | Reduces it to 2D or 3D latent code
| Decoder | Reconstructs full image
| Output | Use latent codes for clustering, visualization, etc.

---

🔧 PyTorch Sketch:

# Encoder output is just 2D
self.encoder = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Linear(128, 2)  # 2D Latent Space
)

---

🧠 Use Cases:

Use	Description
📊 Data Visualization	Compress to 2D for t-SNE / plots
🔍 Clustering	Group similar inputs (e.g., digits, faces)
⚡ Fast Inference	Work on lower-dimensional features
📈 Feature Extraction	Use compressed codes for ML models
🎮 Game AI	Compress game states

---

📝 Practice Questions:

1. Denoising Autoencoder क्या है और कैसे काम करता है?
2. Noise हटाने के लिए Autoencoder को कैसे train किया जाता है?
3. Dimensionality reduction में Autoencoder और PCA में क्या अंतर है?
4. Latent space का क्या role है?
5. Low-dimensional representation किन real-world problems में काम आता है?

---

📌 Summary

Application	Input	Output	Benefit
Denoising	Noisy image	Clean image	Noise removal
Dimensionality Reduction	High-dim data	Low-dim features	Visualization, clustering, compression

अब हम Autoencoders की एक शक्तिशाली और probabilistic form को समझेंगे —
🔮 Variational Autoencoders (VAE)
जो deep generative models की दुनिया में एक foundation की तरह माने जाते हैं।

---

🔶 1. What is a Variational Autoencoder?

VAE एक तरह का Autoencoder है, जो ना केवल input को compress करता है,
बल्कि उसे एक probability distribution में encode करता है।

🎯 “VAE compress करता है input को एक distribution के रूप में, जिससे हम new data generate कर सकते हैं।”

---

🧠 2. Traditional Autoencoder vs VAE

Feature	Autoencoder	Variational Autoencoder
Output	Reconstruct input	Reconstruct + Sample new
Latent Vector	Fixed values	Probability distribution
Generation	No	Yes (Generative model)
Learning	Deterministic	Probabilistic
Regularization	None	KL Divergence

---

🔬 3. VAE Structure

Diagram:

        Input x
           ↓
       [Encoder Network]
           ↓
  Latent Distribution (μ, σ)
           ↓
     Sampling (z ~ N(μ, σ))
           ↓
       [Decoder Network]
           ↓
     Reconstructed x̂

---

🧮 4. Latent Distribution

VAE encoder predicts:

• Mean vector μ
• Log-variance log⁡σ2

From these, we sample latent variable

👉 इसे कहते हैं reparameterization trick
ताकि gradient backpropagation संभव हो।

---

🧮 5. VAE Loss Function

VAE का कुल loss दो हिस्सों से मिलकर बनता है:

L=Reconstruction Loss+ KL Divergence Loss

✅ Reconstruction Loss:

✅ KL Divergence Loss:

---

🔧 6. PyTorch Sketch

class VAE(nn.Module):
    def __init__(self, input_dim, hidden_dim, latent_dim):
        super(VAE, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.mu = nn.Linear(hidden_dim, latent_dim)
        self.log_var = nn.Linear(hidden_dim, latent_dim)
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()
        )

    def encode(self, x):
        h = F.relu(self.fc1(x))
        return self.mu(h), self.log_var(h)

    def reparameterize(self, mu, log_var):
        std = torch.exp(0.5 * log_var)
        eps = torch.randn_like(std)
        return mu + eps * std

    def forward(self, x):
        mu, log_var = self.encode(x)
        z = self.reparameterize(mu, log_var)
        return self.decoder(z), mu, log_var

---

📊 7. Applications of VAE

Application	Description
✅ Image Generation	New samples create करना
✅ Data Imputation	Missing values भरना
✅ Representation Learning	Compressed features
✅ Anomaly Detection	Rare patterns पकड़ना
✅ Drug Design	Molecule generation

---

🎨 8. Generated Sample Example (MNIST)

Train VAE on MNIST, then sample new digits by:

z = torch.randn(1, latent_dim)
generated = model.decoder(z)

👉 ऐसा output real handwritten digit जैसा दिखेगा, despite not being in the original dataset.

---

📝 Practice Questions:

1. VAE क्या है और Autoencoder से कैसे अलग है?
2. Latent vector के लिए reparameterization क्यों ज़रूरी है?
3. VAE का loss function किन भागों में बँटा होता है?
4. KL divergence का क्या उद्देश्य होता है?
5. VAE से synthetic data कैसे generate किया जाता है?

---

🎯 Summary

Feature	Description
VAE	Probabilistic autoencoder
Encoder Output	μ और σ (mean & std)
Sampling	z = μ + σ * ε
Loss	Reconstruction + KL divergence
Use Cases	Generation, anomaly detection, compression

अब हम Deep Learning की सबसे शक्तिशाली और बहुप्रयुक्त संरचना को विस्तार से समझते हैं —
🔁 Encoder-Decoder Structure
जिसका उपयोग NLP, Image Captioning, Machine Translation, Autoencoders आदि में बड़े पैमाने पर किया जाता है।

---

🔶 1. What is the Encoder-Decoder Architecture?

Encoder-Decoder एक ऐसा framework है जिसमें model दो मुख्य भागों में बँटा होता है:

1. Encoder: Input data को एक compact और meaningful representation (context vector या latent vector) में बदलता है।
2. Decoder: उसी compact representation से नया output sequence या data generate करता है।

🎯 “Encoder compress करता है, Decoder expand करता है।”

---

🧱 2. Structural Flow

 Input Sequence / Data
                  ↓
              [Encoder]
                  ↓
           Latent Representation
                  ↓
              [Decoder]
                  ↓
            Output Sequence / Data

---

🔄 3. Encoder-Decoder is a General Pattern

Use Case	Input	Output	Encoder-Decoder
Translation	English sentence	French sentence	✅
Image Captioning	Image features	Text sentence	✅
Autoencoder	Image	Reconstructed image	✅
Chatbot	User query	Response	✅
Speech-to-text	Audio	Text	✅

---

🔧 4. Components of Encoder-Decoder

🔹 Encoder:

• Sequence of layers (CNNs, RNNs, Transformers, etc.)
• Learns to encode features from input
• Outputs context/latent vector: h=f(x)

🔹 Decoder:

• Takes the latent vector as input
• Generates output step-by-step (esp. in sequence models)
• Uses:

---

🧠 5. Why Use Encoder-Decoder?

Advantage	Description
✅ Generalizable	Works for images, text, audio
✅ Flexible	Input/output length may differ
✅ Modular	Encoder & Decoder can be designed separately
✅ Reusability	Encoder can be shared across tasks

---

🧪 6. Variants of Encoder-Decoder

Type	Example	Domain
CNN-CNN	Autoencoders	Vision
CNN-RNN	Image Captioning	Vision + NLP
RNN-RNN	Machine Translation	NLP
Transformer-Transformer	BERT, T5	NLP
ViT-GPT	BLIP, Flamingo	Vision+Language

---

🔧 PyTorch Skeleton Example

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, hidden_dim)

    def forward(self, x):
        return self.linear(x)

class Decoder(nn.Module):
    def __init__(self, hidden_dim, output_dim):
        super().__init__()
        self.linear = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        return self.linear(x)

# Sample use
encoder = Encoder(784, 128)
decoder = Decoder(128, 784)

x = torch.randn(1, 784)
latent = encoder(x)
output = decoder(latent)

---

📝 Practice Questions:

1. Encoder-Decoder structure क्या होता है?
2. इसका प्रयोग किन किन क्षेत्रों में होता है?
3. Encoder और Decoder के कार्य में क्या अंतर है?
4. Autoencoder और Sequence-to-Sequence में ये संरचना कैसे लागू होती है?
5. Encoder-Decoder में latent representation क्या है?

---

📌 Summary

Component	Function
Encoder	Input को compact form में बदलता है
Latent Vector	Input का encoded meaning
Decoder	Latent vector से output generate करता है
Uses	Translation, Captioning, Chatbots, etc.