Handling Imbalanced Data in Machine Learning

The Class Imbalance Problem ⚖️Class Imbalance की समस्या ⚖️类别不平衡问题 ⚖️

Many of the most useful prediction tasks are about rare events: fraud, disease, machine failure, network attacks. When one class is rare, a model can score very well on the usual metrics while doing nothing useful, because simply saying "no" is almost always right. Handling imbalance starts with measuring the right thing.

सबसे काम की कई prediction समस्याएँ दुर्लभ घटनाओं के बारे में हैं: fraud, बीमारी, मशीन ख़राबी, network हमले। जब एक class दुर्लभ हो, तो model आम metrics पर बहुत अच्छा score कर सकता है बिना कुछ काम का किए, क्योंकि बस "नहीं" कहना लगभग हमेशा सही होता है। Imbalance संभालना सही चीज़ मापने से शुरू होता है।

许多最有价值的预测任务都与罕见事件有关：欺诈、疾病、设备故障、网络攻击。当某一类很罕见时，模型可以在常用指标上得分很高却毫无用处，因为一直说“不是”几乎总是对的。处理不平衡要从衡量正确的东西开始。

Step 1 — Measure the Imbalance 🔍Step 1 — Imbalance मापें 🔍第 1 步 —— 度量不平衡 🔍

Count both classes, the ratio and the absolute number of rare rows. The absolute number matters as much as the ratio: 228 frauds in training is enough to learn from; 12 would not be. Split with stratify=y so train, validation and test keep the same fraud rate. Rough guide: up to about 1:10 often needs nothing special; beyond 1:100 plan carefully — but always let validation results decide.

दोनों classes, ratio और दुर्लभ rows की असल संख्या गिनें। असल संख्या ratio जितनी ही अहम है: training में 228 frauds से सीखा जा सकता है; 12 से नहीं। stratify=y से split करें ताकि train, validation और test में fraud दर एक जैसी रहे। मोटा अनुमान: लगभग 1:10 तक अक्सर कुछ ख़ास नहीं चाहिए; 1:100 से आगे ध्यान से योजना बनाएँ — पर फ़ैसला हमेशा validation नतीजों पर छोड़ें।

统计两类的数量、比例以及少数类的绝对数量。绝对数量与比例同样重要：训练集中 228 起欺诈足以学习；12 起就不够。用 stratify=y 划分，让训练、验证和测试集保持相同的欺诈率。粗略参考：约 1:10 以内通常无需特殊处理；超过 1:100 要谨慎规划 —— 但最终总由验证结果决定。

# 1) Measure the imbalance, and see why accuracy fools you
import numpy as np, pandas as pd
from collections import Counter
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.metrics import accuracy_score, recall_score, precision_score
df = pd.read_csv("transactions.csv")
df["log_amount"] = np.log(df["amount"])
df["night"] = ((df["hour"] <= 4) | (df["hour"] >= 23)).astype(int)
feats = ["log_amount", "night", "km_from_home", "txns_last_hour", "account_age_days", "merchant_risk"]
X, y = df[feats], df["fraud"]
X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, stratify=y_tmp, random_state=0)   # 60 / 20 / 20
counts = y_train.value_counts()
print(f"train: {Counter(y_train)} → imbalance ratio {counts.max() / counts.min():.0f}:1")
for name, m in [("always 'not fraud'", DummyClassifier(strategy="most_frequent")),
                ("logistic regression", make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)))]:
    pred = m.fit(X_train, y_train).predict(X_test)
    print(f"{name:<20} accuracy {accuracy_score(y_test, pred):.4f} | recall {recall_score(y_test, pred):.3f} | "
          f"precision {precision_score(y_test, pred, zero_division=0):.3f} | frauds caught {int((pred & y_test).sum())}/{int(y_test.sum())}")

Step 2 — Use the Right Metrics 📏Step 2 — सही Metrics इस्तेमाल करें 📏第 2 步 —— 使用正确的指标 📏

# 2) Metrics that look at the rare class — and how ROC-AUC and PR-AUC react to rarity
from sklearn.metrics import (classification_report, confusion_matrix, roc_auc_score,
                             average_precision_score, balanced_accuracy_score, f1_score)
