Autoencoder — compression, denoising আর representation

পর্ব ৭৪ (Generative modeling-এর মানচিত্র) বলেছে, একটি generative model-এর তিন রকম কাজ: নতুন নমুনা বানানো, একটি নমুনা কতটা সম্ভব তা মাপা, আর ডেটার একটি কাজের representation শেখা। এই পর্বের autoencoder মূলত তৃতীয় কাজের যন্ত্র, আর পরের পর্বগুলোর (৭৬ VAE, ৮০ latent diffusion) ভিত্তি। এখানে লাগবে convolution (পর্ব ২০ · Convolution), U-Net-এর decoder-এ দেখা transposed convolution (পর্ব ২৫ · Detection আর segmentation), আর PCA, যা AI-এর ভিত্তি কোর্সের পর্ব ৬৫-এ আর মেশিন লার্নিং কোর্সের পর্ব ৯-এ আছে। ডেটা Fashion-MNIST (Zalando Research, MIT লাইসেন্স): ২৮ × ২৮ মাপের ধূসর পোশাক আর জুতার ছবি, ১০টি শ্রেণি, train-এ ৬০,০০০ আর test-এ ১০,০০০। বাজারঘরের পণ্যের ছবির বদলে এটি ব্যবহার করছি; এগুলো আসল দোকানের ছবি নয়। Desktop-এর run লেখার সময়ে (নভেম্বর ২০২৬) এই version-এ: Python 3.14.4, torch 2.15.0, NumPy 2.5.4, scikit-learn 1.9.1. এই model-গুলো এত ছোট যে সব training CPU-তে (৩টি thread) চালানো হয়েছে; সময়গুলো এই এক যন্ত্রের একটি run-এর, সাধারণ নিয়ম নয়।

১ · Autoencoder কী — encoder, bottleneck আর decoder

বাজারঘরের গুদামের মালিক ফোনে ম্যানেজারকে একটি নতুন শার্টের বর্ণনা দিচ্ছেন। পুরো ছবি পাঠানোর উপায় নেই, শুধু কয়েকটি কথা: “লম্বা হাতা, গাঢ় রং, বুকে পকেট”। ম্যানেজার সেই কয়েকটি কথা থেকে মনে মনে শার্টটি আবার আঁকেন। যদি আঁকা ছবি আসলের কাছাকাছি হয়, তবে ওই কয়েকটি কথাই শার্টের আসল তথ্য ধরেছে। কথা যত কম, বাছাই তত কঠিন।

Autoencoder ঠিক এই খেলাটি শেখে। দুটি network: encoder f input x-কে ছোট একটি code z = f(x)-এ নেয়, আর decoder g সেই code থেকে x̂ = g(z) বানায়। শেখানো হয় x̂ যেন x-এর কাছাকাছি হয়, অর্থাৎ reconstruction error L(x, x̂) কমাতে। কোনো label লাগে না, input নিজেই লক্ষ্য; তাই একে প্রায়ই self-supervised শেখার শুরুর উদাহরণ বলা হয়। Code-এর মাপ k-কে বলে bottleneck: বোতলের সরু গলা, যেখান দিয়ে সব তথ্য যেতে হয়।

k যদি input-এর মাপ d-এর চেয়ে ছোট হয়, model-টি undercomplete: সব তথ্য রাখা যায় না, তাই model বাধ্য হয়ে গুরুত্বপূর্ণটুকু বাছে। k ≥ d হলে overcomplete: তখন সবচেয়ে সহজ সমাধান হলো input হুবহু কপি করা (identity), যাতে কিছুই শেখা হয় না। তাই overcomplete model-এ অন্য কোনো বাধা লাগে: input-এ noise দেওয়া (অংশ ৫), বা code-এর বেশির ভাগ মান শূন্য রাখতে বাধ্য করা। একেবারে ছোট একটি উদাহরণে একটি forward pass হাতে করে দেখুন: তিনটি pixel, এক সংখ্যার code, কোনো activation নেই।

