Hugging Face ecosystem — transformers, datasets, tokenizers আর pipeline

পর্ব ৪৮ · BERT পরিবার আর পর্ব ৫২ · LLM-এর ভেতরে-এ আমরা Hugging Face-এর টুল ব্যবহার করেছি, কিন্তু কাঠামোটি আলাদা করে দেখিনি। Pretrained model কী আর লাইসেন্স কেন দেখতে হয়, তার প্রথম পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ। এখানে আমরা যন্ত্রের ভেতরে ঢুকব। Desktop-এর সব run CPU-তে, লেখার সময়ে (২০২৬ সালের নভেম্বর) এই version-এ: Python 3.12, torch 2.15.0, transformers 5.22.2, datasets 5.1.0, tokenizers 0.23.3, huggingface_hub 2.4.0, safetensors 0.8.0, evaluate 0.4.6. Version বদলালে আচরণও বদলাতে পারে, এই পর্বেই তার একটি উদাহরণ পাবেন। ডেটা পর্ব ৪২ · Text classification-এর Sazzed-এর বাংলা YouTube মন্তব্য (CC BY 4.0), পরিষ্কার করার পর ১০,৭০৯টি।

১ · মানচিত্র — কোন library কোন কাজ করে

একটি বড় পাইকারি বাজারের কথা ভাবুন। গুদামে মাল থাকে, প্রতিটি বস্তায় লেবেল আর চালানের রসিদ। কেউ মাল মাপে, কেউ প্যাক করে, কেউ দোকানে পৌঁছে দেয়। Hugging Face-এর জগৎও এমন ভাগ করা। Hub হলো গুদাম: প্রতিটি model বা dataset একটি repository, যার Git-এর মতো commit ইতিহাস আছে। বাকি library-গুলো আলাদা আলাদা কাজের লোক।

২ · Hub — model card, dataset card আর লাইসেন্স

বাজারে চালের বস্তা কেনার আগে আপনি লেবেল দেখেন: কোন জাত, কোন মৌসুমের, কোথা থেকে। Model card সেই লেবেল। এটি repo-র README.md: ওপরে একটি YAML অংশ (license, language, datasets, pipeline_tag), নিচে মানুষের পড়ার লেখা। Dataset card একই কাজ করে ডেটার জন্য। কার্ড না পড়ে model চালানো মানে লেবেল ছাড়া বস্তা কেনা।

পড়ার সময় পাঁচটি প্রশ্ন করুন। এক, লাইসেন্স কী, আর আমার কাজে কি চলে? দুই, model কোন কাজের জন্য বানানো (intended use)? তিন, কোন ডেটায় শেখানো, কোন ভাষায়? চার, কীভাবে মাপা হয়েছে? পাঁচ, সীমাবদ্ধতা কী লেখা আছে? আমরা তিনটি সত্যিকারের কার্ড huggingface_hub দিয়ে পড়েছি। প্রথমে একটি সরল keyword খোঁজা, তারপর নিজের চোখে। সত্যিকারের run, কয়েকটি লাইন ছোট করা:

~/bazarghar-dl$ uv run python r1_cards.py
== lxyuan/distilbert-base-multilingual-cased-sentiments-student
 sha: cf991100d706c13c0a080c097134c05b7f436c45 | last modified: 2025-03-03
 card yaml license: apache-2.0 | pipeline_tag: text-classification | gated: False | datasets: ['tyqiangz/multilingual-sentiments']
 languages: ['en', 'ar', 'de', 'es', 'fr', 'ja', 'zh', 'id', 'hi', 'it', 'ms', 'pt']
 weight files (MB): {'model.safetensors': 541.3, 'onnx/model.onnx': 541.4, 'pytorch_model.bin': 541.3, …}
 remote code files: []
  limits         MISSING
== sagorsarker/bangla-bert-base
 sha: 875aa80a42ec196c16bd931ae5d85ad949f58b16 | last modified: 2023-07-21
 card yaml license: mit | pipeline_tag: fill-mask | gated: False | datasets: ['common_crawl', 'wikipedia', 'oscar']
  limits         found · …. we will add it here.**   ## limitations and biases  ## how to use …
