t-SNE আর UMAP — manifold learning আর তার ফাঁদ

আগের পর্বগুলো মাত্রা কমিয়েছে linear ভাবে বা kernel দিয়ে: PCA-র ভিত্তি পর্ব ০৮ আর পর্ব ০৯-এ, PCA-র প্রথম পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৬৫-এ, আর kernel PCA, ICA, NMF পর্ব ৪১ (PCA-র বাইরে — kernel PCA, ICA আর NMF)-এ। এই পর্বের পদ্ধতিগুলো মূলত ছবি আঁকার জন্য: অনেক মাত্রার ডেটাকে দুই মাত্রায় এনে চোখে দেখা। ছবি সুন্দর হয়, আর ঠিক সেজন্যই বিপজ্জনক। পাতার চারটি ব্লক ব্রাউজারের Python-এ চলে (scikit-learn 1.8.0); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে। UMAP ব্রাউজারে চলে না, তাই সেটি ডেস্কটপের সত্যিকারের run.

১ · Manifold hypothesis — অনেক কলাম, কিন্তু আসল স্বাধীনতা কম

এটিই manifold hypothesis: বাস্তবের উঁচু মাত্রার ডেটা (ছবির পিক্সেল, গ্রাহকের কেনাকাটার vector) সাধারণত পুরো জায়গা জুড়ে থাকে না; তা থাকে একটি কম মাত্রার, বাঁকানো “পাতা”-র কাছে, যার গাণিতিক নাম manifold. একটি ৮×৮ হাতের লেখার ছবি ৬৪ মাত্রার vector, কিন্তু এলোমেলো ৬৪টি পিক্সেল প্রায় কখনো একটি অঙ্কের মতো দেখায় না; আসল অঙ্কগুলো অল্প কয়েকটি স্বাধীন পরিবর্তনে (হেলানো, মোটা, আকার) তৈরি। Manifold learning সেই পাতাটি খুঁজে সমতলে বিছাতে চায়।

কেন linear পদ্ধতি যথেষ্ট নয়? PCA ডেটাকে একটি সমতল তলে ছায়া হিসেবে ফেলে। পাতাটি নিজেই বাঁকানো হলে ছায়ায় পাতার দূরের অংশ একে অপরের ওপর পড়ে। পাখির ওড়ার দূরত্ব (Euclidean distance) আর পাতা ধরে হাঁটার দূরত্ব (geodesic distance) আলাদা হয়ে যায়, আর linear পদ্ধতি শুধু প্রথমটি দেখে।

২ · MDS আর Isomap — দূরত্ব রেখে ছবি, আর geodesic দূরত্ব

Multidimensional scaling (MDS) একটি সরল প্রশ্ন করে: সব জোড়ার দূরত্বের একটি টেবিল দিলে, এমন দুই মাত্রার বিন্দু খুঁজুন যাদের মাঝের দূরত্ব টেবিলের যতটা সম্ভব কাছে। জেলা শহরগুলোর সড়ক-দূরত্বের টেবিল থেকে বাংলাদেশের মানচিত্র আঁকার মতো। Classical MDS (Torgerson, ১৯৫২) দূরত্বের বর্গের matrix-কে দুই দিক থেকে centre করে একটি Gram matrix বানায়, তারপর eigen-decomposition; Euclidean দূরত্বে এর ফল PCA-র সমান। Metric MDS আবার “stress” = Σ(d_ij − ‖y_i − y_j‖)² কমায় (scikit-learn-এ SMACOF algorithm). কিন্তু টেবিলে যদি সোজা দূরত্ব থাকে, তাহলে swiss roll-এর A আর B কাছেই থাকবে।

Isomap (Tenenbaum, de Silva আর Langford, Science, ২০০০) শুধু দূরত্বটা বদলায়। (১) প্রতিটি বিন্দুকে তার k জন নিকট প্রতিবেশীর সঙ্গে জুড়ে একটি neighbour graph; কাছের দূরত্বে সোজা দূরত্ব আর পাতা ধরে দূরত্ব প্রায় সমান। (২) দূরের জোড়ার দূরত্ব = graph-এ সবচেয়ে ছোট পথ, Dijkstra দিয়ে (DSA কোর্সের Dijkstra পর্ব দেখুন)। (৩) সেই geodesic টেবিলে classical MDS. প্রথম ব্লকে তিনটি পদ্ধতি একই swiss roll-এ। প্রতিটি বিন্দুর রং t, অর্থাৎ পাতা বরাবর তার অবস্থান। ছবি থেকে t সোজা রেখায় অনুমান করা গেলে (linear regression-এর R² বেশি) ধরা যায় পাতাটি খুলেছে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_swiss_roll
from sklearn.decomposition import PCA
from sklearn.manifold import Isomap, MDS
from sklearn.linear_model import LinearRegression

