Scaling — ডেটা, parameter, compute আর emergent আচরণের দাবি

১ · বড় করলে ভালো হয় কেন, আর কতটা?

কয়েক বছরে language model-এর আকার বহু গুণ বেড়েছে; ২০২২ সালের মধ্যে বড় dense model ৫০০ বিলিয়ন parameter ছাড়িয়েছিল। ফলও ভালো হয়েছে। প্রশ্ন হলো, এই উন্নতি কি হিসাবের মধ্যে আনা যায়? ঠিক এই প্রশ্নের উত্তর খোঁজে scaling law: parameter, ডেটা বা compute কত গুণ বাড়ালে loss কতটা কমে।

এই পর্বে loss মানে সব সময় পরের token-এর cross-entropy, nat এককে (পর্ব ১৩)। এটিকে e-র ঘাতে তুললে পাওয়া যায় perplexity (পর্ব ৩৬)। Tokenizer একই না হলে দুটি সংখ্যা তুলনা করা যায় না, যা পর্ব ৪৬ · Language modeling-এও বলা হয়েছে। LLM-এর মূল ধারণা AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ আছে; এখানে সরাসরি মাপে যাচ্ছি।

২ · Power law পড়া: ঢাল একটি সংখ্যা

Power law মানে L = c · N^−α. এখানে L হলো loss, N আকার, c একটি ধ্রুবক, আর α বলে N বাড়লে L কত দ্রুত কমে। দুই পাশে log নিলে log L = log c − α · log N. এটি একটি সরল রেখার সমীকরণ। তাই log-log ছবিতে power law সোজা রেখা, আর ঢাল −α. রিকশা ভাড়ার মতো যোগ নয়, এখানে হিসাব গুণের: প্রতিবার ২ গুণ করলে L একই অনুপাতে কমে, যত বড়ই হোক N.

৩ · Kaplan ২০২০: কী মাপা হয়েছিল, কী হয়নি

Jared Kaplan, Sam McCandlish আর সহলেখকেরা জানুয়ারি ২০২০ সালের “Scaling Laws for Neural Language Models” paper-এ decoder-only Transformer শেখান, WebText2 নামের ইংরেজি ওয়েব-লেখায়, প্রায় ৫০ হাজার token-এর BPE দিয়ে। মাপা হয় test ভাগের cross-entropy. তাঁদের N-এ embedding নেই, কারণ তাতে রেখা পরিষ্কার হয়েছে। তাঁদের মূল ফল:

তাঁরা আরও জানান, depth আর width-এর ভাগ বিস্তৃত সীমায় প্রায় গুরুত্বহীন; একসঙ্গে N আর D-এর সূত্র হলো L(N, D) = [(N_c/N)^α_N/α_D + D_c/D]^α_D, যেখান থেকে আসে D ∝ N^0.74, অর্থাৎ model ৮ গুণ করলে ডেটা প্রায় ৫ গুণ। Compute-এর ভালো ভাগে তাঁদের ফল: খুব বড় model, তুলনায় অল্প ডেটা, আর convergence-এর অনেক আগে থামা।

৪ · Chinchilla ২০২২: একই বাজেটে ছোট model, বেশি ডেটা

দুই বছর পরে Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch আর সহলেখকেরা “Training Compute-Optimal Large Language Models”-এ প্রশ্নটি ধরলেন বাজেট দিয়ে: compute বাজেট নির্দিষ্ট হলে N আর D কীভাবে ভাগ করবেন? ৪০০-এর বেশি model শিখিয়ে, প্রায় ৭ কোটি থেকে ১,৬০০ কোটি parameter পর্যন্ত, তাঁরা তিনভাবে হিসাব করেন। তৃতীয়টি একটি সূত্র:

L(N, D) = E + A / N^α + B / D^β

এখানে E হলো লেখার নিজের অনিশ্চয়তা। A/N^α হলো ছোট model-এর দোষ, আর B/D^β হলো অল্প দেখার দোষ। তিনটি অংশ যোগ করা বলে, N একা বাড়ালে একসময় বাকি দুটি অংশই থেকে যায়। চায়ের দোকানের হিসাবে ধরুন: চুলা বড় করলেন (N), কিন্তু চা-পাতা কম (D); বড় চুলার লাভ পাতা ফুরালে থেমে যাবে। আর পানির স্বাদের সীমা (E) কোনো চুলা বদলাতে পারবে না।

