AI

अब हम एक बहुत ज़रूरी और व्यावहारिक विषय को समझते हैं — जिसका मक़सद है AI को “क्यों” और “कैसे” समझाना।

🧠 “AI का फ़ैसला समझ में आना चाहिए – काला जादू नहीं।”

---

🔷 1. What is Explainable AI?

Explainable AI (XAI) का उद्देश्य है कि AI/ML models के निर्णय साफ़, पारदर्शी और इंसानों के समझने लायक हों।

“Why did the model predict this?”
“What part of the input influenced the decision?”

---

🔶 2. Why XAI is Important?

कारण	उदाहरण
✅ Trust	Doctor को explainable model चाहिए
✅ Debugging	Developer model की गलती पकड़ सकता है
✅ Fairness	Bias या discrimination detect हो सकता है
✅ Regulation	GDPR / Medical AI में जरूरी है

---

🔷 3. Black Box vs Explainable Models

Model Type	Explainability
Linear Regression	✅ High
Decision Trees	✅ Medium
Deep Neural Nets	❌ Low (Black box)
Transformers, CNN	❌ Complex

इसलिए हमें DNN, CNN, Transformers जैसे models के लिए XAI techniques चाहिए।

---

🔶 4. Popular XAI Techniques

✅ A. Feature Importance (Tabular data)

• Tree-based models (like Random Forests) naturally बताते हैं कि कौन-सा feature कितना important है.

---

✅ B. LIME (Local Interpretable Model-Agnostic Explanations)

Model की prediction के आसपास एक simple interpretable model fit किया जाता है।

pip install lime

from lime.lime_tabular import LimeTabularExplainer

---

✅ C. SHAP (SHapley Additive exPlanations)

Game Theory आधारित: हर feature की contribution value निकाली जाती है।

pip install shap

import shap
explainer = shap.Explainer(model.predict, X_test)
shap_values = explainer(X_test[:10])
shap.plots.waterfall(shap_values[0])

---

✅ D. Saliency Maps (Image models)

CNN model के output को किस image region ने प्रभावित किया?

# torch.autograd + image gradient → heatmap

---

✅ E. Grad-CAM (CNN explainability)

किसी image में कौन-से हिस्से ने prediction को सबसे ज़्यादा influence किया?

pip install grad-cam

• Input image → CNN → last conv layer → gradients → visualization map

---

✅ F. Attention Visualization (Transformer models)

Transformer models (like BERT, GPT) में Attention Score से पता चलता है कि model ने किस word पर सबसे ज़्यादा ध्यान दिया।

from transformers import BertTokenizer, BertModel
# Visualize attention weights

---

🔷 5. Real-World Applications

Domain	Explanation Use
Healthcare	Doctor को पता चले AI ने क्या देखा
Finance	Loan rejection के कारण समझाना
Legal	किसी भी decision का कारण trace करना
Autonomous Cars	Sensor input के आधार पर फ़ैसला क्यों लिया गया?

---

🔶 6. Challenges in XAI

समस्या	कारण
Complex models	Millions of parameters
No ground truth	क्या explanation सही है?
Trade-off	Explainability vs Accuracy

---

🧠 Summary

Aspect	Description
XAI क्या है	AI को explain करना इंसानों के लिए
क्यों ज़रूरी	Trust, Regulation, Debugging
Techniques	LIME, SHAP, Grad-CAM, Attention
Domain Use	Medical, Finance, Legal, Vision

---

📝 Practice Questions:

1. Explainable AI की ज़रूरत क्यों है?
2. LIME और SHAP में क्या अंतर है?
3. CNN models को explain करने के लिए कौन-सी technique use होती है?
4. Grad-CAM क्या है और कैसे काम करता है?
5. XAI healthcare में कैसे मदद करता है?

अब हम deep learning की सबसे आधुनिक और प्रभावशाली तकनीकों में से एक को सीखने जा रहे हैं — जो text-to-image जैसे tasks में breakthroughs लाई है:

🔍 धीरे-धीरे noise जोड़ो, फिर धीरे-धीरे उसे हटाकर नया data generate करो!

---

🔷 1. What are Diffusion Models?

Diffusion Models एक तरह के generative models हैं, जो training में images में noise डालते हैं और फिर सीखते हैं उसे वापस original image में बदलना।

🧠 Goal: Noise से high-quality image generate करना।

---

🔶 2. Real World Analogy