logit = make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)).fit(X_train, y_train)
p_test = logit.predict_proba(X_test)[:, 1]
pred = (p_test >= 0.5).astype(int)
print(confusion_matrix(y_test, pred))
print(classification_report(y_test, pred, target_names=["legit", "fraud"], digits=3))
print(f"balanced accuracy {balanced_accuracy_score(y_test, pred):.3f} | ROC-AUC {roc_auc_score(y_test, p_test):.3f} | "
      f"PR-AUC (average precision) {average_precision_score(y_test, p_test):.3f}")
rand = np.random.default_rng(0).random(len(y_test))
print(f"random scores      : ROC-AUC {roc_auc_score(y_test, rand):.3f} | PR-AUC {average_precision_score(y_test, rand):.3f}  (≈ the fraud rate)")
# keep every fraud, drop legit rows to change how rare fraud is: ROC-AUC stays, PR-AUC moves
r = np.random.default_rng(1)
for keep in [1.0, 0.25, 0.05]:
    idx = np.r_[np.where(y_test == 1)[0], r.choice(np.where(y_test == 0)[0], int(keep * (y_test == 0).sum()), replace=False)]
    print(f"fraud rate {y_test.iloc[idx].mean():6.2%}: ROC-AUC {roc_auc_score(y_test.iloc[idx], p_test[idx]):.3f} | "
          f"PR-AUC {average_precision_score(y_test.iloc[idx], p_test[idx]):.3f}")

Six Strategies — and a Better Order 🧭छह Strategies — और बेहतर क्रम 🧭六种策略 —— 以及更好的顺序 🧭

Class Weights ⚖️Class Weights ⚖️类别权重 ⚖️

class_weight="balanced" multiplies each row's loss by n_rows ÷ (2 × n_rows_in_its_class). Here that is 0.506 for legit and 39.5 for fraud — a 78:1 ratio, the same as the imbalance (the original page printed 0.505 and 50.5, which do not match its own 9,910 : 90 data; those give 0.505 and 55.6). No rows are added or removed.

class_weight="balanced" हर row के loss को n_rows ÷ (2 × उसकी class की rows) से गुणा करता है। यहाँ legit के लिए 0.506 और fraud के लिए 39.5 — 78:1 का ratio, imbalance के बराबर (मूल page ने 0.505 और 50.5 छापा था, जो उसके अपने 9,910 : 90 data से मेल नहीं खाता; वहाँ 0.505 और 55.6 आता)। कोई row जोड़ी या हटाई नहीं जाती।

class_weight="balanced" 会把每行的损失乘以 行数 ÷ (2 × 该类行数)。这里正常类为 0.506、欺诈类为 39.5 —— 比值 78:1，与不平衡比例相同（原页面打印的 0.505 和 50.5 与它自己的 9,910 : 90 数据不符，应为 0.505 和 55.6）。不增加也不删除任何行。

# 3) Class weights: same rows, bigger penalty for missing a fraud
from sklearn.utils.class_weight import compute_class_weight
from sklearn.ensemble import HistGradientBoostingClassifier
w = compute_class_weight("balanced", classes=np.array([0, 1]), y=y_train)
print(f"'balanced' weights: legit {w[0]:.3f}, fraud {w[1]:.1f}  (= n_rows / (2 × n_class); ratio {w[1] / w[0]:.0f}:1)")
def report(name, model):
    model.fit(X_train, y_train)
    p = model.predict_proba(X_test)[:, 1]; pr = (p >= 0.5).astype(int)
    print(f"{name:<34} recall {recall_score(y_test, pr):.3f} | precision {precision_score(y_test, pr, zero_division=0):.3f} | "
          f"F1 {f1_score(y_test, pr):.3f} | PR-AUC {average_precision_score(y_test, p):.3f} | mean prob {p.mean():.3f}")
    return p
report("logistic", make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)))
report("logistic, class_weight='balanced'", make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000, class_weight="balanced")))
report("boosting", HistGradientBoostingClassifier(random_state=0))
report("boosting, class_weight='balanced'", HistGradientBoostingClassifier(random_state=0, class_weight="balanced"))
print(f"(real fraud rate in test: {y_test.mean():.3f})")

SMOTE Oversampling 🧬SMOTE Oversampling 🧬SMOTE 过采样 🧬

SMOTE picks a rare-class row, picks one of its k nearest rare-class neighbours, and creates a new point somewhere on the straight line between them. It is smarter than copying rows, but it does not add information: every synthetic point is made from points you already had, and lines between distant frauds can run straight through legit territory.