নিচের ধাপে হিসাবটি হাতে করুন। প্রতিটি সংখ্যা paper-এর, শুধু ভাগগুলো আমাদের করা।

এই ভবিষ্যদ্বাণী পরীক্ষা করতে তাঁরা Chinchilla (৭০ বিলিয়ন) শেখান, Gopher-এর (২৮০ বিলিয়ন) সমান বাজেটে; paper-এর ভাষ্যে এটি প্রায় সব downstream কাজে এগিয়ে যায়। সতর্কতা হলো, সূত্রের ফল Kaplan থেকে বেশ আলাদা (DQ ০১ দেখুন), আর দুটি model-এর মধ্যে optimizer-সহ ছোট কিছু পার্থক্যও ছিল, যা লেখকেরা Appendix G-তে জানান।

৫ · নিজের হাতে মাপা: একই বাংলা লেখায় ৬০-এর বেশি run

এবার নিজে পরীক্ষা করি। পর্ব ৩৬-এর MiniGPT-ই, শুধু কয়েকটি মাপ বদলানো। ডেটা উপেন্দ্রকিশোর রায়চৌধুরীর গল্প (bn.wikisource থেকে নেওয়া, PD-India), অক্ষর-স্তরের tokenizer, পুরো গল্প ধরে ভাগ করা: train ১,৯২,০১৪ অক্ষর, validation ২০,৩৩৪, test ২৫,৭৯০. Checkpoint বাছা হয় validation-এ, আর সংখ্যা জানানো হয় test-এ। ছোট ডেটা হলো গল্প এলোমেলো করে প্রথম D অক্ষর।

নিচের কোডটি আসল scale.py-এর সংক্ষিপ্ত রূপ (সেভ, মাপা আর সারির অংশ বাদ)। PyTorch 2.15.0, Python 3.14.4, লেখার সময়ে।

model = MiniGPT(len(CHARS), T=64, d=d, heads=4, layers=L, p=p).to(DEV)
total = sum(q.numel() for q in model.parameters())
N = total - model.tok.weight.numel() - model.pos.weight.numel()   # Kaplan-এর N
opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
for step in range(1, S + 1):                    # warmup + cosine, S পর্যন্ত
    ix = torch.randint(0, len(tr) - T - 1, (64,), device=DEV)
    chunk = tr[ix[:, None] + OFFS]              # batch 64, context 64
    with torch.autocast(DEV, dtype=torch.float16, enabled=AMP):
        _, loss = model(chunk[:, :-1], chunk[:, 1:])
    # ... backward, clip 1.0, step ...
    if step % every == 0:                       # validation আর early stopping
        ...

$ uv run python report.py     # সত্যিকারের আউটপুট, এক অংশ
# ডেটা পূর্ণ (D = 192014), 3 layer, dropout 0
d     N        run  train  test   top-1
8    2536     2    2.440  2.423  0.329
12   5532     1    2.192  2.228  0.380
16   9680     2    2.046  2.056  0.430
32   37792    2    1.567  1.719  0.513
64   149312   2    1.404  1.667  0.523
96   334560   2    1.421  1.686  0.518
128  593536   2    1.358  1.666  0.523
192  1332672  1    1.423  1.677  0.520
256  2366720  2    1.324  1.676  0.525
384  5319552  1    1.372  1.680  0.526

# একই model, ডেটা বদলানো: test loss (run সংখ্যা)
D        d=32        d=96        d=256
6000     2.600 (2)   2.579 (1)   3.758 (1)
12000    2.428 (2)   2.506 (1)   2.925 (1)
24001    2.213 (2)   2.219 (2)   2.256 (1)
48003    2.010 (2)   1.980 (1)   2.061 (2)
96007    1.835 (2)   1.833 (1)   1.951 (1)
192014   1.719 (2)   1.686 (2)   1.676 (2)

দুটি জিনিস পড়ুন। প্রথম ছক: N ১৫ গুণ হতে (২,৫৩৬ → ৩৭,৭৯২) loss ২৯% কমে। পরের ১৪০ গুণে প্রায় কিছুই কমে না, যদিও train loss নিচে নামে। মাঝের ফাঁকই overfitting: এটিই আমাদের ডেটার বাধা। দ্বিতীয় ছক: ছোট ডেটায় আকার বাড়িয়ে লাভ নেই; D = ২৪,০০১-এ তিন আকারই প্রায় ২.২. D ৮ গুণে তিনটিই ১.৭-এর কাছে। অর্থাৎ এখানে ডেটা বেশি কাজের।

