Machine Learning Career Options for Students in Delhi NCR

# ml-pipeline.py — a complete ML project a student should be able to build
# This is roughly what an ML Engineer interview expects.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import classification_report, roc_auc_score

# 1. Load a real dataset
df = pd.read_csv("https://raw.githubusercontent.com/plotly/datasets/master/telecom_churn.csv")
df = df.dropna()

# 2. Separate target from features
y = df["Churn"].astype(int)
X = df.drop(columns=["Churn"])

# 3. Column-level preprocessing
cat_cols = X.select_dtypes(include="object").columns.tolist()
num_cols = X.select_dtypes(exclude="object").columns.tolist()

preprocess = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), num_cols),
        ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols),
    ]
)

# 4. Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# 5. Two models — baseline and improved
rf = Pipeline([("pre", preprocess),
               ("clf", RandomForestClassifier(n_estimators=300, random_state=42))])
gb = Pipeline([("pre", preprocess),
               ("clf", GradientBoostingClassifier(random_state=42))])

for name, model in [("RandomForest", rf), ("GradientBoosting", gb)]:
    cv = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc")
    model.fit(X_train, y_train)
    proba = model.predict_proba(X_test)[:, 1]
    print(f"{name}: CV AUC={cv.mean():.3f}, Test AUC={roc_auc_score(y_test, proba):.3f}")

# 6. Final report on the better model
best = gb if roc_auc_score(y_test, gb.predict_proba(X_test)[:, 1]) > \
       roc_auc_score(y_test, rf.predict_proba(X_test)[:, 1]) else rf
print(classification_report(y_test, best.predict(X_test)))

# What this shows a Delhi NCR interviewer:
# - You can load and clean real data
# - You preprocess categoricals and numerics correctly (not just drop them)
# - You use cross-validation, not just one train-test split
# - You compare models honestly
# - You report AUC, not just accuracy — because class imbalance is normal

# neural_net.py — a PyTorch model, the kind an ML Research Engineer writes
# Students heading toward NLP, computer vision, or research should know this.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 1. Define a small neural network
class ChurnNet(nn.Module):
    def __init__(self, input_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1),
        )

    def forward(self, x):
        return self.net(x).squeeze(-1)

# 2. Prepare tensors
# (In a real project, X and y come from the preprocessing pipeline.)
X = torch.randn(1000, 30)   # 30 features
y = torch.randint(0, 2, (1000,)).float()

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

# 3. Instantiate model, loss, optimizer
model = ChurnNet(input_dim=30)
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# 4. Train
for epoch in range(10):
    model.train()
    total_loss = 0.0
    for xb, yb in loader:
        optimizer.zero_grad()
        logits = model(xb)
        loss = criterion(logits, yb)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * len(xb)
    print(f"Epoch {epoch + 1}: loss={total_loss / len(dataset):.4f}")

# 5. Save
torch.save(model.state_dict(), "churn_net.pt")

# Why this matters:
# - PyTorch is the standard for deep learning in Delhi NCR startups
# - This shows you understand tensors, autograd, and training loops
# - Most entry roles don't need this, but NLP/CV roles do
# - If your course only teaches sklearn, you're missing the deep learning layer

# serve_model.py — deployment, the skill that separates a portfolio from homework
# Every ML Engineer and MLOps role in Delhi NCR touches this.

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

model = joblib.load("churn_model.pkl")
scaler = joblib.load("churn_scaler.pkl")

app = FastAPI(title="Churn Prediction API")

class Customer(BaseModel):
    tenure: int
    monthly_charges: float
    total_charges: float
    has_internet: bool
    contract_type: str

def encode(customer: Customer) -> np.ndarray:
    # Encode categorical values consistently with training
    contract_map = {"month-to-month": 0, "one_year": 1, "two_year": 2}
    features = np.array([[
        customer.tenure,
        customer.monthly_charges,
        customer.total_charges,
        int(customer.has_internet),
        contract_map.get(customer.contract_type, 0),
    ]])
    return scaler.transform(features)

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

@app.post("/predict")
def predict(customer: Customer):
    X = encode(customer)
    prob = float(model.predict_proba(X)[0][1])
    return {
        "churn_probability": round(prob, 4),
        "risk_band": "high" if prob > 0.6 else "low",
    }

# Run: uvicorn serve_model:app --reload
# Test: POST to http://localhost:8000/predict with a JSON body
#
# Why this matters:
# - Companies in Delhi NCR don't hire for notebooks — they hire for models in production
# - Deployment is what separates a portfolio project from a homework submission
# - If your course never covers this, your portfolio is missing the
#   single piece that impresses engineering managers