مین مواد پر جائیں

Chapter 28: GANs aur Deep Learning Capstone Mini Project

MODULE 5 | WEEK 28​

Chapter 28: GANs aur Deep Learning Capstone Mini Project​

Ab tak ke tamam models pehchante ya andaza lagate the (classification, regression). Generative models ek qadam aage jate hain: wo bilkul naya data banate hain jo asli jaisa lagta hai (nayi tasveerein, awaaz, text). Is chapter me hum GAN (Generative Adversarial Network) seekhenge: do networks ka muqabla jo ek doosre ko behtar banata hai. Phir Module 5 ka Capstone Mini Project karenge, jis me tum ne jo kuch seekha (ANN, CNN, regularization, evaluation) wo ek mukammal project me jode jayenge.

28.1 Generative models kya hote hain?​

QismSawal jo hal karta haiMisaal
DiscriminativeYe input kis class ka hai? (y ko x se jodta hai)Ye tasveer billi hai ya kutta?
GenerativeIs class jaisanayadata kaise banaun?Naye chehre, nayi tasveerein, nayi dhun

Autoencoder (VAE) ek generative model ban sakta hai (Chapter 27). GAN isi maqsad ka ek alag aur bohat mashhoor tareeqa hai, jis ne 2014 me Ian Goodfellow ke paper se shuruat ki.

28.2 GAN ka idea: Jaali note aur Police​

Loss aur training ke qadam​

Har iteration me do kaam baari baari :

  1. D ko train karo: asli data ke liye target 1 , G ke banaye fake ke liye target 0 (Binary Cross-Entropy).

  2. G ko train karo: fake data D ko dikhao aur target 1 rakho (G chahta hai D use asli samjhe). Is waqt D ke weights nahi badalte , sirf G ke.

D ka loss: -[ log D(asli) + log(1 - D(G(z))) ] <- D ise kam karna chahta hai
G ka loss: -log D(G(z)) <- G ise kam karna chahta hai
(non-saturating)

28.3 NumPy me asli chhota GAN (1D)​

GAN ki jaan samajhne ke liye hum sab se saada GAN banate hain, jis ka data sirf ek number hai. Asli data: Normal distribution (mean = 4, std = 1.25). Generator:

x = a*z + b

(do parameters), jahan z standard normal noise hai. Discriminator: ek chhota logistic model jo x aur x^2 dekhta hai. G ko seekhna hai ke a = 1.25 aur b = 4 hone chahiye, magar usay ye kabhi bataya nahi jata , wo sirf D ke ishare se seekhta hai.

import numpy as np
import matplotlib.pyplot as plt
def sigmoid(s):
return 1 / (1 + np.exp(-s))
def feats(x):
return np.stack([x, x ** 2], axis=1) # D ke features
rng = np.random.RandomState(0)
REAL_MEAN, REAL_STD = 4.0, 1.25
a, b = 1.0, 0.0 # Generator:
x = a*z + b (shuru me bura)
w, c = np.zeros(2), 0.0 # Discriminator:
D(x) = sigmoid(w . [x, x^2] + c)
lr_d, lr_g, batch = 0.05, 0.02, 64
history = []
for step in range(6000):
# ---------- 1) Discriminator ko train karo ----------
real = rng.normal(REAL_MEAN, REAL_STD, batch)
fake = a * rng.randn(batch) + b
D_real, D_fake = sigmoid(feats(real) @ w + c), sigmoid(feats(fake) @ w + c)
grad_w = ((D_real - 1)[:, None] * feats(real)).mean(axis=0) + (D_fake[:, None] *
feats(fake)).mean(axis=0)
grad_c = (D_real - 1).mean() + D_fake.mean()
w -= lr_d * grad_w
c -= lr_d * grad_c
# ---------- 2) Generator ko train karo (D ke weights band) ----------
z = rng.randn(batch)
fake = a * z + b
D_fake = sigmoid(feats(fake) @ w + c)
dL_dx = -(1 - D_fake) * (w[0] + 2 * w[1] * fake) # -log D(G(z)) ka gradient
a -= lr_g * (dL_dx * z).mean()
b -= lr_g * dL_dx.mean()
history.append((a, b))
history = np.array(history)
last = history[-1000:]
print("Asli data : mean =", REAL_MEAN, " std =", REAL_STD)
print("Aakhri 1000 qadam me G ka (a, b) ka average:", last.mean(axis=0).round(2))
gen = history[-1, 0] * rng.randn(10000) + history[-1, 1]
print("Generator ke 10000 samples: mean =", gen.mean().round(2), " std =",
gen.std().round(2))
OUTPUT​
Asli data : mean = 4.0 std = 1.25
Aakhri 1000 qadam me G ka (a, b) ka average: [1.28 3.38]
Generator ke 10000 samples: mean = 3.86 std = 1.03