৬ · Fit, interval আর যেখানে সূত্র ভাঙে

নিচের কোড ওপরের সত্যিকারের সংখ্যাই পড়ে (পাতায় ফাইল হিসেবে রাখা)। ঢালের অনিশ্চয়তার জন্য bootstrap নেওয়া হয়, যা মেশিন লার্নিং কোর্সের পর্ব ২১-এ বিস্তারে আছে: run-গুলো ফেরত রেখে টেনে বারবার fit. প্রথমবার চালালে NumPy আর matplotlib আসতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np
import matplotlib.pyplot as plt
d = np.loadtxt("runs_n.csv", delimiter=",", skiprows=1)
N, L = d[:, 0], d[:, 2]
rng = np.random.default_rng(42)

def fit(x, y, B=4000):
    lx, ly = np.log(x), np.log(y)
    slope, icpt = np.polyfit(lx, ly, 1)
    i = rng.integers(0, len(x), (B, len(x)))      # run-গুলো ফেরত রেখে টানা
    X, Y = lx[i], ly[i]
    X = X - X.mean(1, keepdims=True)
    Y = Y - Y.mean(1, keepdims=True)
    s = (X * Y).sum(1) / (X * X).sum(1)           # প্রতিটি নমুনার ঢাল
    lo, hi = np.nanpercentile(s, [2.5, 97.5])
    return slope, icpt, lo, hi

parts = {"all runs": N > 0, "N <= 40k": N <= 4e4, "N >= 100k": N >= 1e5}
fig, ax = plt.subplots(figsize=(5.2, 3))
ax.loglog(N, L, "o", ms=4, label="runs")
print("যে অংশ        run   ঢাল     95% interval")
for name, m in parts.items():
    s, b, lo, hi = fit(N[m], L[m])
    print(f"{name:12s} {m.sum():3d}  {s:6.3f}  [{lo:6.3f}, {hi:6.3f}]")
    x = np.array([N[m].min(), N[m].max()])
    ax.loglog(x, np.exp(b) * x ** s, label=f"{name}: {s:.3f}")
D = np.loadtxt("runs_d.csv", delimiter=",", skiprows=1)
s, b, lo, hi = fit(D[:, 0], D[:, 2])
print(f"\ndata, d=32    {len(D):3d}  {s:6.3f}  [{lo:6.3f}, {hi:6.3f}]")
print(f"D ২ গুণে loss × {2 ** s:.3f}")
ax.set(xlabel="non-embedding parameters N", ylabel="test loss (nats/char)")
ax.legend(fontsize=7)

এবার সবচেয়ে বিপজ্জনক কাজটি: extrapolation. ধরুন শুধু ছোট তিনটি আকার (N ≤ ১০,০০০) দেখে রেখা টানলেন। পাশের ঘরে অনুমান কেমন, আর দূরে কেমন? সঙ্গে Chinchilla-র ধাঁচে সীমাসহ একটি রূপও fit করি: L = E + A/N^a.

import numpy as np
import matplotlib.pyplot as plt
d = np.loadtxt("runs_n.csv", delimiter=",", skiprows=1)
Ns = np.unique(d[:, 0])
L = np.array([d[d[:, 0] == n, 2].mean() for n in Ns])
small = Ns <= 1e4                          # শুধু ছোট তিনটি আকার দেখে fit
s, b = np.polyfit(np.log(Ns[small]), np.log(L[small]), 1)
pure = lambda n: np.exp(b) * n ** s
print(f"ছোট model থেকে ঢাল {s:.3f}")
print("      N    মাপা  অনুমান  ভুল%")
for n, l in zip(Ns, L):
    print(f"{n:9.0f}  {l:.3f}  {pure(n):.3f}  {100 * (pure(n) - l) / l:5.1f}")

# সীমাসহ রূপ: L = E + A / N^a; E-র প্রতিটি মানে সরল রেখা fit
best = (np.inf,)
for E in np.arange(0.0, L.min() - 0.001, 0.002):
    a, c = np.polyfit(np.log(Ns), np.log(L - E), 1)
    sse = ((E + np.exp(c) * Ns ** a - L) ** 2).sum()
    if sse < best[0]:
        best = (sse, E, a, c)