X, t = make_swiss_roll(n_samples=600, noise=0.3, random_state=42)
print("X:", X.shape, f" t (position on the roll) {t.min():.1f}..{t.max():.1f}")
models = {"PCA": PCA(n_components=2),
          "MDS": MDS(n_components=2, n_init=1, init="classical_mds",
                     random_state=42),
          "Isomap": Isomap(n_neighbors=10, neighbors_algorithm="kd_tree")}
fig, axes = plt.subplots(1, 3, figsize=(9, 3))
for ax, (name, m) in zip(axes, models.items()):
    Z = m.fit_transform(X)
    r2 = LinearRegression().fit(Z, t).score(Z, t)   # is t a straight line in Z?
    print(f"{name:6s} R^2 of t from the 2-D picture = {r2:.3f}")
    ax.scatter(Z[:, 0], Z[:, 1], c=t, s=6, cmap="viridis")
    ax.set_title(f"{name}  (R^2 = {r2:.2f})", fontsize=9)
    ax.set_xticks([]); ax.set_yticks([])
fig.subplots_adjust(wspace=0.08)

i, j = np.argmin(t), np.argmax(t)              # the two ends of the roll
s = np.linspace(t[i], t[j], 2001)
arc = np.trapezoid(np.sqrt(1 + s**2), s)        # length of the spiral r = t
print(f"ends: straight line {np.linalg.norm(X[i] - X[j]):.1f}, true arc {arc:.1f}")
for n in (400, 600):                            # Isomap's graph distance
    Xn, tn = make_swiss_roll(n_samples=n, noise=0.3, random_state=42)
    g = Isomap(n_neighbors=10, neighbors_algorithm="kd_tree").fit(Xn)
    a, b = np.argmin(tn), np.argmax(tn)
    print(f"n={n}: graph distance between the ends {g.dist_matrix_[a, b]:.1f}")

X: (600, 3)  t (position on the roll) 4.8..14.1
PCA    R^2 of t from the 2-D picture = 0.075
MDS    R^2 of t from the 2-D picture = 0.077
Isomap R^2 of t from the 2-D picture = 0.982
ends: straight line 19.0, true arc 89.1
n=400: graph distance between the ends 27.9
n=600: graph distance between the ends 92.8

একই পরিবারে আরও পদ্ধতি আছে: Locally Linear Embedding (Roweis আর Saul, Science, ২০০০) প্রতিটি বিন্দুকে প্রতিবেশীদের ওজনযুক্ত যোগ হিসেবে লেখে আর সেই ওজন দুই মাত্রায় রাখে; Laplacian eigenmap graph-এর Laplacian-এর eigenvector নেয়। সবগুলোরই মূল ধাপ একটি প্রতিবেশীর graph. পরিষ্কার গাণিতিক পাতায় এগুলো সুন্দর কাজ করে, কিন্তু অনেক দলে ভাগ হওয়া আসল ডেটায় (হাতের লেখা, কোষের জিন-প্রকাশ) প্রায়ই ঘিঞ্জি ছবি দেয়। সেই সমস্যার জন্যই এসেছে t-SNE.

৩ · t-SNE, প্রথম অর্ধেক — affinity আর perplexity

t-SNE (t-distributed Stochastic Neighbor Embedding; Laurens van der Maaten আর Geoffrey Hinton, JMLR, ২০০৮) দূরত্ব রাখতে চায় না; চায় প্রতিবেশিত্ব রাখতে। এটি Hinton আর Roweis-এর আগের SNE (NIPS ২০০২ সম্মেলন)-এর উন্নত রূপ। প্রথম অর্ধেকে প্রতিটি বিন্দু i-এর জন্য একটি সম্ভাবনা: “i যদি নিজের প্রতিবেশী বাছে, j-কে বাছার সম্ভাবনা কত”:

p_j|i = exp(−‖x_i − x_j‖² / 2σ_i²) / Σ_k≠i exp(−‖x_i − x_k‖² / 2σ_i²)

এখানে x_i মূল ডেটার বিন্দু, σ_i বিন্দু i-এর Gaussian-এর চওড়া। কাছের j বেশি সম্ভাবনা পায়, দূরের j প্রায় শূন্য। এই সম্ভাবনাকে বলে affinity. প্রশ্ন হলো σ_i কত হবে। ঘন এলাকার বিন্দুতে ছোট σ যথেষ্ট, পাতলা এলাকায় বড় σ লাগে। তাই t-SNE প্রতিটি বিন্দুর জন্য আলাদা σ_i খোঁজে, যাতে তার সম্ভাবনা-বণ্টনের entropy একটি নির্দিষ্ট মানে আসে:

Perp(P_i) = 2^H(P_i), H(P_i) = −Σ_j p_j|i log₂ p_j|i

Entropy-র ভিত্তি AI-এর ভিত্তি কোর্সের পর্ব ৩৮-এ। মূল কথা: k জন প্রতিবেশীর মধ্যে সমান ভাগ হলে H = log₂ k, তাই perplexity = k. অর্থাৎ perplexity হলো কার্যকর প্রতিবেশীর সংখ্যা। Perplexity বাড়ালে σ বাড়ে, বণ্টন চওড়া হয়, বেশি প্রতিবেশী গোনা হয়। নিচের stepper-এ একটি বিন্দুর পাঁচ প্রতিবেশী, দূরত্বের বর্গ ১, ২, ৪, ৯ আর ১৬:

শেষে দুই দিকের সম্ভাবনা মিলিয়ে একটি প্রতিসম সংখ্যা: p_ij = (p_j|i + p_i|j) / 2n, যাতে সব জোড়ার যোগফল ১. দূরে একা পড়ে থাকা বিন্দুও এতে অন্তত 1/2n ভাগ পায়। scikit-learn খরচ বাঁচাতে প্রতিটি বিন্দুর শুধু প্রায় ৩ × perplexity জন নিকট প্রতিবেশী নিয়ে হিসাব করে, বাকিদের p ধরে শূন্য।

৪ · t-SNE, দ্বিতীয় অর্ধেক — Student-t, KL আর crowding problem

এবার দুই মাত্রায় বিন্দু y_i রাখতে হবে, যাদের মাঝেও একটি সম্ভাবনা q_ij. মূল SNE এখানেও Gaussian নিত। t-SNE নেয় এক degree of freedom-এর Student-t (Cauchy) বণ্টন:

q_ij = (1 + ‖y_i − y_j‖²)⁻¹ / Σ_k≠l (1 + ‖y_k − y_l‖²)⁻¹

তারপর y-গুলো এমনভাবে সরানো হয় যাতে KL divergence C = Σ p_ij log(p_ij/q_ij) সবচেয়ে কম হয়; gradient হলো ∂C/∂y_i = 4 Σ_j (p_ij − q_ij)(y_i − y_j)(1 + ‖y_i − y_j‖²)⁻¹. p > q হলে j-কে কাছে টানে, p < q হলে দূরে ঠেলে। KL অপ্রতিসম: কাছের জোড়াকে (বড় p) দূরে রাখলে বড় শাস্তি, দূরের জোড়াকে (ছোট p) কাছে রাখলে ছোট শাস্তি। তাই t-SNE স্থানীয় গঠন রক্ষায় কঠোর আর বৈশ্বিক গঠনে উদাসীন। Optimisation-এর শুরুতে সব p-কে কিছুক্ষণ ১২ গুণ বাড়ানো হয় (early exaggeration), যাতে দলগুলো আগে আঁটসাঁট হয়ে সরে যাওয়ার জায়গা পায়।

কেন Student-t? দশ মাত্রায় একটি বিন্দুর চারপাশে মাঝারি দূরত্বে যত প্রতিবেশী আঁটে, দুই মাত্রায় তত জায়গা নেই। একে বলে crowding problem. নিচের stepper-এ সংখ্যায়:

