Deep Learning Career Options for Students in Greater Noida

# train_cnn.py — a real CNN training loop in PyTorch
# This is the kind of project a Deep Learning Engineer interview tests.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 1. Load a real dataset (CIFAR-10 is the standard starting point)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])

train_ds = datasets.CIFAR10(root="./data", train=True, download=True, transform=transform)
test_ds = datasets.CIFAR10(root="./data", train=False, download=True, transform=transform)

train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)
test_loader = DataLoader(test_ds, batch_size=64, shuffle=False)

# 2. Define a small CNN
class SmallCNN(nn.Module):
    def __init__(self, num_classes: int = 10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes),
        )

    def forward(self, x):
        return self.classifier(self.features(x))

# 3. Train
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SmallCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    model.train()
    total_loss = 0.0
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        optimizer.zero_grad()
        loss = criterion(model(xb), yb)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * len(xb)
    print(f"Epoch {epoch+1}: loss={total_loss / len(train_ds):.4f}")

# 4. Evaluate
model.eval()
correct = total = 0
with torch.no_grad():
    for xb, yb in test_loader:
        xb, yb = xb.to(device), yb.to(device)
        preds = model(xb).argmax(dim=1)
        correct += (preds == yb).sum().item()
        total += len(yb)
print(f"Test accuracy: {correct / total * 100:.2f}%")

# Why this matters:
# - This is the foundational pattern every DL interview tests.
# - A course that skips this and goes straight to pre-trained models
#   is teaching model usage, not deep learning.
#
# What interviewers look for:
# - Do you understand convolutions and pooling?
# - Can you explain why we use CrossEntropyLoss for classification?
# - Do you know when to use dropout and batch normalisation?
# - Can you read the loss curve and know if the model is overfitting?

# finetune_transformer.py — the modern NLP/GenAI workflow
# This is what a Data Scientist – Deep Learning role in NCR looks like.

from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    Trainer,
    TrainingArguments,
)
from datasets import load_dataset
import numpy as np
from sklearn.metrics import accuracy_score, f1_score

# 1. Load a real dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

def tokenize(batch):
    return tokenizer(batch["text"], truncation=True, padding="max_length", max_length=256)

dataset = dataset.map(tokenize, batched=True)
dataset = dataset.rename_column("label", "labels")
dataset.set_format("torch", columns=["input_ids", "attention_mask", "labels"])

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

# 3. Training arguments
args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=2,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1",
)

# 4. Metrics
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    preds = np.argmax(logits, axis=-1)
    return {
        "accuracy": accuracy_score(labels, preds),
        "f1": f1_score(labels, preds, average="binary"),
    }

# 5. Train
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    compute_metrics=compute_metrics,
)
trainer.train()

# What interviewers in NCR look for:
# - Do you understand tokenisation and max_length?
# - Can you explain why we fine-tune instead of training from scratch?
# - Do you know the difference between accuracy and F1 for
#   imbalanced data?
# - Can you talk about catastrophic forgetting and LoRA/PEFT?
#
# Why this is valuable in Greater Noida:
# - GenAI and LLM roles are the fastest-growing DL roles in NCR.
# - Companies like Optum, HCL, and AI startups are hiring for exactly
#   this skill set.

# deploy_model.py — from notebook to production API
# Every DL role now expects deployment skills.

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

# --- Model definition (must match training) ---
class SmallCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 128), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(128, num_classes),
        )
    def forward(self, x):
        return self.classifier(self.features(x))

# --- Load model ---
model = SmallCNN()
model.load_state_dict(torch.load("cifar10_cnn.pt", map_location="cpu"))
model.eval()

app = FastAPI(title="Image Classifier API")

class ImageFeatures(BaseModel):
    pixels: list  # flattened 3x32x32 = 3072 floats

@app.post("/predict")
def predict(image: ImageFeatures):
    x = torch.tensor(image.pixels, dtype=torch.float32).reshape(1, 3, 32, 32)
    with torch.no_grad():
        logits = model(x)
        probs = torch.softmax(logits, dim=1)[0]
    top3 = torch.topk(probs, 3)
    return {
        "predicted_class": int(top3.indices[0]),
        "confidence": round(float(top3.values[0]), 4),
        "top3": [
            {"class": int(i), "score": round(float(v), 4)}
            for i, v in zip(top3.indices, top3.values)
        ],
    }

# Run: uvicorn deploy_model:app --reload
#
# Why this matters:
# - Companies don't hire for notebooks — they hire for models
#   that serve real traffic.
# - Deployment is what separates a portfolio project from a
#   homework submission.
# - If your DL course never covers deployment, your portfolio is
#   missing the piece that actually impresses engineering managers.
#
# What interviewers look for:
# - Do you know how to save and load a PyTorch model?
# - Do you understand eval() vs train() mode in production?
# - Can you handle input validation and error cases?