শেষ ধাপের কথাটিই autoencoder-এর মূল ধারণা: bottleneck ছোট হলে model ধরে নেয় ডেটা একটি নিচু মাত্রার জায়গার কাছাকাছি থাকে। ২৮ × ২৮ = ৭৮৪ মাত্রার সব সম্ভাব্য ছবির মধ্যে আসল জামা-জুতার ছবি খুব ছোট একটি অংশ; এই ধারণার নাম manifold hypothesis, যা মেশিন লার্নিং কোর্সের পর্ব ৪২-এ আছে।

২ · Linear autoencoder আর PCA — একই subspace

Activation না রাখলে encoder আর decoder দুটিই শুধু matrix: z = W_ex, x̂ = W_dz. MSE loss-এ এর সেরা সমাধান কী? ১৯৮৯ সালে Baldi আর Hornik দেখান, এমন network-এর loss-এর সব local minimum আসলে global, আর সেরা সমাধানে decoder-এর কলামগুলো ঠিক প্রথম k টি principal component-এর span-এ পড়ে। অর্থাৎ linear autoencoder নতুন কিছু শেখে না, PCA-র subspace আবার খুঁজে পায়। তবে পার্থক্য আছে: PCA-র দিকগুলো একে অপরের লম্ব (orthonormal) আর variance অনুযায়ী সাজানো, autoencoder-এর দিকগুলো সেই একই সমতলের যেকোনো ঘোরানো রূপ হতে পারে।

নিচের কোডে scikit-learn-এর হাতে লেখা অঙ্কের ছবিতে (৮ × ৮, ৬৪ pixel) NumPy দিয়ে gradient descent-এ একটি linear autoencoder শেখানো হয়েছে, k = ৪, তারপর SVD দিয়ে PCA-র সঙ্গে তুলনা। দুই subspace-এর মধ্যে কোণ (principal angle) শূন্যের কাছে হলে দুটি একই সমতল। পাতায় প্রথমবার scikit-learn লোড হতে ১০ সেকেন্ডের মতো লাগতে পারে।

import numpy as np
from sklearn.datasets import load_digits
from scipy.linalg import subspace_angles

X = load_digits().data / 16.0            # 1797টি ছবি, প্রতিটি 8×8 = 64 pixel
X = X - X.mean(axis=0)                   # কেন্দ্রে আনা, PCA-র মতোই
n, d, k = X.shape[0], X.shape[1], 4      # bottleneck: 64 → 4
rng = np.random.default_rng(42)
We = rng.normal(0, 0.1, (d, k))          # encoder-এর ওজন
Wd = rng.normal(0, 0.1, (k, d))          # decoder-এর ওজন
lr = 0.1
for step in range(1501):
    Z = X @ We                           # code, (1797, 4)
    E = Z @ Wd - X                       # reconstruction − আসল
    loss = (E ** 2).sum(axis=1).mean()   # প্রতি ছবির squared error-এর যোগফল, গড়
    gWd = 2 * Z.T @ E / n                # ∂loss/∂Wd
    gWe = 2 * X.T @ (E @ Wd.T) / n       # ∂loss/∂We (chain rule)
    We -= lr * gWe
    Wd -= lr * gWd
    if step % 300 == 0:
        print(f"step {step:4d}  loss {loss:.4f}")

U, S, Vt = np.linalg.svd(X, full_matrices=False)
P = Vt[:k]                               # প্রথম 4টি principal direction
pca = ((X @ P.T @ P - X) ** 2).sum(axis=1).mean()
print(f"PCA (k=4) loss      {pca:.4f}")
ang = np.degrees(subspace_angles(Wd.T, P.T))
print("দুই subspace-এর কোণ (ডিগ্রি):", np.round(ang, 2))
u = Wd[0] / np.linalg.norm(Wd[0])
print("decoder-এর প্রথম দিক আর PC1-এর |cos|:", round(abs(u @ P[0]), 3))
print("Wd-এর সারিগুলো কি orthonormal?", np.allclose(Wd @ Wd.T, np.eye(k), atol=0.05))

