Anomaly detection — isolation forest, LOF আর one-class SVM

AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ precision, recall আর precision-recall curve, পর্ব ৬২-এ IQR আর robust z দিয়ে outlier খোঁজা, আর পর্ব ৬৫-এ label ছাড়া গঠন খোঁজা (k-means, DBSCAN) এসেছে। এই কোর্সের পর্ব ১৯ দেখিয়েছে Mahalanobis দূরত্ব আর χ² সীমা দিয়ে outlier ধরা, আর তার ফাঁদ (masking, বাঁকা ডেটা)। এই পর্ব সেখান থেকে এগোয়: Gaussian না ধরে, label প্রায় ছাড়াই, কীভাবে অস্বাভাবিক লেনদেন খোঁজা যায়, আর কোন পদ্ধতি কোন ধরনের অস্বাভাবিকতা ধরে। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python: NumPy, SciPy, matplotlib আর scikit-learn), আর ব্লকগুলো একই ডেটা ভাগ করে নেয়; প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে।

১ · Anomaly কী — তিন ধরন আর label ছাড়া সমস্যা

Anomaly detection মানে স্বাভাবিক আচরণ থেকে অনেক আলাদা উদাহরণ খোঁজা। Douglas Hawkins-এর ১৯৮০ সালের বই Identification of Outliers-এর বহুল উদ্ধৃত সংজ্ঞা: এমন পর্যবেক্ষণ, যা বাকিদের থেকে এত আলাদা যে সন্দেহ জাগে এটি ভিন্ন কোনো প্রক্রিয়া থেকে এসেছে। Chandola, Banerjee আর Kumar-এর ২০০৯ সালের survey তিনটি ভাগ জনপ্রিয় করে:

Label কতটা আছে, তা দিয়ে কাজটির ধরন বদলায়। সবচেয়ে গুরুত্বপূর্ণ পার্থক্যটি scikit-learn-এর docs-ও আলাদা করে লেখে:

যথেষ্ট label থাকলে সাধারণত supervised classifier জেতে, কারণ সে জানে জালিয়াতি দেখতে কেমন। কিন্তু জালিয়াতি বিরল, নতুন ধরনের জালিয়াতির label আগে থাকে না, আর প্রতিটি label মানে কারও হাতে যাচাই। তাই এই পর্বের পদ্ধতিগুলো unsupervised: এরা শুধু “স্বাভাবিক কেমন” শেখে, আর প্রতিটি সারিকে একটি anomaly score দেয়। সিদ্ধান্ত (কোনটি যাচাই হবে) আসে সেই score-এর ওপর একটি সীমা থেকে, যা অংশ ৭-এর বিষয়।

২ · অল্প label দিয়ে মূল্যায়ন — precision at k আর PR AUC

Detector শেখে label ছাড়া, কিন্তু মূল্যায়নের জন্য কিছু যাচাই করা উদাহরণ লাগে: অডিট দলের একটি নমুনা, বা আগে ধরা পড়া জালিয়াতি। দুটি মাপ এখানে স্বাভাবিক।

Precision at k (P@k): score অনুযায়ী সাজিয়ে শীর্ষ k-টি সারির কত ভাগ সত্যিই anomaly. অডিট দল দিনে ৩০টি লেনদেন যাচাই করতে পারলে P@৩০ ঠিক সেই প্রশ্নের উত্তর: “আমাদের সময়ের কত ভাগ কাজে লাগল?” Average precision (AP, precision-recall curve-এর নিচের এলাকার একটি ধাপ-রূপ): প্রতিটি সত্যিকারের anomaly-র অবস্থানে precision মেপে তাদের গড়। একটি ছোট উদাহরণ: ১০টি লেনদেন সাজানো, সত্যিকারের জালিয়াতি ১, ৩ আর ৬ নম্বরে।

AP = (১/১ + ২/৩ + ৩/৬) / ৩ = (১ + ০.৬৬৭ + ০.৫) / ৩ = ০.৭২২

