Non-IT Graduate to ML Engineer: Career Timeline

# Phase 1 (months 1–2): Python + Pandas — the foundation
# A real data exploration task you'll do dozens of times

import pandas as pd
import numpy as np

# Load real data
df = pd.read_csv("sales_data.csv")

# Understand the shape of the data
print(df.shape)          # (rows, columns)
print(df.info())         # types, null counts
print(df.describe())     # numeric stats

# Handle missing values
df["revenue"] = df["revenue"].fillna(0)
df = df.dropna(subset=["customer_id"])

# Feature engineering
df["order_date"] = pd.to_datetime(df["order_date"])
df["month"] = df["order_date"].dt.month
df["is_weekend"] = df["order_date"].dt.dayofweek.isin([5, 6])

# Aggregation
monthly = df.groupby("month").agg(
    total_revenue=("revenue", "sum"),
    order_count=("order_id", "count"),
    avg_order=("revenue", "mean")
)

print(monthly)

# This is the kind of work you'll do daily in months 1–5.
# Master it — it's 40% of real ML engineering.

# Phase 1 (months 3–4): NumPy + math
# The math foundation for ML — but in practical terms

import numpy as np

# Linear algebra — matrix operations (used in every NN)
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print("Matrix multiply:\n", A @ B)
print("Transpose:\n", A.T)
print("Determinant:", np.linalg.det(A))

# Calculus — derivatives (concept of gradient descent)
# Simulate gradient of f(x) = x^2 at x=3
def f(x): return x**2
def numerical_gradient(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

print("Gradient at x=3:", numerical_gradient(f, 3.0))  # ≈ 6

# Statistics — used in every ML evaluation
samples = np.random.normal(loc=50, scale=10, size=1000)
print("Mean:", samples.mean())      # ≈ 50
print("Std dev:", samples.std())    # ≈ 10

# You don't need to derive theorems — you need to know what these mean
# when scikit-learn calls them internally.

# Phase 3 (month 14): serve an ML model as an API
# (this is what separates "did a course" from "can deploy")

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import numpy as np

app = FastAPI(title="Iris Classifier API")
model = joblib.load("iris_model.pkl")

class PredictionRequest(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

class PredictionResponse(BaseModel):
    prediction: str
    confidence: float

@app.get("/health")
def health():
    return {"status": "ok"}

@app.post("/predict", response_model=PredictionResponse)
def predict(req: PredictionRequest):
    try:
        features = np.array([[
            req.sepal_length, req.sepal_width,
            req.petal_length, req.petal_width
        ]])
        pred = model.predict(features)[0]
        proba = model.predict_proba(features).max()
        classes = ["setosa", "versicolor", "virginica"]
        return PredictionResponse(
            prediction=classes[pred],
            confidence=float(proba)
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Run: uvicorn main:app --reload
# Visit: http://127.0.0.1:8000/docs
# Real skills: serving models, Pydantic validation, error handling.

# Phase 3 (month 13–16): deploy your model with Docker
# The container that makes your ML work run anywhere

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

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

# Copy model + code
COPY model.pkl .
COPY main.py .

EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# requirements.txt
# fastapi==0.115.0
# uvicorn[standard]==0.32.0
# scikit-learn==1.5.2
# joblib==1.4.2
# numpy==2.1.0

# Build and run:
# docker build -t iris-api .
# docker run -p 8000:8000 iris-api
# curl -X POST http://localhost:8000/predict \
#   -H "Content-Type: application/json" \
#   -d '{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}'

# Result: real production ML service.
# This is what interviews actually test — not just "I trained a model".