Can a Bank Employee Become an ML Engineer Without a Degree?

# churn_model.py — an end-to-end ML project any bank employee can build
# Uses a public banking dataset to predict customer churn.
# This is the type of project that directly uses your domain knowledge.

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

# 1. Load real banking data (Kaggle: churn modelling dataset)
df = pd.read_csv("bank_churn.csv")
df = df.dropna()

# 2. Target and features
y = df["Exited"]
X = df.drop(columns=["Exited", "CustomerId", "Surname"])

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

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

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

# 5. Train a model
model = Pipeline([
    ("pre", pre),
    ("clf", GradientBoostingClassifier(random_state=42)),
])
model.fit(X_train, y_train)

# 6. Evaluate on AUC — the right metric for imbalanced problems
proba = model.predict_proba(X_test)[:, 1]
print("AUC:", round(roc_auc_score(y_test, proba), 3))
print(classification_report(y_test, (proba > 0.5).astype(int)))


# Why this project fits a bank employee specifically:
# - It uses a banking dataset, so you already understand what the
#   columns mean and why churn matters.
# - It demonstrates proper train/test split, stratification, and AUC.
# - It maps directly to real work in banking ML teams.
#
# What interviewers look for:
# - Do you know why AUC is better than accuracy here?
# - Can you interpret false positives vs false negatives in banking context?
# - Do you validate the model beyond raw metrics?

# credit_risk.py — a credit default prediction project
# Uses the classic German Credit dataset — one of the most common
# interview project topics in banking ML.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import roc_auc_score, confusion_matrix

# Load the German Credit dataset (available via sklearn)
from sklearn.datasets import fetch_openml
data = fetch_openml(name="credit-g", version=1, as_frame=True)

X = pd.get_dummies(data.data)
y = (data.target == "bad").astype(int)  # 1 = default

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

# Logistic regression is still the standard baseline in banking
model = Pipeline([
    ("scale", StandardScaler(with_mean=False)),
    ("clf", LogisticRegression(max_iter=1000)),
])
model.fit(X_train, y_train)

proba = model.predict_proba(X_test)[:, 1]
print("AUC:", round(roc_auc_score(y_test, proba), 3))

# The confusion matrix is often more useful than accuracy in banking
cm = confusion_matrix(y_test, (proba > 0.5).astype(int))
print("Confusion matrix:\n", cm)

# Interpret coefficients in business terms
coefs = model.named_steps["clf"].coef_[0]
feature_names = X.columns
importance = sorted(zip(feature_names, coefs), key=lambda x: abs(x[1]), reverse=True)[:10]
print("Top drivers (positive = increases default risk):")
for name, coef in importance:
    print(f"  {name}: {coef:+.3f}")


# Why this project fits a bank employee:
# - Credit risk is a domain you already understand.
# - Logistic regression is still the industry standard for interpretability.
# - Confusion matrix maps directly to cost-of-error thinking.
#
# What interviewers look for:
# - Do you know why logistic regression is still used over more complex models?
# - Can you explain coefficients in business terms?
# - Do you think about regulatory constraints?

# serve_fraud_model.py — deployment with FastAPI
# Banks care about deployable models, not just notebooks.

import joblib
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = joblib.load("fraud_model.pkl")
scaler = joblib.load("fraud_scaler.pkl")


class Transaction(BaseModel):
    amount: float
    hour: int
    merchant_category: str
    customer_age: int
    previous_declines: int


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


@app.post("/predict")
def predict(txn: Transaction):
    features = [[
        txn.amount, txn.hour, txn.customer_age, txn.previous_declines,
    ]]
    scaled = scaler.transform(features)
    proba = model.predict_proba(scaled)[0][1]

    return {
        "fraud_probability": round(float(proba), 4),
        "decision": "review" if proba > 0.5 else "approve",
        "model_version": "v1.0.0",
    }


# Why this matters:
# - Banks deploy models, not Jupyter notebooks.
# - A small API like this is often part of the interview process.
# - It demonstrates deployment thinking, which many ML candidates lack.
#
# What interviewers look for:
# - Do you log inputs and outputs (for audit)?
# - Do you version the model?
# - Do you handle edge cases (missing values, bad inputs)?