এখানে P@৩ = ২/৩, P@৫ = ২/৫ = ০.৪. এলোমেলো ক্রমের AP মোটামুটি anomaly-র অনুপাতের সমান (এখানে ০.৩), তাই AP-কে সবসময় সেই ভিত্তির সঙ্গে তুলনা করুন। scikit-learn-এর average_precision_score ঠিক এই ধাপ-সূত্র ব্যবহার করে (কোনো interpolation নেই), একটি ডেস্কটপ run-এ এই উদাহরণে ০.৭২২২ দেয়। ROC AUC কেন এখানে কম কাজের, তা ভাবনার প্রশ্ন ২-এ: anomaly ০.১%-এর মতো বিরল হলে হাজার হাজার সাধারণ সারির মধ্যে সামান্য ভুল-ক্রমও ROC-তে প্রায় দেখা যায় না, কিন্তু অডিট দলের কাজের তালিকা ভরিয়ে দেয়।

এই পর্বের ডেটা। বাজারঘরের কাল্পনিক ৭০৩টি লেনদেন, চারটি feature: টাকার অঙ্ক (ডানে বাঁকা, তাই log), ঘণ্টা (০–২৩), পণ্যের সংখ্যা, আর দূরত্ব (km). ৬০০টি সাধারণ গ্রাহক, আর ৮০টি অফিসের লাঞ্চ-অর্ডারের একটি আঁটসাঁট দল (প্রায় ৩৫০ টাকা, দুপুর ১টা, ২টি পণ্য, ১.৫ km). তার মধ্যে seed দিয়ে বসানো ২৩টি anomaly, তিন ধরনের:

Label (কোনটি বসানো anomaly) শুধু মূল্যায়নে ব্যবহার হবে, কোনো detector শেখার সময় তা দেখবে না। মোট anomaly ২৩টি, তাই প্রতিটি পদ্ধতির P@২৩ আর AP মাপা হবে, আর শীর্ষ ২৩-এ প্রতিটি ধরনের কতগুলো এল, তাও।

৩ · পরিসংখ্যানের baseline — z, robust z আর Mahalanobis

প্রথম চেষ্টা সবসময় সরল কিছু, কারণ জটিল পদ্ধতি তার চেয়ে ভালো কি না, তা মাপার ওই একটিই উপায়। প্রতিটি feature-এর z-score (x − গড়)/σ, আর সারির score হিসেবে সবচেয়ে বড় |z|. সমস্যা: চরম মান নিজেই গড় আর σ টেনে নেয়। নিচে আটটি অর্ডারের টাকা, যার একটি ৫০,০০০ আর একটি ২,৬০০.

এক feature-এ robust z স্পষ্টভাবে ভালো। কিন্তু অনেক feature-এ দুটি নতুন সমস্যা আসে। প্রথমত, প্রতিটি feature আলাদা দেখলে “সম্পর্ক ভাঙা” সারি ধরা পড়ে না; সমাধান Mahalanobis দূরত্ব, যার বর্গ Gaussian ডেটায় χ²_d মানে (পর্ব ১৯)। চার feature-এ ৯৯% সীমা ১৩.২৮. দ্বিতীয়ত, MAD ধরে নেয় ডেটার মাঝের অংশ মোটামুটি প্রতিসম; বাঁকা বা পূর্ণসংখ্যার feature-এ সে লেজকে অস্বাভাবিক ভাবে। নিচের ব্লক ডেটা বানায় (পরের তিনটি ব্লক এটিই ব্যবহার করবে) আর তিনটি baseline মাপে।

import numpy as np
from scipy.stats import chi2
from sklearn.metrics import average_precision_score