SMOTE एक दुर्लभ-class row चुनता है, उसके k नज़दीकी दुर्लभ-class पड़ोसियों में से एक चुनता है, और उनके बीच की सीधी रेखा पर कहीं नया बिंदु बनाता है। यह rows copy करने से समझदार है, पर जानकारी नहीं जोड़ता: हर synthetic बिंदु उन्हीं बिंदुओं से बनता है जो पहले से थे, और दूर के frauds के बीच की रेखाएँ legit इलाक़े के बीच से गुज़र सकती हैं।

SMOTE 选一个少数类样本，再从它的 k 个最近少数类邻居中选一个，在两者之间的直线上某处生成新点。它比复制行更聪明，但并不增加信息：每个合成点都由已有的点构成，而相距较远的欺诈点之间的连线可能直接穿过正常区域。

# 4) SMOTE: make synthetic frauds — inside an imblearn Pipeline
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.pipeline import Pipeline as SkPipeline
X_res, y_res = SMOTE(sampling_strategy=0.5, k_neighbors=5, random_state=42).fit_resample(X_train, y_train)
print("after SMOTE(sampling_strategy=0.5):", Counter(y_res))
try:
    SkPipeline([("smote", SMOTE()), ("model", LogisticRegression())]).fit(X_train, y_train)
except TypeError as e:
    print("sklearn Pipeline + SMOTE →", str(e).split(" or be")[0])
smote_lr = ImbPipeline([("scale", StandardScaler()), ("smote", SMOTE(sampling_strategy=0.5, random_state=42)),
                        ("model", LogisticRegression(max_iter=2000))])
report("logistic + SMOTE (imblearn Pipeline)", smote_lr)
print("rows the model was trained on:", Counter(smote_lr.named_steps["smote"].fit_resample(StandardScaler().fit_transform(X_train), y_train)[1]),
      "| rows predicted:", len(X_test), "(test is never resampled)")

The SMOTE Leak 🔒SMOTE Leak 🔒SMOTE 泄漏 🔒

If you oversample the whole training set and then cross-validate, each validation fold is full of synthetic frauds that were built from frauds in the training folds. The model only has to recognise near-copies.

अगर आप पूरे training set को oversample करके फिर cross-validate करते हैं, तो हर validation fold उन synthetic frauds से भरा होता है जो training folds के frauds से बने थे। Model को बस लगभग-copies पहचाननी होती हैं।

如果先对整个训练集过采样、再做交叉验证，每个验证折里都塞满了由训练折中的欺诈生成的合成欺诈。模型只需要认出近似复制品。

# 5) The SMOTE leak: oversample first, then cross-validate → copies of the same fraud land on both sides
from sklearn.model_selection import StratifiedKFold, cross_val_score
cv = StratifiedKFold(5, shuffle=True, random_state=0)
res = {"wrong": [], "right": [], "wrong_roc": [], "right_roc": []}
for seed in range(5):
    Xs, ys = SMOTE(random_state=seed).fit_resample(X_train, y_train)               # wrong: before CV
    for sc in ["average_precision", "roc_auc"]:
        k = "" if sc == "average_precision" else "_roc"
        res["wrong" + k].append(cross_val_score(HistGradientBoostingClassifier(random_state=0), Xs, ys, cv=cv, scoring=sc).mean())
        res["right" + k].append(cross_val_score(ImbPipeline([("smote", SMOTE(random_state=seed)), ("m", HistGradientBoostingClassifier(random_state=0))]),
                                                X_train, y_train, cv=cv, scoring=sc).mean())
print(f"SMOTE before CV : PR-AUC {np.mean(res['wrong']):.3f} | ROC-AUC {np.mean(res['wrong_roc']):.3f}   ← looks amazing")
print(f"SMOTE inside CV : PR-AUC {np.mean(res['right']):.3f} | ROC-AUC {np.mean(res['right_roc']):.3f}   ← the honest number")
print(f"(no SMOTE at all: PR-AUC {cross_val_score(HistGradientBoostingClassifier(random_state=0), X_train, y_train, cv=cv, scoring='average_precision').mean():.3f})")

Undersampling and Combined Methods ✂️Undersampling और Combined Methods ✂️欠采样与组合方法 ✂️