step    0  loss 4.7799
step  300  loss 2.4090
step  600  loss 2.4077
step  900  loss 2.4074
step 1200  loss 2.4072
step 1500  loss 2.4072
PCA (k=4) loss      2.4070
দুই subspace-এর কোণ (ডিগ্রি): [0.05 0.03 0.03 0.01]
decoder-এর প্রথম দিক আর PC1-এর |cos|: 0.171
Wd-এর সারিগুলো কি orthonormal? False

৩ · Reconstruction loss — MSE না BCE

x̂ আর x-এর পার্থক্য মাপার দুটি প্রচলিত উপায়। MSE: প্রতিটি pixel-এর (x̂ − x)²-এর গড়। এটি ধরে নেয় প্রতিটি pixel একটি Gaussian-এর মতো ছড়ায়, যার কেন্দ্র x̂; তখন MSE কমানো আর likelihood বাড়ানো একই (মেশিন লার্নিং কোর্সের পর্ব ১৮)। BCE (binary cross-entropy): pixel-এর মান ০ থেকে ১-এর মধ্যে থাকলে প্রতিটি pixel-কে একটি “কতটা সাদা” probability ধরে −[x log x̂ + (১ − x) log(১ − x̂)]. Decoder-এর শেষে sigmoid দিয়ে x̂-কে (০, ১)-এ রাখতে হয়; PyTorch-এ sigmoid আর BCE একসঙ্গে, সংখ্যাগতভাবে নিরাপদে করে BCEWithLogitsLoss (পর্ব ১৩ · Loss function).

একটি সূক্ষ্ম কথা: x যদি ০ বা ১ না হয়ে ধূসর (যেমন ০.৪) হয়, BCE-র সর্বনিম্ন মান শূন্য নয়। x̂ = x হলেও loss থাকে, কারণ এটি x-এর নিজের entropy. তাই BCE-র সংখ্যা দিয়ে দুটি ভিন্ন ডেটাসেটের মান তুলনা চলে না; তুলনার জন্য একই মাপ, যেমন test MSE, সব model-এ আলাদা করে মাপা ভালো। কোনটি বাছবেন? ধূসর ছবিতে প্রায়ই BCE নেওয়া হয়, কারণ এটি pixel-এর মানকে probability হিসেবে স্বাভাবিকভাবে ধরে; বাস্তব মানের (তাপমাত্রা, বিক্রি) ডেটায় MSE বা SmoothL1 স্বাভাবিক। দুটি একই conv autoencoder (k = ৩২, ১০ epoch, seed ০) শুধু loss বদলে শেখানো হলো, আর দুটির test MSE মাপা হলো (CPU-তে, সত্যিকারের run):

৪ · Convolutional autoencoder আর transposed convolution

MLP autoencoder ছবিকে ৭৮৪টি আলাদা সংখ্যা হিসেবে দেখে; কোন pixel কার পাশে, তা জানে না। Convolutional autoencoder-এর encoder পর্ব ২০-এর মতো stride ২-এর convolution দিয়ে মাপ কমায়: ২৮ → ১৪ → ৭, তারপর একটি Linear দিয়ে k সংখ্যার code. Decoder উল্টো পথে যায়: Linear দিয়ে ৩২ × ৭ × ৭, তারপর দুটি transposed convolution দিয়ে ৭ → ১৪ → ২৮। এই পর্বের মডেল (PyTorch, ছোট করে লেখা):

enc = nn.Sequential(nn.Conv2d(1, 16, 3, stride=2, padding=1), nn.ReLU(),    # 16×14×14
                    nn.Conv2d(16, 32, 3, stride=2, padding=1), nn.ReLU(),   # 32×7×7
                    nn.Flatten(), nn.Linear(32*7*7, k))
dec = nn.Sequential(nn.Linear(k, 32*7*7), nn.ReLU(), nn.Unflatten(1, (32, 7, 7)),
                    nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1), nn.ReLU(),
                    nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1))  # logits

