# Fraud detection — a simple PyTorch model
# Input: engineered features from transactions
# Goal: probability of fraud per transaction

import torch
import torch.nn as nn

class FraudNet(nn.Module):
    def __init__(self, n_features):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_features, 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)

# In practice:
# - Class imbalance is severe (often <1% fraud)
# - Use pos_weight in BCEWithLogitsLoss or focal loss
# - Evaluate with PR-AUC and recall at a fixed FPR
# - Calibrate outputs before using for decisions

# Credit risk — gradient-boosted + neural ensemble
# A very common fintech pattern for tabular data

import torch
import torch.nn as nn

class CreditRiskMLP(nn.Module):
    def __init__(self, n_features):
        super().__init__()
        self.blocks = nn.Sequential(
            nn.Linear(n_features, 128),
            nn.BatchNorm1d(128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1),
        )

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

# Responsibilities touch on:
# - Feature engineering from bureau + bank statements
# - Explainability (SHAP, monotonic constraints)
# - Calibration to PD (probability of default)
# - Fairness checks across demographic slices
# - Regulatory documentation

# AML — sequence model over transaction history
# Sequence of transactions per customer → risk score

import torch
import torch.nn as nn

class AMLSequenceModel(nn.Module):
    def __init__(self, n_features, hidden=64):
        super().__init__()
        self.gru = nn.GRU(
            input_size=n_features,
            hidden_size=hidden,
            batch_first=True,
            num_layers=2,
            bidirectional=False,
        )
        self.head = nn.Linear(hidden, 1)

    def forward(self, seq, lengths=None):
        out, _ = self.gru(seq)
        # Take last valid timestep per sequence
        last = out[:, -1, :]
        return self.head(last).squeeze(-1)

# Responsibilities:
# - Model entity-relationship graphs
# - Detect structuring, layering, smurfing
# - Reduce false positives to save investigator time
# - Generate human-readable risk narratives

# FastAPI — real-time fraud scoring
# Target: under 100ms per request in production

from fastapi import FastAPI
from pydantic import BaseModel
import torch
import torch.nn as nn
import joblib

app = FastAPI()

# Load once at startup
model = nn.Sequential(
    nn.Linear(40, 64), nn.ReLU(),
    nn.Linear(64, 32), nn.ReLU(),
    nn.Linear(32, 1),
)
model.load_state_dict(torch.load("fraud.pt", weights_only=True))
model.eval()

scaler = joblib.load("scaler.joblib")

class Txn(BaseModel):
    amount: float
    hour: int
    country_risk: float
    user_txn_count_24h: int
    # ... more features

@app.post("/score")
def score(txn: Txn):
    with torch.no_grad():
        x = scaler.transform([[
            txn.amount, txn.hour,
            txn.country_risk, txn.user_txn_count_24h,
        ]])
        x = torch.tensor(x, dtype=torch.float32)
        proba = torch.sigmoid(model(x)).item()
    return {"fraud_probability": round(proba, 4)}

# Drift monitoring — a core responsibility in fintech
# Compare production feature distribution vs training.

import pandas as pd
from scipy.stats import ks_2samp

train = pd.read_parquet("features_train.parquet")
live  = pd.read_parquet("features_live_7d.parquet")

def drift_report(cols, alpha=0.05):
    out = []
    for col in cols:
        stat, p = ks_2samp(train[col], live[col])
        out.append({
            "feature": col,
            "ks_stat": round(stat, 4),
            "p_value": round(p, 4),
            "drift": p < alpha,
        })
    return pd.DataFrame(out).sort_values("ks_stat", ascending=False)

# Typical fintech cadence:
# - Weekly drift report by data type
# - Alert if top-5 features show drift
# - Escalate to model retraining review

Portfolio project — fraud detection on a public dataset
(e.g., IEEE-CIS or a Kaggle credit card dataset)

1. EDA and feature engineering
   - Time-based features, aggregates per user
   - Handle class imbalance carefully

2. Modelling
   - Baseline: logistic regression / XGBoost
   - Improvement: PyTorch MLP or sequence model
   - Calibrate probabilities (Platt or isotonic)

3. Evaluation
   - PR-AUC, recall at fixed FPR
   - Cost matrix using realistic fraud loss values
   - SHAP for top-N explanations

4. Deployment
   - FastAPI endpoint with <100ms latency
   - Docker container
   - Simple monitoring dashboard

5. Documentation
   - README with business framing
   - Explain trade-offs and decisions
   - Note what you would test with A/B

This project alone can carry an interview conversation
for 30 minutes — that's the goal.

6-month roadmap into fintech DL roles:

Months 1-2:
- Python, NumPy, Pandas refresher
- ML fundamentals (bias-variance, calibration)
- SQL deep practice

Months 3-4:
- PyTorch model building
- Work through 2 public fintech datasets
- Learn SHAP and calibration

Month 5:
- Deploy one model via FastAPI + Docker
- Add monitoring and drift report

Month 6:
- Interview prep: ML theory, system design
- Refine portfolio
- Apply to fraud / credit / AML teams

Cities hiring most in India:
Bengaluru, Mumbai, Gurugram, Hyderabad, Pune.