RandomUnderSampler throws away common-class rows until the ratio you ask for; with sampling_strategy=0.5 and our 228 frauds that leaves 456 legit rows (the original comment said 200 and 100). TomekLinks removes common-class points that form a "nearest-neighbour pair" with a rare point — only 100 rows here. SMOTETomek and SMOTEENN oversample and then clean. All of these use distances, so scale first.

RandomUnderSampler आम class की rows तब तक फेंकता है जब तक माँगा ratio न आ जाए; sampling_strategy=0.5 और हमारे 228 frauds के साथ 456 legit rows बचती हैं (मूल comment में 200 और 100 था)। TomekLinks उन आम-class बिंदुओं को हटाता है जो किसी दुर्लभ बिंदु के साथ "nearest-neighbour जोड़ी" बनाते हैं — यहाँ सिर्फ़ 100 rows। SMOTETomek और SMOTEENN oversample करके फिर साफ़ करते हैं। ये सब दूरियाँ इस्तेमाल करते हैं, इसलिए पहले scale करें।

RandomUnderSampler 会丢弃多数类样本直到达到指定比例；设 sampling_strategy=0.5、我们有 228 起欺诈时，剩下 456 条正常记录（原注释写的是 200 和 100）。TomekLinks 删除与某个少数类点构成“互为最近邻”的多数类点 —— 这里只删了 100 行。SMOTETomek 和 SMOTEENN 先过采样再清理。它们都用距离，所以先缩放。

# 6) Undersampling and combined methods
from imblearn.under_sampling import RandomUnderSampler, TomekLinks
from imblearn.combine import SMOTETomek, SMOTEENN
Xs_tr = StandardScaler().fit_transform(X_train)                              # Tomek / ENN use distances → scale first
for name, s in [("RandomUnderSampler(0.5)", RandomUnderSampler(sampling_strategy=0.5, random_state=42)),
                ("TomekLinks()", TomekLinks()),
                ("SMOTETomek", SMOTETomek(random_state=42)),
                ("SMOTEENN", SMOTEENN(random_state=42))]:
    print(f"{name:<24} → {dict(Counter(s.fit_resample(Xs_tr, y_train)[1]))}")
report("logistic + RandomUnderSampler", ImbPipeline([("sc", StandardScaler()), ("rus", RandomUnderSampler(sampling_strategy=0.5, random_state=42)), ("m", LogisticRegression(max_iter=2000))]))
report("logistic + SMOTETomek", ImbPipeline([("sc", StandardScaler()), ("st", SMOTETomek(random_state=42)), ("m", LogisticRegression(max_iter=2000))]))

Threshold Tuning 🎯Threshold Tuning 🎯阈值调整 🎯

A classifier gives a probability; predict() just compares it with 0.5. For rare events 0.5 is rarely the right cut-off. Pick the threshold on validation data — maximising F1, or better, minimising the real cost of misses and false alarms — then check it once on test. Two bugs fixed from the original: it tuned on the test set, and precision_recall_curve returns one more precision/recall value than thresholds, so thresholds[argmax(f1)] can go out of range.

Classifier एक probability देता है; predict() बस उसकी 0.5 से तुलना करता है। दुर्लभ घटनाओं के लिए 0.5 शायद ही सही cut-off हो। Threshold को validation data पर चुनें — F1 सबसे ज़्यादा करके, या बेहतर, छूटे frauds और झूठे alarms की असली क़ीमत सबसे कम करके — फिर test पर एक बार जाँचें। मूल से दो bugs ठीक किए: उसने test set पर tune किया था, और precision_recall_curve thresholds से एक ज़्यादा precision/recall मान देता है, इसलिए thresholds[argmax(f1)] range से बाहर जा सकता है।

分类器输出概率；predict() 只是把它与 0.5 比较。对罕见事件，0.5 很少是合适的阈值。在验证集上选阈值 —— 最大化 F1，或者更好地，最小化漏判与误报的真实成本 —— 然后在测试集上只检验一次。修正了原代码的两个错误：它在测试集上调阈值；而且 precision_recall_curve 返回的精确率/召回率比阈值多一个，所以 thresholds[argmax(f1)] 可能越界。