def make_data(seed):                      # কাল্পনিক বাজারঘর: টাকা, ঘণ্টা, পণ্য, km
    r = np.random.default_rng(seed)
    a = np.c_[r.lognormal(7, .45, 600), r.normal(18, 3.5, 600),
              r.poisson(3, 600) + 1, r.gamma(4, 1.5, 600)]   # সাধারণ গ্রাহক
    b = np.c_[r.normal(350, 15, 80), r.normal(13, .5, 80),
              np.full(80, 2), r.normal(1.5, .2, 80)]         # অফিসের লাঞ্চ: আঁটসাঁট দল
    g = [[45000, 20, 4, 6], [1200, 18, 40, 5], [900, 19, 3, 60],
         [30000, 4, 25, 2], [2000, 22, 2, 45]]               # ১) global চরম
    f = np.c_[r.normal(4800, 40, 12), r.normal(3, .3, 12),
              np.ones(12), r.normal(16, .3, 12)]             # ২) ঘন জালিয়াতির দল
    l = np.c_[r.normal(470, 10, 6), r.normal(13, .4, 6),
              np.full(6, 2), r.normal(3.2, .1, 6)]           # ৩) local: লাঞ্চ-দলের পাশে
    X = np.vstack([a, b, g, f, l])
    X[:, 0] = np.log(X[:, 0])             # টাকা ডানে বাঁকা, তাই log
    return X, np.repeat([0, 0, 1, 2, 3], [600, 80, 5, 12, 6])

X, kind = make_data(42); y = (kind > 0).astype(int)     # label শুধু মূল্যায়নে
def report(name, score, k=23):            # score বড় = বেশি সন্দেহজনক
    top = np.argsort(-score)[:k]
    g, c, l = (np.sum(kind[top] == t) for t in (1, 2, 3))
    print(f"{name:13s} P@{k}={y[top].mean():.2f} AP={average_precision_score(y, score):.2f}"
          f"  top-{k} has global {g}/5 cluster {c}/12 local {l}/6")
z = np.abs((X - X.mean(0)) / X.std(0)).max(1)            # প্রতিটি feature-এর z, সবচেয়ে বড়টি
med = np.median(X, 0); mad = np.median(np.abs(X - med), 0)
Xs = (X - med) / (1.4826 * mad)                          # robust z (পরের ব্লকেও লাগবে)
D = X - X.mean(0)
d2 = np.einsum("ij,ij->i", D @ np.linalg.inv(np.cov(X, rowvar=False)), D)
cut = chi2.ppf(0.99, df=4)
print(f"{len(X)} rows, {y.sum()} planted | chi2(4) 99% cut {cut:.2f}, d2 flags {np.sum(d2 > cut)}")
for name, s in (("max |z|", z), ("max robust z", np.abs(Xs).max(1)), ("Mahalanobis", d2)):
    report(name, s)

703 rows, 23 planted | chi2(4) 99% cut 13.28, d2 flags 18
max |z|       P@23=0.74 AP=0.71  top-23 has global 5/5 cluster 12/12 local 0/6
max robust z  P@23=0.43 AP=0.48  top-23 has global 5/5 cluster 5/12 local 0/6
Mahalanobis   P@23=0.74 AP=0.76  top-23 has global 5/5 cluster 12/12 local 0/6

৪ · Isolation forest — অস্বাভাবিককে একা করা সহজ

Fei Tony Liu, Kai Ming Ting আর Zhi-Hua Zhou ২০০৮ সালে (ICDM সম্মেলনে) এই ধারণাকে একটি পদ্ধতি বানান। একটি isolation tree বানাতে: একটি এলোমেলো feature নিন, তার বর্তমান সর্বনিম্ন আর সর্বোচ্চের মাঝে একটি এলোমেলো কাটার জায়গা নিন, ডেটা দুই ভাগ করুন, আর প্রতিটি ভাগে আবার একই কাজ, যতক্ষণ প্রতিটি বিন্দু একা না হয় বা গভীরতার সীমায় না পৌঁছায়। কোনো impurity, কোনো label নেই (পর্ব ৩২-এর CART-এর মতো “সবচেয়ে ভালো কাট” খোঁজাও নেই)। একটি বিন্দুর path length h(x) হলো root থেকে তার পাতায় পৌঁছাতে কয়টি কাট লাগল।

