# Pandas cleaning — the work before any model
import pandas as pd

df = pd.read_csv("orders.csv")

# Inspect
print(df.info())
print(df.isna().sum())
print(df.duplicated().sum())

# Clean
df = df.drop_duplicates()
df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce")
df["revenue"]    = pd.to_numeric(df["revenue"], errors="coerce")
df["revenue"]    = df["revenue"].fillna(df["revenue"].median())
df["city"]       = df["city"].str.strip().str.title()

# Validate before moving on
assert df["revenue"].min() >= 0, "Negative revenue"
assert df["order_date"].notna().all(), "Bad dates"

# What a data science interviewer actually checks:
# - Can you spot the data issues?
# - Do you know which fix to apply and why?
# - Do you validate the result?

# ML model — with the choices explained
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    precision_score, recall_score,
    f1_score, roc_auc_score, confusion_matrix,
)

X = df.drop(columns=["churned"])
y = df["churned"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

model = RandomForestClassifier(
    n_estimators=200,
    max_depth=8,
    class_weight="balanced",   # handle churn imbalance
    random_state=42,
)
model.fit(X_train, y_train)

y_pred  = model.predict(X_test)
y_proba = model.predict_proba(X_test)[:, 1]

print("Precision:", precision_score(y_test, y_pred))
print("Recall:   ", recall_score(y_test, y_pred))
print("F1:       ", f1_score(y_test, y_pred))
print("ROC-AUC:  ", roc_auc_score(y_test, y_proba))
print(confusion_matrix(y_test, y_pred))

# Interview talking points:
# - Why RandomForest? (non-linear, robust, decent defaults)
# - Why class_weight='balanced'? (churn is imbalanced)
# - Which metric matters more here? (usually recall)

# Model serving — the MLOps module
# Every trained model must be deployable, not just accurate.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("churn_model.joblib")

class Customer(BaseModel):
    tenure_months:   int
    monthly_charges: float
    support_tickets: int
    plan:            str

@app.post("/predict")
def predict(c: Customer):
    features = [[
        c.tenure_months, c.monthly_charges,
        c.support_tickets, c.plan,
    ]]
    proba = model.predict_proba(features)[0][1]
    return {
        "churn_probability": round(float(proba), 3),
        "action": "retain" if proba > 0.5 else "monitor",
    }

# In the Uncodemy module you also cover:
# - Dockerising the FastAPI service
# - Deploying to a free host
# - Adding basic monitoring
# This is what makes you stand out in interviews.

Capstone — Customer churn prediction
(the most common data scientist interview project)

1. Business problem
   "Which customers are likely to churn, and why?"

2. Data
   - users.csv (tenure, plan, monthly charges)
   - events.csv (logins, purchases, support)

3. Workflow
   - Clean and merge data
   - Feature engineering (recency, frequency, engagement)
   - Baseline: logistic regression
   - Improved: gradient boosting
   - Evaluate precision, recall, F1, ROC-AUC
   - Calibrate probabilities

4. Explainability
   - SHAP values for top features
   - Business-friendly summary

5. Deployment
   - FastAPI endpoint
   - Dockerised and deployed publicly

6. Documentation
   - README with business framing
   - Two charts that tell the story
   - A 2-minute demo video

What interviewers see:
- Full data science workflow
- Judgment in model choice
- Communication skills
- Deployment capability

Capstone — RAG chatbot on internal documents
(2026's most in-demand project type)

1. Business problem
   "Let employees ask questions across internal docs."

2. Data
   - 50–100 PDFs (your own notes, policies, or public docs)

3. Workflow
   - Chunk and embed documents
   - Store in a vector DB (FAISS or Chroma)
   - Retrieve top-k chunks per query
   - Generate an answer with an LLM
   - Add a citation for each answer

4. Evaluation
   - Faithfulness: does the answer match the source?
   - Coverage: does it answer the question asked?
   - Hallucination checks on 20 hard queries

5. Deployment
   - Streamlit or simple React UI
   - Deployed publicly with a demo login

6. Documentation
   - README with architecture diagram
   - Known limitations listed honestly

What interviewers see:
- Modern GenAI skill
- Evaluation judgment
- Product-thinking
- Ability to ship

This is now the most differentiating project
for data scientist interviews in 2026.

Mock interview structure (data scientist role):

Round 1 — SQL (45 min)
  - 3–4 queries on a real schema
  - JOINs, window functions, aggregation
  - Discussion of query performance

Round 2 — ML theory (45 min)
  - Explain precision vs recall
  - Why would you choose X over Y?
  - Debug an overfitting scenario
  - Handle class imbalance

Round 3 — Coding (45 min)
  - Write a Pandas transformation
  - Implement a simple model from scratch
  - Discuss complexity

Round 4 — Case study (45 min)
  - Business question with a dataset
  - Estimate and validate
  - Recommend an action

Round 5 — Project walkthrough (30 min)
  - Walk through your capstone
  - Explain decisions and trade-offs
  - Handle follow-up questions

Uncodemy-style mocks rehearse all five.

Before you enrol — a data science course checklist:

☐ Attend a demo class
☐ Ask for the full module-by-module syllabus
☐ Confirm it includes deployment (not just modelling)
☐ Confirm the capstone is required, not optional
☐ Ask for the interview mock format
☐ Request names of 2–3 recent alumni in DS roles
☐ Verify placement claims with actual numbers
☐ Confirm refund policy in writing
☐ Confirm batch timings and size
☐ Ask what happens if you miss sessions

This checklist is worth more than any
"100% placement" claim.