AI Archives - Page 6 of 17

Evaluation Metrics – Confusion Matrix, Precision, Recall

July 12, 2025 by Anand Singh

अब हम Deep Learning में सबसे ज़रूरी और ज़्यादा इस्तेमाल होने वाले Evaluation Metrics — विशेषकर Confusion Matrix, Precision, और Recall — को पूरी गहराई से समझेंगे।

🔷 1. What Are Evaluation Metrics?

Evaluation metrics यह मापने के लिए होते हैं कि trained model कितनी सही predictions कर पा रहा है — खासकर classification problems में।

🔶 2. Confusion Matrix (गड़बड़ी मैट्रिक्स)

Confusion matrix classification prediction को चार हिस्सों में तोड़ता है:

	Predicted Positive	Predicted Negative
Actual Positive (1)	✅ TP (True Positive)	❌ FN (False Negative)
Actual Negative (0)	❌ FP (False Positive)	✅ TN (True Negative)

🤖 ये matrix binary और multi-class दोनों में काम करता है।

✅ Python Code (PyTorch compatible)

from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 1, 0]         # Ground truth
y_pred = [0, 1, 1, 1, 0, 0]         # Model predictions

cm = confusion_matrix(y_true, y_pred)
print("Confusion Matrix:\n", cm)

Output:

[[2 1]
 [1 2]]

यह कहता है:

2 True Negatives (class 0 सही predict किया)
1 False Positive
1 False Negative
2 True Positives

🔶 3. Precision (सटीकता)

Definition:

Model ने जितने positive predict किए, उनमें से कितने सच में positive थे?

Precision = TP / (TP + FP)

✅ Example:

Model ने 10 images को “cat” कहा, पर केवल 6 ही असली cat थीं →
Precision = 6 / 10 = 0.60

✅ Code:

from sklearn.metrics import precision_score
precision = precision_score(y_true, y_pred)
print("Precision:", precision)

🔶 4. Recall (Sensitivity / True Positive Rate)

Definition:

Total actual positive samples में से कितनों को model ने सही predict किया?

Recall = TP / (TP + FN)

✅ Example:

10 में से 8 असली cats थीं, और model ने 6 को correctly पकड़ा →
Recall = 6 / 8 = 0.75

✅ Code:

from sklearn.metrics import recall_score
recall = recall_score(y_true, y_pred)
print("Recall:", recall)

🔶 5. F1 Score (Precision + Recall का Balance)

Definition:

Precision और Recall का harmonic mean:

F1 = 2 * (Precision * Recall) / (Precision + Recall)

✅ Code:

from sklearn.metrics import f1_score
f1 = f1_score(y_true, y_pred)
print("F1 Score:", f1)

🔷 🔍 Visualization (Optional)

import seaborn as sns
import matplotlib.pyplot as plt

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix")
plt.show()

🧠 कब क्या Use करें?

Metric	Use When…
Accuracy	Data balanced हो
Precision	False Positive से बचना ज़रूरी हो (e.g. spam)
Recall	False Negative से बचना ज़रूरी हो (e.g. cancer detection)
F1 Score	Precision और Recall दोनों ज़रूरी हों

📝 Objective Questions:

Confusion matrix के 4 parts क्या होते हैं?
Precision और Recall में अंतर क्या है?
Precision कब ज़्यादा important होता है?
f1_score metric कब use करते हैं?
Confusion matrix का visualization कैसे करें?

🔚 Summary

Metric	Formula	Meaning
Precision	TP / (TP + FP)	Predicted Positives में से सही कितने
Recall	TP / (TP + FN)	Actual Positives में से सही कितने
F1 Score	Harmonic mean of P & R	Balance of both metrics
Confusion Matrix	TP, FP, FN, TN	Overall prediction structure

What is Model Evaluation and Deployment

July 12, 2025 by Anand Singh

अब आपने deep learning models बनाना, train करना और save/load करना सीख लिया है — अगला ज़रूरी कदम है:Model Evaluation and Deployment

🔷 Part 1: 📊 Model Evaluation

Model को train करने के बाद यह जानना ज़रूरी है कि वो कितना अच्छा काम कर रहा है — इसके लिए हम evaluation metrics का उपयोग करते हैं।

✅ 1. Accuracy (शुद्धता)

Classification के लिए सबसे आम metric
Formula:
Accuracy = सही अनुमान / कुल उदाहरण