== Qwen/Qwen2.5-0.5B-Instruct
 sha: 7ae557604adf67be50417f59c2c2f167def9a775 | last modified: 2024-09-25
 card yaml license: apache-2.0 | pipeline_tag: text-generation | gated: False | datasets: None
 weight files (MB): {'model.safetensors': 988.1}
  limits         found · …wiglu, rmsnorm, attention qkv bias and tied word embeddings …
  training data  MISSING

ডেটারও কার্ড লাগে। আমাদের Sazzed-এর ডেটা Hub-এর নয়, Mendeley Data-র (DOI 10.17632/p6zc7krs37.4), তবু একই প্রশ্নগুলো করা যায়। উৎস: বাংলা নাটকের YouTube মন্তব্য, মানুষের হাতে লেবেল। লাইসেন্স: CC BY 4.0, অর্থাৎ ব্যবহার আর বিতরণ চলে, তবে উৎসের স্বীকৃতি দিতে হবে; সঙ্গের README একটি প্রবন্ধের উদ্ধৃতি চায়। সীমা: নাটকের মন্তব্য, পণ্যের রিভিউ নয়; পরিষ্কার করার পর positive প্রায় ৭১.৫%. এই ডেটায় শেখানো model বাজারঘরের রিভিউতে একই রকম চলবে, এমন নিশ্চয়তা নেই। এমন কয়েক লাইনই একটি কাজের dataset card.

এবার নিজে একটি checklist scorer চালান। তিনটি বানানো কার্ড পাতায় রাখা আছে: একটি পরিপূর্ণ, একটি বিজ্ঞাপনের মতো, আর একটি ফাঁকা শিরোনামওয়ালা। Scorer শুধু শব্দ খোঁজে না, অংশের ভেতরে লেখা আছে কি না, আর evaluation-এ অন্তত একটি সংখ্যা আছে কি না তাও দেখে।

import re
NEED = ["intended use", "training data", "evaluation", "limitations"]

def read_card(path):
    text = open(path, encoding="utf-8").read()
    _, yaml, body = text.split("---", 2)
    meta = dict(re.findall(r"^(\w+):\s*(.+)$", yaml, re.M))
    parts = re.split(r"^## (.+)$", body, flags=re.M)        # [আগে, h1, b1, h2, b2, ...]
    secs = {h.strip().lower(): b.strip() for h, b in zip(parts[1::2], parts[2::2])}
    return meta, secs, body.lower()

def score(path):
    meta, secs, body = read_card(path)
    rows = [("license", "license" in meta, meta.get("license", "নেই"))]
    for k in NEED:
        hit = [b for h, b in secs.items() if h.startswith(k)]
        if not hit:
            why = "শব্দটি আছে, অংশ নেই" if k.split()[0] in body or (k == "limitations" and "bias" in body) else "অংশ নেই"
            rows.append((k, False, why))
        elif not hit[0]:
            rows.append((k, False, "শিরোনাম আছে, লেখা ফাঁকা"))
        elif k == "evaluation" and not re.search(r"\d", hit[0]):
            rows.append((k, False, "কোনো সংখ্যা নেই, শুধু দাবি"))
        else:
            rows.append((k, True, " ".join(hit[0].split()[:4]) + " …"))
    return rows

for path in ("card_a.md", "card_b.md", "card_c.md"):
    rows = score(path)
    print(f"\n{path}: {sum(ok for _, ok, _ in rows)}/{len(rows)}")
    for k, ok, why in rows:
        print(f"  {'✓' if ok else '✗'} {k:14} {why}")

card_a.md: 5/5
  ✓ license        apache-2.0
  ✓ intended use   বাজারঘরের বাংলা পণ্য-রিভিউয়ের positive/negative …
  ✓ training data  ১২,০০০ রিভিউ (২০২৫–২৬), দুজন …
  ✓ evaluation     আলাদা test set-এ macro-F1 …
  ✓ limitations    ব্যঙ্গ আর বাংলা-ইংরেজি মেশানো …