_, E, a, c = best
floor = lambda n: E + np.exp(c) * n ** a
print(f"\nসীমাসহ fit: E = {E:.3f}, ঢাল = {a:.3f}")
for n in (7e10, 7e13):
    print(f"N = {n:.0e}: সোজা রেখা {pure(n):.3f}, সীমাসহ {floor(n):.3f}")
x = np.logspace(3, 11, 50)
fig, ax = plt.subplots(figsize=(5.2, 2.8))
ax.loglog(Ns, L, "ko", ms=4, label="measured")
ax.loglog(x, pure(x), label="line fit on N <= 10k")
ax.loglog(x, floor(x), "--", label="E + A/N^a on all")
ax.set(xlabel="parameters N", ylabel="loss (log)", ylim=(0.2, 3))
ax.legend(fontsize=7)

এই সমতলের কারণ কি শুধু ডেটা? একটি সহজ পরীক্ষা: একই d = 256 model-কে একই ডেটায় একটু অন্যভাবে শেখানো।

# সত্যিকারের আউটপুট, seed 1. dropout 0-এর একই seed-এ test = 1.656
drop  d=32   N=37792    test=1.998 train=1.943 best_step=5800
drop  d=64   N=149312   test=1.701 train=1.550 best_step=5800
drop  d=128  N=593536   test=1.571 train=1.220 best_step=5000
drop  d=256  N=2366720  test=1.587 train=1.135 best_step=2000
drop  d=384  N=5319552  test=1.608 train=1.162 best_step=1400
lr    d=256  N=2366720  test=1.668 train=1.184 best_step=1000

এক seed-এর ফল, তাই সতর্কভাবে পড়ুন। Dropout ০.২ দিয়ে d = 256 নামল ১.৬৫৬ থেকে ১.৫৮৭-এ, d = 128 নামল ১.৬৬১ থেকে ১.৫৭১-এ, d = 384 নামল ১.৬৮০ থেকে ১.৬০৮-এ। কিন্তু d = 64 উঠল ১.৬৬১ থেকে ১.৭০১-এ, আর d = 32 উঠল ১.৭২১ থেকে ১.৯৯৮-এ, কারণ ছোট model-এ জায়গা কম (পর্ব ১৬)। কম learning rate (৩×১০^−৪) তেমন কিছু বদলায়নি। অর্থাৎ §৫-এর সমতল শুধু “ডেটা শেষ” নয়, “এই training রেসিপিতে ডেটা শেষ”। Kaplan-এর দল Appendix C-তে ঠিক এই সতর্কতা দিয়েছিল: regularization নিয়ে তারা পরীক্ষা করেনি, আর তা ফল বদলাতে পারে। একটি fit-এর সবচেয়ে কঠিন অংশ হলো, কোন জিনিস স্থির রাখা হয়েছিল তা মনে রাখা।

৭ · Compute-এর হিসাব: FLOP, মেমরি আর সমান বাজেট

Kaplan-এর হিসাবে N non-embedding parameter-এর জন্য forward pass-এ প্রতি token-এ প্রায় 2N FLOP, কারণ একটি গুণ-যোগ জোড়া দুটি FLOP. Backward pass প্রায় তার দ্বিগুণ। তাই training-এ প্রতি token প্রায় 6N, আর মোট C ≈ 6·N·D. D এখানে দেখা token, আলাদা token নয়। Hoffmann-এর দলের Table A4-এ এই সংক্ষিপ্ত হিসাব পুরো হিসাবের ০.৯৯ থেকে ১.১০ গুণের মধ্যে।

def counts(V, T, d, L):
    """নিজের MiniGPT-এর হুবহু parameter আর FLOP হিসাব।"""
    N = L * (12 * d * d + 9 * d) + 2 * d        # block + শেষ LayerNorm
    emb = (V + T) * d                           # token + position
    fwd = 2 * N + 2 * L * T * d + 2 * d * V     # প্রতি token, forward
    return N, emb, fwd, 6 * N

print("d    N(non-emb)  total     fwd/token  train(6N)/token  MB(16B/param)")
for d in (64, 128, 256):
    N, emb, fwd, train = counts(83, 64, d, 3)
    tot = N + emb
    print(f"{d:<4d} {N:<11,d} {tot:<9,d} {fwd:<10,d} {train:<16,d} {tot * 16 / 2**20:.1f}")