দ্বিতীয় ব্লক প্রথম অর্ধেক নিজে করে: load_digits-এর (scikit-learn-এর সঙ্গে আসা UCI হাতের লেখার ডেটা) ৩০০টি ছবির প্রথমটির জন্য binary search দিয়ে perplexity ৫, ৩০ আর ৫০-এর σ খোঁজে। তারপর scikit-learn-এর TSNE চালিয়ে PCA-র সঙ্গে trustworthiness তুলনা করে। Trustworthiness (Venna আর Kaski, ২০০১) মাপে: ছবিতে যারা কাছের k প্রতিবেশী, তারা আসল ডেটাতেও কাছে কি না। ছবিতে “ভুয়া প্রতিবেশী” এলে শাস্তি, শাস্তি তার আসল র‍্যাংক কত দূরে তার অনুপাতে; ১ মানে নিখুঁত।

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE, trustworthiness

X, y = load_digits(return_X_y=True)
idx = np.random.default_rng(42).choice(len(y), 300, replace=False)
X, y = X[idx], y[idx]                       # 300 images, 64 pixels each
d2 = ((X - X[0]) ** 2).sum(axis=1)[1:]      # squared distances from point 0

def perp_of(sigma):                          # perplexity of p(j|0) for one sigma
    p = np.exp(-(d2 - d2.min()) / (2 * sigma**2)); p /= p.sum()
    H = -(p[p > 0] * np.log2(p[p > 0])).sum()
    return 2 ** H, p
for target in (5, 30, 50):
    lo, hi = 1e-3, 1e3
    for _ in range(60):                      # binary search on sigma
        mid = (lo + hi) / 2
        lo, hi = (mid, hi) if perp_of(mid)[0] < target else (lo, mid)
    perp, p = perp_of(mid)
    print(f"perplexity {target:2d}: sigma {mid:5.2f}, perp {perp:5.2f},"
          f" top-5 p sum {np.sort(p)[-5:].sum():.2f}")

t0 = time.perf_counter()
P15 = PCA(n_components=15).fit_transform(X)  # 64 -> 15 columns first
Z = TSNE(perplexity=30, random_state=42).fit_transform(P15)
print(f"t-SNE on {P15.shape}: {time.perf_counter() - t0:.1f} s")
for name, E in (("PCA", P15[:, :2]), ("t-SNE", Z)):
    print(f"{name:5s} trustworthiness (k=5) {trustworthiness(X, E, n_neighbors=5):.3f}")
fig, ax = plt.subplots(figsize=(5, 4))
sc = ax.scatter(Z[:, 0], Z[:, 1], c=y, cmap="tab10", s=10)
ax.legend(*sc.legend_elements(), fontsize=7, ncol=2, title="digit")
ax.set_title("t-SNE of 300 digits (perplexity 30)", fontsize=9)

perplexity  5: sigma  8.37, perp  5.00, top-5 p sum 0.97
perplexity 30: sigma 13.11, perp 30.00, top-5 p sum 0.56
perplexity 50: sigma 14.33, perp 50.00, top-5 p sum 0.44
t-SNE on (300, 15): 2.9 s
PCA   trustworthiness (k=5) 0.820
t-SNE trustworthiness (k=5) 0.991

৫ · ফাঁদ — perplexity, seed, দলের আকার, ফাঁক আর noise-এ দল

ফাঁদগুলো দেখতে এমন ডেটা লাগে, যার আসল উত্তর আমরা জানি। দশ মাত্রায় তিনটি কাল্পনিক দল, প্রতিটিতে ৬৪টি বিন্দু: A খুব আঁটসাঁট (standard deviation ০.৫), B তার ৮ গুণ ছড়ানো (৪.০), C মাঝারি (১.০)। নকশায় কেন্দ্রের দূরত্ব A–B = ২০, B–C = ৬০, A–C = ৮০ (নমুনার এলোমেলোতায় মাপা অনুপাত একটু আলাদা আসবে)। তুলনার জন্য ১৯২টি বিন্দুর একটি গোল Gaussian মেঘ, যাতে কোনো দলই নেই। তারপর চারটি t-SNE: তিন দলে perplexity ২, ৫ আর ৩০, আর noise-এ perplexity ২. এই ব্লক আর পরেরটি একই namespace ভাগ করে।

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

rng = np.random.default_rng(42)
centres = np.zeros((3, 10))             # three groups in 10-D
centres[1, 0] = 20                      # B is 20 from A
centres[2, 0] = 80                      # C is 80 from A, 60 from B
spread = [0.5, 4.0, 1.0]                # A tight, B 8 times wider, C medium
X = np.vstack([c + s * rng.standard_normal((64, 10))
               for c, s in zip(centres, spread)])