# 7) Threshold tuning — choose the cut-off on VALIDATION data, check it once on test
from sklearn.metrics import precision_recall_curve
p_val = logit.predict_proba(X_val)[:, 1]
prec, rec, thr = precision_recall_curve(y_val, p_val)
f1s = 2 * prec[:-1] * rec[:-1] / np.maximum(prec[:-1] + rec[:-1], 1e-12)   # the last (prec, rec) pair has no threshold
best = thr[np.argmax(f1s)]
print(f"best threshold on validation (max F1): {best:.3f}")
for t in [0.5, 0.3, 0.2, best, 0.05]:
    pr = (p_test >= t).astype(int)
    print(f"threshold {t:.3f}: precision {precision_score(y_test, pr, zero_division=0):.3f} | recall {recall_score(y_test, pr):.3f} | "
          f"F1 {f1_score(y_test, pr):.3f} | alerts {pr.sum():>4} | frauds caught {int((pr & y_test).sum())}/{int(y_test.sum())}")

Which Strategy Wins? 🏁कौन सी Strategy जीतती है? 🏁哪种策略胜出？🏁

We gave every strategy the same logistic model, the same data and — to be fair — its own threshold tuned on validation data. The original page showed a table with recall up to 0.89 and F1 up to 0.77; those numbers were invented. Here is what really happened.

हमने हर strategy को वही logistic model, वही data और — निष्पक्षता के लिए — validation data पर tuned उसका अपना threshold दिया। मूल page ने 0.89 तक recall और 0.77 तक F1 वाली table दिखाई थी; वे संख्याएँ गढ़ी हुई थीं। असल में यह हुआ।

我们给每种策略相同的逻辑模型、相同的数据，并且 —— 为了公平 —— 各自在验证集上调好的阈值。原页面的表格里召回率高达 0.89、F1 高达 0.77，这些数字是编造的。下面是真实结果。

# 8) Fair comparison: every strategy also gets its own threshold tuned on validation data
def lr(**kw): return LogisticRegression(max_iter=2000, **kw)
strategies = {
    "no treatment": make_pipeline(StandardScaler(), lr()),
    "class_weight='balanced'": make_pipeline(StandardScaler(), lr(class_weight="balanced")),
    "random undersampling": ImbPipeline([("s", StandardScaler()), ("r", RandomUnderSampler(sampling_strategy=0.5, random_state=42)), ("m", lr())]),
    "SMOTE": ImbPipeline([("s", StandardScaler()), ("r", SMOTE(sampling_strategy=0.5, random_state=42)), ("m", lr())]),
    "SMOTE + class weights": ImbPipeline([("s", StandardScaler()), ("r", SMOTE(sampling_strategy=0.5, random_state=42)), ("m", lr(class_weight="balanced"))]),
    "SMOTETomek": ImbPipeline([("s", StandardScaler()), ("r", SMOTETomek(random_state=42)), ("m", lr())]),
}
def tuned_threshold(y, p):
    pr, rc, th = precision_recall_curve(y, p)
    return th[np.argmax(2 * pr[:-1] * rc[:-1] / np.maximum(pr[:-1] + rc[:-1], 1e-12))]
rows = []
for name, m in strategies.items():
    m.fit(X_train, y_train)
    pv, pt = m.predict_proba(X_val)[:, 1], m.predict_proba(X_test)[:, 1]
    t = tuned_threshold(y_val, pv)
    rows.append({"strategy": name, "recall@0.5": recall_score(y_test, pt >= .5), "precision@0.5": precision_score(y_test, pt >= .5, zero_division=0),
                 "F1@0.5": f1_score(y_test, pt >= .5), "tuned t": t, "F1@tuned": f1_score(y_test, pt >= t),
                 "PR-AUC": average_precision_score(y_test, pt), "mean prob": pt.mean()})
bench = pd.DataFrame(rows).set_index("strategy")
pd.set_option("display.width", 160)
print(bench.round(3).to_string())
print(f"\nreal fraud rate in test: {y_test.mean():.3f}")

A Complete Pipeline 🔗पूरी Pipeline 🔗完整管道 🔗

Use StratifiedKFold so every fold keeps the 1.3% fraud rate, score with average_precision, choose the threshold on validation data, and save it with the model — a model loaded without its threshold silently goes back to 0.5. Fixed from the original: X_val and new_raw_data were never defined, and SMOTE plus class_weight="balanced" corrected the imbalance twice. Note also how much the CV PR-AUC varies (± 0.031) with only about 45 frauds per fold.

