# First Git repository — from zero to pushed on GitHub
# 1. Install Git (git-scm.com) and configure once
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# 2. Create a project folder
mkdir my-first-project && cd my-first-project

# 3. Initialise the repo
git init

# 4. Create a README
echo "# My First Project" > README.md

# 5. Stage and commit
git add README.md
git commit -m "Add project readme"

# 6. Create the repo on github.com, then connect
git remote add origin https://github.com/username/my-first-project.git

# 7. Push
git branch -M main
git push -u origin main

# Daily Git workflow (the loop you'll run forever)
git status                 # what changed?
git diff                   # exactly what changed?
git add .                  # stage everything
git commit -m "Add X"      # save a snapshot
git push                   # upload to GitHub

# Undo a file that isn't staged
git checkout -- file.py

# Undo the last commit (keep the changes)
git reset --soft HEAD~1

# See recent history
git log --oneline --graph -10

# Team collaboration — branches and pull requests
# 1. Start from main
git checkout main
git pull

# 2. Create a feature branch
git checkout -b feature/add-login

# 3. Work, stage, commit
git add .
git commit -m "Add login form"

# 4. Push the branch
git push -u origin feature/add-login

# 5. Open a Pull Request on GitHub
#    - Reviewers leave comments
#    - Fix and push (same branch)
#    - Approve and merge

# 6. Delete the local branch after merge
git checkout main
git pull
git branch -d feature/add-login

# 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 with the codebase in Git.

Git & GitHub — 30-day beginner plan:
Week 1: Install, init, add, commit, push
Week 2: Branches, merges, pull requests
Week 3: Conflicts, history, revert, .gitignore
Week 4: Contribute to an open-source repo (docs)

Result: Interview-ready for any tech role.
Every role expects Git.

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 (e.g., MNIST or
        a small tabular dataset)

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

Not recommended without:
- Python fundamentals
- Basic linear algebra
- Familiarity with NumPy
- Git (so you can share your work)

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

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

Data analyst path (recommended order):
1. Excel + SQL           (4-8 weeks)
2. Git & GitHub          (1 week)
3. Power BI / Tableau    (4 weeks)
4. Python + Pandas       (4-8 weeks)
5. Statistics basics     (4 weeks)

Roles: Data Analyst, BI Developer,
       MIS Analyst, Reporting Analyst

Note: PyTorch is usually NOT required
for analyst roles — Python and Pandas are.