G ne bina asli parameters dekhe sirf D ke ishare se data banana seekh liya: generated data ka mean taqreeban 3.9 (asal 4) aur std taqreeban 1.0 (asal 1.25) aaya. Mukammal nahi, magar asli ke qareeb. Dekhte hain ke training ke dauran a aur b ne kaise safar kiya, aur aakhir me generated aur asli data ki shakal:

fig, axes = plt.subplots(1, 2, figsize=(10, 3.6))
axes[0].plot(history[:, 1], color="#6B5B95", lw=1, label="b (mean)")
axes[0].plot(history[:, 0], color="#A4457A", lw=1, label="a (std)")
axes[0].axhline(REAL_MEAN, color="#6B5B95", ls=":")
axes[0].axhline(REAL_STD,
color="#A4457A", ls=":")
axes[0].set_xlabel("training step")
axes[0].set_title("G ke parameters (dotted = asli
qeemat)")
axes[0].legend()
real = rng.normal(REAL_MEAN, REAL_STD, 10000)
axes[1].hist(real, bins=50, density=True, alpha=0.6, color="gray", label="Asli data")
axes[1].hist(gen, bins=50, density=True, alpha=0.6, color="#A4457A", label="Generator ka
data")
axes[1].set_title("Training ke baad")
axes[1].legend()
plt.tight_layout()
plt.show()
OUTPUT (chart)​
28.3 NumPy me asli chhota GAN (1D): G ke parameters (dotted = asli qeemat) Trainingkebaad 0.4 Asli data Generatorkadata 0.3 0.2 0.1 b (mean) a (std) 0.0 1000 2000 3000 4000 5000 6000 training step
28.3 NumPy me asli chhota GAN (1D): G ke parameters (dotted = asli qeemat) Trainingkebaad 0.4 Asli data Generatorkadata 0.3 0.2 0.1 b (mean) a (std) 0.0 1000 2000 3000 4000 5000 6000 training step

Ek ahem baat nazar aati hai: G ke parameters seedhe asli qeemat par ja kar rukte nahi , balki uske ird gird ghoomte (oscillate) rehte hain. Ye GAN training ki asli fitrat hai: do networks ek minimax khel khel rahe hain, jahan ek ka fayda doosre ka nuqsan hai, isi liye GAN ki training mushkil aur beqarar hoti hai.

28.4 GAN ke masail​

MaslaMatlabAam hal
Mode collapseG sirfek ya chand qismka data banata hai (maslan sirf
digit 1) kyun ke D ko wohi bewaqoof bana raha hai
Minibatch features, WGAN loss, zyada
diverse data
Unstable trainingLoss uchhalte hain, kabhi D bohat tez, kabhi GDono ka learning rate chhota (2e-4),
Adam beta1 = 0.5, label smoothing
Vanishing gradient for GD bohat tez ho jaye to G ko seekhne ka signal nahi miltaNon-saturating loss, D ko G se bohat
zyada na seekhne do
Parakhna mushkilAccuracy jaisa koi saaf number nahiSamples dekho, FID score
SUNEHRA USOOL​
  • Adam(2e-4, beta_1=0.5) dono ke liye.

  • LeakyReLU hidden layers me (ReLU nahi), Generator ke aakhir me sigmoid ya tanh .

  • Label smoothing: asli ke target 1.0 ke bajaye 0.9.

  • Har kuch epochs par samples ki tasveer save karo aur khud dekho.

28.5 Keras me GAN ka dhancha​

Hum Digits (8x8 = 64 pixels, 0 se 1) ke liye ek chhota GAN banate hain. Generator 32 numbers ke noise se 64 pixels banata hai, Discriminator 64 pixels dekh kar asli/nakli ka faisla deta hai.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
latent_dim = 32
generator = keras.Sequential([
keras.Input(shape=(latent_dim,)),
layers.Dense(128), layers.LeakyReLU(0.2),
layers.Dense(64, activation="sigmoid"), # 64 pixels, 0 se 1
], name="generator")
discriminator = keras.Sequential([
keras.Input(shape=(64,)),
layers.Dense(128), layers.LeakyReLU(0.2),
layers.Dropout(0.3),
layers.Dense(1, activation="sigmoid"), # asli (1) ya nakli (0)
], name="discriminator")
generator.summary()
discriminator.summary()

OUTPUT (namoona)

Model: "generator"
Layer (type)Output shapeParam #
dense (Dense)(None, 128)4,224
leaky_re_lu (LeakyReLU)(None, 128)0
dense_1 (Dense)(None, 64)8,256
Total params12,480 (48.75 KB)
Trainable params12,480 (48.75 KB)
Non-trainable params0 (0.00 B)
Model: "discriminator"
Layer (type)Output shapeParam #
dense_2 (Dense)(None, 128)8,320
leaky_re_lu_1 (LeakyReLU)(None, 128)0
dropout (Dropout)(None, 128)0
dense_3 (Dense)(None, 1)129
Total params8,449 (33.00 KB)
Trainable params8,449 (33.00 KB)
Non-trainable params0 (0.00 B)

28.6 Doosre generative models​

ModelIdeaFaydaNuqsan
VAEEncoder-decoder, code ek distributionTraining stable, latent space saafSamples aksar dhundle
GANG aur D ka muqablaTez, tez-o-saaf samplesTraining mushkil, mode collapse
DiffusionNoise se shuru kar ke qadam ba qadam saaf karnaBehtareen quality aur variety (aaj ke tasveer-banane wale AI)Sample banana dheema
LLM (Transformer)Agla lafz predict karna (Module 6)Text, code, aur bohat kuchBohat bara compute

Aaj ke tasveer banane wale tools aksar diffusion models par bane hain, aur text ke liye Transformers/LLMs (hamara agla module). GANs ka idea magar hamesha ahem raha: do networks ka muqabla aur adversarial training, jo security, robustness aur data banane me ab bhi kaam aata hai.

28.7 Capstone Mini Project: Haath se likhe number pehchanne wala system​

Ye Module 5 ka mini project hai, jo ek mukammal data science project ka poora dhancha dikhata hai. Maqsad: tasveer se digit pehchanna aur poora kaam ek professional tareeqe se karna: problem, data, baseline, model, tuning, evaluation, error analysis, save, aur report.

MarhalaKya karna haiChapter
1. Problem statementMaqsad aur success metric tay karo (maslan accuracy >= 97%)Module 1
2. Data samajhna (EDA)Shape, classes ki ginti, tasveerein dekhoChapter 23
3. TayyariTrain/validation/test, scalingChapter 22
4. BaselinesSaade models (Logistic, Random Forest, SVM)Module 4
5. Neural Network / CNNANN, phir CNN, regularization, callbacksChapter 21 se 24
6. EvaluationTest accuracy, confusion matrix, error analysisChapter 24
7. Save aur predict functionModel save, naye data par predictionChapter 24
8. ReportNateeje, ghaltiyan, aage ka kaamNeeche

Marhala 1 se 3: Problem, data aur tayyari​

Problem statement:
"8x8 greyscale tasveer se digit (0 se 9) pehchanne wala model banana.
Success metric: test accuracy >= 97%, aur har class ka recall >= 90%."
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
digits = load_digits()
X, y = digits.data / 16.0, digits.target
print("Tasveerein:", X.shape[0], "| Pixels:", X.shape[1], "| Classes:", len(np.unique(y)))
print("Har class ki ginti:", np.bincount(y))
# Train 60% / Validation 20% / Test 20%
X_tr, X_tmp, y_tr, y_tmp = train_test_split(X, y, test_size=0.4, random_state=42,
stratify=y)
X_val, X_te, y_val, y_te = train_test_split(X_tmp, y_tmp, test_size=0.5, random_state=42,
stratify=y_tmp)
print("Train:", X_tr.shape, " Validation:", X_val.shape, " Test:", X_te.shape)
fig, axes = plt.subplots(2, 10, figsize=(10, 2.4))
for d in range(10):
for r in range(2):
axes[r, d].imshow(digits.images[np.where(y == d)[0][r]], cmap="gray_r",
interpolation="nearest")
axes[r, d].axis("off")
axes[0, d].set_title(str(d), fontsize=9)
plt.tight_layout()
plt.show()
OUTPUT​
Tasveerein: 1797 | Pixels: 64 | Classes: 10
Har class ki ginti: [178 182 177 183 181 182 181 179 174 180]
Train: (1078, 64) Validation: (359, 64) Test: (360, 64)
OUTPUT (chart)​
Marhala 1 se 3: Problem, data aur tayyari
Marhala 1 se 3: Problem, data aur tayyari

Test set ko abhi se alag kar liya. Isay sirf aakhir me ek baar istemal karenge. Model chunne ke liye validation set hai.

Marhala 4 aur 5: Baseline se neural network tak​

import warnings
warnings.filterwarnings("ignore")
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neural_network import MLPClassifier
candidates = {
"Logistic Regression": LogisticRegression(max_iter=3000),
"Random Forest": RandomForestClassifier(n_estimators=200, random_state=0),
"SVM (RBF)": SVC(),
"Neural Net (64,)": MLPClassifier(hidden_layer_sizes=(64,), max_iter=500,
random_state=0),
"Neural Net (128,64) + early stop": MLPClassifier(hidden_layer_sizes=(128, 64),
early_stopping=True,
n_iter_no_change=10, max_iter=500,
random_state=0),
}
print("Model".ljust(34), "Train acc Validation acc")
results = {}
for name, m in candidates.items():
m.fit(X_tr, y_tr)
results[name] = m
print(name.ljust(34), str(round(m.score(X_tr, y_tr), 3)).ljust(11), round(m.score(X_val,
y_val), 3))
OUTPUT​
Model Train acc Validation acc
Logistic Regression 0.985 0.958
Random Forest 1.0 0.972
SVM (RBF) 0.998 0.986
Neural Net (64,) 1.0 0.972
Neural Net (128,64) + early stop 0.987 0.961

Is table se validation accuracy dekh kar model chuno (test se nahi!). Train aur validation accuracy ka bara farq overfitting ki nishani hai (Chapter 22).

best_name = max(results, key=lambda n: results[n].score(X_val, y_val))
best = results[best_name]
print("Validation par behtareen model:", best_name)
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
pred = best.predict(X_te) # test set ka PEHLA aur AAKHRI istemal
print("Test accuracy:", round((pred == y_te).mean(), 3))
print()
print(classification_report(y_te, pred, digits=3))
cm = confusion_matrix(y_te, pred)
fig, ax = plt.subplots(figsize=(5.6, 4.6))
sns.heatmap(cm, annot=True, fmt="d", cmap="Purples", cbar=False, ax=ax)
ax.set_xlabel("Predicted")
ax.set_ylabel("Asli")
ax.set_title("Test set: confusion
matrix")
plt.show()
OUTPUT​
Validation par behtareen model: SVM (RBF)
Test accuracy: 0.986
precision recall f1-score support
0 1.000 0.971 0.986 35
1 0.974 1.000 0.987 37
2 1.000 1.000 1.000 35
3 1.000 1.000 1.000 37
4 0.973 1.000 0.986 36
5 1.000 1.000 1.000 37
6 1.000 1.000 1.000 36
7 0.923 1.000 0.960 36
8 1.000 0.971 0.986 35
9 1.000 0.917 0.957 36
accuracy 0.986 360
macro avg 0.987 0.986 0.986 360
weighted avg 0.987 0.986 0.986 360
OUTPUT (chart)​
Marhala 4 aur 5: Baseline se neural network tak: Test set: confusion matrix 34 37 35 37 36 Asli 36 36 34 33 Predicted
Marhala 4 aur 5: Baseline se neural network tak: Test set: confusion matrix 34 37 35 37 36 Asli 36 36 34 33 Predicted

Ye nateeja humare success metric (accuracy 97% aur har class ka recall 90%) se milaya jata hai. Is run me test accuracy 98.6% aur sab se kam recall (digit 9) 91.7% hai, yani dono shartein poori hain. Agar pura na ho to error analysis karo (Chapter 24: ghalat tasveerein dekho) aur model/data behtar banao.

Marhala 5 (jari): Final CNN ka Keras code (Colab)​

Neeche ka CNN wohi hai jo Chapter 23 me seekha, bas Dropout, callbacks aur augmentation ke saath mukammal project ki shakal me:

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers, callbacks
X_tr_img = X_tr.reshape(-1, 8, 8, 1)
X_val_img = X_val.reshape(-1, 8, 8, 1)
X_te_img = X_te.reshape(-1, 8, 8, 1)
cnn = keras.Sequential([
keras.Input(shape=(8, 8, 1)),
layers.RandomTranslation(0.1, 0.1), # augmentation (sirf training me)
layers.Conv2D(16, 3, padding="same", activation="relu"),
layers.BatchNormalization(),
layers.MaxPooling2D(),
layers.Conv2D(32, 3, padding="same", activation="relu"),
layers.MaxPooling2D(),
layers.Flatten(),
layers.Dropout(0.3),
layers.Dense(64, activation="relu"),
layers.Dense(10, activation="softmax"),
])
cnn.compile(optimizer=keras.optimizers.Adam(1e-3),
loss="sparse_categorical_crossentropy", metrics=["accuracy"])
cb = [callbacks.EarlyStopping(patience=12, restore_best_weights=True),
callbacks.ReduceLROnPlateau(factor=0.5, patience=5),
callbacks.ModelCheckpoint("best_digits_cnn.keras", save_best_only=True)]
history = cnn.fit(X_tr_img, y_tr, validation_data=(X_val_img, y_val),
epochs=200, batch_size=32, callbacks=cb, verbose=0)
test_loss, test_acc = cnn.evaluate(X_te_img, y_te, verbose=0) # test sirf ab, ek baar
print("CNN test accuracy:", round(test_acc, 3))

Is cell ko Colab me chalao, apni test accuracy likho aur upar ke sklearn model se muqabla karo. Dono nateeje apne report me likhna (jo behtar ho wo final model, magar dono ka zikr zaroori hai).

Marhala 7: Save aur predict function​

model = keras.models.load_model("best_digits_cnn.keras")
def predict_digit(image_8x8):
"""image_8x8: 8x8 numpy array, pixels 0 se 16"""
x = (np.asarray(image_8x8, dtype="float32") / 16.0).reshape(1, 8, 8, 1) # training wala preprocessing
probs = model.predict(x, verbose=0)[0]
return {"digit": int(probs.argmax()), "confidence": round(float(probs.max()), 3)}
print(predict_digit(digits.images[0]))

28.8 Project Report aur Marking Rubric​

Project ki report me ye hissay hone chahiyen:

  1. Title aur maqsad: masla kya hai, kyun ahem hai.

  2. Data ka tarruf: ginti, shape, classes, kuch tasveerein.

  3. Tareeqa: preprocessing, split (60/20/20), models jo aazmaye.

  4. Nateeje: validation aur test accuracy ka table, confusion matrix, chart.

  5. Error analysis: model kahan ghalti karta hai aur kyun.

  6. Natija aur aage ka kaam: kya seekha, kya behtar ho sakta hai (zyada data, augmentation, Transfer Learning).

  7. Ethics aur hadd: model kahan kaam nahi karega (maslan alag likhai, bari tasveeren).

HissaNumber
Problem aur data ki samajh10
Preprocessing aur sahi split (leakage nahi)15
Baseline aur model muqabla20
Neural network / CNN ki kaarkardagi20
Evaluation aur error analysis20
Code ki safai aur report ki wazahat15
Kul100

28.9 Module 5 ka Mukhtasar​

ChapterSeekha
21Neuron, activation, loss, backpropagation, Keras ke 5 steps
ChapterSeekha
22Overfitting ka ilaaj (Dropout, L2, Early Stopping, BatchNorm), initialization, optimizers
23CNN: convolution, pooling, parameters ki ginti
24ResNet, MobileNet ke idea, Transfer Learning, image project
25RNN, LSTM, GRU, text ko numbers me badalna
26Time series: baselines, windowing, differencing, walk-forward validation
27Autoencoder, PCA se muqabla, denoising, anomaly detection
28GAN, generative models, capstone mini project

Module 6 me tum Transformers aur Attention seekhogi, jin par ChatGPT jaise LLMs bane hain, aur phir OpenAI API se khud AI applications banaogi.

28.10 Aam Galtiyan aur Hands-on​

AAM GALTIYAN​
  • GAN me sirf loss dekhna. Samples ko khud dekho.

  • Discriminator ko Generator se bohat taqatwar bana dena (G ko seekhne ka signal nahi milta).

  • Test set par model chunna (validation istemal karo).

  • Preprocessing ka training aur prediction me farq.

  • Project me sirf accuracy likhna, error analysis aur hadood ka zikr na karna.

  • Generated/nakli content ko asli bata kar share karna.

Hands-on​

  • NumPy GAN: asli data ka mean 4 se 8 aur std 1.25 se 2 karo; G ke (a, b) ko dobara dekho.

  • Learning rate: lr_g ko 0.002 aur 0.2 karo aur training ka farq likho.

  • Generated samples: Colab me Keras GAN train kar ke har 50 epoch par 16 samples ki tasveer banao.

  • Capstone: upar ke project me ek aur model (maslan KNN ya Gradient Boosting) jodo aur validation table update karo.

  • Report: is project ki 2 safhe ki report rubric ke hisaab se likho.

KEY TAKEAWAYS​
  • Generative models naya data banate hain; discriminative models pehchante ya andaza lagate hain.

  • GAN: Generator (nakli banata hai) aur Discriminator (asli/nakli pehchanta hai) ek doosre se muqabla kar ke behtar hote hain.

  • G ko non-saturating loss (-log D(G(z))) se train karte hain; training me dono ko baari baari update karte hain.

  • GAN training beqarar hoti hai (oscillation, mode collapse); loss se nahi, samples dekh kar parakho.

  • Adam(2e-4, beta1=0.5), LeakyReLU, label smoothing GAN ke aam nuskhe hain.

  • Diffusion aur LLM aaj ke bade generative models hain; VAE aur GAN ne rasta banaya.

  • Capstone ka dhancha: problem, EDA, split, baselines, model, evaluation, error analysis, save, report.

  • Test set sirf aakhir me ek baar; model validation set se chuno.

  • Deepfake jaisi cheezon me ethics aur ijazat ka khayal rakho.