How Fresh Graduates Can Enter Deep Learning in 2026

# PyTorch — a clean training loop (the pattern used everywhere)
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

def train_epoch(model, loader, optimizer, criterion, device):
    model.train()
    total_loss = 0.0
    for x, y in loader:
        x, y = x.to(device), y.to(device)

        optimizer.zero_grad()
        logits = model(x)
        loss = criterion(logits, y)
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * x.size(0)

    return total_loss / len(loader.dataset)

@torch.no_grad()
def evaluate(model, loader, criterion, device):
    model.eval()
    total_loss, correct, n = 0.0, 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        logits = model(x)
        total_loss += criterion(logits, y).item() * x.size(0)
        correct += (logits.argmax(1) == y).sum().item()
        n += x.size(0)
    return total_loss / n, correct / n

# Usage
device = "cuda" if torch.cuda.is_available() else "cpu"
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(256, 10),
).to(device)

optimizer = optim.AdamW(model.parameters(), lr=3e-4)
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    train_loss = train_epoch(model, train_loader, optimizer, criterion, device)
    val_loss, val_acc = evaluate(model, val_loader, criterion, device)
    print(f"epoch {epoch}: train={train_loss:.4f} "
          f"val={val_loss:.4f} acc={val_acc:.3f}")

# Fine-tuning a pretrained transformer — the most-hired skill
# This is what "Applied DL Engineer" roles actually do.
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer,
)
from datasets import load_dataset

# Load dataset and tokenizer
ds = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

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

ds = ds.map(tokenize, batched=True)

# Load model with a classification head
model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=2,
)

# Train
args = TrainingArguments(
    output_dir="./results",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    num_train_epochs=2,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    fp16=True,   # mixed precision — expected in real projects
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=ds["train"],
    eval_dataset=ds["test"],
)

trainer.train()

# A resume bullet like this wins interviews:
# "Fine-tuned DistilBERT on IMDB, 92.1% accuracy,
#  trained in 18 min on a single T4 GPU with fp16."

# Build a CNN from scratch — proves you understand convolution
# Interviewers often ask: "Compute the output shape of each layer."
import torch.nn as nn

class SmallCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            # Input: 1 x 28 x 28
            nn.Conv2d(1, 32, kernel_size=3, padding=1),  # 32 x 28 x 28
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2),                              # 32 x 14 x 14

            nn.Conv2d(32, 64, kernel_size=3, padding=1),  # 64 x 14 x 14
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),                              # 64 x 7 x 7
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes),
        )

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

# Why this matters in interviews:
# - You can compute output shapes by hand
# - You understand padding, stride, pooling
# - You know why BatchNorm + Dropout are used
# - You can explain parameter counts per layer

Deep learning fresher — 6-month learning plan

Month 1 — Foundations (12–15 hrs/week)
  Week 1: Linear algebra — vectors, matrices, dot products
  Week 2: Matrix multiplication, transpose, inverse intuition
  Week 3: Calculus — derivatives, chain rule, partial derivatives
  Week 4: Probability — distributions, expectation, Bayes

Month 2 — Python + NumPy
  Week 1: Python OOP, functions, list comprehensions
  Week 2: NumPy arrays, broadcasting, vectorized ops
  Week 3: Matplotlib, Pandas basics
  Week 4: Implement linear regression from scratch

Month 3 — Neural networks from scratch
  Week 1: Perceptron, activation functions
  Week 2: Backprop derivation (do it on paper)
  Week 3: Implement a 2-layer NN in NumPy
  Week 4: Implement a 3-layer CNN in NumPy (slow but educational)

Month 4 — PyTorch
  Week 1: Tensors, autograd, nn.Module
  Week 2: DataLoader, transforms, loss functions
  Week 3: Train an MNIST CNN to 99%+
  Week 4: Experiment tracking with W&B

Month 5 — Transformers + Hugging Face
  Week 1: Attention mechanism (implement scaled dot-product)
  Week 2: Load and use a pretrained BERT
  Week 3: Fine-tune DistilBERT on a classification task
  Week 4: Fine-tune T5 for summarization or translation

Month 6 — Deployment + portfolio
  Week 1: FastAPI basics, model serving
  Week 2: Docker for model APIs
  Week 3: ONNX export and inference
  Week 4: Polish portfolio — 3 strong repos

Then 2–3 months of interview prep while applying.

Deep learning portfolio checklist

Repos to publish (pick 3):
  [ ] Fine-tuned transformer on a non-trivial dataset
      (e.g., sentiment, NER, summarization)
  [ ] Vision classifier deployed as an API
      (CNN + FastAPI + Docker + live URL)
  [ ] One from-scratch implementation
      (backprop in NumPy, or attention in PyTorch)

Per-repo requirements:
  [ ] Clear README: problem, approach, results
  [ ] Baseline comparison (not just accuracy)
  [ ] Training curves (W&B screenshot or TensorBoard)
  [ ] Reproducibility — fixed seeds, requirements.txt
  [ ] Inference demo — live URL or sample inputs

Resume bullets (examples):
  [ ] "Fine-tuned DistilBERT on IMDB — 92.1% accuracy,
       trained in 18 min on T4 GPU with fp16"
  [ ] "Deployed image classifier via FastAPI + Docker
       — 45ms p95 latency"
  [ ] "Implemented attention from scratch in PyTorch
       — matched nn.MultiheadAttention on benchmark"

LinkedIn:
  [ ] Add PyTorch, Hugging Face, Transformers to skills
  [ ] Post 1 write-up on a project
  [ ] Link portfolio site or GitHub pinned repos