card_b.md: 0/5
  ✗ license        নেই
  ✗ intended use   অংশ নেই
  ✗ training data  অংশ নেই
  ✗ evaluation     কোনো সংখ্যা নেই, শুধু দাবি
  ✗ limitations    শব্দটি আছে, অংশ নেই

card_c.md: 3/5
  ✓ license        mit
  ✗ intended use   অংশ নেই
  ✓ training data  OSCAR আর বাংলা Wikipedia …
  ✓ evaluation     একটি বাংলা classification কাজে …
  ✗ limitations    শিরোনাম আছে, লেখা ফাঁকা

৩ · Revision আর commit hash — পুনরুৎপাদনের চাবি

Hub-এর প্রতিটি repo একটি Git repository. লেখক নতুন ফাইল push করলে নতুন commit হয়, আর main নামের branch নতুন commit-এ সরে যায়। from_pretrained(name) লিখলে ডিফল্টে main নামে। অর্থাৎ আজ আর তিন মাস পর একই লাইন দুটি আলাদা ফাইল আনতে পারে। চায়ের দোকানের খাতায় “আজকের দাম” লিখলে কাল তা বদলায়; তারিখসহ রসিদ বদলায় না। Commit hash সেই রসিদ: ফাইলের বিষয়বস্তু আর ইতিহাস থেকে হিসাব করা ৪০ অক্ষরের নাম। Reproducibility-র বাকি অংশ (seed, version লিখে রাখা) পর্ব ১৯ · Experiment tracking-এ।

নিচের খেলনা Hub-এ একটি ছোট classifier আছে। দ্বিতীয় দিনে লেখক ওজন একই রেখে শুধু label-এর ক্রম বদলালেন। আপনার কোড একটি অক্ষরও বদলায়নি।

import hashlib, json
import numpy as np

class ToyHub:                                   # একটি repo: commit ইতিহাস আর branch
    def __init__(self): self.commits, self.refs = {}, {}
    def push(self, files, parent=None, branch="main"):
        body = json.dumps({"files": files, "parent": parent}, sort_keys=True)
        sha = hashlib.sha1(body.encode()).hexdigest()
        self.commits[sha] = files; self.refs[branch] = sha
        return sha
    def resolve(self, rev):                     # branch নাম → sha, sha → sha
        return self.refs.get(rev, rev)

CACHE, downloads = {}, []
def load(hub, rev="main"):
    sha = hub.resolve(rev)
    if sha not in CACHE:                        # cache-এর চাবি commit hash
        CACHE[sha] = hub.commits[sha]; downloads.append(sha[:7])
    return sha, CACHE[sha]

def predict(files, x):
    w = np.array(files["weight"]); return int(np.argmax(w @ x)), files["labels"]

hub = ToyHub()
v1 = hub.push({"weight": [[1, -1], [-1, 1]], "labels": ["neg", "pos"]})
x = np.array([0.2, 0.9])
pinned = v1                                     # কাজ শুরুর দিন লিখে রাখা
for day, rev in [(1, "main"), (1, pinned), (2, "main"), (2, pinned), (3, "main")]:
    if day == 2 and len(hub.commits) == 1:      # দ্বিতীয় দিনে লেখক label-এর ক্রম বদলালেন
        hub.push({"weight": [[1, -1], [-1, 1]], "labels": ["pos", "neg"]}, parent=v1)
    sha, files = load(hub, rev)
    k, labels = predict(files, x)
    print(f"day {day} rev={rev[:7]:7} → sha {sha[:7]} | label: {labels[k]}")
print("নামানো হয়েছে:", downloads, "| cache-এ commit:", len(CACHE))
print("main এখন:", hub.resolve("main")[:7], "| pinned:", pinned[:7])

day 1 rev=main    → sha da920ab | label: pos
day 1 rev=da920ab → sha da920ab | label: pos
day 2 rev=main    → sha ff3ed6e | label: neg
day 2 rev=da920ab → sha da920ab | label: pos
day 3 rev=main    → sha ff3ed6e | label: neg
নামানো হয়েছে: ['da920ab', 'ff3ed6e'] | cache-এ commit: 2
main এখন: ff3ed6e | pinned: da920ab