कल्पना कीजिए आपके पास एक साफ़ तस्वीर है, जिसे आप बार-बार थोड़ा-थोड़ा धुंधला (noise) करते हैं। अब model सीखता है कि कैसे इस धुंधली तस्वीर से साफ़ तस्वीर वापस बनाई जाए।

---

🔷 3. Core Idea

Diffusion Process में दो चरण होते हैं:

✅ 1. Forward Process (Adding Noise)

Original image में step-by-step Gaussian noise मिलाया जाता है।

• जहां x_0 = original image
• x_t = noisy image at step t
• ε = Gaussian noise

---

✅ 2. Reverse Process (Denoising)

Model सीखता है कि इस noise को step-by-step हटाकर original image कैसे reconstruct की जाए।

---

🔶 4. Intuition:

Stage	क्या हो रहा है
Forward Process	Image → Noise
Reverse Process	Noise → Image (generate करने के लिए!)

---

🔷 5. Architecture

Diffusion models आमतौर पर U-Net architecture का उपयोग करते हैं।

• Noise-added image input किया जाता है
• Time-step embedding दिया जाता है
• U-Net output करता है predicted noise
• Loss: MSE between actual noise और predicted noise

---

🔶 6. Training Objective

Model को सिखाया जाता है:

यानी: Model सिखे कि original noise (ε) क्या था, ताकि उसे हटाकर साफ़ image बन सके।

---

🔷 7. Famous Diffusion Models

Model	Highlights	Organization
DDPM	Denoising Diffusion Probabilistic Model	Google
Stable Diffusion	Text-to-Image diffusion model	Stability AI
Imagen	High-quality generation from text	Google Brain
DALLE-2	CLIP + Diffusion	OpenAI

---

🔶 8. Applications of Diffusion Models

✅ Text-to-Image Generation
✅ Inpainting (Missing image fill करना)
✅ Super-resolution
✅ Audio synthesis
✅ 3D scene generation

---

🔷 9. Sample Code (Simplified PyTorch)

import torch
import torch.nn as nn

class SimpleDenoiseModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Linear(512, 784),
        )
    def forward(self, x, t):
        return self.net(x)

# Forward diffusion (add noise)
def add_noise(x, t):
    noise = torch.randn_like(x)
    alpha = 1 - 0.02 * t  # Simplified
    return alpha * x + (1 - alpha) * noise, noise

---

🧠 Difference from GANs

Feature	GAN	Diffusion Model
Stable	❌ Hard to train	✅ More stable
Output Quality	Medium to High	✅ High
Mode Collapse	❌ Possible	✅ Rare
Training Time	Faster	❌ Slower
Use Case	Image, video, text	Mostly high-fidelity images

---

📝 Practice Questions:

1. Diffusion model में forward और reverse process क्या होते हैं?
2. Stable Diffusion किस technique पर आधारित है?
3. GAN और Diffusion में क्या अंतर है?
4. Time-step embedding क्यों ज़रूरी है?
5. Diffusion से कौन-कौन से real-world tasks solve किए जा सकते हैं?

---

🧾 Summary

Concept	Description
Forward Pass	Clean image → Add noise
Reverse Pass	Noisy image → Remove noise (generate)
Architecture	Mostly U-Net
Training Loss	MSE between true and predicted noise
Output	New image generated from pure noise

अब हम Deep Learning के एक cutting-edge topic की ओर बढ़ते हैं:

🔍 “Learn from data itself – without explicit labels.”

---

🔷 1. What is Self-Supervised Learning?

Self-Supervised Learning (SSL) एक ऐसी approach है जिसमें model को बिना manually labeled data के train किया जाता है।
👉 ये unlabeled data से ही pseudo labels generate करता है।

Goal: Supervised learning जैसी performance, लेकिन बिना manually labeled dataset के।

---

🔶 2. SSL क्यों ज़रूरी है?

समस्या	समाधान
Labeling data महंगा है	SSL human labeling को minimize करता है
कई domains में unlabeled data abundant है	SSL उससे फायदा उठाता है
Pretraining + Fine-tuning = बेहतर generalization	SSL मॉडल transferable बनाता है

---

🔷 3. SSL कैसे काम करता है?

✅ Key Idea:

Model खुद ही input के कुछ हिस्सों से दूसरा हिस्सा predict करने का task सीखता है।

SSL Task Type	उदाहरण
Contrastive	Two similar images → close representations
Masked modeling	Sentence का हिस्सा छिपा दो → predict करो
Pretext tasks	Rotation predict करना, Colorization, etc.

---

🔶 4. Popular Self-Supervised Tasks

✅ A. Contrastive Learning (Image)