একটি গাছ এলোমেলো, তাই isolation forest অনেক গাছের (scikit-learn-এ ডিফল্ট ১০০টি) গড় E[h(x)] নেয়। প্রতিটি গাছ পুরো ডেটা নয়, ২৫৬টি সারির একটি ছোট নমুনায় বানানো (max_samples="auto" মানে min(২৫৬, n)). ছোট নমুনা অদ্ভুত শোনালেও এটি সাহায্য করে: ঘন জালিয়াতির দলের অনেক সদস্য নমুনায় না আসায় দলটি পাতলা হয়, masking কমে। গভীরতার সীমা ⌈log₂ ২৫৬⌉ = ৮: অস্বাভাবিকেরা এর আগেই একা হয়, তাই সাধারণ বিন্দুর জন্য বাড়তি কাট খরচ করার দরকার নেই।

Path length-কে score বানাতে একটি মাপকাঠি লাগে: n-টি বিন্দুর একটি এলোমেলো গাছে গড়ে path কত? Binary search tree-তে ব্যর্থ খোঁজের গড় দৈর্ঘ্য থেকে আসে c(n):

c(n) = 2H(n − 1) − 2(n − 1)/n, H(i) ≈ ln i + 0.5772, s(x, n) = 2^{−E[h(x)] / c(n)}

এখানে H(i) হলো harmonic number ১ + ১/২ + … + ১/i, আর ০.৫৭৭২ Euler–Mascheroni ধ্রুবক। c(n)-কে প্রায় ২ ln n ভাবতে পারেন। Score s সবসময় ০ থেকে ১-এর মধ্যে। পাতায় পৌঁছে থেমে গেলে (গভীরতার সীমায়) সেখানে বাকি m-টি বিন্দুর জন্য c(m) যোগ হয়, যেন গাছটি আরও বাড়ানো হলে গড়ে কত লাগত।

নিচের ব্লক একটি ক্ষুদ্র isolation tree নিজে লেখে: পুরো গাছ জমা না রেখে শুধু একটি বিন্দুর পথ অনুসরণ করে। তারপর ১০০টি গাছের গড় path থেকে score, আর scikit-learn-এর IsolationForest-এর সঙ্গে তুলনা। score_samples উল্টো চিহ্নে −s দেয় (বড় মানে বেশি স্বাভাবিক), তাই আমরা মাইনাস দিয়ে উল্টাই।

from sklearn.ensemble import IsolationForest

def c(n):                                 # n বিন্দুর গাছে গড় path length
    return 0.0 if n <= 1 else 1.0 if n == 2 else 2 * (np.log(n - 1) + np.euler_gamma) - 2 * (n - 1) / n

def path(x, S, rng, depth=0, limit=8):    # একটি এলোমেলো গাছে x কত ধাপে একা হয়
    if len(S) <= 1 or depth >= limit:
        return depth + c(len(S))          # থেমে গেলে বাকি গাছের গড় অনুমান যোগ
    j = rng.integers(S.shape[1])          # এলোমেলো feature
    lo, hi = S[:, j].min(), S[:, j].max()
    if lo == hi:
        return depth + c(len(S))
    t = rng.uniform(lo, hi)               # এলোমেলো কাটার জায়গা
    side = S[S[:, j] < t] if x[j] < t else S[S[:, j] >= t]
    return path(x, side, rng, depth + 1, limit)

rng = np.random.default_rng(0)
for i in (0, 680):                        # একটি সাধারণ সারি আর ৪৫,০০০ টাকার সারি
    h = []
    for _ in range(100):                  # ১০০টি গাছ, প্রতিটি ২৫৬ সারির নমুনায়
        S = Xs[rng.choice(len(Xs), 256, replace=False)]
        h.append(path(Xs[i], S, rng))
    Eh = np.mean(h)
    print(f"row {i}: first paths {np.round(h[:5], 1)}  E[h]={Eh:.2f}  "
          f"score=2^(-E[h]/c(256))={2 ** (-Eh / c(256)):.3f}")