৪ · pipeline() — এক লাইনের ভেতরে কী লুকানো

pipeline() রেস্তোরাঁর “সেট মেনু”-র মতো: একটি নাম বললেই পুরো থালা আসে। সুবিধা হলো গতি। অসুবিধা হলো, থালায় কী কী আছে তা আপনি বেছে দেননি। নিচের stepper-এর সব সংখ্যা সত্যিকারের run থেকে, বাক্যটি “ডেলিভারি দেরি, কিন্তু পণ্য ভালো”।

ধাপগুলো আলাদা করে ডাকার সত্যিকারের run (একটু ছোট করা):

~/bazarghar-dl$ uv run python r4_inside.py
preprocess keys: ['input_ids', 'attention_mask'] | shape: (1, 18)
tokens: ['[CLS]', 'ড', '##েল', '##ি', '##ভা', '##রি', 'দ', '##ের', '##ি', ',', 'কিন্তু', 'প', '##ণ', '##্য', 'ভ', '##াল', '##ো', '[SEP]']
logits: [0.146, -0.394, 0.272]
softmax: [0.368, 0.214, 0.417]
postprocess: [{'label': 'positive', 'score': 0.36803287267684937}, {'label': 'neutral', 'score': 0.21446722745895386}, {'label': 'negative', 'score': 0.41749992966651917}]
model.training: False | framework device: cpu

Batch দিলেই কি দ্রুত? একই ৪০০টি মন্তব্য, একই model, CPU-তে (সত্যিকারের run, একবার):

pipeline batch_size= 1:   6.9 s
pipeline batch_size=16:  14.0 s

৫ · Auto class দিয়ে একই কাজ, আর ফল মেলানো

Auto class (AutoConfig, AutoTokenizer, AutoModelForSequenceClassification) config-এর model_type দেখে ঠিক class বেছে নেয়। আপনাকে DistilBertForSequenceClassification নাম জানতে হয় না। নিচের কোড r3_pipeline.py-এর মূল অংশ, একটু ছোট করে দেখানো:

cfg = AutoConfig.from_pretrained(NAME, revision=REV)
tok = AutoTokenizer.from_pretrained(NAME, revision=REV)
model = AutoModelForSequenceClassification.from_pretrained(NAME, revision=REV).eval()
with torch.inference_mode():
    for s in range(0, len(texts), 16):
        enc = tok(texts[s:s+16], padding=True, truncation=True, return_tensors="pt")
        p = torch.softmax(model(**enc).logits, dim=-1)
        labels += [cfg.id2label[int(b)] for b in p.argmax(-1)]
        scores += p.max(-1).values.tolist()

৪০০টি মন্তব্য (seed ৫৩-এ বাছাই), pipeline আর হাতের পথ পাশাপাশি। সত্যিকারের run:

pipeline load: 431.0 s | TextClassificationPipeline
model: DistilBertForSequenceClassification | tokenizer: DistilBertTokenizer
[{'label': 'positive', 'score': 0.5337483286857605}, {'label': 'positive', 'score': 0.48220622539520264}]
pipeline 400 rows: 12.6 s
id2label: {0: 'positive', 1: 'neutral', 2: 'negative'} | problem_type: None
manual 400 rows: 13.2 s
labels identical: True | max score diff: 5.96e-08
predicted: {'positive': 270, 'negative': 127, 'neutral': 3}
non-neutral: 397 | agree with Sazzed label: 0.68
majority baseline on same rows: 0.703

যে repo-তে classification head নেই

Bangla BERT শুধু masked language model হিসেবে শেখানো। একই repo থেকে তিনটি Auto class কী দেয়? (সত্যিকারের run, CPU-তে; transformers-এর load report থেকে কয়েকটি লাইন বেছে নেওয়া)

