Deep Learning Skills That Recruiters Look For in 2026

import torch

# A tiny model: y = w * x + b, trained on one example
w = torch.tensor(0.5, requires_grad=True)
b = torch.tensor(0.0, requires_grad=True)
x, y_true = torch.tensor(2.0), torch.tensor(5.0)

for step in range(50):
    y_pred = w * x + b
    loss = (y_pred - y_true) ** 2
    loss.backward()                 # backpropagation
    with torch.no_grad():
        w -= 0.05 * w.grad          # gradient descent
        b -= 0.05 * b.grad
        w.grad.zero_(); b.grad.zero_()

print(round(w.item(), 3), round(b.item(), 3), round(loss.item(), 5))

import torch
from torch import nn

# Multi-class classification: raw scores (logits) for 3 classes
logits = torch.tensor([[2.0, 0.5, -1.0],
                       [0.1, 1.5,  0.3]])
targets = torch.tensor([0, 1])     # correct class indices

# CrossEntropyLoss applies softmax internally - pass raw logits
loss = nn.CrossEntropyLoss()(logits, targets)
print("cross-entropy:", round(loss.item(), 4))

# Regression: predict numbers -> mean squared error
pred, true = torch.tensor([2.5, 0.0]), torch.tensor([3.0, -0.5])
print("MSE:", nn.MSELoss()(pred, true).item())

import torch

def run_epoch(model, loader, loss_fn, optimizer=None, device="cpu"):
    training = optimizer is not None
    model.train() if training else model.eval()
    total, n = 0.0, 0
    with torch.set_grad_enabled(training):
        for x, y in loader:
            x, y = x.to(device), y.to(device)
            loss = loss_fn(model(x), y)
            if training:
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
            total += loss.item() * len(x)
            n += len(x)
    return total / n

# for epoch in range(20):
#     tr = run_epoch(model, train_loader, loss_fn, optimizer)
#     va = run_epoch(model, val_loader, loss_fn)
#     print(epoch, round(tr, 4), round(va, 4))

# Stop when validation loss stops improving (uses run_epoch from the left tab)
import copy

best_loss, best_state, patience, bad_epochs = float("inf"), None, 3, 0

for epoch in range(100):
    train_loss = run_epoch(model, train_loader, loss_fn, optimizer)
    val_loss = run_epoch(model, val_loader, loss_fn)
    if val_loss < best_loss - 1e-4:
        best_loss, best_state, bad_epochs = val_loss, copy.deepcopy(model.state_dict()), 0
    else:
        bad_epochs += 1
        if bad_epochs >= patience:
            print(f"stopping at epoch {epoch}")
            break

model.load_state_dict(best_state)

import torch
import torch.nn.functional as F

# Scaled dot-product attention for a tiny sequence of 4 tokens
torch.manual_seed(0)
Q = torch.randn(4, 8)   # queries
K = torch.randn(4, 8)   # keys
V = torch.randn(4, 8)   # values

scores = Q @ K.T / (K.shape[-1] ** 0.5)
weights = F.softmax(scores, dim=-1)      # each row sums to 1
output = weights @ V

print(weights.sum(dim=-1))   # tensor([1., 1., 1., 1.])
print(output.shape)          # torch.Size([4, 8])

# pip install fastapi uvicorn torch
# run: uvicorn serve_model:app
import torch
from torch import nn
from fastapi import FastAPI

model = nn.Sequential(nn.Linear(4, 16), nn.ReLU(), nn.Linear(16, 3))
# model.load_state_dict(torch.load("model.pt", map_location="cpu"))
model.eval()

app = FastAPI()

@app.post("/predict")
def predict(features: list[float]):
    with torch.no_grad():
        x = torch.tensor([features], dtype=torch.float32)
        probs = torch.softmax(model(x), dim=1)[0]
    return {"class": int(probs.argmax()), "confidence": round(float(probs.max()), 3)}

Skill                  | Evidence                                   | Link
-----------------------|--------------------------------------------|-----
Fundamentals           | Hand-written training loop notebook         |
Training & debugging   | Experiment log with learning curves         |
CNNs                   | Transfer-learning image project            |
Transformers           | Fine-tuned text classifier                 |
Deployment             | FastAPI or Docker demo                     |
Communication          | Blog post explaining one project           |

# [Project title]

## Problem and data
What, why, dataset source and licence.

## Baseline
Simple model and its score.

## Model
Architecture, pretrained weights used, key settings.

## Training
Learning curves, what failed, what fixed it.

## Results
Test metrics + error analysis (examples of failures).

## Deployment
How to run the API or demo.

## Limitations and next steps

Run | Change made          | Train loss | Val loss | Metric | Keep?
----|----------------------|------------|----------|--------|------
1   | baseline             |            |          |        |
2   | lr 1e-3 -> 3e-4      |            |          |        |
3   | + augmentation       |            |          |        |
4   | + dropout 0.3        |            |          |        |

One change per run. Note why you tried it.