Artificial Intelligence Career Options for Students in Delhi

# Load, clean, and summarise a real dataset
import pandas as pd

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

# First things every AI student should do:
print(df.shape)                 # rows, columns
print(df.isna().sum())          # missing values per column
print(df["region"].value_counts())

# Clean
df = df.dropna(subset=["amount"])
df["order_date"] = pd.to_datetime(df["order_date"])

# Summarise
revenue = (
    df.groupby(df["order_date"].dt.to_period("M"))["amount"]
      .sum()
      .reset_index()
)
print(revenue.tail())

# Why this matters:
# - 70% of an AI job is data wrangling
# - Interviewers ask "walk me through your data"
# - pandas fluency is assumed, not taught

-- SQL is non-negotiable for every AI track
-- Top customers by revenue in the last 90 days

SELECT
  u.id,
  u.email,
  COUNT(o.id)        AS order_count,
  SUM(o.total_amount) AS lifetime_value
FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.created_at >= NOW() - INTERVAL '90 days'
GROUP BY u.id, u.email
HAVING SUM(o.total_amount) > 5000
ORDER BY lifetime_value DESC
LIMIT 25;

-- What interviewers look for:
-- - JOINs (users × orders)
-- - Aggregation (COUNT, SUM)
-- - Filtering (WHERE, HAVING)
-- - Sorting + limiting
-- - Clear column names

-- If you can write this, you clear the SQL round.

# Your first end-to-end ML model
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
import pandas as pd

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

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
)

model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

preds = model.predict(X_test)
print(classification_report(y_test, preds))

# Why this matters:
# - Demonstrates the full ML loop
# - Shows you understand train/test split
# - Shows you can read precision/recall
# - This one notebook is 50% of a portfolio

# Project 1: Exploratory data analysis on a public dataset
# Goal: show you can read data before modelling it

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

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

# 1. Shape and types
print(df.dtypes)

# 2. Missing values
print(df.isna().sum())

# 3. Distribution
df["release_year"].value_counts().sort_index().plot()
plt.title("Titles released per year")
plt.savefig("release_trend.png")

# 4. Correlation (numeric cols only)
sns.heatmap(df.select_dtypes("number").corr(), annot=True)
plt.savefig("correlations.png")

# What interviewers want to see:
# - Question → chart → insight (not just code)
# - Clean code, readable variable names
# - A short README explaining findings

# Project 2: End-to-end ML with a proper evaluation
# Goal: show you understand the ML loop, not just .fit()

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import pandas as pd

df = pd.read_csv("employee_attrition.csv")
X = df.drop(columns=["attrition"])
y = df["attrition"]

num_cols = X.select_dtypes("number").columns.tolist()
cat_cols = X.select_dtypes("object").columns.tolist()

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

pipe = Pipeline([
    ("pre", pre),
    ("clf", RandomForestClassifier(n_estimators=300, random_state=42)),
])

scores = cross_val_score(pipe, X, y, cv=5, scoring="f1_macro")
print(f"CV F1: {scores.mean():.3f} ± {scores.std():.3f}")

# What interviewers want to see:
# - Proper train/CV split
# - Column-aware preprocessing
# - Metric choice justified
# - Reproducibility (random_state)

# Project 3: Deploy a model as an API
# Goal: show you can ship, not just train

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

app = FastAPI(title="Attrition Predictor")
model = joblib.load("attrition_pipeline.pkl")

class Employee(BaseModel):
    age: int
    monthly_income: float
    years_at_company: int
    overtime: str
    job_role: str

@app.post("/predict")
def predict(emp: Employee):
    row = np.array([[
        emp.age, emp.monthly_income, emp.years_at_company,
        emp.overtime, emp.job_role,
    ]], dtype=object)
    proba = model.predict_proba(row)[0][1]
    return {"attrition_risk": float(proba)}

# Run:
#   uvicorn app:app --reload
#   curl -X POST localhost:8000/predict -d '{...}'

# Why this matters:
# - Most students stop at a notebook
# - A deployed API beats 10 notebooks
# - This is what "AI engineer" actually looks like

# Attrition Predictor

An end-to-end ML project that predicts employee
attrition risk from HR data.

## Problem
HR teams waste hours manually reviewing at-risk
employees. This tool scores attrition probability
in under a second.

## Approach
- Dataset: 1,470 records (IBM HR dataset)
- Features: 35 columns, mixed numeric + categorical
- Model: RandomForest with ColumnTransformer
- Metric: F1-macro (chose this over accuracy
  because classes are imbalanced)

## Results
- CV F1-macro: 0.71 ± 0.03
- Top drivers: overtime, monthly income, tenure

## Live demo
https://attrition-demo.onrender.com

## How to run
    pip install -r requirements.txt
    uvicorn app:app --reload

## What I learned
- Class imbalance handling
- Column-aware preprocessing
- FastAPI deployment

# Why this README works:
# - Leads with the problem, not the code
# - Explains the metric choice
# - Links to a live demo
# - Ends with reflection

# GitHub profile hygiene (5 things recruiters check)

1. Pinned repos
   - 3–5 best projects only
   - Pinned in the order you want them read

2. Commit messages
   - Bad: "update", "final", "asdf"
   - Good: "Add cross-validation to attrition pipeline"

3. READMEs
   - Every project needs one
   - Start with the problem, end with the result

4. Live demos
   - Deploy at least one project (Render, Railway, HF Spaces)
   - A link beats a screenshot

5. Consistency
   - Regular commits over 6+ months beat
     a burst of activity last weekend
   - Recruiters check activity graphs

# The 30-second rule:
# If a recruiter cannot tell what your top
# project does in 30 seconds, it is not pinned
# effectively.