Transposed convolution-এ input-এর প্রতিটি মান kernel দিয়ে গুণ হয়ে output-এ একটি ছাপ ফেলে, আর stride সেই ছাপের দূরত্ব ঠিক করে (পর্ব ২৫)। এবার মাপ আর parameter হাতে বের করুন; শেষ অংশে output_padding কেন লাগে, সেটিই পরীক্ষার প্রিয় প্রশ্ন।

এবার মূল তুলনা। MLP autoencoder (৭৮৪ → ২৫৬ → k → ২৫৬ → ৭৮৪, ReLU) আর উপরের conv autoencoder, চারটি bottleneck-এ: k = ২, ৮, ৩২, ১২৮। দুটিই BCE loss, Adam (lr ১০^−৩), batch ১২৮, ১০ epoch, seed ০, CPU-তে। পাশে একই k-তে PCA-র test MSE (CPU-তে, scikit-learn). সব MSE test-এর ১০,০০০ ছবিতে, pixel-এর মান ০ থেকে ১। সত্যিকারের run, JSON লাইন থেকে সাজানো:

৫ · Denoising autoencoder — নষ্ট ছবি থেকে পরিষ্কার ছবি

পুরনো ঝাপসা ফটোকপি থেকে একজন অভিজ্ঞ কেরানি দলিলের লেখা ঠিকঠাক পড়ে ফেলেন, কারণ তিনি জানেন বাংলা অক্ষর দেখতে কেমন হয়। দাগ আর ময়লা তিনি নিজেই বাদ দেন। Denoising autoencoder (Vincent ও সহলেখক, ২০০৮) একই দক্ষতা শেখে: input-এ ইচ্ছা করে noise দেওয়া হয়, x̃ = x + noise, কিন্তু loss মাপা হয় পরিষ্কার x-এর সঙ্গে: L(x, g(f(x̃))). তখন হুবহু কপি করলে আর কাজ হয় না, কারণ কপি করলে noise-ও ফিরে আসে। Model-কে জানতে হয় আসল ছবি “দেখতে কেমন”।

এই কৌশল overcomplete model-কেও কাজের বানায়। নিচের run-এ conv autoencoder (k = ৩২) তিনভাবে শেখানো হয়েছে: noise ছাড়া, আর Gaussian noise σ = ০.৩ ও ০.৫ দিয়ে (তারপর মান ০ থেকে ১-এ আটকানো)। সঙ্গে একটি overcomplete MLP (৭৮৪ → ১,০২৪ → ১,০২৪ → ১,০২৪ → ৭৮৪), noise ছাড়া আর σ = ০.৩ দিয়ে। সবগুলো ১০ epoch, seed ০, CPU-তে। Test-এর noise একটি নির্দিষ্ট seed-এ একবার বানানো, তাই সব model একই নষ্ট ছবি পেয়েছে। প্রতিটি ঘরে model-এর output আর পরিষ্কার ছবির MSE. সত্যিকারের run:

Overcomplete model-কে আটকানোর আরেকটি উপায় sparse autoencoder: loss-এ code-এর ওপর একটি শাস্তি যোগ করা, যেমন λ·Σ|z_j| (L1), যাতে প্রতিটি input-এ code-এর অল্প কয়েকটি মান শূন্য ছাড়া থাকে। এই পর্বে এটি চালানো হয়নি, শুধু নাম আর ধারণা; বড় language model-এর ভেতরের activation বোঝার গবেষণায় sparse autoencoder সম্প্রতি আবার বেশ ব্যবহৃত হচ্ছে বলে প্রকাশিত কাজে দেখা যায়।