iso = IsolationForest(n_estimators=100, max_samples=256, random_state=42).fit(Xs)
print(f"c(256)={c(256):.3f} | sklearn score: row 0 {-iso.score_samples(Xs[[0]])[0]:.3f},"
      f" row 680 {-iso.score_samples(Xs[[680]])[0]:.3f}")
report("IsolationForest", -iso.score_samples(Xs))
for cont in ("auto", 0.02, 0.05):         # contamination শুধু কাটার সীমা বদলায়
    m = IsolationForest(contamination=cont, random_state=42).fit(Xs)
    print(f"contamination={cont}: offset {m.offset_:.3f}, flagged {np.sum(m.predict(Xs) == -1)}")

row 0: first paths [13.6 15.1 13.5 16.6 15.3]  E[h]=14.22  score=2^(-E[h]/c(256))=0.382
row 680: first paths [ 1.  14.2  5.  14.  12.2]  E[h]=8.08  score=2^(-E[h]/c(256))=0.579
c(256)=10.245 | sklearn score: row 0 0.390, row 680 0.591
IsolationForest P@23=0.74 AP=0.75  top-23 has global 5/5 cluster 12/12 local 0/6
contamination=auto: offset -0.500, flagged 88
contamination=0.02: offset -0.649, flagged 15
contamination=0.05: offset -0.547, flagged 36

৫ · Local Outlier Factor — প্রতিবেশীর তুলনায় কতটা একা

Global পদ্ধতি পুরো ডেটার একটি “কেন্দ্র” থেকে দূরত্ব মাপে। কিন্তু বাজারঘরের লাঞ্চ-দল খুব ঘন (৩৫০ ± ১৫ টাকা), আর সাধারণ গ্রাহকেরা ছড়ানো। লাঞ্চ-দলের ঠিক পাশের একটি বিন্দু global মাপে নিরীহ, কিন্তু তার প্রতিবেশীদের তুলনায় সে অনেক একা। Markus Breunig, Hans-Peter Kriegel, Raymond Ng আর Jörg Sander ২০০০ সালে (SIGMOD) এই ধারণা থেকে Local Outlier Factor দেন। চারটি সংজ্ঞা, ক্রমানুসারে:

• k-distance(p): p থেকে তার k-তম নিকটতম প্রতিবেশীর দূরত্ব। N_k(p) হলো সেই k-টি প্রতিবেশী।
• Reachability distance: reach_k(p, o) = max(k-distance(o), d(p, o)). o-এর খুব কাছের বিন্দুগুলোর দূরত্ব o-এর k-distance পর্যন্ত “সমান করে” ধরা হয়, যাতে ঘন এলাকার ছোট ওঠানামা ফল না নাড়ায়।
• Local reachability density: lrd(p) = ১ / (N_k(p)-এর ওপর reach_k(p, o)-এর গড়)। প্রতিবেশী যত কাছে, ঘনত্ব তত বেশি।
• LOF(p) = প্রতিবেশীদের lrd-এর গড় / lrd(p). প্রায় ১ মানে প্রতিবেশীর মতোই ঘন; ১-এর অনেক বেশি মানে প্রতিবেশীরা তার চেয়ে অনেক ঘন জায়গায় থাকে।

LOF-এর শক্তি তার দুর্বলতাও। “Local” মানে k-টি প্রতিবেশীর জগৎ। ঘন জালিয়াতির দলে ১২টি সদস্য; k ≤ ১১ হলে প্রতিটি সদস্যের সব প্রতিবেশী দলের ভেতরেই, সবার ঘনত্ব সমান, LOF ≈ ১: দলটি নিজেকে “স্বাভাবিক” প্রমাণ করে। এটি collective anomaly-র masking. আর ঘনত্বের অনুপাত বলে LOF-এর কোনো সর্বজনীন সীমা নেই: এক ডেটায় ১.৫ অস্বাভাবিক, আরেকটিতে ২-ও সাধারণ। scikit-learn-এর ডিফল্ট n_neighbors=20, আর মূল প্রবন্ধ কয়েকটি k-এর সর্বোচ্চ LOF নেওয়ার পরামর্শ দেয়।