AutoModel                    -> BertModel
AutoModelForMaskedLM         -> BertForMaskedLM
seq-cls seed 0: BertForSequenceClassification logits [-0.4646, -0.0229]
seq-cls seed 1: BertForSequenceClassification logits [-0.0898, -0.0963]
id2label (default): {0: 'LABEL_0', 1: 'LABEL_1'}
classifier.weight                          | MISSING    |
classifier.bias                            | MISSING    |
cls.seq_relationship.weight                | UNEXPECTED |  |
- MISSING:	those params were newly initialized because missing from the checkpoint. Consider training on your downstream task.

৬ · Tokenizers — fast, legacy আর দুটি অমিল

Tokenization-এর তত্ত্ব (BPE, WordPiece, বাংলার সমস্যা) পর্ব ৪০ · Tokenization-এ। এখানে প্রশ্ন যান্ত্রিক: কোন class চলছে, কত দ্রুত, আর ফল কি সব সময় এক? Fast tokenizer Rust-এ লেখা tokenizers library ব্যবহার করে; batch দিলে একসঙ্গে অনেক বাক্য ভাঙে, আর প্রতিটি token মূল লেখার কোন অক্ষর থেকে এসেছে (offset) তাও দেয়। Bangla BERT-এর জন্য সবসময় do_lower_case=False (পর্ব ৪৮-এর ফাঁদ)। সত্যিকারের run:

tokenizer class: BertTokenizer | is_fast: True
tokens: ['আমার', 'জীবনের', 'সব', '##থেকে', 'ফালতু', 'একটা', 'নাটক', 'এইট', '##া']
use_fast=False gives: BertTokenizer | legacy class: BertTokenizerLegacy is_fast: False
fast   batched=False:   0.97 s (median of 3) | calls: 10709
fast   batched=True :   0.32 s (median of 3) | calls: 11
legacy batched=False:   2.20 s (median of 3) | calls: 10709
legacy batched=True :   1.73 s (median of 3) | calls: 11
legacy == fast ids on 500 rows: False

“দুটি একই tokenizer” কথাটি পরীক্ষা করা দরকার। পুরো ১০,৭০৯টি সারিতে তুলনা (সত্যিকারের run):

rows differing: 2 of 10709
'￰সাইড আর্টিস্ট গুলুর এতো বাজে অভিনয় সত্যি বিরক্তিকর আর ফারি'
  fast  : ['[UNK]', 'আর্টিস্ট', 'গুল', '##ুর']
  legacy: ['সাইড', 'আর্টিস্ট', 'গুল', '##ুর']
'অসাধারন৤৤৤৤৤৤'
  fast  : ['[UNK]']
  legacy: ['অসাধারন']

Offset আর word_ids: Fast tokenizer প্রতিটি token-এর জন্য মূল লেখায় শুরু আর শেষের অবস্থান দেয়, আর word_ids() বলে token কোন শব্দের। পর্ব ৪৩ · Sequence labeling-এর মতো NER-এ subword-এর label মেলাতে এটিই লাগে। সত্যিকারের run:

[CLS]      ( 0,  0) ''
ডেলিভারি   ( 0,  8) 'ডেলিভারি'
দেরি       ( 9, 13) 'দেরি'
,          (13, 14) ','
পণ্য       (15, 19) 'পণ্য'
##টা       (19, 21) 'টা'
ভালো       (22, 26) 'ভালো'
[SEP]      ( 0,  0) ''
word_ids: [None, 0, 1, 2, 3, 3, 4, None]
legacy keys: ['input_ids', 'attention_mask']

৭ · datasets — map, batched, filter, set_format, Arrow আর streaming

পোস্ট অফিসে চিঠি এক এক করে বাছলে প্রতিটির জন্য উঠে দাঁড়াতে হয়, তাক খুলতে হয়। এক বস্তা একসঙ্গে বাছলে সেই বাড়তি কাজ একবার। Dataset.map(fn, batched=True) ঠিক এটি করে: fn একটি সারির বদলে ১,০০০ সারির একটি dict (প্রতিটি কলাম একটি list) পায়। ডাকের সংখ্যা কমে, আর fast tokenizer পুরো list একবারে ভাঙতে পারে।

