import torch
from torch import nn

torch.manual_seed(0)
X = torch.randn(256, 10)
y = (X[:, 0] + X[:, 1] > 0).long()          # simple synthetic labels

model = nn.Sequential(nn.Linear(10, 32), nn.ReLU(), nn.Linear(32, 2))
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(50):
    opt.zero_grad()
    loss = loss_fn(model(X), y)
    loss.backward()
    opt.step()

acc = (model(X).argmax(1) == y).float().mean().item()
print(f"loss={loss.item():.3f} train_acc={acc:.2f}")

import numpy as np

def softmax(z):
    z = z - z.max(axis=-1, keepdims=True)   # numerical stability
    e = np.exp(z)
    return e / e.sum(axis=-1, keepdims=True)

print(softmax(np.array([2.0, 1.0, 0.1])).round(3))   # [0.659 0.242 0.099]

import torch
from torch import nn
from torchvision import models

# Start from ImageNet weights, replace the final layer for 3 classes
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)
for p in model.parameters():
    p.requires_grad = False                 # freeze the backbone first
model.fc = nn.Linear(model.fc.in_features, 3)

optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)
preprocess = weights.transforms()           # use the matching preprocessing
# Train on your DataLoader, then unfreeze later layers to fine-tune further

# pip install sentence-transformers
from sentence_transformers import SentenceTransformer, util

model = SentenceTransformer("all-MiniLM-L6-v2")
docs = [
    "Refunds are processed within seven working days.",
    "You can change your batch timing from the student portal.",
    "Certificates are issued after the final project review.",
]
doc_emb = model.encode(docs, convert_to_tensor=True)
query = model.encode("How do I switch to a weekend batch?", convert_to_tensor=True)
best = util.cos_sim(query, doc_emb).argmax().item()
print(docs[best])

# pip install fastapi uvicorn torch
import torch
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = torch.jit.load("model.pt")   # a TorchScript model exported earlier
model.eval()

class Features(BaseModel):
    values: list[float]

@app.post("/predict")
def predict(f: Features):
    with torch.no_grad():
        logits = model(torch.tensor([f.values]))
    return {"class": int(logits.argmax(1).item())}

# pip install mlflow
import mlflow

with mlflow.start_run(run_name="resnet18-freeze"):
    mlflow.log_params({"lr": 1e-3, "epochs": 5, "frozen": True})
    # ... train ...
    mlflow.log_metric("val_accuracy", 0.91)   # use your real result
    mlflow.log_artifact("confusion_matrix.png")
# View runs: mlflow ui

Spend one weekend on each mini-task
Vision:  fine-tune a classifier on 3 classes of your own photos
NLP:     build an embedding search over 50 FAQ answers
MLOps:   serve any trained model with FastAPI and log runs in MLflow
Rate each 1-5: enjoyment ____  confidence ____  wanted to continue? ____

Scan 20 ML/DL job posts in your target city
Computer vision mentions: ____
NLP / LLM mentions:       ____
MLOps / deployment:       ____
Speech / audio:           ____
Skills repeated most:     ____
Combine this with your interest test.

Chosen area: ____
Foundation gaps to close: ____
Three projects (increasing difficulty):
1. ____  2. ____  3. ____
Evaluation I will report: ____
Deployment target: ____
Review date: ____