Detecting Financial Transaction Fraud

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "txn_id":       ["T001","T002","T003","T004","T005","T006","T007","T008",
                     "T009","T010","T011","T012","T013","T014","T015","T016",
                     "T017","T018","T019","T020"],
    "amount":       [42.8,1840.0,28.5,920.0,65.2,112.4,2450.0,38.9,
                     780.0,55.6,34.2,1560.0,89.4,47.1,3200.0,72.8,
                     910.0,41.3,29.8,1100.0],
    "merchant_cat": ["Grocery","Electronics","Petrol","Online","Restaurant",
                     "Grocery","Electronics","Utility","Online","Petrol",
                     "Grocery","Electronics","Restaurant","Petrol","Online",
                     "Grocery","Online","Restaurant","Grocery","Electronics"],
    "hour":         [14,2,8,23,19,11,3,9,22,7,
                     13,1,18,6,4,15,21,12,16,0],
    "country":      ["Domestic","Foreign","Domestic","Foreign","Domestic",
                     "Domestic","Foreign","Domestic","Foreign","Domestic",
                     "Domestic","Foreign","Domestic","Domestic","Foreign",
                     "Domestic","Foreign","Domestic","Domestic","Foreign"],
    "is_fraud":     [0,1,0,1,0,0,1,0,1,0,
                     0,1,0,0,1,0,1,0,0,1]
})

print(f"Transactions: {len(df)} | Fraud: {df['is_fraud'].sum()} | Legitimate: {(df['is_fraud']==0).sum()}")
print(f"Fraud rate: {df['is_fraud'].mean():.1%}")

# IQR-based outlier detection on transaction amount
Q1  = df["amount"].quantile(0.25)
Q3  = df["amount"].quantile(0.75)
IQR = Q3 - Q1
lower_fence = Q1 - 1.5 * IQR
upper_fence = Q3 + 1.5 * IQR

print(f"\nAmount distribution:")
print(f"  Q1: ${Q1:.2f} | Q3: ${Q3:.2f} | IQR: ${IQR:.2f}")
print(f"  Lower fence: ${lower_fence:.2f} | Upper fence: ${upper_fence:.2f}")

# Flag IQR outliers
df["iqr_outlier"] = ((df["amount"] < lower_fence) | (df["amount"] > upper_fence)).astype(int)

outliers = df[df["iqr_outlier"] == 1][["txn_id","amount","is_fraud"]]
print(f"\nIQR amount outliers ({len(outliers)} transactions):")
print(outliers.sort_values("amount", ascending=False).to_string(index=False))

# What % of IQR outliers are confirmed fraud?
precision = df[df["iqr_outlier"]==1]["is_fraud"].mean()
print(f"\nIQR outlier precision (% that are fraud): {precision:.1%}")

# Signal 1: IQR amount outlier (already computed)
# Signal 2: Odd-hours flag — transactions between 23:00 and 06:00
df["odd_hours"] = ((df["hour"] >= 23) | (df["hour"] <= 6)).astype(int)

# Signal 3: High-risk merchant category
HIGH_RISK_CATS = {"Electronics", "Online"}
df["high_risk_merchant"] = df["merchant_cat"].isin(HIGH_RISK_CATS).astype(int)

# Signal 4: Foreign country flag
df["foreign_flag"] = (df["country"] == "Foreign").astype(int)

# Composite fraud score: sum all four binary signals (0–4)
df["fraud_score"] = df[["iqr_outlier","odd_hours",
                          "high_risk_merchant","foreign_flag"]].sum(axis=1)

# Show signal breakdown for all transactions
print("Transaction fraud signals:")
print(df[["txn_id","amount","hour","merchant_cat","country",
          "iqr_outlier","odd_hours","high_risk_merchant",
          "foreign_flag","fraud_score","is_fraud"]].sort_values(
    "fraud_score", ascending=False
).to_string(index=False))

# Signal correlation with is_fraud
signals = ["iqr_outlier","odd_hours","high_risk_merchant","foreign_flag"]
print("\nCorrelation of each signal with is_fraud:")
for s in signals:
    r = df[s].corr(df["is_fraud"]).round(3)
    print(f"  {s:<22} r = {r:+.3f}")

# Profile comparison: fraud vs legitimate
profile = df.groupby("is_fraud").agg(
    count        = ("txn_id",       "count"),
    mean_amount  = ("amount",       "mean"),
    mean_hour    = ("hour",         "mean"),
    mean_score   = ("fraud_score",  "mean"),
    pct_foreign  = ("foreign_flag", "mean"),
    pct_odd_hrs  = ("odd_hours",    "mean")
).round(2)
profile.index = profile.index.map({0:"Legitimate", 1:"Fraud"})

print("Fraud vs Legitimate profile comparison:")
print(profile.to_string())

# Precision and recall at each score threshold
print("\nComposite score precision and recall:")
print(f"{'Threshold':>10} {'Flagged':>8} {'True Fraud':>10} {'Precision':>10} {'Recall':>8}")
for thresh in [4, 3, 2, 1]:
    flagged    = df[df["fraud_score"] >= thresh]
    true_fraud = flagged["is_fraud"].sum()
    precision  = true_fraud / len(flagged) if len(flagged) > 0 else 0
    recall     = true_fraud / df["is_fraud"].sum()
    print(f"  >= {thresh}  {len(flagged):>8}  {true_fraud:>10}  {precision:>9.1%}  {recall:>7.1%}")

# Pivot: fraud rate by merchant category × country
pivot_fraud = pd.pivot_table(
    df,
    index   = "merchant_cat",
    columns = "country",
    values  = "is_fraud",
    aggfunc = "mean",
    fill_value = 0
).round(2)

print("Fraud rate by merchant category × country:")
print((pivot_fraud * 100).round(0).to_string())

# Mean amount by merchant × country for fraud transactions only
pivot_amount = pd.pivot_table(
    df[df["is_fraud"] == 1],
    index   = "merchant_cat",
    columns = "country",
    values  = "amount",
    aggfunc = "mean",
    fill_value = 0
).round(0)

print("\nMean fraud amount by merchant × country ($):")
print(pivot_amount.to_string())

# Which combination has the highest fraud rate?
stacked = pivot_fraud.stack().reset_index()
stacked.columns = ["merchant_cat","country","fraud_rate"]
stacked = stacked[stacked["fraud_rate"] > 0].sort_values(
    "fraud_rate", ascending=False
)
print("\nHighest-risk combinations (fraud rate > 0):")
print(stacked.to_string(index=False))