নিচের খেলনা mini_map সেই কৌশল নকল করে। প্রতিটি ডাকের ফল একটি টাইপ করা NumPy array-তে লেখা হয়, যেমন datasets প্রতিটি ফল Arrow কলামে লেখে। প্রথমবার চালাতে কয়েক সেকেন্ড লাগতে পারে, কারণ পাতার Python আর NumPy লোড হয়।

import time
import numpy as np
rng = np.random.default_rng(53)
words = np.array(["দাম", "ভালো", "বাজে", "ডেলিভারি", "দ্রুত", "নষ্ট", "সুন্দর", "দেরি"])
rows = [" ".join(rng.choice(words, rng.integers(3, 9))) for _ in range(20500)]
VOCAB = {w: i + 5 for i, w in enumerate(words)}         # 0-4 special id

def tok(texts):                       # সবসময় list নেয়, list ফেরত দেয়
    return [[VOCAB.get(w, 1) for w in t.split()] for t in texts]

def mini_map(texts, batched, batch_size=1000):
    calls, chunks, lens = 0, [], []
    step = batch_size if batched else 1
    for s in range(0, len(texts), step):
        ids = tok(texts[s:s + step])  # একটি ডাক
        calls += 1
        lens += [len(x) for x in ids]
        flat = np.fromiter((i for x in ids for i in x), np.int32)
        chunks.append(flat)           # Arrow-এর মতো টাইপ করা কলামে লেখা
    return np.concatenate(chunks), np.array(lens), calls

res = {}
for batched in (False, True):
    t = time.perf_counter()
    res[batched] = mini_map(rows, batched)
    ms = (time.perf_counter() - t) * 1000
    print(f"batched={batched!s:5} ডাক={res[batched][2]:6d}  সময় ≈ {ms:.0f} ms")