lab = np.repeat([0, 1, 2], 64)
noise = rng.standard_normal((192, 10))  # one round Gaussian blob, no groups

def tsne(data, perp, seed=0, init="pca"):
    return TSNE(perplexity=perp, init=init, random_state=seed,
                max_iter=500).fit_transform(data)

t0 = time.perf_counter()
runs = {"perplexity 2": tsne(X, 2), "perplexity 5": tsne(X, 5),
        "perplexity 30": tsne(X, 30), "pure noise, perp 2": tsne(noise, 2)}
print(f"4 t-SNE runs of 192 points: {time.perf_counter() - t0:.1f} s")
fig, axes = plt.subplots(1, 4, figsize=(10, 2.8))
for ax, (name, Z) in zip(axes, runs.items()):
    if "noise" in name:
        ax.scatter(Z[:, 0], Z[:, 1], color="gray", s=6)
    else:
        ax.scatter(Z[:, 0], Z[:, 1], c=lab, cmap="brg", s=6)
    ax.set_title(name, fontsize=9); ax.set_xticks([]); ax.set_yticks([])
fig.subplots_adjust(wspace=0.08)

4 t-SNE runs of 192 points: 2.5 s

পরের ব্লক প্রতিটি দলের কেন্দ্র আর ছড়ানো (কেন্দ্র থেকে গড় দূরত্ব) মাপে, আসল দশ মাত্রায় আর প্রতিটি ছবিতে। t-SNE-র এককের কোনো মানে নেই, তাই সব ফাঁককে A–B ফাঁক দিয়ে, আর সব ছড়ানোকে A-এর ছড়ানো দিয়ে ভাগ করা হয়েছে। সঙ্গে দুটি random শুরু (seed ০ আর ১), আর noise-এর জোড়া-দূরত্বের তুলনা।

from scipy.spatial.distance import pdist

def summary(P, lab):
    """centre gaps (A-B, B-C, A-C) and average spread of each group"""
    m = [P[lab == k].mean(axis=0) for k in range(3)]
    gaps = [np.linalg.norm(m[a] - m[b]) for a, b in ((0, 1), (1, 2), (0, 2))]
    spr = [np.linalg.norm(P[lab == k] - m[k], axis=1).mean() for k in range(3)]
    return np.array(gaps), np.array(spr)

def show(name, P):
    g, s = summary(P, lab)
    print(f"{name:22s} gaps {np.round(g / g[0], 2)}  spreads {np.round(s / s[0], 2)}")

print("(gaps divided by the A-B gap, spreads divided by A's spread)")
show("original 10-D", X)
for name in ("perplexity 5", "perplexity 30"):
    show("t-SNE " + name, runs[name])
for seed in (0, 1):
    show(f"perp 5, random init {seed}", tsne(X, 5, seed=seed, init="random"))

for name, P in (("pure noise", noise), ("its t-SNE", runs["pure noise, perp 2"])):
    d = pdist(P)
    print(f"{name:10s}: nearest/farthest pair distance ratio "
          f"{d.min() / d.max():.3f}, CV of distances {d.std() / d.mean():.2f}")