# Keras
model.evaluate(X_test, y_test)

# PyTorch
with torch.no_grad():
    preds = model(X_test)
    predicted = preds.round()
    acc = (predicted == y_test).float().mean()

✅ 2. Confusion Matrix

Classification output को True Positives, False Positives, True Negatives, और False Negatives में बांटता है।

from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_true, y_pred))

✅ 3. Precision, Recall, F1 Score

Metric	Meaning
Precision	Positive prediction में से कितने सही थे
Recall	कितने actual positive सही पकड़े गए
F1 Score	Precision और Recall का balance

from sklearn.metrics import classification_report
print(classification_report(y_true, y_pred))

✅ 4. Loss Curve / Accuracy Curve (Visualization)

import matplotlib.pyplot as plt

plt.plot(history.history['loss'], label='loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.legend()
plt.show()

🔷 Part 2: 🚀 Model Deployment

Model को दुनिया तक पहुँचाने के लिए हमें उसे deploy करना पड़ता है — यानी किसी app, API, या web server पर चलाना।

✅ 1. Deployment Methods:

Method	Use Case
Flask API	Simple Web/API deployment
TensorFlow Serving	Production-ready serving
TorchScript	PyTorch model serialization
ONNX	Cross-platform compatibility
TF Lite	Mobile apps (Android/iOS)
TF.js	Browser-based models
Gradio / Streamlit	Quick UI + demo

✅ 2. PyTorch Model Export (TorchScript)

traced_model = torch.jit.trace(model, torch.rand(1, 2))
traced_model.save("model.pt")

Use in any PyTorch-enabled environment.

✅ 3. TensorFlow/Keras Model Export

pythonCopyEditmodel.save("model.h5")  # Full model (Keras)

Convert to TF Lite for mobile:

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

✅ 4. Simple Flask API for Inference

from flask import Flask, request, jsonify
import torch

app = Flask(__name__)
model = torch.load("model.pt")
model.eval()

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

app.run(debug=True)

✅ 5. Deployment Tools

Tool	Purpose
Docker	Containerize model + environment
Kubernetes	Deploy at scale
Heroku	Simple web hosting
AWS/GCP/Azure	Cloud deployment
Hugging Face Spaces	Deploy public demos

📝 Practice Questions:

Accuracy और F1-score में क्या अंतर है?
PyTorch में confusion matrix कैसे calculate करते हैं?
Model को Flask API में कैसे deploy किया जाता है?
torch.jit.trace() और model.save() में क्या अंतर है?
TensorFlow Lite का उपयोग कब और क्यों करना चाहिए?

🧠 Summary Table

Task	PyTorch	TensorFlow/Keras
Accuracy Eval	`(preds == y).float().mean()`	`model.evaluate()`
Save for Deployment	`torch.jit.save()`	`model.save()`
Mobile	ONNX or TorchScript	TF Lite
API	Flask/FastAPI	Flask/FastAPI
Web UI	Gradio / Streamlit	Gradio / Streamlit

Using GPUs and TPUs in Deep Learning

July 12, 2025 by Anand Singh

अब जब आप PyTorch और Keras दोनों में model बना और train कर रहे हैं, तो performance boost के लिए GPU/TPU का इस्तेमाल करना ज़रूरी हो जाता है — खासकर बड़े datasets या deep models के लिए।

🔷 1. 🔥 Why Use GPUs?

CPU vs GPU	GPU Advantage
Sequential	Parallel computing
Few cores	Thousands of cores
Slower matrix ops	Faster tensor operations
General-purpose	Special for ML/DL, CUDA-optimized

🔶 PyTorch में GPU का उपयोग कैसे करें?

✅ Step 1: Check GPU Availability

import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device:", device)

✅ Step 2: Model और Data को GPU पर भेजना

model = MyNet().to(device)  # Model को GPU पर भेजें
X = X.to(device)
y = y.to(device)

✅ Training Code में बदलाव:

for epoch in range(1000):
    y_pred = model(X)
    loss = criterion(y_pred, y)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

बस यह ध्यान रखें कि model और data दोनों एक ही device पर होने चाहिए।

🔷 2. GPU से Prediction (Inference)

model.eval()
with torch.no_grad():
    test = torch.tensor([[1., 0.]]).to(device)
    output = model(test)
    print("Prediction:", output.item())

🔷 3. Keras (TensorFlow) में GPU का उपयोग

TensorFlow अपने आप GPU को detect करता है और उपयोग करता है (अगर उपलब्ध हो)। बस ensure करें कि:

TensorFlow-GPU version install हो
NVIDIA Drivers + CUDA Toolkit सही से install हो

✅ Check GPU:

import tensorflow as tf
print("Num GPUs Available:", len(tf.config.list_physical_devices('GPU')))

✅ Tensor और Model GPU पर चलेंगे अपने आप:

model.fit(X, y, epochs=10)  # If GPU available, TensorFlow will use it

✅ Manually GPU select करना:

with tf.device('/GPU:0'):
    model = tf.keras.Sequential([...])
    model.compile(...)
    model.fit(...)

🔷 4. Google Colab में GPU/TPU Use

✅ GPU Enable करें:

Runtime → Change runtime type → Hardware accelerator → GPU or TPU

✅ Check GPU/TPU:

import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))   # For GPU
print(tf.config.list_logical_devices('TPU'))    # For TPU

