# Dockerfile — a container for a Python app
# (works for Flask, FastAPI, PyTorch serving, and more)

FROM python:3.12-slim

WORKDIR /app

# Install dependencies first (better layer caching)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the code
COPY . .

EXPOSE 8000

CMD ["python", "app.py"]

# Build:
#   docker build -t my-python-app .
# Run:
#   docker run -p 8000:8000 my-python-app

# Docker CLI — the commands you'll use every day
# Build an image
docker build -t my-app:1.0 .

# Run a container
docker run -d -p 8000:8000 --name myapp my-app:1.0

# See what's running
docker ps

# Follow logs
docker logs -f myapp

# Open a shell inside the container
docker exec -it myapp bash

# Stop and remove
docker stop myapp
docker rm myapp

# Clean unused images and containers
docker system prune -f

# docker-compose.yml — a small stack
# App + database + optional model service

services:
  web:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://app:app@db:5432/app

  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=app
      - POSTGRES_PASSWORD=app
      - POSTGRES_DB=app
    volumes:
      - dbdata:/var/lib/postgresql/data

volumes:
  dbdata:

# Run the whole stack:
#   docker compose up -d
# Tear it down:
#   docker compose down

# PyTorch — tensors (the foundation)
import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.ones_like(x)

print("x:\n", x)
print("y:\n", y)
print("x + y:\n", x + y)
print("x @ y:\n", x @ y)   # matrix multiply

# GPU if available
device = "cuda" if torch.cuda.is_available() else "cpu"
x = x.to(device)
print("Device:", device, "| On device:", x.device)

# PyTorch — a minimal training loop
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader

# Tiny synthetic dataset
X = torch.randn(1000, 10)
y = (X.sum(dim=1) > 0).long()

loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)

model = nn.Sequential(
    nn.Linear(10, 32),
    nn.ReLU(),
    nn.Linear(32, 2),
)

loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(3):
    epoch_loss = 0
    for xb, yb in loader:
        logits = model(xb)
        loss = loss_fn(logits, yb)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        epoch_loss += loss.item()

    print(f"Epoch {epoch+1}: loss={epoch_loss/len(loader):.4f}")

# PyTorch — save and load models
import torch
import torch.nn as nn

# Save only the learned parameters (recommended)
torch.save(model.state_dict(), "model.pt")

# Recreate the model architecture, then load weights
model2 = nn.Sequential(
    nn.Linear(10, 32),
    nn.ReLU(),
    nn.Linear(32, 2),
)
model2.load_state_dict(torch.load("model.pt", weights_only=True))
model2.eval()

# Save / load the full model object (for quick prototyping)
torch.save(model, "model_full.pt")
model3 = torch.load("model_full.pt", weights_only=False)

# In production, always ship:
# 1. The state_dict
# 2. The model architecture code
# 3. The preprocessing pipeline
# — usually packaged inside a Docker image with the app.

Docker — 30-day beginner plan:
Week 1: Install, images vs containers, first run
Week 2: Dockerfile, build, run your app
Week 3: Volumes, networking, docker compose
Week 4: Deploy a small stack, read logs, fix errors

Result: Confident Docker user — a universal,
        interview-relevant skill in 4 weeks.

PyTorch — 30-day plan (assumes Python basics):
Week 1: Tensors, devices, autograd
Week 2: nn.Module, layers, loss functions
Week 3: Training loop, optimizers, metrics
Week 4: Real dataset project (MNIST or tabular)

Result: Can build a small model end-to-end.

Not recommended without:
- Python fundamentals
- Basic linear algebra
- Familiarity with NumPy
- Git and (ideally) Docker

AI / ML engineering path (recommended order):
1. Python fundamentals     (4-8 weeks)
2. Git & GitHub            (1 week)
3. Docker                  (1-2 weeks)
4. NumPy + math basics     (2-4 weeks)
5. ML fundamentals         (4-8 weeks)
6. PyTorch                 (4-8 weeks)
7. Dockerised deployment   (2-4 weeks)

Roles: ML Engineer, AI Engineer,
       MLOps Engineer, Research Engineer

DevOps / platform path (recommended order):
1. Linux basics            (2-4 weeks)
2. Bash + one language     (4-6 weeks)
3. Git & GitHub            (1 week)
4. Docker                  (2-3 weeks)
5. Kubernetes              (4-8 weeks)
6. Terraform               (3-4 weeks)
7. Cloud (AWS/GCP/Azure)   (4-8 weeks)

Roles: DevOps Engineer, Platform Engineer,
       SRE, Cloud Engineer