एक ही object के दो augmentations → similar representation
अलग-अलग object → दूर representation

• Frameworks: SimCLR, MoCo, BYOL

Loss = NT-Xent (Normalized Temperature-scaled Cross Entropy)

---

✅ B. Masked Language Modeling (NLP)

Input में कुछ tokens को mask करो, फिर उन्हें predict करो
जैसे BERT करता है

Input: "I like [MASK] learning."  
Target: "deep"

---

✅ C. Autoencoding

Input से खुद को reconstruct करना

• Example: Autoencoders, Variational Autoencoders

---

✅ D. Predict Context (Next Frame, Next Word, etc.)

• Next Word Prediction: GPT जैसे models
• Next Frame Prediction: Video prediction tasks

---

🔷 5. Examples of SSL in Practice

Model / Method	Domain	Technique
BERT	NLP	Masked token prediction
SimCLR	Vision	Contrastive loss
BYOL, MoCo	Vision	Momentum encoder
GPT	NLP	Next token prediction
MAE (Masked Autoencoders)	Vision	Mask patches, reconstruct

---

🔶 6. Advantages of Self-Supervised Learning

✅ Manual labels की dependency नहीं
✅ Large-scale data से बेहतर generalization
✅ Transfer learning के लिए बेहतरीन
✅ Few-shot या Zero-shot tasks में useful

---

🔶 7. Self-Supervised vs Unsupervised vs Supervised

Method	Labels Required	Example
Supervised	✅ Yes	Classification, Regression
Unsupervised	❌ No	Clustering, PCA
Self-Supervised	❌ Pseudo	BERT, SimCLR, GPT

---

🧪 Use Case: SimCLR in Vision (PyTorch)

import torchvision.transforms as T
from PIL import Image

transform = T.Compose([
    T.RandomResizedCrop(224),
    T.RandomHorizontalFlip(),
    T.ColorJitter(),
    T.ToTensor()
])

img = Image.open("cat.jpg")
x1 = transform(img)  # View 1
x2 = transform(img)  # View 2

# Pass x1, x2 to encoder → project → NT-Xent loss

---

📝 Practice Questions

1. Self-Supervised learning में labels कैसे generate होते हैं?
2. Contrastive Learning और Masked Modeling में क्या अंतर है?
3. SimCLR किस domain में काम करता है और कैसे?
4. GPT और BERT में SSL का role क्या है?
5. SSL के फायदे क्या हैं supervised learning के comparison में?

---

🔚 Summary

Concept	Detail
SSL Definition	Data से खुद labels generate करके learning
Famous Tasks	Masking, Contrastive, Autoencoding
Popular Models	BERT, GPT, SimCLR, BYOL, MAE
Advantage	Label-free pretraining, Generalization
Real Use	NLP, Vision, Robotics, Video

model को train और save कर लिया है — अब बारी है उसे दुनिया के सामने पेश करने की 🎯
यानि model को API या Web App के ज़रिए serve करना।

---

🧩 दो मुख्य तरीकें:

तरीका	विवरण	उदाहरण
✅ API-Based	Model को backend में serve करें	Flask / FastAPI
✅ Web App	Model के ऊपर UI बनाएं	Streamlit / Gradio

---

🔶 1. ✅ Flask API से Model Serve करना (PyTorch Example)

🛠️ Step-by-step Code

📌 app.py:

from flask import Flask, request, jsonify
import torch
import torch.nn as nn