# একটি training-এর মোট খরচ: d=128, 1500 step
N, emb, fwd, train = counts(83, 64, 128, 3)
tokens = 1500 * 64 * 64
print(f"\nd=128: {tokens:,} দেখা token, 6ND = {6 * (N + emb) * tokens:.2e} FLOP")

# Chinchilla: একই সূত্র, paper-এর N আর D
N, D = 70e9, 1.4e12
C = 6 * N * D
print(f"Chinchilla: 6ND = {C:.2e} FLOP = {C / 8.64e19:,.0f} PF-day")
print(f"1 পেটা-FLOP/s যন্ত্রে সময় = {C / 1e15 / 86400 / 365:.1f} বছর")
for name, b in [("float32", 4), ("float16", 2)]:
    print(f"শুধু weight, {name}: {N * b / 1e9:,.0f} GB")
print(f"weight+grad+Adam-এর ২ buffer (float32): {N * 16 / 1e12:.2f} TB")

এই হাতের হিসাব কি ঠিক? PyTorch-এর FlopCounterMode দিয়ে আসল forward pass গুনে দেখা যাক (এটি গুণ-যোগ জোড়াকে ২ ধরে); মেমরিও মেপেছি:

$ uv run python flops.py      # সত্যিকারের আউটপুট, GPU-তে শেষ লাইন
d    N_nonembed  total    counted_fwd  2N+2LTd+2dV  6N(train)
64   149312      158720   354688       333824       895872
128  593536      612352   1299200      1257472      3561216
256  2366720     2404352  4957696      4874240      14200320
param MB 2.34 before-train MB 2.38 peak in training MB 102.5

গণনা আর সূত্রের পার্থক্য ৬%-এর কম। মেমরিতে দেখুন: weight মাত্র ২.৩ MB, অথচ training-এর সর্বোচ্চ ১০২.৫ MB, কারণ gradient, Adam-এর buffer আর forward-এর মাঝের ফল সবই রাখতে হয় (পর্ব ১২)। ১৬ বাইট প্রতি parameter তাই শুধু নিচের সীমা।

এবার Chinchilla-র মূল প্রশ্ন ছোট আকারে: সমান FLOP খরচে কোন আকার ভালো? বড় model কম step পায়, ছোট model বেশি। বাজেট C1 হলো ২.২৬×১০^১৩ (d = 128-এর ১,৫০০ step), আর C4 তার এক-চতুর্থাংশ:

# সত্যিকারের আউটপুট; বেশিরভাগ সারি এক seed
বাজেট  d    N        step  দেখা token  token/param  test
C4    32   37792    5946  24354816    573          1.719
C4    48   84336    2653  10866688    119          1.732
C4    64   149312   1495  6123520     39           1.772
C4    96   334560   666   2727936     8            1.958
C4    128  593536   375   1536000     3            2.113
C4    192  1332672  167   684032      1            2.311
C1    64   149312   5982  24502272    154          1.665
C1    96   334560   2664  10911744    31           1.660
C1    128  593536   1500  6144000     10           1.641
C1    192  1332672  667   2732032     2            1.661
C1    256  2366720  376   1540096     1            1.739
C1    384  5319552  167   684032      0            2.107

তিনটি পর্যবেক্ষণ, একটি পরীক্ষার, সতর্কভাবে। এক: সবচেয়ে ভালো আকার বাজেটের সঙ্গে সরে: C4-এ d = 32, C1-এ d = 128. দুই: token/param সেরা বিন্দুতে ৫৭৩ আর ১০; ২০-এর সঙ্গে মেলে না। অবাক হওয়ার কিছু নেই: আমাদের লেখা ১.৯২ লাখ অক্ষর, তাই এখানে একই অক্ষর ৩২–১২৭ বার দেখা হয়েছে, আর Chinchilla-র অনুপাত এক epoch-এর কমে মাপা। তিন: d = 128-এ S = ১,৫০০ দিয়েছে ১.৬৪১, অথচ S = ৬,০০০-এ দুই seed-এ ১.৬৬১ আর ১.৬৭১ (seed আলাদা, তাই সতর্ক থাকুন)। এটি Hoffmann-এর একটি কথার সঙ্গে মেলে: schedule-এর দৈর্ঘ্য training-এর সঙ্গে মিলতে হয়। আকৃতি নিয়েও ছোট একটি পরীক্ষা: N প্রায় ৬ লাখ রেখে L = 2, 3, 6, 12-তে test ছিল ১.৬৬২, ১.৬৭১, ১.৬৮৫, ১.৬৮৪; Kaplan-এর কথা (আকৃতি প্রায় গুরুত্বহীন) এখানে মোটামুটি খাটে, যদিও এটি এক seed-এর ফল।

৮ · Emergent দাবি, আর মেট্রিকের মরীচিকা

Scaling law বলে উন্নতি মসৃণ। তাহলে অনেক কাজে ছবিতে হঠাৎ লাফ দেখা যায় কেন? Jason Wei আর সহলেখকেরা ২০২২ সালে “Emergent Abilities of Large Language Models”-এ emergent ability-র এই সংজ্ঞা দেন: ছোট model-এ নেই, বড় model-এ আছে, আর ছোট model-এর উন্নতি টেনে অনুমান করা যায় না। ছবিতে এটি phase transition-এর মতো: এক সীমা পর্যন্ত প্রায় random, তারপর ওপরে। তাঁদের এক উদাহরণ: ৩ অঙ্কের যোগ-বিয়োগ আর ২ অঙ্কের গুণের একটি benchmark, যেখানে GPT-3-এ প্রায় 2×10²² training FLOP (১,৩০০ কোটি parameter)-এ আর LaMDA-তে প্রায় 10²³ FLOP-এ ফল র‍্যান্ডমের অনেক ওপরে ওঠে। তাঁরা নিজেরাই বলেন, এই সীমা স্থির কিছু নয়; ডেটার মান আর অন্য বিষয়ে বদলায়।

Rylan Schaeffer, Brando Miranda, Sanmi Koyejo ২০২৩ সালে “Are Emergent Abilities of Large Language Models a Mirage?”-এ অন্য ব্যাখ্যা দেন: মরীচিকা. এক token-এর সঠিকতা p যদি মসৃণ বাড়ে, আর পুরো উত্তরে L-টি token হুবহু মিলতে হয়, তাহলে স্বাধীন ধরলে ফল p^L, যা log অক্ষে হঠাৎ লাফের মতো দেখায়। ৫০টি প্রশ্নে ১/৫০-এর নিচের হার তো ০-ই দেখাবে। Multiple Choice Grade তো সরাসরি ধাপ-ফাংশন। তাঁদের হিসাবে BIG-Bench-এ হাতে চিহ্নিত emergent কাজের ৯২%-এর বেশি এই দুই ধরনের মেট্রিকে। Token edit distance বা Brier score-এর মতো ধারাবাহিক মেট্রিকে তাঁরা মসৃণ ছবি পেয়েছেন। কিন্তু তাঁরা স্পষ্ট বলেন, বড় model emergent ক্ষমতা দেখাতেই পারে না, এমন দাবি তাঁরা করছেন না। Wei-এর দলও লিখেছিল, exact match ধাপে ধাপে উন্নতি লুকাতে পারে, তবে একে অসম্পূর্ণ ব্যাখ্যা বলে।

আগে একটি খেলনা দেখুন। নিচের সব সংখ্যা বানানো, শুধু পদ্ধতি দেখানোর জন্য।

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(42)
N = np.logspace(5, 11, 13)
ce = (3e8 / N) ** 0.35           # কাল্পনিক, মসৃণ per-token loss
p = np.exp(-ce)                  # এক token ঠিক হওয়ার সম্ভাবনা
L = 10                           # উত্তরে ১০ token
exact = p ** L                   # হুবহু মেলা (স্বাধীন ধরে)
edit = L * (1 - p)               # গড়ে কতটি token ভুল
hits = rng.binomial(50, exact)   # ৫০ প্রশ্নের test-এ যা দেখা যাবে

print("      N    ce     p   exact  edit  hits/50")
for i in range(0, 13, 2):
    print(f"{N[i]:.0e} {ce[i]:5.2f} {p[i]:5.3f} {exact[i]:6.4f}"
          f" {edit[i]:5.2f} {hits[i]:4d}")
j = np.argmax(hits > 0)
print(f"\n৫০ প্রশ্নে প্রথম মিল N = {N[j]:.0e}; তার আগে দেখায় শূন্য")
print(f"সেখানে আসল exact = {exact[j]:.4f}; এক ধাপ আগে = {exact[j-1]:.6f}")

fig, ax = plt.subplots(1, 2, figsize=(6.4, 2.6))
ax[0].semilogx(N, edit, "o-")
ax[0].set(xlabel="parameters N", ylabel="wrong tokens (of 10)",
          title="continuous metric: smooth")
