Why Faridabad Students Are Choosing Deep Learning in 2026

# A minimal PyTorch training loop.
# This is the single most important pattern in deep learning.
# If you understand this, you understand the core of every model.

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 (dummy example — replace with your dataset)
X = torch.randn(1000, 20)          # 1000 samples, 20 features
y = torch.randint(0, 3, (1000,))   # 3 classes
dataset = TensorDataset(X, y)
loader = DataLoader(dataset, 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 proves in an interview:
# - You know the forward/backward/step loop
# - You know why zero_grad() is called
# - You can swap the model and data without breaking the loop
# This is the foundation of every deep learning project you'll build.

# A small CNN in TensorFlow / Keras.
# Computer vision is one of the most common deep learning entry points.

import tensorflow as tf
from tensorflow.keras import layers, models

# 1. Build the model
model = models.Sequential([
    layers.Input(shape=(28, 28, 1)),

    layers.Conv2D(32, (3, 3), activation="relu"),
    layers.MaxPooling2D((2, 2)),

    layers.Conv2D(64, (3, 3), activation="relu"),
    layers.MaxPooling2D((2, 2)),

    layers.Flatten(),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax"),  # 10 classes
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# 2. Train on MNIST (or any image dataset)
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train[..., None] / 255.0
x_test = x_test[..., None] / 255.0

model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.1)

# 3. Evaluate
loss, acc = model.evaluate(x_test, y_test)
print(f"test accuracy: {acc:.3f}")

# What this proves in an interview:
# - You understand convolutions and pooling
# - You know how to preprocess image data
# - You can train and evaluate a model end to end
# This is the pattern behind most image classification systems.

# Transfer learning with Hugging Face.
# You do not need to train a transformer from scratch to use one well.

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

# 1. Quick inference with a pre-trained model
classifier = pipeline(
    "sentiment-analysis",
    model="distilbert-base-uncased-finetuned-sst-2-english",
)
print(classifier("Deep learning is changing how we build software."))

# 2. Load a model and tokenizer for fine-tuning
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, num_labels=2
)

# 3. 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)

# 4. Fine-tune with Trainer
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 proves in an interview:
# - You know how to use pre-trained models
# - You understand tokenization
# - You can fine-tune without training from scratch
# This is how most real-world NLP work is done in 2026.