(gaps divided by the A-B gap, spreads divided by A's spread)
original 10-D          gaps [1.   2.88 3.87]  spreads [1.   8.12 2.14]
t-SNE perplexity 5     gaps [1.   0.94 0.93]  spreads [1.   0.99 0.99]
t-SNE perplexity 30    gaps [1.   1.22 1.3 ]  spreads [1.   1.05 1.  ]
perp 5, random init 0  gaps [1.   0.96 0.92]  spreads [1.   1.05 1.01]
perp 5, random init 1  gaps [1.   0.97 0.98]  spreads [1.   1.01 0.96]
pure noise: nearest/farthest pair distance ratio 0.117, CV of distances 0.22
its t-SNE : nearest/farthest pair distance ratio 0.002, CV of distances 0.47

৬ · t-SNE ছবি পড়া — কী বলা যায়, কী যায় না

এখন নিয়মগুলো একসঙ্গে। একজন বিশ্লেষক বাজারঘরের কাল্পনিক গ্রাহকদের কেনাকাটার vector-এর t-SNE ছবি নিয়ে মিটিং-এ এসেছেন। তাঁর প্রতিটি দাবি পরখ করুন:

Feature হিসেবে t-SNE-র ফল। scikit-learn-এর TSNE-এ fit_transform আছে, transform নেই: নতুন একটি বিন্দু বসাতে পুরো ছবি আবার বানাতে হয়। তাই কেউ train আর test একসঙ্গে t-SNE করে তার দুই কলামে classifier শেখালে test-এর বিন্দুগুলো train-এর ছবির আকারে প্রভাব ফেলেছে: এটি data leakage (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। আবার t-SNE ছবিতে দল খুঁজে সেই দলকেই “আবিষ্কৃত segment” বলে রিপোর্ট করা চক্রাকার যুক্তি। নিরাপদ নিয়ম: t-SNE ছবি অনুসন্ধানের জন্য; model-এর feature লাগলে PCA বা train-এ শেখা অন্য পদ্ধতি pipeline-এর ভেতরে।

Trustworthiness-এর সীমা। এটি শুধু k জন কাছের প্রতিবেশী দেখে, তাই ছোট k-তে বৈশ্বিক বিকৃতি ধরে না। অংশ ৫-এর সমবাহু ত্রিভুজেও স্থানীয় প্রতিবেশী ঠিক থাকে। বড় k-তেও মাপুন (অনুশীলন ৪), আর দূরত্বের প্রশ্নে সরাসরি মূল ডেটায় যান।

৭ · UMAP — fuzzy neighbour graph, আর ডেস্কটপে সত্যিকারের run

UMAP (Uniform Manifold Approximation and Projection; Leland McInnes, John Healy আর James Melville, arXiv ২০১৮) তত্ত্বে লেখা হয়েছে topology-র ভাষায়, কিন্তু কাজের ধাপগুলো সহজে বলা যায়, মোটামুটি এভাবে: (১) প্রতিটি বিন্দুর n_neighbors জন নিকট প্রতিবেশী, দ্রুত আনুমানিক পদ্ধতিতে (NN-descent). (২) প্রতিটি কিনারার একটি ওজন, ০ থেকে ১: সবচেয়ে কাছের প্রতিবেশী পায় ১, বাকিরা দূরত্ব অনুযায়ী কম; প্রতিটি বিন্দুর নিজস্ব মাপকাঠি, t-SNE-র σ_i-এর মতো। এই ওজনের graph-কে বলে fuzzy neighbour graph. (৩) দুই দিকের ওজন মেলানো হয় a + b − ab নিয়মে। (৪) দুই মাত্রায় একটি Student-t-এর মতো বক্ররেখা 1/(1 + a·d^2b), যার আকার min_dist ঠিক করে, আর cross-entropy কমানো হয় stochastic gradient দিয়ে, দূরের জোড়া এলোমেলো নমুনা নিয়ে (negative sampling).

ব্যবহারিক পার্থক্য: UMAP সাধারণত বড় ডেটায় দ্রুত, transform দিয়ে নতুন বিন্দু বসাতে পারে, আর ডিফল্ট শুরু spectral (graph Laplacian থেকে), তাই বৈশ্বিক বিন্যাস প্রায়ই একটু ভালো থাকে। কিন্তু “UMAP বৈশ্বিক গঠন রাখে” কথাটি সাবধানে বলতে হয়: Dmitry Kobak আর George Linderman (Nature Biotechnology, ২০২১) দেখান যে এই পার্থক্যের বড় অংশ শুরুর পদ্ধতি থেকে আসে; একই শুরু দিলে t-SNE-ও কাছাকাছি করে। UMAP numba-নির্ভর, তাই ব্রাউজারের Python-এ চলে না। ডেস্কটপে uv দিয়ে একটি project (uv-এর পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ০৭-এ):

~$ uv init bazarghar-manifold
~/bazarghar-manifold$ uv add numpy scipy scikit-learn==1.8.0 matplotlib umap-learn
…
 + numba==0.68.1
 + pynndescent==0.7.0
 + scikit-learn==1.8.0
 + umap-learn==0.5.12
…

স্ক্রিপ্টটি পুরো ১,৭৯৭টি digit-এ t-SNE আর UMAP চালিয়ে সময় আর trustworthiness মাপে (numba প্রথমবার compile করে, তাই আগে একটি ছোট warm-up run), তারপর অংশ ৫-এর একই তিন দলে n_neighbors ৫, ১৫ আর ৫০, প্রতিটিতে দুটি seed. সত্যিকারের run (একটি সাধারণ ল্যাপটপ, একবার; সময় সাধারণ ফল নয়):

~/bazarghar-manifold$ uv run python umap_run.py
…/umap/umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.
  (একই warning আরও ৭ বার, প্রতিটি seed দেওয়া run-এ)
Python 3.14.4, umap-learn 0.5.12, scikit-learn 1.8.0, numba 0.68.1
t-SNE (1797, 64) -> (1797, 2) in 2.2 s, trustworthiness(k=5) 0.995
UMAP  (1797, 64) -> (1797, 2) in 3.8 s, trustworthiness(k=5) 0.989
original      gaps [1.   2.88 3.87] spreads [1.   8.12 2.14]
UMAP nn= 5 s=0 gaps [1.   0.99 0.95] spreads [1.   1.   0.99]
UMAP nn= 5 s=1 gaps [1.   1.48 1.95] spreads [1.   1.07 0.97]
UMAP nn=15 s=0 gaps [1.   1.05 0.7 ] spreads [1.   1.02 1.03]
UMAP nn=15 s=1 gaps [1.   0.95 1.43] spreads [1.   1.04 1.05]
UMAP nn=50 s=0 gaps [1.   1.26 1.69] spreads [1.   0.97 0.95]
UMAP nn=50 s=1 gaps [1.   1.89 1.21] spreads [1.   0.97 1.01]

Warning: seed দিলে UMAP একটি thread-এ চলে, যাতে ফল পুনরুৎপাদনযোগ্য হয়; গতি আর পুনরুৎপাদনের এই বিনিময় সে নিজেই জানায়। সময়: এই ছোট ডেটায় UMAP (৩.৮ s) t-SNE-র (২.২ s) চেয়ে দ্রুত নয়; UMAP-এর গতির সুবিধা সাধারণত লাখ বিন্দুর ডেটায় দেখা যায়, আর এখানে একবারের মাপ। Trustworthiness: দুটিই প্রায় সমান (০.৯৯৫ আর ০.৯৮৯)। ফাঁদ: ছড়ানো এখানেও প্রায় সমান (০.৯৫–১.০৭, আসলে ৮.১২)। ফাঁকের অনুপাত n_neighbors আর seed-এ লাফায়, t-SNE-র চেয়ে অনেক বেশি: ১৫ প্রতিবেশীতে seed ০-এ ১ : ১.০৫ : ০.৭, যেখানে সবচেয়ে দূরের জোড়া A–C ছবিতে সবচেয়ে কাছে; seed ১-এ ১ : ০.৯৫ : ১.৪৩. ৫০ প্রতিবেশীতে seed ১-এ B–C (১.৮৯) A–C-র (১.২১) চেয়ে বড়, আসল ক্রমের উল্টো। আসল ১ : ২.৮৮ : ৩.৮৭ কোনো run-এই আসেনি। UMAP-এর ছবিও একই নিয়মে পড়তে হয়।

৮ · AI-এর যুগে — t-SNE/UMAP কোড আর সিদ্ধান্ত যাচাই

AI assistant-কে “আমার গ্রাহকদের segment দেখাও” বললে সে প্রায়ই একটি সুন্দর t-SNE বা UMAP ছবি আর আত্মবিশ্বাসী ব্যাখ্যা দেয়। পরিচিত ভুলগুলো:

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

• কয়েকটি perplexity (বা n_neighbors) আর কয়েকটি seed-এ ছবি দেখেছি, একটিতে নয়
• Trustworthiness ছোট আর বড় k-তে মেপেছি, আর PCA-র সঙ্গে তুলনা করেছি
• দলের আকার, দলের মাঝের দূরত্ব বা অক্ষ নিয়ে কোনো দাবি করিনি
• দলের দাবি মূল ডেটায় clustering আর কেন্দ্রের দূরত্ব দিয়ে মিলিয়েছি
• Model-এর feature হিসেবে t-SNE ব্যবহার করিনি; করলে split আগে, pipeline-এর ভেতরে
• Argument-এর নাম (যেমন max_iter) নিজের version-এর docs-এ মিলিয়েছি, আর আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি