Multimodal model — CLIP, image captioning আর vision-language model

এ পর্যন্ত model হয় ছবি পড়েছে (পর্ব ২০, পর্ব ৩৮), নয়তো লেখা (মডিউল ৫ থেকে ৯)। বাস্তবের প্রশ্ন প্রায়ই দুটি মিলিয়ে: “এই জুতার ছবির সঙ্গে কোন বিবরণ মেলে?”, “রসিদের ছবিতে মোট কত টাকা?” এই পর্বে তিন ধরনের multimodal model দেখবেন: ছবি আর লেখাকে একই জায়গায় আনা CLIP, ছবি দেখে বাক্য লেখা captioner, আর ছবি দেখে প্রশ্নের উত্তর দেওয়া vision-language model. চারটি ব্লক ব্রাউজারের Python-এ চলে (প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে)। CLIP আর SmolVLM-এর সংখ্যা ডেস্কটপের সত্যিকারের run থেকে, CPU-তে, Python 3.14-এ।

১ · ছবি কীভাবে token হয় — patch, projection আর CLS

LLM লেখা পড়ে token-এর sequence হিসেবে (পর্ব ৪০)। ছবিকে একই যন্ত্রে ঢোকাতে হলে ছবিকেও token-এর sequence বানাতে হয়। পর্ব ৩৮-এ ViT-এর পুরো হিসাব দেখেছেন; এখানে শুধু সারাংশ, কারণ বাকি পর্বের প্রতিটি model এই ধাপ দিয়ে শুরু। H × W pixel-এর ছবিকে P × P মাপের patch-এ কাটলে patch-এর সংখ্যা

N = (H ÷ P) × (W ÷ P),   প্রতিটি patch-এ P × P × 3টি সংখ্যা

প্রতিটি patch-কে একটি সারিতে সাজিয়ে একই matrix W দিয়ে গুণ করলে d-মাত্রার vector আসে; এটিই patch embedding. সামনে একটি শেখা CLS token বসে, আর প্রতিটি অবস্থানে একটি শেখা position embedding যোগ হয়, যাতে model জানে কোন patch কোথায় ছিল।

নিচের ব্লক এই হিসাব NumPy-তে করে: patch কাটা ঠিক জায়গা থেকে হচ্ছে কি না যাচাই, projection আর CLS-এর shape, একটি vision-language model যে pixel shuffle দিয়ে token কমায় তার shape, আর API-র নথিতে দেওয়া token-গণনার সূত্র।

import math
import numpy as np

for h, p, name in [(224, 32, "CLIP ViT-B/32"), (224, 16, "ViT-B/16"), (336, 14, "ViT-L/14, 336px"), (512, 16, "SigLIP-B/16, 512px")]:
    g = h // p
    print(f"{name:18s} {h}x{h}, patch {p:2d}: {g}x{g} = {g * g:4d} patches, {p * p * 3:4d} numbers each")

rng = np.random.default_rng(0); P = 32
img = rng.random((224, 224, 3), dtype=np.float32)
x = img.reshape(7, P, 7, P, 3).transpose(0, 2, 1, 3, 4).reshape(49, P * P * 3)   # cut into patches
print("patch 0 = top-left block:", np.array_equal(x[0], img[:32, :32].reshape(-1)),
      "| patch 8 = row 1, col 1:", np.array_equal(x[8], img[32:64, 32:64].reshape(-1)))
W = rng.normal(0, 0.02, (P * P * 3, 768)).astype(np.float32)   # one shared projection
tok = x @ W
cls = rng.normal(0, 0.02, (1, 768)).astype(np.float32)         # learned CLS token
pos = rng.normal(0, 0.02, (50, 768)).astype(np.float32)        # learned position embedding
seq = np.vstack([cls, tok]) + pos
print("patches", x.shape, "@ W", W.shape, "->", tok.shape, "-> + CLS + pos ->", seq.shape)
print(f"projection weights {W.size:,} (no bias, as in CLIP)")

grid = rng.random((32, 32, 768), dtype=np.float32)              # SigLIP output for one 512x512 tile
r = 4                                                            # pixel shuffle: merge 4x4 neighbours
s = grid.reshape(8, r, 8, r, 768).transpose(0, 2, 1, 3, 4).reshape(64, r * r * 768)
print("pixel shuffle r=4:", grid.shape, "->", s.shape, "-> 64 visual tokens for the LLM")

for w, h in [(1000, 1000), (1920, 1080)]:
    print(f"{w}x{h}: ceil(w/28)*ceil(h/28) = {math.ceil(w / 28) * math.ceil(h / 28)}, "
          f"ceil(w/32)*ceil(h/32) = {math.ceil(w / 32) * math.ceil(h / 32)}  (before any resize cap)")

CLIP ViT-B/32      224x224, patch 32: 7x7 =   49 patches, 3072 numbers each
ViT-B/16           224x224, patch 16: 14x14 =  196 patches,  768 numbers each
ViT-L/14, 336px    336x336, patch 14: 24x24 =  576 patches,  588 numbers each
SigLIP-B/16, 512px 512x512, patch 16: 32x32 = 1024 patches,  768 numbers each
patch 0 = top-left block: True | patch 8 = row 1, col 1: True
patches (49, 3072) @ W (3072, 768) -> (49, 768) -> + CLS + pos -> (50, 768)
projection weights 2,359,296 (no bias, as in CLIP)
pixel shuffle r=4: (32, 32, 768) -> (64, 12288) -> 64 visual tokens for the LLM
1000x1000: ceil(w/28)*ceil(h/28) = 1296, ceil(w/32)*ceil(h/32) = 1024  (before any resize cap)
1920x1080: ceil(w/28)*ceil(h/28) = 2691, ceil(w/32)*ceil(h/32) = 2040  (before any resize cap)

২ · CLIP — দুটি encoder, একটি জায়গা, contrastive শেখা

CLIP (Contrastive Language–Image Pre-training; Radford ও সহকর্মীরা, OpenAI, ২০২১) দুটি আলাদা encoder রাখে: একটি ছবির জন্য (ViT বা ResNet), একটি লেখার জন্য (Transformer). দুটির শেষে একটি করে linear projection, যাতে দুই দিকের vector একই মাপের (আমাদের model-এ ৫১২) আর দৈর্ঘ্য ১-এ normalise করা। প্রবন্ধ অনুযায়ী শেখানো হয় ইন্টারনেট থেকে সংগ্রহ করা প্রায় ৪০ কোটি ছবি-লেখা জোড়ায়; আমরা যে OpenCLIP সংস্করণ চালাব, তার card বলে LAION-2B-এর ইংরেজি অংশে।

শেখার নিয়মটি contrastive: একটি batch-এ N জোড়া থাকলে N × N-টি cosine হয়। কর্ণের N-টি মিলে যাওয়া জোড়া, বাকি N² − N-টি “negative”. লক্ষ্য কর্ণের মান বাড়ানো আর বাকিগুলো কমানো। ঠিক এই ধারণা বাক্যের embedding-এ পর্ব ৬৭-এ InfoNCE আর in-batch negative নামে দেখেছেন; CLIP একই loss দুই দিকে চালায়।

সূত্রে, normalise করা ছবির vector I_i আর লেখার vector T_j-এর জন্য logit ℓ_ij = s · (I_i · T_j), যেখানে s হলো logit scale, অর্থাৎ ১/temperature. তারপর

L = ½ [ −(1/N) ∑_i log softmax_j(ℓ_ij)_j=i  −  (1/N) ∑_j log softmax_i(ℓ_ij)_i=j ]

প্রথম অংশ প্রতিটি সারিতে (ছবি → লেখা), দ্বিতীয়টি প্রতিটি কলামে (লেখা → ছবি) সাধারণ cross-entropy, যার সঠিক “class” কর্ণের ঘরটি (পর্ব ১৩)। এলোমেলো শুরুতে loss প্রায় log N, কারণ N-টির মধ্যে আন্দাজ। প্রবন্ধে s নিজেই শেখা হয়: শুরু ১/০.০৭ ≈ ১৪.৩ থেকে, আর ১০০-এর বেশি হতে দেওয়া হয় না। আমাদের model-এর config-এ শুরুর মান ln s = ২.৬৫৯২ লেখা, যা ln(১/০.০৭); শেখার পর logit_scale.exp() ছাপে 100.0.

কেন বড় batch? প্রতিটি সারিতে negative যত বেশি, কাজ তত কঠিন আর শেখা তত সূক্ষ্ম; প্রবন্ধে batch ছিল ৩২,৭৬৮. পরে SigLIP (Zhai ও সহকর্মীরা, ২০২৩) softmax-এর বদলে প্রতিটি ঘরে আলাদা sigmoid loss ব্যবহার করে, যাতে পুরো সারির যোগফল লাগে না; নিচে যে SmolVLM চালাব, তার vision encoder এই পরিবারের। নিচের ব্লক ছয় জোড়া খেলনা ডেটায় দুটি ছোট linear encoder-কে এই loss দিয়ে শেখায়, হাতে লেখা gradient দিয়ে।

import numpy as np

def softmax(L, ax):
    e = np.exp(L - L.max(ax, keepdims=True)); return e / e.sum(ax, keepdims=True)

def clip_loss(A, B, s):                      # symmetric InfoNCE, diagonal = matched pair
    L = s * A @ B.T; N = len(A); I = np.eye(N)
    Pi, Pt = softmax(L, 1), softmax(L, 0)    # image->text (rows), text->image (columns)
    loss = -(np.log(np.diag(Pi)).mean() + np.log(np.diag(Pt)).mean()) / 2
    G = ((Pi - I) + (Pt - I)) / (2 * N)      # dloss/dL
    return loss, L, G

rng = np.random.default_rng(42); N = 6
z = rng.normal(size=(N, 3))                  # hidden "meaning" shared by a pair
X = z @ rng.normal(size=(3, 5)) + 0.1 * rng.normal(size=(N, 5))   # image features
Y = z @ rng.normal(size=(3, 4)) + 0.1 * rng.normal(size=(N, 4))   # text features
Wi = 0.1 * rng.normal(size=(5, 3)); Wt = 0.1 * rng.normal(size=(4, 3))
s = 2.0
print(f"chance level log(N) = {np.log(N):.3f}")
for step in range(301):
    A, B = X @ Wi, Y @ Wt
    loss, L, G = clip_loss(A, B, s)
    if step in (0, 10, 50, 300):
        acc = (L.argmax(1) == np.arange(N)).mean()
        print(f"step {step:3d}  loss {loss:.3f}  image->text top-1 {acc:.2f}")
    dA, dB = s * G @ B, s * G.T @ A
    Wi -= 0.1 * X.T @ dA; Wt -= 0.1 * Y.T @ dB
np.set_printoptions(precision=1, suppress=True)
print("similarity matrix after training (rows = images):")
print(L)

chance level log(N) = 1.792
step   0  loss 1.802  image->text top-1 0.00
step  10  loss 0.780  image->text top-1 0.67
step  50  loss 0.513  image->text top-1 0.67
step 300  loss 0.323  image->text top-1 0.83
similarity matrix after training (rows = images):
[[ 6.8 -2.2  1.1  1.9 -0.4 -6.3]
 [-0.3 13.1  0.8 -8.2 -4.4  0. ]
 [ 0.6  0.6  0.1 -0.4 -0.1 -0.8]
 [ 2.9 -8.6 -0.2  6.9  0.6  0.6]
 [-3.4 -4.3 -0.8  0.9  4.3 -0.6]
 [-2.9  3.5 -0.5 -0.1 -4.2  8.3]]

৩ · Zero-shot classification — label নয়, prompt

CLIP-এর সবচেয়ে চমকপ্রদ ব্যবহার: কোনো label-যুক্ত ছবি ছাড়াই classifier. বাজারঘরের নতুন একটি পণ্য-বিভাগ “স্যান্ডেল, কেডস না বুট” আলাদা করতে চাইলে প্রতিটি class-এর নাম একটি বাক্যে বসান (“a photo of a sneaker.”), লেখার encoder দিয়ে তিনটি vector নিন। এই vector-গুলোই classifier-এর weight. নতুন ছবির vector-এর সঙ্গে cosine নিয়ে s দিয়ে গুণ, তারপর softmax. একে zero-shot বলে, কারণ এই class-গুলোর একটি উদাহরণও দেখানো হয়নি।

দুটি জিনিস এখানেই চোখে পড়ে। এক, cosine-গুলো খুব কাছাকাছি (০.২-এর আশপাশে); s = ১০০ না থাকলে softmax প্রায় সমান ভাগ দিত। দুই, ফলাফল prompt-এর শব্দের ওপর নির্ভর করে, তাই CLIP প্রবন্ধ একাধিক template-এর embedding-এর গড় নেয়, যাকে prompt ensemble বলে (প্রবন্ধে ImageNet-এ ৮০টি template). নিচের ব্লক stepper-এর একই সত্যিকারের embedding (৫১২ মাত্রা, পাতায় ডেটা হিসেবে রাখা) থেকে হিসাব করে, আর s বদলালে softmax কীভাবে বদলায় তা দেখায়।

import numpy as np
import matplotlib.pyplot as plt

E = {}
for line in open("clip_emb.txt"):                  # real CLIP embeddings x 10000, 512 numbers each
    name, *vals = line.split()
    E[name] = np.array(vals, dtype=float) / 10000
img = E["image"]; names = ["sneaker", "sandal", "ankle_boot"]
T = np.stack([E[n] for n in names])
print("vector length:", img.shape, "norms", np.round(np.linalg.norm(T, axis=1), 4))
cos = T @ img / (np.linalg.norm(T, axis=1) * np.linalg.norm(img))
print("cosine:", ", ".join(f"{n} {c:.4f}" for n, c in zip(names, cos)))
np.set_printoptions(suppress=True)

def softmax(z):
    e = np.exp(z - z.max())
    return e / e.sum()

for s in [1, 10, 100]:                            # s = logit scale = 1 / temperature
    print(f"s = {s:3d}  logits {np.round(s * cos, 2)}  softmax {np.round(softmax(s * cos), 4)}")

ss = np.linspace(1, 120, 60)
P = np.array([softmax(s * cos) for s in ss])
plt.figure(figsize=(5, 3))
for k, n in enumerate(names):
    plt.plot(ss, P[:, k], label=n)
plt.axvline(100, ls="--", c="grey")
plt.xlabel("logit scale s"); plt.ylabel("probability"); plt.legend()
plt.title("Same cosines, sharper softmax as s grows")
plt.show()

vector length: (512,) norms [1. 1. 1.]
cosine: sneaker 0.1984, sandal 0.1619, ankle_boot 0.1262
s =   1  logits [0.2  0.16 0.13]  softmax [0.3455 0.3331 0.3214]
s =  10  logits [1.98 1.62 1.26]  softmax [0.4587 0.3184 0.2229]
s = 100  logits [19.84 16.19 12.62]  softmax [0.974  0.0253 0.0007]

৪ · সত্যিকারের run — ইংরেজি বনাম বাংলা prompt, ensemble আর linear probe

Model: laion/CLIP-ViT-B-32-laion2B-s34B-b79K (OpenCLIP দলের ViT-B/32, card-এ MIT লাইসেন্স, token ছাড়া নামে, প্রায় ৬০৫ MB; পর্ব ৮১-এ CLIP score-এ এটিই ছিল)। Card স্পষ্ট বলে, যাচাই ছাড়া চালু পণ্যে ব্যবহার “out of scope”; আমরা শুধু শেখার জন্য মাপছি। ডেটা Fashion-MNIST (Zalando Research, MIT লাইসেন্স), বাজারঘরের পণ্যের ছবির বদলি: test সেট থেকে প্রতি class-এ ১০০টি (মোট ১০০০, seed ৪২), সাদা পটভূমিতে গাঢ় পণ্য করে উল্টে নেওয়া। Linear probe-এর জন্য train সেট থেকে আলাদা ১০০০টি। তুলনা করা হয়েছে:

• ইংরেজি prompt “a photo of a {}.”, আর ৬টি template-এর ensemble (“a black and white photo of a {}.” ইত্যাদি)।
• বাংলা prompt “একটি {}-এর ছবি”, বাংলা class-নামে (টি-শার্ট, প্যান্ট, … কেডস, বুট জুতা), আর ৬টি বাংলা template-এর ensemble; সঙ্গে বাংলা বাক্যে ইংরেজি class-নাম।
• Linear probe: ছবির encoder স্থির রেখে তার embedding-এর ওপর logistic regression (scikit-learn, C = ১), প্রতি class-এ ১, ১০ আর ১০০টি label দিয়ে।

প্রতিটি accuracy-র পাশে ৯৫% Wilson interval (confidence interval-এর একটি রূপ, অনুপাতের জন্য)। CPU-তে, Python 3.14, torch 2.15.0, transformers 5.22.2, scikit-learn 1.9.1 (লেখার সময়ে)।

~/bazarghar-dl$ uv run python clip_zs.py
model laion/CLIP-ViT-B-32-laion2B-s34B-b79K | logit_scale.exp() = 100.0
patch_embedding weight (768, 3, 32, 32) bias False | class_embedding (768,) | position_embedding (50, 768) | visual_projection (512, 768) | text_projection (512, 512)
pixel_values (1, 3, 224, 224) -> vision last_hidden_state (1, 50, 768)
image embeddings: test (1000, 512), train (1000, 512), 55.0s on CPU
tokens for 'a photo of a sneaker.': 6 (+2 special), context limit 77
tokens for 'একটি কেডস-এর ছবি': 27 (+2 special), context limit 77
zero-shot EN, 1 template           acc 0.845  95% CI [0.821, 0.866]
zero-shot EN, 6-template ensemble  acc 0.858  95% CI [0.835, 0.878]
zero-shot BN, 1 template           acc 0.113  95% CI [0.095, 0.134]
zero-shot BN, 6-template ensemble  acc 0.135  95% CI [0.115, 0.158]
zero-shot class name only (EN)     acc 0.789  95% CI [0.763, 0.813]
zero-shot BN sentence, EN names    acc 0.835  95% CI [0.811, 0.857]
per class (EN ensemble): T-shirt 0.64, pair of trousers 0.98, pullover sweater 0.93, dress 0.84, coat 0.91, sandal 0.95, shirt 0.43, sneaker 0.94, handbag 0.98, ankle boot 0.98
linear probe,   1 labelled/class        acc 0.703  95% CI [0.674, 0.731]
linear probe,  10 labelled/class        acc 0.848  95% CI [0.824, 0.869]
linear probe, 100 labelled/class        acc 0.899  95% CI [0.879, 0.916]
page example: test index 8108 cos sneaker/sandal/ankle boot [0.1984 0.1619 0.1262]
x100 logits [19.84 16.19 12.62] softmax [9.739e-01 2.540e-02 7.000e-04]
symmetric InfoNCE on 8 real image-caption pairs: image->text 1.113, text->image 1.063, mean 1.088; chance log(8)=2.079

পাঁচটি শিক্ষা। এক, প্রথম তিন লাইন অংশ ১-এর হিসাব নিশ্চিত করে: patch-এর weight (৭৬৮, ৩, ৩২, ৩২), bias নেই, position embedding (৫০, ৭৬৮), আর ছবি ঢুকে (১, ৫০, ৭৬৮) বের হয়। দুই, ইংরেজি prompt-এ zero-shot ০.৮৪৫, ensemble-এ ০.৮৫৮; ব্যবধান দুটি অনেকটা মিলে যায়, তাই এই উন্নতি এখানে নিশ্চিত নয় (একই ছবিতে জোড়া তুলনা লাগত)। শুধু class-নাম (template ছাড়া) ০.৭৮৯, স্পষ্টভাবে কম: prompt-এর গঠন সত্যিই প্রভাব ফেলে। তিন, বাংলা prompt-এ ০.১১৩ আর ০.১৩৫, দশ class-এ আন্দাজের (০.১০) প্রায় সমান। অথচ বাংলা বাক্যে ইংরেজি class-নাম বসালে ০.৮৩৫: model আসলে ইংরেজি শব্দটি চিনছে, বাংলা বাক্য নয়। কারণ দুটি: card অনুযায়ী training ছিল ইংরেজি অংশে, আর বাংলা বাক্যটি ২৭টি byte-level token-এ ভেঙেছে (ইংরেজিটি ৬টিতে)। চার, “shirt” ০.৪৩ আর “T-shirt” ০.৬৪: ২৮ × ২৮ ধূসর ছবিতে শার্ট, টি-শার্ট আর কোট আলাদা করা মানুষের পক্ষেও কঠিন। পাঁচ, প্রতি class-এ মাত্র ১০টি label-এর linear probe (০.৮৪৮) zero-shot-এর সমান, ১০০টিতে ০.৮৯৯, স্পষ্টভাবে বেশি; আর মাত্র ১টি label-এ (০.৭০৩) zero-shot-ই ভালো। অর্থাৎ label একেবারে না থাকলে prompt, কয়েক ডজন থাকলে probe. শেষ লাইনে ৮টি সত্যিকারের জোড়ায় দুই দিকের InfoNCE ১.০৮৮, আন্দাজের log ৮ = ২.০৭৯-এর অনেক নিচে। এটি একটি ছোট স্থানীয় run, একটি ডেটাসেট আর একটি model; সাধারণ ফল নয়।

নিচের ব্লক এই সংখ্যাগুলো থেকে Wilson ব্যবধান নিজে হিসাব করে ছবি আঁকে, যাতে কোন পার্থক্য ব্যবধানের বাইরে, তা চোখে দেখা যায়।

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

n = 1000                                       # correct answers out of 1000 test images (desktop run)
runs = {"EN prompt, 1 template": 845, "EN prompt, 6-template ensemble": 858,
        "BN prompt, 1 template": 113, "BN prompt, 6-template ensemble": 135,
        "class name only (EN)": 789, "BN sentence + EN class name": 835,
        "linear probe, 1 label/class": 703, "linear probe, 10 labels/class": 848,
        "linear probe, 100 labels/class": 899}

def wilson(k, n, z=1.96):                       # 95% Wilson score interval
    p = k / n; d = 1 + z**2 / n
    c = (p + z**2 / (2 * n)) / d
    h = z * np.sqrt(p * (1 - p) / n + z**2 / (4 * n**2)) / d
    return c - h, c + h

rows = [(name, k / n, *wilson(k, n)) for name, k in runs.items()]
df = pd.DataFrame(rows, columns=["setting", "acc", "lo", "hi"]).round(3)
pd.set_option("display.width", 100)
print(df.to_string(index=False))
print("chance with 10 classes:", 1 / 10)

fig, ax = plt.subplots(figsize=(6, 3.6))
y = np.arange(len(df))
ax.errorbar(df.acc, y, xerr=[df.acc - df.lo, df.hi - df.acc], fmt="o", capsize=3)
ax.axvline(0.1, ls=":", c="grey")
ax.set_yticks(y); ax.set_yticklabels(df.setting, fontsize=8); ax.invert_yaxis()
ax.set_xlabel("accuracy (95% Wilson interval), n = 1000")
ax.set_title("CLIP ViT-B/32 on Fashion-MNIST: prompts vs probe")
fig.subplots_adjust(left=0.42)
plt.show()

                       setting   acc    lo    hi
         EN prompt, 1 template 0.845 0.821 0.866
EN prompt, 6-template ensemble 0.858 0.835 0.878
         BN prompt, 1 template 0.113 0.095 0.134
BN prompt, 6-template ensemble 0.135 0.115 0.158
          class name only (EN) 0.789 0.763 0.813
   BN sentence + EN class name 0.835 0.811 0.857
   linear probe, 1 label/class 0.703 0.674 0.731
 linear probe, 10 labels/class 0.848 0.824 0.869
linear probe, 100 labels/class 0.899 0.879 0.916
chance with 10 classes: 0.1

৫ · Image captioning — ছবি দেখে বাক্য লেখা

CLIP মিল মাপে, কিন্তু নিজে একটি শব্দও লেখে না। ছবি থেকে বাক্য লেখা image captioning, যা গঠনে পর্ব ৩০-এর encoder-decoder: encoder ছবিকে vector-এর sequence বানায়, decoder একটি একটি করে শব্দ লেখে, আর প্রতিটি ধাপে cross-attention দিয়ে ছবির কোন অংশে তাকাবে ঠিক করে (পর্ব ৩২)। Training-এ loss সাধারণ next-token cross-entropy: ছবি আর আগের শব্দগুলো দেখে পরের শব্দ।

মূল্যায়নে মডেলের caption-কে মানুষের লেখা কয়েকটি caption-এর সঙ্গে n-gram মিলিয়ে BLEU বা CIDEr মাপা হয় (ধারণা পর্ব ৪৫-এ)। সমস্যাও একই: “একটি লাল মগ টেবিলে” আর “টেবিলের ওপর একটি লাল কাপ” দুটিই ঠিক, কিন্তু শব্দ কম মেলে; আবার ছবিতে নেই এমন বস্তুর নাম লিখলেও সাবলীল বাক্য ভালো নম্বর পেতে পারে। তাই caption-এ ভুল বস্তু ধরার আলাদা মাপ লাগে (অংশ ৭)।

৬ · Vision-language model — vision encoder, projector আর LLM

আজকের “ছবি আপলোড করে প্রশ্ন” ধরনের সহায়ক সাধারণত একটি vision-language model (VLM). সবচেয়ে প্রচলিত প্রকাশিত নকশাটি LLaVA (Liu ও সহকর্মীরা, ২০২৩) থেকে পরিচিত, তিনটি অংশে:

1. Vision encoder: CLIP বা SigLIP-এর ছবির অংশ; patch-গুলোর vector দেয় (CLS-এর একটি নয়, সবগুলো)।
2. Projector: একটি linear layer বা ছোট MLP, যা ছবির vector-কে LLM-এর token embedding-এর মাপে আনে। LLaVA-র প্রথম সংস্করণে একটি linear layer, LLaVA-1.5-এ দুই স্তরের MLP.
3. LLM: সাধারণ decoder-only model (পর্ব ৪৯)। Projector-এর output “visual token” হিসেবে prompt-এর ভেতরে লেখার token-এর পাশে বসে, আর LLM সেগুলোর ওপর সাধারণ self-attention চালায়।

LLaVA প্রবন্ধে শেখানো হয় দুই ধাপে: প্রথমে শুধু projector, ছবি-caption জোড়ায় (encoder আর LLM স্থির); তারপর projector আর LLM একসঙ্গে, ছবি নিয়ে প্রশ্নোত্তরের নির্দেশনা-ডেটায় (পর্ব ৫৬-এর ধারণা), যার বড় অংশ লেখকেরা একটি লেখা-ভিত্তিক GPT-4 দিয়ে বানান। ভিন্ন পথ নেয় Flamingo (Alayrac ও সহকর্মীরা, DeepMind, ২০২২): visual token prompt-এ না বসিয়ে LLM-এর স্তরের মাঝে নতুন gated cross-attention স্তর ঢোকায়। খোলা model-এর মধ্যে Qwen-VL পরিবার ছবির আকার অনুযায়ী token-এর সংখ্যা বদলায়; Qwen2.5-VL-এর card বলে প্রতিটি visual token ২৮ × ২৮ pixel-এর সমান, আর ডিফল্টে একটি ছবিতে ৪ থেকে ১৬,৩৮৪টি visual token (লেখার সময়ে, নভেম্বর ২০২৬; পরিবর্তন হতে পারে)।

আমরা চালাব HuggingFaceTB/SmolVLM-256M-Instruct (card-এ Apache 2.0 লাইসেন্স, প্রায় ২৫.৬ কোটি parameter). Card অনুযায়ী এটি Idefics3-ভিত্তিক: ৯.৩ কোটি parameter-এর SigLIP vision encoder (siglip-base-patch16-512), ভাষার অংশে SmolLM2, আর প্রতিটি ৫১২ × ৫১২ টুকরোকে ৬৪টি visual token-এ আনে; বড় ছবি কয়েকটি টুকরোয় ভাগ হয়। নিচের stepper সত্যিকারের run-এর shape ধরে একটি প্রশ্নের পুরো পথ দেখায়।

এই হিসাবের ব্যবহারিক মানে: প্রতিটি visual token LLM-এর context-এ জায়গা নেয়, KV cache-এ মেমরি নেয় (পর্ব ৩৭), আর hosted API-তে input token হিসেবে গোনা হয় (পর্ব ৬৫)। বড় ছবিকে টুকরো করলে ছোট লেখা পড়া সহজ হয়, কিন্তু token কয়েক গুণ বাড়ে; সত্যিকারের run-এ ঠিক এই trade-off মাপা হয়েছে।

৭ · সত্যিকারের run — SmolVLM-256M: বর্ণনা, গণনা, লেখা পড়া আর hallucination

ছবি: আটটি, কোনোটিতে মানুষ নেই। পাঁচটি নিজে আঁকা (PIL দিয়ে, ৫১২ × ৫১২): একটি প্লেটে ৭টি কমলা, দামের ট্যাগে “Price: 450 Tk” বড় (৬৪ px) আর ছোট (১৪ px) font-এ, নীল বোর্ডে বাংলায় “দাম ১২০ টাকা”, আর টেবিলে একটি লাল মগ, নীল বই ও টবের গাছ। বাকি তিনটি Fashion-MNIST-এর sneaker, ব্যাগ আর প্যান্ট, ২৮ থেকে ৫১২ pixel-এ বড় করা। Model fp32-এ CPU-তে, greedy decoding (do_sample=False), একটি টুকরোয় (do_image_splitting=False) যদি না অন্যভাবে বলা থাকে। প্রশ্ন ইংরেজি আর বাংলায়, উত্তর হুবহু।

~/bazarghar-dl$ uv run python vlm_run.py
transformers 5.22.2, torch 2.15.0+cpu, params 256,484,928
== trace: desk.png, one 512x512 tile vs default splitting
  pixel_values (1, 1, 3, 512, 512)  prompt tokens 82 (image tokens 64)  {'vision_out': (1, 1024, 768), 'connector_out': (1, 64, 576)}
  split=False: 1.2s, 18 new tokens -> 'In this image, there is a table with a red square on the left side.'
  pixel_values (1, 17, 3, 512, 512)  prompt tokens 1142 (image tokens 1088)  {'vision_out': (17, 1024, 768), 'connector_out': (17, 64, 576)}
  split=True: 13.8s, 15 new tokens -> 'In this image we can see a table with some objects on it.'
== descriptions (no splitting, greedy, max 60 new tokens)
[desk] Describe this image in one sentence.
   -> 'In this image, there is a table with a red square on the left side.'  (1.2s)
[desk] এই ছবিতে কী আছে? বাংলায় এক বাক্যে বলুন।
   -> '1.'  (0.9s)
[oranges7] Describe this image in one sentence.
   -> 'In this image there is a white plate and there are orange fruits on it.'  (1.2s)
[oranges7] এই ছবিতে কী আছে? বাংলায় এক বাক্যে বলুন।
   -> '9'  (0.9s)
[fm_sneaker] Describe this image in one sentence.
   -> 'In this image there is a shoe.'  (1.0s)
[fm_sneaker] এই ছবিতে কী আছে? বাংলায় এক বাক্যে বলুন।
   -> 'Yes, the shoe is a standard size for children.'  (1.1s)
[bangla_sign] Describe this image in one sentence.
   -> 'A blue rectangle with the text "বাংলাকাতাক"'  (1.4s)
[bangla_sign] এই ছবিতে কী আছে? বাংলায় এক বাক্যে বলুন।
   -> 'নিতে কাক্কার কাক্কার কাক্কার কা�'  (2.1s)
== reading text and counting
[tag_big] What price is written on the tag? -> '450 TK'
[tag_small] What price is written on the tag? -> 'The price written on the tag is 450 Tk.'
[bangla_sign] What does the text in the image say? -> '11000000'
[oranges7] How many oranges are on the plate? -> '9'
[oranges7] How many oranges are on the plate? Answer with a number. -> '9'
== hand-labelled yes/no questions: 'Is there a X in the image? Answer yes or no.'
  desk        red mug           truth yes model 'No.'
  desk        blue book         truth yes model 'No.'
  desk        plant             truth yes model 'Yes.'
  desk        cat               truth no  model 'No.'
  desk        laptop            truth no  model 'No.'
  desk        person            truth no  model 'No.'
  desk        banana            truth no  model 'No.'
  oranges7    plate             truth yes model 'Yes.'
  oranges7    orange            truth yes model 'Yes.'
  oranges7    banana            truth no  model 'No.'
  oranges7    knife             truth no  model 'No.'
  oranges7    dog               truth no  model 'No.'
  fm_sneaker  shoe              truth yes model 'Yes.'
  fm_sneaker  dog               truth no  model 'No.'
  fm_sneaker  car               truth no  model 'No.'
  fm_bag      bag               truth yes model 'Yes.'
  fm_bag      shoe              truth no  model 'No.'
  fm_trouser  pair of trousers  truth yes model 'No.'
  fm_trouser  shoe              truth no  model 'No.'
  fm_trouser  cat               truth no  model 'No.'
present objects: said yes 5/8 | absent objects: said yes 0/12 (hallucinated) | accuracy 17/20
peak RSS of this process: 2296 MiB

ফলগুলো পড়ুন সাবধানে; এটি একটি ছোট model, ২০টি প্রশ্ন আর আটটি ছবি, তাই এক run-এর পর্যবেক্ষণ, সাধারণ সিদ্ধান্ত নয়।

• বর্ণনা: কমলার প্লেট আর জুতো ঠিকমতো বর্ণনা করেছে। টেবিলের ছবিতে মগকে “a red square” বলেছে: সরল আঁকা মগটি সে মগ হিসেবে চেনেনি, কিন্তু যা দেখেছে তার বাইরে কিছু বানায়নি। টুকরো-ভাগে ১৭ গুণ token দিয়েও বর্ণনা আরও অস্পষ্ট হয়েছে (“some objects”), ১১ গুণ বেশি সময়ে।
• গণনা: প্লেটে ৭টি কমলা, দুবারই উত্তর ৯. সংখ্যা আত্মবিশ্বাসী, কিন্তু ভুল।
• লেখা পড়া: ইংরেজি দাম “450 Tk” বড় আর ছোট (১৪ px) দুই font-এই ঠিক পড়েছে; এই পরিষ্কার, কৃত্রিম ছবিতে ছোট লেখা সমস্যা হয়নি। কিন্তু বাংলা “দাম ১২০ টাকা” পড়তে পারেনি: বর্ণনায় অর্থহীন “বাংলাকাতাক”, আর লেখা জিজ্ঞেস করলে “11000000”. এটি hallucination: সাবলীল, নির্দিষ্ট, আর সম্পূর্ণ বানানো।
• বাংলায় প্রশ্ন: চারটি বাংলা প্রশ্নের একটিরও বোধগম্য উত্তর আসেনি: “1.”, “9”, জুতা নিয়ে বানানো তথ্য (“standard size for children”), আর বাংলা চিহ্নে একই শব্দের পুনরাবৃত্তি, যা ৬০ token-এর সীমায় একটি বাংলা অক্ষরের মাঝখানে কেটে গেছে (শেষের � চিহ্ন)। Card-এ training ডেটার ভাষা আলাদা করে বলা নেই; ফল দেখে বলা যায়, এই model বাংলায় ব্যবহারযোগ্য নয়।
• হ্যাঁ/না প্রশ্ন: ছবিতে নেই এমন ১২টি বস্তুর কোনোটিতেই “হ্যাঁ” বলেনি (object hallucination ০/১২), কিন্তু উপস্থিত ৮টির ৩টিতে “না” বলেছে (লাল মগ, নীল বই, প্যান্ট)। মোট ১৭/২০. এই model “না”-র দিকে ঝুঁকে আছে; শুধু hallucination-এর হার দেখলে ভালো মনে হতো, তাই দুটি হার একসঙ্গে দিতে হয়। ১২টি প্রশ্নে ০ পেলেও আসল হার শূন্য বলা যায় না: Wilson-এর ৯৫% ব্যবধান প্রায় [০, ০.২৪]।

পুরো run একটি Python process-এ, সর্বোচ্চ মেমরি প্রায় ২,২৯৬ MiB (fp32-এ; card bf16-এ ১ GB-এর কম GPU মেমরির কথা বলে)। এক টুকরোয় একটি বর্ণনা প্রায় ১ সেকেন্ড, CPU-তে ৩টি thread-এ।

৮ · অডিও, আর পণ্যের নথিতে image input

একই কৌশল শব্দেও খাটে: শব্দ-তরঙ্গকে আগে ছোট ছোট সময়-খণ্ডের কম্পাঙ্ক-ছবিতে (log-Mel spectrogram) আনা হয়, তারপর সেই “ছবি”-কে token বানানো হয়। Whisper (Radford ও সহকর্মীরা, OpenAI, ২০২২) একটি encoder-decoder Transformer: প্রবন্ধ অনুযায়ী ৩০ সেকেন্ডের খণ্ডের spectrogram encoder-এ যায়, আর decoder লেখা দেয়; শেখানো হয় ইন্টারনেট থেকে নেওয়া প্রায় ৬.৮ লাখ ঘণ্টার অডিও আর তার transcript-এ। এটি বহু ভাষায় কাজ করে বলে প্রবন্ধে দাবি, কিন্তু প্রবন্ধের ফলাফলেই training ডেটা কম এমন ভাষায় ভুলের হার বেশি; বাংলায় ব্যবহার করলে নিজের অডিওর নমুনায় word error rate মেপে নিন। আজকের কিছু model শব্দ সরাসরি LLM-এর token হিসেবেও নেয়; সেই খুঁটিনাটি এই পর্বের বাইরে।

Hosted assistant-গুলো image input কীভাবে নেয়, তাদের নিজের নথিতে যা লেখা পেয়েছি, তার সারাংশ নিচে। সংখ্যাগুলো লেখার সময়ের (নভেম্বর ২০২৬), পরিবর্তন হতে পারে; দাম বাদ রাখা হয়েছে, খরচ বোঝাতে শুধু token. কোনো তুলনা বা মান-বিচার নয়, শুধু নথির বক্তব্য।

লক্ষ করুন, তিনটি নথিই patch বা টুকরো-ভিত্তিক token গণনা বলে, ঠিক অংশ ১-এর হিসাব। Claude-এর নথির উদাহরণ ১০০০ × ১০০০ ছবিতে ১,২৯৬ token, যা ব্লক ১-এর ⌈১০০০/২৮⌉² = ৩৬²-এর সমান। নিচের request-এর আকার একটি নমুনা, চালানো হয়নি (key ছাড়া hosted API ডাকা যায় না):

// নমুনা (OpenAI-ধাঁচের chat request; DeepSeek ও Kimi-ও এই আকার নথিতে দেখায়)
{"model": "<model-name>",
 "messages": [{"role": "user", "content": [
   {"type": "text", "text": "এই রসিদে মোট কত টাকা?"},
   {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBOR..."}}]}]}

৯ · ব্যর্থতার চার ধরন আর কীভাবে মাপবেন

মূল্যায়নের সাধারণ নিয়ম আগের পর্বগুলোর মতোই (পর্ব ৫৮): নির্দিষ্ট test সেট, prompt বাছাইয়ের জন্য আলাদা validation সেট, ব্যবধানসহ সংখ্যা, আর একই ছবিতে দুটি model-এর জোড়া তুলনা। ছবির ক্ষেত্রে বাড়তি সতর্কতা: test ছবি যেন model-এর training ডেটায় না থাকে (ইন্টারনেটের জনপ্রিয় ছবি প্রায়ই থাকে), আর মানুষের ছবি হলে সম্মতি ও গোপনীয়তার প্রশ্ন। এই পর্বের সব ছবি নিজে আঁকা বা MIT লাইসেন্সের Fashion-MNIST; কোনো মানুষের ছবি নেই।

১০ · AI-এর যুগে — multimodal কোড আর দাবিতে AI-এর ভুল

AI assistant CLIP বা VLM-এর কোড কয়েক লাইনে লিখে দেয়, আর তা প্রায়ই চলে; কিন্তু সাধারণ ভুলগুলো ফলকে নীরবে বদলে দেয়। আর “model ছবিটা বুঝেছে” ধরনের দাবি প্রায়ই একটি দুটি সুন্দর উত্তর দেখে করা হয়।

Multimodal কাজ — যাচাইয়ের চেকলিস্ট

• Model card-এ লাইসেন্স, training ডেটার ভাষা আর “out of scope” ব্যবহার পড়েছি
• একটি ছবিতে processor-এর output-এর shape আর token-এর সংখ্যা ছাপিয়ে হিসাবের সঙ্গে মিলিয়েছি
• Zero-shot-এর পাশে একটি linear probe বা সরল baseline, আর ব্যবধানসহ accuracy দিয়েছি
• VLM-কে অনুপস্থিত বস্তু, গণনা, ছোট লেখা আর বাংলা লেখার প্রশ্নে হাতে label করা সেটে মেপেছি
• ক্রেতার ব্যক্তিগত ছবি বা মানুষের মুখ কোনো assistant-এ পাঠাইনি; API-র সীমা সেই দিনের নথি থেকে নিয়েছি