same = all(np.array_equal(a, b) for a, b in zip(res[False][:2], res[True][:2]))
print("দুই পথের ফল এক?", same)
print("প্রথম সারি:", rows[0], "→", res[True][0][:res[True][1][0]].tolist())
print("মোট id:", res[True][0].size, "| dtype:", res[True][0].dtype)
print("শেষ batch-এর আকার:", len(rows) % 1000, "| ডাক = ceil(20500/1000) =", -(-len(rows) // 1000))

batched=False ডাক= 20500  সময় ≈ 159 ms
batched=True  ডাক=    21  সময় ≈ 47 ms
দুই পথের ফল এক? True
প্রথম সারি: দাম নষ্ট নষ্ট সুন্দর বাজে দ্রুত দেরি → [5, 10, 10, 11, 7, 9, 12]
মোট id: 112274 | dtype: int32
শেষ batch-এর আকার: 500 | ডাক = ceil(20500/1000) = 21

এবার আসল datasets, Sazzed-এর মন্তব্যে (সত্যিকারের run, r2_datasets.py; উপরের tokenizer-এর সময়ও এই run থেকে):

Dataset({
    features: ['text', 'label'],
    num_rows: 10709
})
format: None | first: {'text': 'আমার জীবনের সবথেকে ফালতু একটা নাটক এইটা', 'label': 0}
first 200 rows identical to direct call: True
columns: ['label', 'input_ids', 'token_type_ids', 'attention_mask']
filter len<=16: 6425 of 10709
set_format torch: Tensor torch.int64 | label tensor(0)
saved Arrow MB: 1.45 | files: ['data-00000-of-00001.arrow', 'dataset_info.json', 'state.json']
reloaded rows: 10709 | backed by 1 memory-mapped file(s)
iterable: IterableDataset | first ids: [101, 2211, 2960, 2132, 12125, 40520, 2157, 3634]

Hub থেকে dataset: load_dataset("org/name", revision=sha) model-এর মতোই commit hash নেয়, আর লোড শেষে একই Arrow-ভিত্তিক Dataset দেয়। নিজের CSV বা JSON ফাইলও load_dataset("csv", data_files=...) দিয়ে একই পথে আসে। ডেটা বদলালে fingerprint বদলায়, তাই পুরনো cache-এর ফল ভুল করে আসে না; তবে function বাইরের কোনো ফাইল পড়লে সেই বদল fingerprint-এ ধরা না পড়তে পারে (ভাবনার প্রশ্ন ০৪ দেখুন)।

৮ · safetensors বনাম pickle, আর trust_remote_code

কেউ আপনাকে একটি সিল করা বাক্স দিল। একটিতে শুধু ওজনের তালিকা আর মাপা চাল। আরেকটিতে একটি চিরকুট: “বাক্স খোলার সময় এই কাজগুলো করো”। আপনি চিরকুটটি পড়ার আগেই কাজগুলো হয়ে যায়। দ্বিতীয় বাক্সটি pickle. Python-এর pickle ফরম্যাট বস্তু ফিরিয়ে আনার জন্য যেকোনো function ডাকার নির্দেশ রাখতে পারে। Python-এর নিজের নথিতে স্পষ্ট সতর্কতা আছে: pickle নিরাপদ নয়, শুধু বিশ্বাসযোগ্য ডেটা unpickle করুন। পুরনো pytorch_model.bin ফাইল pickle-ভিত্তিক।

safetensors প্রথম বাক্স: প্রথম ৮ byte একটি সংখ্যা N (little-endian, unsigned 64-bit), তারপর N byte-এর JSON header (প্রতিটি tensor-এর নাম, dtype, shape আর byte-এর অবস্থান), তারপর কাঁচা সংখ্যা। পড়ার সময় কোনো কোড চলে না। নিচে নিজে একটি ফাইল বানিয়ে পড়ুন। Pickle-এর অংশে একটি নিরীহ print-এর নির্দেশ শুধু disassemble করা হয়েছে, কখনো load করা হয়নি।

import json, struct, pickle, pickletools, io
import numpy as np
W = np.arange(6, dtype=np.float32).reshape(2, 3) / 10
b = np.array([0.5, -1.0], dtype=np.float32)
# --- safetensors ফাইল নিজে বানানো: 8 byte দৈর্ঘ্য + JSON header + কাঁচা byte
header = {"classifier.weight": {"dtype": "F32", "shape": [2, 3], "data_offsets": [0, 24]},
          "classifier.bias":   {"dtype": "F32", "shape": [2], "data_offsets": [24, 32]},
          "__metadata__": {"format": "pt"}}
h = json.dumps(header, separators=(",", ":")).encode()
h += b" " * (-len(h) % 8)                       # ৮-এর গুণিতকে আনা
blob = struct.pack("<Q", len(h)) + h + W.tobytes() + b.tobytes()
print("মোট byte:", len(blob), "| প্রথম 8 byte:", blob[:8].hex(" "))
# --- পড়া: কোনো কোড চলে না, শুধু সংখ্যা আর JSON
n = struct.unpack("<Q", blob[:8])[0]
meta = json.loads(blob[8:8 + n])
data = blob[8 + n:]
for name, t in meta.items():
    if name == "__metadata__": continue
    s, e = t["data_offsets"]
    arr = np.frombuffer(data[s:e], dtype=np.float32).reshape(t["shape"])
    print(f"{name:18} {t['dtype']} {t['shape']} →", [round(float(x), 2) for x in arr.ravel()])
# --- pickle: খোলার সময় একটি function ডাকার নির্দেশ রাখা যায়
class Gift:
    def __reduce__(self):
        return (print, ("pickle.load এই লাইন চালাত!",))
p = pickle.dumps(Gift(), protocol=2)
out = io.StringIO(); pickletools.dis(p, out=out)   # শুধু পড়া, চালানো নয়
ops = [l.split()[2] for l in out.getvalue().splitlines() if len(l.split()) > 2 and l.split()[0].endswith(":")]
print("pickle opcodes:", ops)
print("GLOBAL লাইন:", [l.split(None, 3)[3] for l in out.getvalue().splitlines() if "GLOBAL" in l])
print("REDUCE আছে?", "REDUCE" in ops, "| print একবারও চলেনি, কারণ load করিনি")

মোট byte: 216 | প্রথম 8 byte: b0 00 00 00 00 00 00 00
classifier.weight  F32 [2, 3] → [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]
classifier.bias    F32 [2] → [0.5, -1.0]
pickle opcodes: ['PROTO', 'GLOBAL', 'BINPUT', 'BINUNICODE', 'BINPUT', 'TUPLE1', 'BINPUT', 'REDUCE', 'BINPUT', 'STOP']
GLOBAL লাইন: ["'__builtin__ print'"]
REDUCE আছে? True | print একবারও চলেনি, কারণ load করিনি

সত্যিকারের model.safetensors-এর header-ও একইভাবে পড়া যায়, ৫৪১ MB ফাইলের শুধু প্রথম ১২ KB-র মতো পড়ে (সত্যিকারের run, একটি পুনরাবৃত্ত লাইন বাদ):

header bytes: 12528 | tensors: 104 | metadata: {'format': 'pt'}
  classifier.bias F32 [3]
  classifier.weight F32 [3, 768]
  distilbert.embeddings.LayerNorm.bias F32 [768]
parameters from header: 135326979 | from model: 135326979

৯ · Cache, offline mode, evaluate আর accelerate

প্রথম নামানো ফাইল cache-এ থাকে; ঠিকানা ঠিক করে HF_HOME environment variable. Cache-এ ফাইল commit hash অনুযায়ী আলাদা snapshot-এ থাকে। HF_HUB_OFFLINE=1 দিলে library নেটওয়ার্কে যায়ই না, শুধু cache দেখে। পরীক্ষার হলে বা কারখানার বন্ধ নেটওয়ার্কে model চালানোর এটিই নিয়ম। সত্যিকারের run, নেটওয়ার্ক বন্ধ রেখে:

cache: sagorsarker/bangla-bert-base | revisions: ['875aa80'] | MB: 2.2
cache: lxyuan/distilbert-base-multilingual-cased-sentiments-student | revisions: ['cf99110'] | MB: 545.2
cache: Qwen/Qwen2.5-0.5B-Instruct | revisions: ['7ae5576'] | MB: 0.0
offline reload from cache: 0.5 s
offline, not in cache: OSError

evaluate: evaluate.load("accuracy") আর "f1" একই ইন্টারফেসে metric দেয়। আমাদের run-এ macro-F1 ০.৬২৩৯, scikit-learn-এর f1_score-এর সঙ্গে হুবহু। একটি metric-এর সংজ্ঞা (macro নাকি micro, positive label কোনটি) নিজে লিখে রাখুন; metric-এর বিস্তারিত পর্ব ৪৫ · NLP মূল্যায়ন-এ। accelerate: একই training কোড এক CPU, এক GPU বা কয়েকটি GPU-তে চালানোর ব্যবস্থা; device_map="auto" দিয়ে বড় model স্তর ভাগ করে কয়েকটি device-এ রাখাও এর কাজ। পরের পর্বগুলোতে Trainer-এর ভেতরে এটি নীরবে চলবে।

১০ · AI-এর যুগে — Hugging Face কোড যাচাই

Hugging Face-এর কোড AI assistant খুব দ্রুত লেখে, কারণ অনলাইনে উদাহরণ অগণিত। সমস্যা হলো, সেই উদাহরণগুলো নানা version-এর।

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

• Model card, লাইসেন্স আর ভাষার তালিকা নিজে পড়েছি
• প্রতিটি from_pretrained-এ একই commit hash দিয়েছি, library-র version লিখে রেখেছি
• Tokenizer-এর class আর is_fast print করেছি; কয়েকটি সারিতে আগের tokenizer-এর সঙ্গে তুলনা করেছি
• Pipeline আর হাতের পথের output কয়েকটি সারিতে মিলিয়েছি
• Label-ওয়ালা test set আর সরল baseline-এর সঙ্গে মান মেপেছি, এক run-এ সিদ্ধান্ত নিইনি
• trust_remote_code বা pickle ফাইল নেই, থাকলে কোড পড়েছি; কোনো token বা ব্যক্তিগত ডেটা prompt-এ দিইনি