Best Deep Learning Training Institute in Delhi NCR 2026

# PyTorch — training loop.
# The single most important pattern in deep learning.

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

# 1. Build a small model
class TinyNet(nn.Module):
    def __init__(self, in_features, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, 64),
            nn.ReLU(),
            nn.Linear(64, num_classes),
        )

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

# 2. Prepare data
X = torch.randn(1000, 20)
y = torch.randint(0, 3, (1000,))
loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)

# 3. Model, loss, optimizer
model = TinyNet(in_features=20, num_classes=3)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 4. The training loop — this is the pattern to memorise
for epoch in range(10):
    for batch_X, batch_y in loader:
        optimizer.zero_grad()              # clear old gradients
        logits = model(batch_X)            # forward pass
        loss = criterion(logits, batch_y)  # compute loss
        loss.backward()                    # backprop
        optimizer.step()                   # update weights

    print(f"epoch {epoch+1} | loss {loss.item():.4f}")

# What this teaches:
# - The forward/backward/step loop
# - Why zero_grad() is called
# - How optimizers update weights
#
# What a good mentor adds:
# - How to debug a loss curve that won't decrease
# - Why batches matter for generalization
# - How to move this to GPU with .to(device)
#
# If your course never writes this loop by hand, you are watching
# deep learning — not doing it.

# Transfer learning — fine-tune a pre-trained model.
# What most modern NLP work actually looks like.

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer
import torch

# 1. Load a pre-trained model and tokenizer
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=2
)

# 2. Tokenize a small dataset
texts = ["great product", "terrible experience", "okay I guess", "loved it"]
labels = [1, 0, 1, 1]

encodings = tokenizer(texts, truncation=True, padding=True, return_tensors="pt")

class SimpleDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        item = {k: v[idx] for k, v in self.encodings.items()}
        item["labels"] = torch.tensor(self.labels[idx])
        return item

dataset = SimpleDataset(encodings, labels)

# 3. Fine-tune
args = TrainingArguments(
    output_dir="./out",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    logging_steps=1,
)
trainer = Trainer(model=model, args=args, train_dataset=dataset)
trainer.train()

# What this teaches:
# - Using pre-trained models instead of training from scratch
# - Tokenization for NLP
# - The Hugging Face Trainer API
# - What fine-tuning actually does
#
# What a good mentor adds:
# - When to fine-tune vs when to train from scratch
# - How to evaluate NLP models beyond accuracy
# - How to serve the fine-tuned model
#
# This is how most real-world NLP work is done in 2026.
# A course that skips this is behind.

# Deployment — FastAPI model server.
# Training a model is only half the job. Deploying it is the other half.

from fastapi import FastAPI
from pydantic import BaseModel
import torch
import torch.nn as nn

class TinyNet(nn.Module):
    def __init__(self, in_features, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, 64),
            nn.ReLU(),
            nn.Linear(64, num_classes),
        )
    def forward(self, x):
        return self.net(x)

app = FastAPI()

# Load the trained model once at startup
model = TinyNet(in_features=20, num_classes=3)
model.load_state_dict(torch.load("model.pt"))
model.eval()

class PredictRequest(BaseModel):
    features: list[float]

@app.post("/predict")
def predict(req: PredictRequest):
    x = torch.tensor([req.features], dtype=torch.float32)
    with torch.no_grad():
        logits = model(x)
    probs = torch.softmax(logits, dim=1)[0].tolist()
    return {
        "prediction": int(torch.argmax(logits, dim=1)[0]),
        "probabilities": probs,
    }

@app.get("/healthz")
def health():
    return {"status": "ok"}

# What this teaches:
# - Wrapping a trained model in an API
# - Loading weights once at startup
# - torch.no_grad() for inference (saves memory)
# - healthz endpoint (production hygiene)
#
# What a good mentor adds:
# - How to containerise this with Docker
# - How to batch requests for throughput
# - How to handle malformed inputs
#
# The interview question:
# "How would you deploy this model?" — this is the answer.
#
# A course that ends at "the model trains" leaves you with
# 50% of the job. A course that ends at "the model serves"
# prepares you for the role.