৬ · One-class SVM, আর তিন ধরনের anomaly-তে সবার তুলনা

One-class SVM (Schölkopf, Platt, Shawe-Taylor, Smola আর Williamson; Neural Computation, ২০০১) ভিন্ন প্রশ্ন করে: স্বাভাবিক ডেটার চারপাশে সবচেয়ে ছোট কোন সীমা আঁকা যায়? পর্ব ২৯-এর RBF kernel দিয়ে ডেটাকে একটি feature space-এ নিয়ে, সেখানে মূলবিন্দু থেকে ডেটাকে যতটা সম্ভব দূরে সরানো একটি hyperplane খোঁজা হয়। ফলাফলের function f(x) = ∑ α_i k(x_i, x) − ρ: ধনাত্মক হলে ভেতরে (সাধারণ), ঋণাত্মক হলে বাইরে। দুটি knob:

Tax আর Duin-এর SVDD (support vector data description, ২০০৪) একই কাজ করে ডেটার চারপাশে সবচেয়ে ছোট গোলক খুঁজে; RBF kernel-এ দুটি পদ্ধতি সমতুল্য। Kernel matrix-এর জন্য খরচ n-এর সঙ্গে প্রায় বর্গ থেকে ঘন হারে বাড়ে, তাই বড় ডেটায় পর্ব ৩১-এর Nyström বা random features দিয়ে SGDOneClassSVM একটি বিকল্প।

এবার সব একসঙ্গে। নিচের ব্লক LOF (তিনটি k, আর novelty মোডে আগের মাসের পরিষ্কার লেনদেনে শিখিয়ে) আর one-class SVM (একই ব্যাচে দুটি γ, আর novelty মোডে) মাপে, তারপর দুটি feature-এ (log টাকা আর দূরত্ব) তিন পদ্ধতির score-এর contour আঁকে।

import matplotlib.pyplot as plt
from sklearn.neighbors import LocalOutlierFactor
from sklearn.svm import OneClassSVM

for k in (5, 10, 20):                     # novelty=False: এই ব্যাচকেই নিজের সঙ্গে তুলনা
    lof = LocalOutlierFactor(n_neighbors=k, algorithm="kd_tree")
    lof.fit_predict(Xs)
    report(f"LOF k={k}", -lof.negative_outlier_factor_)
H, hk = make_data(7)                      # আগের মাসের যাচাই করা পরিষ্কার লেনদেন
Hs = ((H - med) / (1.4826 * mad))[hk == 0]
lofn = LocalOutlierFactor(n_neighbors=20, novelty=True, algorithm="kd_tree").fit(Hs)
report("LOF novelty", -lofn.score_samples(Xs))
for g in (0.02, 1.0):                     # এই ব্যাচেই fit, γ বদলে
    oc = OneClassSVM(nu=0.05, gamma=g).fit(Xs)
    report(f"OCSVM g={g}", -oc.score_samples(Xs))
    print(f"   support vectors {len(oc.support_)}, flagged {np.mean(oc.predict(Xs) == -1):.3f}")
report("OCSVM novelty", -OneClassSVM(nu=0.05, gamma="scale").fit(Hs).score_samples(Xs))

P, HP = Xs[:, [0, 3]], Hs[:, [0, 3]]      # ছবির জন্য দুটি feature: log টাকা, km
gx, gy = np.meshgrid(np.linspace(-4, 9, 120), np.linspace(-3, 20, 120))
G = np.c_[gx.ravel(), gy.ravel()]
models = {"IsolationForest": IsolationForest(random_state=42),
          "LOF k=20 (novelty)": LocalOutlierFactor(20, novelty=True, algorithm="kd_tree"),
          "One-class SVM nu=0.05": OneClassSVM(nu=0.05, gamma=0.5)}