StratifiedKFold इस्तेमाल करें ताकि हर fold में 1.3% fraud दर रहे, average_precision से score करें, validation data पर threshold चुनें, और उसे model के साथ save करें — बिना threshold load हुआ model चुपचाप 0.5 पर लौट जाता है। मूल से ठीक किया: X_val और new_raw_data कभी define नहीं हुए थे, और SMOTE के साथ class_weight="balanced" ने imbalance को दो बार ठीक किया। यह भी देखें कि हर fold में सिर्फ़ लगभग 45 frauds होने से CV PR-AUC कितना बदलता है (± 0.031)।

用 StratifiedKFold 让每一折都保持 1.3% 的欺诈率，用 average_precision 打分，在验证集上选阈值，并把阈值和模型一起保存 —— 没带阈值加载的模型会悄悄回到 0.5。修正了原代码：X_val 和 new_raw_data 从未定义；SMOTE 加 class_weight="balanced" 把不平衡纠正了两次。另外注意，每折只有约 45 起欺诈，CV PR-AUC 波动有多大（± 0.031）。

# 9) A complete pipeline: stratified CV on PR-AUC, threshold from validation, saved together
import joblib
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000))
scores = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="average_precision")
print(f"5-fold stratified CV PR-AUC {scores.mean():.3f} ± {scores.std():.3f}")
pipe.fit(X_train, y_train)
threshold = tuned_threshold(y_val, pipe.predict_proba(X_val)[:, 1])
p = pipe.predict_proba(X_test)[:, 1]
print(f"threshold {threshold:.3f} → test precision {precision_score(y_test, p >= threshold):.3f}, "
      f"recall {recall_score(y_test, p >= threshold):.3f}, PR-AUC {average_precision_score(y_test, p):.3f}")
joblib.dump({"pipeline": pipe, "threshold": threshold}, "fraud_model.joblib")
art = joblib.load("fraud_model.joblib")
new_txn = pd.DataFrame([{"log_amount": np.log(42000), "night": 1, "km_from_home": 12.0, "txns_last_hour": 1,
                         "account_age_days": 400, "merchant_risk": 0.30}])
prob = art["pipeline"].predict_proba(new_txn)[0, 1]
print(f"new transaction: fraud probability {prob:.2f} → {'ALERT' if prob >= art['threshold'] else 'ok'}")

Make the Practice Data 🐍Practice Data बनाएँ 🐍生成练习数据 🐍

Run this first. Fraud is more likely for large amounts, night-time payments, far from home, several transactions in the last hour, new accounts and risky merchants. About 1 transaction in 80 is fraud.

इसे पहले चलाएँ। बड़ी राशि, रात के भुगतान, घर से दूर, पिछले घंटे में कई transactions, नए accounts और जोखिम भरे merchants में fraud की संभावना ज़्यादा है। लगभग 80 में से 1 transaction fraud है।

请先运行它。金额大、夜间支付、离家远、过去一小时交易多、新账户和高风险商户更可能是欺诈。大约每 80 笔交易中有 1 笔是欺诈。

# 0) Practice data: 30,000 card transactions, about 1 in 80 is fraud
import numpy as np, pandas as pd
rng = np.random.default_rng(8)
n = 30000
amount = np.round(np.exp(rng.normal(7.0, 1.0, n)), 2)                      # ₹
hour = rng.choice(24, n, p=np.r_[np.full(6, .015), np.full(18, (1 - .09) / 18)])
km_from_home = np.round(rng.gamma(1.2, 6, n), 1)
txns_last_hour = rng.poisson(0.6, n)
account_age_days = rng.integers(1, 3650, n)
merchant_risk = np.round(rng.beta(2, 8, n), 3)
night = ((hour <= 4) | (hour >= 23)).astype(int)
z = (-7.3 + 0.8 * (np.log(amount) - 7) + 2.0 * night + 0.09 * km_from_home + 0.8 * txns_last_hour
     - 0.0009 * account_age_days + 7.0 * merchant_risk + rng.normal(0, 0.5, n))
fraud = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(int)
pd.DataFrame({"amount": amount, "hour": hour, "km_from_home": km_from_home, "txns_last_hour": txns_last_hour,
              "account_age_days": account_age_days, "merchant_risk": merchant_risk, "fraud": fraud}).to_csv("transactions.csv", index=False)
print(f"transactions.csv: {n:,} rows, {fraud.sum()} frauds ({fraud.mean():.2%})")

Golden Rules for Imbalanced Data 🏆Imbalanced Data के सुनहरे नियम 🏆不平衡数据黄金法则 🏆