🔷 5. TPUs क्या होते हैं?

Aspect	Detail
TPU	Tensor Processing Unit (Google द्वारा बनाया गया)
Speed	GPU से भी तेज़ है कुछ tasks में
Best for	Very large models, production-level serving
Use	Mainly in Google Colab, Cloud TPUs, TensorFlow

📝 Practice Questions:

PyTorch में GPU support कैसे check करते हैं?
Model को GPU पर भेजने के लिए कौनसा syntax है?
TensorFlow GPU vs TPU में क्या अंतर है?
Google Colab में GPU enable कैसे करते हैं?
क्या CPU से GPU training में फर्क आता है?

🧠 Summary Table

Task	PyTorch	Keras (TF)
GPU Check	`torch.cuda.is_available()`	`tf.config.list_physical_devices()`
Send to GPU	`x.to(device)`	Automatic
Model to GPU	`model.to(device)`	Automatic
Use Colab GPU	Runtime > Change > GPU	Same
TPU Support	❌ (Limited)	✅ (Good)

Model Training, Saving, and Loading in Keras

July 12, 2025 by Anand Singh

अब हम Keras (जो TensorFlow का high-level API है) में Deep Learning Model को Train, Save, और Load करना सीखेंगे — step-by-step और practical examples के साथ।

🔷 1. ✅ Model Training in Keras (Step-by-Step)

📌 Step 1: Import Libraries

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

📌 Step 2: Define Model

model = Sequential([
    Dense(8, activation='relu', input_shape=(2,)),
    Dense(1, activation='sigmoid')
])

📌 Step 3: Compile Model

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

📌 Step 4: Prepare Data

import numpy as np

X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 1, 1, 0])

📌 Step 5: Train Model

model.fit(X, y, epochs=100, batch_size=2, verbose=1)

🔷 2. 💾 Saving a Keras Model

✅ Option 1: Save Full Model (Best Practice)

model.save("my_model.h5")  # Saves architecture + weights + optimizer state

OR in newer format:

model.save("my_model.keras")  # New native format

✅ Option 2: Save Only Weights

model.save_weights("model_weights.h5")

🔷 3. 📂 Loading a Saved Model

✅ Load Full Model:

from tensorflow.keras.models import load_model

model = load_model("my_model.h5")

This will return the model ready to use — no need to recompile or redefine.

✅ Load Only Weights:

First define the model architecture same as before:

model = Sequential([
    Dense(8, activation='relu', input_shape=(2,)),
    Dense(1, activation='sigmoid')
])

Then load the weights:

model.load_weights("model_weights.h5")

🔷 4. 🔁 Save and Load during Training (Checkpointing)

✅ Use ModelCheckpoint Callback

from tensorflow.keras.callbacks import ModelCheckpoint

checkpoint = ModelCheckpoint("best_model.h5", save_best_only=True, monitor="loss")

model.fit(X, y, epochs=50, callbacks=[checkpoint])

🔷 5. 🧪 Inference (Prediction)

pred = model.predict(np.array([[1, 0]]))
print("Prediction:", pred[0][0])

🧠 Use .predict() method for classification, regression, or output generation.

🔧 Extra: Exporting to TF Lite (Mobile/Edge)

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

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

📝 Practice Questions:

Keras में model train करने के steps क्या हैं?
.h5 और .keras में क्या अंतर है?
model.save() और model.save_weights() में क्या फर्क है?
Training के दौरान best model कैसे save करते हैं?
Model load करने के बाद inference कैसे करते हैं?

🧠 Summary Table

Task	Keras Method
Train Model	`model.fit()`
Save Full Model	`model.save("model.h5")`
Save Only Weights	`model.save_weights()`
Load Full Model	`load_model("model.h5")`
Load Weights Only	`model.load_weights()`
Predict / Inference	`model.predict(x)`
Save Best during Training	`ModelCheckpoint(callback)`

Model Training, Saving, and Loading in PyTorch

July 12, 2025 by Anand Singh

अब हम PyTorch में Model Training, फिर उसे Save और Load करने की पूरी प्रक्रिया विस्तार से सीखते हैं —
जो किसी भी Deep Learning project का core हिस्सा है।

🔷 1. 🔁 Model Training in PyTorch

🧱 Training Steps Overview:

Model बनाना (nn.Module)
Loss function चुनना (nn.CrossEntropyLoss, etc.)
Optimizer सेट करना (torch.optim)
Forward pass करना
Loss calculate करना
Backward pass (loss.backward())
Optimizer step (optimizer.step())

🧪 Full Example (Classifier):

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Sample data
X = torch.tensor([[0.,0.],[0.,1.],[1.,0.],[1.,1.]])
y = torch.tensor([[0.],[1.],[1.],[0.]])

dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

# Step 1: Model
class XORNet(nn.Module):
    def __init__(self):
        super(XORNet, 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 = XORNet()

# Step 2: Loss and Optimizer
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.1)

# Step 3: Training loop
for epoch in range(500):
    for xb, yb in dataloader:
        y_pred = model(xb)
        loss = criterion(y_pred, yb)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

🔷 2. 💾 Saving a PyTorch Model

PyTorch में 2 तरीके हैं model save करने के:

✅ Option 1: State Dict Only (Recommended)

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

यह केवल model के weights save करता है, architecture नहीं।

✅ Option 2: Complete Model (Not Recommended)

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

यह पूरा model + structure save करता है, पर version compatibility issues आ सकते हैं।

🔷 3. 📂 Loading a Model

🔁 Load from State Dict (Best Practice):

model = XORNet()  # पहले architecture बनाओ
model.load_state_dict(torch.load("xor_model.pth"))
model.eval()  # evaluation mode में डालना ज़रूरी

🔍 .eval() inference के समय BatchNorm / Dropout को deactivate करता है।

🧠 Bonus: GPU Compatibility (Saving/Loading)

✅ Save on GPU, Load on CPU:

# Save (from GPU)
torch.save(model.state_dict(), "model_gpu.pth")

# Load on CPU
device = torch.device("cpu")
model.load_state_dict(torch.load("model_gpu.pth", map_location=device))

🧪 Example: Inference After Loading

model.eval()
with torch.no_grad():
    test = torch.tensor([[1., 1.]])
    output = model(test)
    print("Predicted:", output.item())

📦 Advanced Tip: Save Optimizer State Too

torch.save({
    'model_state': model.state_dict(),
    'optimizer_state': optimizer.state_dict(),
}, "checkpoint.pth")

Load Later:

checkpoint = torch.load("checkpoint.pth")
model.load_state_dict(checkpoint['model_state'])
optimizer.load_state_dict(checkpoint['optimizer_state'])

🧠 Evaluation Tips

हमेशा model.eval() use करें inference के लिए
torch.no_grad() में prediction करें (memory efficiency के लिए)
Large models के लिए model checkpoints का उपयोग करें

📝 Practice Questions:

PyTorch में model train करने के मुख्य steps क्या हैं?
State dict और full model saving में क्या अंतर है?
Optimizer state क्यों save करना चाहिए?
.eval() और .train() modes में क्या फर्क है?
Inference में torch.no_grad() का उपयोग क्यों करें?

🧠 Summary Table

Task	Method
🔧 Train	Forward → Loss → Backward → Optimizer
💾 Save Weights	`torch.save(model.state_dict(), path)`
📂 Load Weights	`model.load_state_dict(torch.load(path))`
📌 Inference	`model.eval()` + `with torch.no_grad()`
🔁 Save with Optimizer	Use `checkpoint = {'model': ..., 'opt': ...}`