fig, axes = plt.subplots(1, 3, figsize=(11, 3.8), sharey=True)
for ax, (name, m) in zip(axes, models.items()):
    Z = -m.fit(HP).score_samples(G).reshape(gx.shape)   # বড় = বেশি অস্বাভাবিক
    ax.contourf(gx, gy, Z, levels=12, cmap="Greys")
    for t, mk, lab in ((0, ".", "normal"), (1, "s", "global"), (2, "^", "cluster"), (3, "*", "local")):
        ax.scatter(*P[kind == t].T, s=6 if t == 0 else 30, marker=mk, label=lab)
    ax.set_title(name, fontsize=10); ax.set_xlabel("log amount (robust z)")
axes[0].set_ylabel("distance (robust z)"); axes[0].legend(fontsize=7, loc="upper left")
fig.subplots_adjust(left=0.06, right=0.99, bottom=0.14, wspace=0.08)
plt.show()

LOF k=5       P@23=0.22 AP=0.24  top-23 has global 5/5 cluster 0/12 local 0/6
LOF k=10      P@23=0.48 AP=0.42  top-23 has global 5/5 cluster 0/12 local 6/6
LOF k=20      P@23=0.74 AP=0.83  top-23 has global 5/5 cluster 6/12 local 6/6
LOF novelty   P@23=0.87 AP=0.88  top-23 has global 5/5 cluster 9/12 local 6/6
OCSVM g=0.02  P@23=0.52 AP=0.52  top-23 has global 5/5 cluster 7/12 local 0/6
   support vectors 38, flagged 0.051
OCSVM g=1.0   P@23=0.00 AP=0.04  top-23 has global 0/5 cluster 0/12 local 0/6
   support vectors 230, flagged 0.171
OCSVM novelty P@23=0.74 AP=0.76  top-23 has global 5/5 cluster 12/12 local 0/6

এই টেবিল একটি কাল্পনিক ডেটার একটি seed-এর ফল, সাধারণ রায় নয়। তবু একটি শিক্ষা টেকসই: কোন পদ্ধতি জিতবে, তা নির্ভর করে আপনি কোন ধরনের anomaly খুঁজছেন তার ওপর। Global চরম মান সবাই ধরে; local অস্বাভাবিকতা শুধু LOF; আর ঘন দলের জন্য পরিষ্কার training ডেটা বা বড় k লাগে। বাস্তবে কয়েকটি পদ্ধতির score-এর rank গড় করা (ensemble) প্রায়ই একক পদ্ধতির চেয়ে স্থিতিশীল।

৭ · Contamination, threshold আর টাকার হিসাব

Score একটি ক্রম দেয়; সিদ্ধান্তের জন্য একটি সীমা লাগে। scikit-learn-এর IsolationForest আর LocalOutlierFactor-এ (OneClassSVM-এ এর জায়গায় ν) contamination parameter আছে, যা training score-এর একটি quantile থেকে offset_ ঠিক করে। সমস্যা: আসল anomaly-র হার কেউ জানে না, আর "auto"-র সীমা (isolation forest-এ s > ০.৫, LOF-এ LOF > ১.৫) কোনো ব্যবসায়িক যুক্তি থেকে আসেনি। সীমার আসল প্রশ্ন হলো খরচ: একটি জালিয়াতি না ধরলে কত ক্ষতি, আর একটি সাধারণ লেনদেন হাতে যাচাই করতে কত খরচ (পর্ব ০২-এর cost matrix-এর মতো)।

মোট খরচ(t) = ১৫০ × (চিহ্নিত সংখ্যা) + ৫,০০০ × (ধরা না পড়া anomaly)

সংখ্যাগুলো কাল্পনিক: একটি হাতে-যাচাইয়ে কর্মীর সময় ১৫০ টাকা, আর একটি জালিয়াতি গড়ে ৫,০০০ টাকার ক্ষতি। নিচের ব্লক LOF novelty-র score নিয়ে অডিট করা এই ব্যাচে (label জানা) সবচেয়ে সস্তা সীমা খোঁজে, তারপর সেই score-এর মান পরের সপ্তাহের নতুন ব্যাচে প্রয়োগ করে, আর contamination দিয়ে বাছা সীমার সঙ্গে তুলনা করে।

MISS, REVIEW = 5000, 150                  # কাল্পনিক টাকা: ধরা না পড়া জালিয়াতি, একটি হাতে-যাচাই
def cost(score, y, t):                    # সীমা t বা তার ওপরে সব হাতে যাচাই
    flag = score >= t
    missed = np.sum(y[~flag])
    return REVIEW * flag.sum() + MISS * missed, flag.sum(), missed

s = -lofn.score_samples(Xs)               # LOF novelty-র score, অডিট করা এই ব্যাচ
cands = np.sort(s)[::-1][:80]             # সম্ভাব্য সীমা: শীর্ষ ৮০টি score
table = [cost(s, y, t) + (t,) for t in cands]
best = min(table)
print(f"no review at all: {MISS * y.sum():,} taka")
for k in (5, 10, 20, 23, 30, 50):
    tot, f, m, t = table[k - 1]
    print(f"review top {k:2d}: flagged {f:2d} missed {m:2d} cost {tot:6,} taka")
print(f"best on audit batch: threshold {best[3]:.2f}, flagged {best[1]}, "
      f"missed {best[2]}, cost {best[0]:,} taka")

Xn, kn = make_data(8)                     # পরের সপ্তাহ: নতুন seed, একই ধরনের লেনদেন
yn = (kn > 0).astype(int)
sn = -lofn.score_samples((Xn - med) / (1.4826 * mad))
tot, f, m = cost(sn, yn, best[3])
print(f"next week, same threshold: flagged {f}, missed {m}, cost {tot:,} taka")
for cont in ("auto", 0.03):               # contamination দিয়ে সীমা ঠিক করলে
    off = LocalOutlierFactor(20, novelty=True, contamination=cont,
                             algorithm="kd_tree").fit(Hs).offset_
    tot, f, m = cost(sn, yn, -off)
    print(f"contamination={cont}: threshold {-off:.2f}, flagged {f}, missed {m}, cost {tot:,}")

no review at all: 115,000 taka
review top  5: flagged  5 missed 18 cost 90,750 taka
review top 10: flagged 10 missed 15 cost 76,500 taka
review top 20: flagged 20 missed  6 cost 33,000 taka
review top 23: flagged 23 missed  3 cost 18,450 taka
review top 30: flagged 30 missed  0 cost  4,500 taka
review top 50: flagged 50 missed  0 cost  7,500 taka
best on audit batch: threshold 3.64, flagged 26, missed 0, cost 3,900 taka
next week, same threshold: flagged 27, missed 0, cost 4,050 taka
contamination=auto: threshold 1.50, flagged 51, missed 0, cost 7,650
contamination=0.03: threshold 1.49, flagged 56, missed 0, cost 8,400

৮ · AI-এর যুগে — anomaly detector-এর কোড আর দাবি যাচাই

AI assistant এই বিষয়ে চটপটে কোড দেয়, কিন্তু ভুলগুলো চুপচাপ থাকে, কারণ label ছাড়া কোড “চলে” আর কিছু একটা চিহ্নিত করে। নিচের ভুলগুলো বারবার দেখা যায়:

AI-এর দেওয়া anomaly detector হাতে পেলে — যাচাইয়ের চেকলিস্ট

• একটি কৃত্রিম চরম সারি ঢুকিয়ে দেখেছি সেটি শীর্ষে আসে কি না (চিহ্নের দিক ঠিক)
• z-score বা Mahalanobis-এর মতো একটি সরল baseline-এর সঙ্গে P@k আর AP তুলনা করেছি
• কয়েকটি seed আর কয়েকটি k বা γ-তে ফল কতটা নড়ে, দেখেছি
• সীমা খরচ বা যাচাইয়ের ক্ষমতা থেকে বেছেছি, আর অডিট নমুনার আলাদা অংশে মেপেছি
• চিহ্নিতের হার সময়ের সঙ্গে নজরে রাখছি, যাতে drift আর anomaly গুলিয়ে না যায়
• কোনো আসল গ্রাহকের ব্যক্তিগত ডেটা AI-তে পেস্ট করিনি