# Your trained model class
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.fc1 = nn.Linear(2, 4)
        self.fc2 = nn.Linear(4, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return torch.sigmoid(self.fc2(x))

# Load model
model = MyNet()
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

# Create Flask app
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    input_tensor = torch.tensor(data["input"]).float()
    with torch.no_grad():
        output = model(input_tensor).item()
    return jsonify({"prediction": round(output)})

if __name__ == "__main__":
    app.run(debug=True)

---

📲 Test via curl or Postman:

curl -X POST http://127.0.0.1:5000/predict \
     -H "Content-Type: application/json" \
     -d '{"input": [1.0, 0.0]}'

---

🔶 2. ✅ Streamlit Web App (Quick & Visual)

📌 app.py

import streamlit as st
import torch
import torch.nn as nn

# Load model
class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.fc1 = nn.Linear(2, 4)
        self.fc2 = nn.Linear(4, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return torch.sigmoid(self.fc2(x))

model = MyNet()
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

# UI
st.title("XOR Prediction Model")
x1 = st.slider("x1", 0.0, 1.0, 0.0)
x2 = st.slider("x2", 0.0, 1.0, 0.0)

if st.button("Predict"):
    input_tensor = torch.tensor([[x1, x2]])
    with torch.no_grad():
        output = model(input_tensor).item()
        st.write("Prediction:", round(output))

🔼 Run the App:

streamlit run app.py

---

🔶 3. ✅ Gradio Web Interface

import gradio as gr
import torch
import torch.nn as nn

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.fc1 = nn.Linear(2, 4)
        self.fc2 = nn.Linear(4, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return torch.sigmoid(self.fc2(x))

model = MyNet()
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

def predict(x1, x2):
    input_tensor = torch.tensor([[x1, x2]])
    with torch.no_grad():
        output = model(input_tensor).item()
    return round(output)

gr.Interface(fn=predict, inputs=["slider", "slider"], outputs="text").launch()

---

✅ Deployment Options:

Platform	Tool	Suitable For
Local Machine	Flask / Streamlit	Testing, demos
Heroku / Render	Flask + Gunicorn	Cloud API
Hugging Face	Gradio Space	Public demo
AWS/GCP	Docker / API	Production

---

📝 Practice Questions:

1. Flask API बनाने के लिए कौन से steps follow होते हैं?
2. Streamlit और Gradio में क्या अंतर है?
3. Model को Web पर serve करने के 3 तरीके क्या हैं?
4. TorchScript model को Flask में कैसे load करेंगे?
5. curl से API call कैसे की जाती है?

---

🧠 Summary Table

Method	Interface	Setup Time	UI
Flask	JSON API	Medium	❌
Streamlit	Web UI	Very Low	✅
Gradio	Web UI	Very Low	✅
FastAPI	Fast JSON	Medium-High	❌

Model को train करने के बाद उसे save करना ज़रूरी होता है ताकि उसे:

• Future में reuse किया जा सके
• Production में deploy किया जा सके
• किसी और प्लेटफॉर्म पर इस्तेमाल किया जा सके (e.g., mobile, web, edge devices)

---

🔷 🔹 Why Save Models?

Reason	Benefit
Training time बचाना	बार-बार retrain करने की ज़रूरत नहीं
Deployment possible	Web, mobile, or production में model use
Sharing & Reuse	दूसरों से share करना या reuse करना

---

🔶 1. PyTorch में Model Saving & Loading

✅ 1.1 Only Weights Save करें

torch.save(model.state_dict(), "model_weights.pth")

🔁 Load Only Weights

model = MyNet()  # same structure
model.load_state_dict(torch.load("model_weights.pth"))
model.eval()

---

✅ 1.2 Save Full Model (Structure + Weights)

torch.save(model, "full_model.pth")

🔁 Load Full Model

model = torch.load("full_model.pth")
model.eval()

⚠️ Recommended method: save state_dict() instead of full model, for more flexibility and safety.

---

✅ 1.3 Export for Production (TorchScript)

example_input = torch.randn(1, 2)
traced = torch.jit.trace(model, example_input)
traced.save("model_scripted.pt")

🔁 Load TorchScript Model

model = torch.jit.load("model_scripted.pt")
model.eval()

---

🔶 2. TensorFlow / Keras में Model Saving

✅ 2.1 Save Entire Model (.h5 or .keras)

model.save("my_model.h5")
# OR
model.save("my_model.keras")  # Recommended in latest TF

🔁 Load:

from tensorflow.keras.models import load_model
model = load_model("my_model.h5")

---

✅ 2.2 Save Weights Only

model.save_weights("weights.h5")

🔁 Load Weights:

model = build_model()  # Define same structure
model.load_weights("weights.h5")

---

✅ 2.3 Export to TensorFlow Lite (for Mobile/IoT)

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

---

✅ 2.4 Export to TF.js (Browser Use)

pip install tensorflowjs
tensorflowjs_converter --input_format keras my_model.h5 web_model/

---

📝 Practice Questions:

1. PyTorch में state_dict क्या होता है और क्यों ज़रूरी है?
2. Keras में .h5 और .keras में क्या अंतर है?
3. TorchScript और ONNX में क्या उपयोगिता है?
4. TensorFlow Lite क्यों और कब use करते हैं?
5. Model को JSON या TF.js में कैसे export किया जाता है?

---

🔚 Summary Table

Framework	Save Weights	Save Full Model	Export Option
PyTorch	state_dict()	torch.save()	TorchScript / ONNX
Keras	save_weights()	model.save()	TF Lite, TF.js
TensorFlow	checkpoint	SavedModel format	TensorFlow Serving