ax[1].semilogx(N, hits / 50, "s-", color="C3", label="seen, 50 questions")
ax[1].semilogx(N, exact, ":", color="k", label="true exact match")
ax[1].set(xlabel="parameters N", ylabel="exact match",
          title="thresholded metric: a 'jump'")
ax[1].legend(fontsize=7)
fig.subplots_adjust(wspace=0.35, bottom=0.2)

এবার আমাদের সত্যিকারের model-গুলোতে একই পরীক্ষা। প্রতিটি শেখা model-কে test লেখার ২,০০০ জায়গায় ৬৪ অক্ষর দেখিয়ে greedy-তে পরের অক্ষর চাওয়া হলো। ex8 মানে টানা ৮টি অক্ষর হুবহু মিলল, আর exact-match হিসেবে এটি হ্যাঁ/না ধরনের। top-1 হলো এক অক্ষরের সঠিকতা, আর ex1 একই জিনিস এই ২,০০০ জায়গায়।

# সত্যিকারের আউটপুট, run-এর গড়; প্রতি run-এ 2000 জায়গা
d    N        loss  top-1  ex1   ex4   ex8    ex16
8    2536     2.423 0.329  0.314 0.006 0.0000 0.00000
12   5532     2.228 0.380  0.381 0.018 0.0020 0.00000
16   9680     2.056 0.430  0.434 0.036 0.0037 0.00000
32   37792    1.719 0.513  0.530 0.069 0.0077 0.00000
64   149312   1.667 0.523  0.534 0.083 0.0090 0.00000
96   334560   1.686 0.518  0.536 0.089 0.0128 0.00000
128  593536   1.666 0.523  0.542 0.087 0.0120 0.00025
192  1332672  1.677 0.520  0.527 0.086 0.0120 0.00050
256  2366720  1.676 0.525  0.541 0.099 0.0143 0.00000
384  5319552  1.680 0.526  0.535 0.083 0.0135 0.00000

৯ · লাভ কি কমছে? ডেটা, শক্তি আর খোলা প্রশ্ন

Scaling নিয়ে আলোচনার বড় অংশ একটি প্রশ্নে এসে দাঁড়ায়: এই পথে আর কতদূর? আমরা কোনো উত্তর দাবি করছি না; নিচে শুধু যা প্রকাশিত, তার সারাংশ। প্রতিটি পক্ষের বিস্তার ভাবনার প্রশ্ন ০৫-এ আছে।

বাস্তব কাজের পরামর্শ সহজ। বড় training-এর সিদ্ধান্ত আপনার সামনে সম্ভবত আসবে না; আপনার সিদ্ধান্ত হলো: কোন আকারের model নেবেন, কতটা fine-tune করবেন, কত ডেটা জোগাড় করবেন। সেখানে ছোট learning curve আর iso-FLOP তুলনা খুব কাজের। Model ছোট করার পদ্ধতি (quantization, distillation, pruning) পর্ব ৫৯-এ আসবে। আর একটি কথা: বাংলাদেশে এই কাজে সীমিত GPU একটি সাধারণ বাস্তবতা হতে পারে, তাই খরচ আগে হিসাব করার অভ্যাসটি এখানে আরও কাজের।

১০ · AI-এর যুগে scaling-এর দাবি পরীক্ষা করা

AI সহায়ক এই বিষয়ে দ্রুত সূত্র আর সংখ্যা দিতে পারে। সমস্যা হলো, এই বিষয়ের ভুলগুলো দেখতে ঠিক সঠিক উত্তরের মতোই। নিচের ভুলগুলো সাধারণত ঘটে:

• উদ্ধৃত সূচক আর সংখ্যা মূল paper-এ নিজে দেখেছি
• N, D, C-এর সংজ্ঞা মিলিয়েছি: embedding, আলাদা token বনাম দেখা token, FLOP-এর হিসাব
• Fit-এর ঢালের সঙ্গে interval আছে, আর seed একটির বেশি
• অন্তত একটি বিন্দু fit থেকে বাইরে রেখে অনুমান পরীক্ষা করেছি
• লাফ দেখলে ধারাবাহিক মেট্রিকেও মেপেছি, আর test আকার দেখেছি
• ব্যক্তিগত ডেটা বা key AI-তে পেস্ট করিনি