এবার ছবিতে দেখুন। নিচের কোড desktop run-এর আসল output-এর সাত সারি আঁকে, প্রতিটি সারিতে চারটি ছবি: test-এর আসল ছবি, সাধারণ autoencoder-এর পুনর্গঠন, σ = ০.৫-এর নষ্ট ছবি, সেই নষ্ট ছবিতে সাধারণ autoencoder, সেই নষ্ট ছবিতে denoising autoencoder (σ = ০.৫-এ শেখানো), আর শেষ দুই সারিতে এলোমেলো code decode করা ছবি (অংশ ৮-এ ব্যাখ্যা)। পাতার আকার ছোট রাখতে প্রতিটি pixel ১৬টি ধূসর ধাপে (৪ bit) রাখা, তাই ছবি সামান্য দানাদার।

import numpy as np
import matplotlib.pyplot as plt

rows = open("ae_pics.txt").read().split("\n")
names = ["test image", "AE reconstruction", "noisy input (sigma 0.5)", "plain AE on noisy",
         "denoising AE on noisy", "decode z ~ N(0, I)", "decode z ~ fitted Gaussian"]
imgs = [[np.array([int(ch, 16) for ch in h]).reshape(28, 28) / 15 for h in r.split()]
        for r in rows]                       # প্রতিটি অক্ষর একটি pixel, 0–15
fig, ax = plt.subplots(7, 4, figsize=(4.2, 8.4))
for r in range(7):
    for c in range(4):
        ax[r, c].imshow(imgs[r][c], cmap="gray", vmin=0, vmax=1)
        ax[r, c].set_xticks([]); ax[r, c].set_yticks([])
    ax[r, 0].set_title(names[r], fontsize=8, loc="left")
fig.subplots_adjust(hspace=0.45, wspace=0.05)
plt.show()

clean = np.array(imgs[0])
for r in (1, 2, 3, 4):
    mse = ((np.array(imgs[r]) - clean) ** 2).mean()
    print(f"{names[r]:24s} MSE vs test image: {mse:.4f}")

AE reconstruction        MSE vs test image: 0.0078
noisy input (sigma 0.5)  MSE vs test image: 0.1148
plain AE on noisy        MSE vs test image: 0.0821
denoising AE on noisy    MSE vs test image: 0.0150

৬ · Reconstruction error দিয়ে anomaly detection

বাজারঘরের গুদামে প্রতিদিন হাজার হাজার জামা-জুতার ছবি তোলা হয়। হঠাৎ একটি ব্যাগের ছবি এলো, যা কখনো এই তালিকায় ছিল না। Autoencoder যা দেখে শিখেছে, তা ভালো ফেরায়; যা দেখেনি, তা ভালো ফেরাতে পারে না। তাই একটি ছবির reconstruction error-কে একটি anomaly score হিসেবে ধরা যায়: বেশি error মানে “অচেনা”। Isolation forest, LOF আর one-class SVM-এর মতো পদ্ধতি মেশিন লার্নিং কোর্সের পর্ব ৪৩-এ আছে; এখানে শুধু autoencoder-এর দিক।

পরীক্ষাটি এভাবে: Fashion-MNIST-এর একটি শ্রেণি train থেকে পুরো বাদ। Train-এর প্রথম ৫৫,০০০ ছবির বাকি ৯টি শ্রেণির প্রায় ৪৯,৫০০টিতে conv autoencoder (k = ৩২, ৫ epoch, seed ০, CPU-তে); শেষ ৫,০০০-এর সাধারণ ছবিগুলো (প্রায় ৪,৫০০) আলাদা validation, শুধু threshold বাছার জন্য। তারপর test-এর ১০,০০০ ছবির প্রতিটির MSE score; বাদ দেওয়া শ্রেণির ১,০০০টি ছবি “anomaly”. Score কতটা ভালো আলাদা করে, তা মাপে ROC curve-এর নিচের ক্ষেত্রফল, AUC: একটি এলোমেলো anomaly-র score একটি এলোমেলো সাধারণ ছবির চেয়ে বেশি হওয়ার সম্ভাবনা (০.৫ মানে আন্দাজ, ১ মানে নিখুঁত; ROC-এর মূল কথা AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ)। তুলনায় একই কাজ PCA (k = ৩২)-এর reconstruction error দিয়ে। প্রতিটি শ্রেণি একবার করে বাদ দিয়ে দশটি আলাদা run, সত্যিকারের ফল:

এবার নিজে চালিয়ে দেখুন। Bag বাদ দেওয়া run-এর আসল score থেকে এলোমেলোভাবে নেওয়া ৬০০টি সাধারণ আর ৩০০টি Bag-এর test score, আর validation-এর ৫০০টি সাধারণ score পাতায় রাখা আছে (MSE × ১০,০০০, পূর্ণসংখ্যায়)। কোড ROC-AUC, দুটি threshold-এ TPR আর FPR, আর score-এর histogram আঁকে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import roc_auc_score, roc_curve

d = {}
for line in open("anom_scores.txt").read().split("\n"):
    name, *vals = line.split()
    d[name] = np.array(vals, dtype=float) / 10000   # ফাইলে MSE × 10000, পূর্ণসংখ্যা
val = d["normal_val"]                    # train-এর বাইরের সাধারণ ছবি
s = np.concatenate([d["normal_test"], d["anomaly_test"]])
a = np.r_[np.zeros(600, bool), np.ones(300, bool)]
print("ROC-AUC (এই 900টি test score):", round(roc_auc_score(a, s), 4))
for q in (0.95, 0.99):
    t = np.quantile(val, q)              # threshold শুধু validation থেকে
    tpr, fpr = (s[a] >= t).mean(), (s[~a] >= t).mean()
    print(f"val-এর {q:.0%} percentile t = {t:.4f}: TPR {tpr:.3f}, FPR {fpr:.3f}")

fpr_c, tpr_c, _ = roc_curve(a, s)
fig, ax = plt.subplots(1, 2, figsize=(8, 3.2))
bins = np.linspace(0, np.quantile(s, 0.995), 40)
ax[0].hist(s[~a], bins, alpha=0.6, density=True, label="normal")
ax[0].hist(s[a], bins, alpha=0.6, density=True, label="held-out class")
ax[0].axvline(np.quantile(val, 0.99), color="k", ls="--", label="99% val threshold")
ax[0].set_xlabel("reconstruction MSE"); ax[0].legend(fontsize=7)
ax[1].plot(fpr_c, tpr_c); ax[1].plot([0, 1], [0, 1], "k:")
ax[1].set_xlabel("FPR"); ax[1].set_ylabel("TPR"); ax[1].set_title("ROC")
fig.subplots_adjust(wspace=0.3, bottom=0.18)
plt.show()

ROC-AUC (এই 900টি test score): 0.9107
val-এর 95% percentile t = 0.0227: TPR 0.460, FPR 0.050
val-এর 99% percentile t = 0.0320: TPR 0.150, FPR 0.017

একটি threshold-এ TPR আর FPR হাতে গুনে দেখুন। নিচের দশটি score একই run-এর আসল সংখ্যা (৫টি সাধারণ, ৫টি Bag, উপরের নমুনার প্রথম পাঁচটি করে)।

৭ · Latent code কতটা কাজের — probe দিয়ে মাপা

ভালো পুনর্গঠন মানেই কি ভালো representation? সরাসরি মাপার একটি উপায় linear probe: encoder স্থির রেখে code-এর ওপর একটি সরল classifier শেখানো (পর্ব ৪৮-এর probe-এর মতো)। Label শুধু এই মাপার সময় লাগে, autoencoder শেখার সময় নয়। Code-এ যদি শ্রেণির তথ্য সহজে আলাদা করা যায় এমনভাবে থাকে, logistic regression ভালো করবে। সঙ্গে k-NN (k = ৫): কাছের code-এর ছবি কি একই শ্রেণির?

চারটি feature-এ তুলনা: কাঁচা ৭৮৪ pixel, PCA-র ৩২ মাত্রা, অংশ ৪-এর conv autoencoder-এর ৩২ মাত্রার code (seed ০), আর একই গঠনের কিন্তু শেখানো হয়নি এমন (এলোমেলো ওজনের) encoder-এর ৩২ মাত্রার code. প্রতিটিতে StandardScaler, তারপর logistic regression (C = ১) আর k-NN; train-এর ৬০,০০০-এ শেখানো, test-এর ১০,০০০-এ accuracy. CPU-তে, scikit-learn 1.9.1, সত্যিকারের run:

৮ · সাধারণ autoencoder কেন ভালো generator নয়

Decoder তো code থেকে ছবি বানায়। তাহলে এলোমেলো একটি code দিয়ে নতুন জামার ছবি পাওয়া যায় না কেন? কারণ সাধারণ autoencoder-কে কখনো বলা হয়নি code-গুলো কোথায় থাকবে। Train-এর code-গুলো latent জায়গার কিছু এলোমেলো দ্বীপে জড়ো হয়, মাঝের বিশাল ফাঁকা জায়গায় decoder কখনো শেখেনি। এলোমেলো code প্রায়ই সেই ফাঁকা জায়গায় পড়ে। ঢাকার মানচিত্রে যদি শুধু কয়েকটি মহল্লার ঠিকানা থাকে, মানচিত্রের এলোমেলো একটি বিন্দু প্রায়ই নদী বা ফাঁকা মাঠে পড়বে, কোনো বাড়িতে নয়।

পরীক্ষা: অংশ ৪-এর conv autoencoder (k = ৩২)-এর decoder-এ দুই রকম এলোমেলো code, প্রতিটি ১,০০০টি: (ক) standard normal N(০, I), আর (খ) train-এর code থেকে মাপা গড় আর covariance-এর একটি Gaussian. ফলের মান যাচাইয়ের জন্য আলাদা একটি ছোট CNN classifier (৩ epoch, test accuracy নিচে) প্রতিটি ছবিকে কতটা আত্মবিশ্বাসে কোনো শ্রেণিতে ফেলে, তা মাপা হলো: সর্বোচ্চ probability-র গড়, আর কতগুলো ছবিতে সেটি ০.৯-এর বেশি। এটি ছবির মানের একটি মোটা দাগের মাপ, পূর্ণ মূল্যায়ন নয় (সেটি পর্ব ৮১-এর বিষয়)। CPU-তে, সত্যিকারের run:

৯ · কোনটি কখন — autoencoder-এর রূপগুলোর তুলনা

একটি বাস্তব নিয়ম: autoencoder নিয়ে কোনো দাবির আগে PCA-কে baseline রাখুন। সংকোচন, anomaly আর probe, তিনটি কাজেই আমাদের run-এ PCA কিছু জায়গায় খুব কাছাকাছি বা ভালো এসেছে। Deep model-এর খরচ (GPU সময়, hyperparameter, seed-এর ওঠানামা) তখনই সার্থক, যখন baseline-কে স্পষ্টভাবে ছাড়ায়।

১০ · AI-এর যুগে — autoencoder-এর কোড আর দাবি যাচাই

Autoencoder-এর কোড AI assistant কয়েক সেকেন্ডে লেখে। কিন্তু এই ক্ষেত্রের ভুলগুলো চুপচাপ ঘটে: আকার মিলে গেলেও ভুল সূত্র, test-এ বেছে নেওয়া threshold, বা একটি ভাগ্যবান seed-এর “চমৎকার AUC”.

AI-এর লেখা autoencoder কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• একটি ছোট batch চালিয়ে প্রতিটি layer-এর আকার আর মোট parameter হাতে হিসাবের সঙ্গে মিলিয়েছি
• এক batch-এ overfit করে দেখেছি loss প্রায় শূন্যে নামে (পর্ব ১৮)
• মূল্যায়নের আগে model.eval() আর torch.no_grad() আছে
• PCA baseline আর কয়েকটি seed ছাড়া “ভালো” দাবি করিনি
• Threshold আর hyperparameter test দেখে বাছিনি; test শুধু শেষে একবার
• গ্রাহকের ছবি বা ব্যক্তিগত ডেটা assistant-কে পাঠাইনি