nn.Module দিয়ে model বানানো — layer, parameter আর state_dict

এই কোর্সের পর্ব ০৩-এ NumPy-তে MLP-এর forward pass নিজে লিখেছেন, আর পর্ব ০৫-এ নিজের autograd. পর্ব ০৭ (PyTorch tensor — shape, dtype, device আর broadcasting) আর পর্ব ০৮ (PyTorch autograd — requires_grad, backward আর gradient-এর ফাঁদ) tensor আর gradient-এর দিকটি দেখায়। কিন্তু হাতে লেখা model-এ weight-গুলো আলাদা আলাদা চলক: ছয়টি স্তর হলে বারোটি চলক, সেগুলো optimizer-কে দেওয়া, ফাইলে রাখা, GPU-তে পাঠানো, সবই হাতে। এই পর্বের প্রশ্ন: PyTorch কীভাবে একটি model-এর সব weight নিজে খুঁজে পায়, গোনে, সেভ করে আর ফিরিয়ে আনে? উত্তর nn.Module. PyTorch পাতায় চলে না, তাই মূল কাজ ডেস্কটপের সত্যিকারের run; পাতার তিনটি ব্লক (ব্রাউজারের Python আর NumPy) সেই model-এর হিসাব আলাদাভাবে যাচাই করে।

১ · nn.Module কী — layer আর weight-এর হিসাব খাতা

nn.Module PyTorch-এর সব model আর layer-এর মূল class. nn.Linear, nn.ReLU, nn.Dropout সবাই এর subclass, আর আপনার নিজের model-ও তাই হবে। নিয়ম দুটি: __init__-এ অংশগুলো তৈরি করে self-এর attribute হিসেবে রাখুন, আর forward-এ input থেকে output-এর হিসাব লিখুন। Class, subclass আর super() Python কোর্সের পর্ব ৩১ আর পর্ব ৩৩-এ আছে; এখানে শুধু ব্যবহার। model(x) লিখলে আসলে __call__ চলে, যা কিছু hook সামলে forward(x) ডাকে; তাই model.forward(x) সরাসরি না ডেকে model(x) লেখাই নিয়ম।

সারা পর্বে একটি model: বাজারঘরের ডেলিভারি সময়ের অনুমান। Input তিনটি: দূরত্ব (km), পণ্যের সংখ্যা আর বৃষ্টি (০ বা ১); output মিনিটে সময়। ডেটা seed দিয়ে বানানো ৪০০টি কাল্পনিক অর্ডার, সময় = ২০ + ২.৫ × দূরত্ব + ৬√(পণ্য) + ৮ × বৃষ্টি + দূরত্বের একটি ছোট বর্গ পদ + noise. Model একটি ৩ → ১৬ → ৮ → ১ MLP. ভেতরে input-কে গড় বিয়োগ করে standard deviation দিয়ে ভাগ করা হয় (standardization), আর সেই গড় আর standard deviation model-এর সঙ্গেই থাকে।

import torch
from torch import nn
# make_data(): seed দিয়ে ৪০০টি কাল্পনিক অর্ডার (X, y) বানায়; এখানে বাদ

class DeliveryMLP(nn.Module):
    def __init__(self, x_mean, x_std, p_drop=0.1):
        super().__init__()                            # প্রথম লাইন, বাদ দেওয়া যাবে না
        self.register_buffer("x_mean", x_mean)        # parameter নয়, কিন্তু state_dict-এ যায়
        self.register_buffer("x_std", x_std)
        self.hidden = nn.Sequential(
            nn.Linear(3, 16), nn.ReLU(), nn.Dropout(p_drop),
            nn.Linear(16, 8), nn.ReLU())
        self.head = nn.Linear(8, 1)

    def forward(self, x):
        z = (x - self.x_mean) / self.x_std
        return self.head(self.hidden(z)).squeeze(-1)

নিচের ছবিটি এই model-এর গাছ। প্রতিটি অংশের নাম তার পথ: hidden-এর ভেতরের শূন্য নম্বর Linear-এর weight-এর পুরো নাম hidden.0.weight. এই নামগুলোই পরে state_dict-এর key হবে।

ডেস্কটপে uv দিয়ে একটি আলাদা project বানিয়ে CPU-র PyTorch install করা হলো (uv-এর পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৭-এ; pyproject.toml-এ PyTorch-এর CPU wheel index যোগ করা)। তারপর model বানিয়ে ছাপানো, প্রতিটি parameter-এর নাম, আকার আর সংখ্যা, আর buffer দেখা হলো।

~/bazarghar-dl$ uv add "torch==2.15.0" numpy
 …
 + numpy==2.5.4
 …
 + torch==2.15.0+cpu
 …

import torch
from bazarghar import make_data, DeliveryMLP
print("torch", torch.__version__)

X, y = make_data()                          # ৪০০টি কাল্পনিক অর্ডার, seed 42
torch.manual_seed(42)
model = DeliveryMLP(X.mean(0), X.std(0))
print(model)

total = 0
for name, p in model.named_parameters():
    total += p.numel()
    print(f"{name:16s} {str(tuple(p.shape)):9s} {p.numel():4d}")
print("মোট parameter:", total)
for name, b in model.named_buffers():
    print("buffer:", name, b.numpy().round(3))

lin = model.hidden[0]                       # nn.Linear(3, 16)
z = (X[:2] - model.x_mean) / model.x_std
manual = z @ lin.weight.T + lin.bias        # y = x Wᵀ + b
print("weight", tuple(lin.weight.shape), "| bias", tuple(lin.bias.shape))
print("max |lin(z) − (z Wᵀ + b)| =", (lin(z) - manual).abs().max().item())
print("|W| সর্বোচ্চ:", round(lin.weight.abs().max().item(), 4),
      "| 1/√in =", round(3 ** -0.5, 4))

সত্যিকারের run (ডেস্কটপ, CPU, Python 3.14.4, PyTorch 2.15.0 CPU build, NumPy 2.5.4; লেখার সময়ের সংস্করণ, পরে বদলাতে পারে):

~/bazarghar-dl$ uv run python module_tour.py
torch 2.15.0+cpu
DeliveryMLP(
  (hidden): Sequential(
    (0): Linear(in_features=3, out_features=16, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.1, inplace=False)
    (3): Linear(in_features=16, out_features=8, bias=True)
    (4): ReLU()
  )
  (head): Linear(in_features=8, out_features=1, bias=True)
)
hidden.0.weight  (16, 3)     48
hidden.0.bias    (16,)       16
hidden.3.weight  (8, 16)    128
hidden.3.bias    (8,)         8
head.weight      (1, 8)       8
head.bias        (1,)         1
মোট parameter: 209
buffer: x_mean [6.185 3.102 0.29 ]
buffer: x_std [3.209 1.392 0.454]
weight (16, 3) | bias (16,)
max |lin(z) − (z Wᵀ + b)| = 0.0
|W| সর্বোচ্চ: 0.5702 | 1/√in = 0.5774

চারটি জিনিস লক্ষ করুন। এক: print(model) গাছটি দেখায়, কিন্তু buffer দেখায় না; buffer দেখতে named_buffers() লাগে। দুই: আমরা কোথাও weight-এর তালিকা লিখিনি, তবু named_parameters() ছয়টি tensor খুঁজে পেয়েছে, ঠিক ছবির পথ ধরে। তিন: প্রথম Linear-এর weight (১৬, ৩), অর্থাৎ (out, in), আর z @ W.T + b হাতে হিসাব করলে layer-এর output-এর সঙ্গে পার্থক্য হুবহু ০. চার: weight-এর সবচেয়ে বড় মান ০.৫৭০২, যা 1/√৩ ≈ ০.৫৭৭৪-এর নিচে; কারণ অংশ ৩-এ।

২ · নিবন্ধন কীভাবে হয় — __setattr__-এর ভেতরে

সাধারণ Python object-এ self.fc = … লিখলে মানটি শুধু object-এর __dict__-এ বসে। nn.Module নিজের __setattr__ লিখে রেখেছে (dunder method-এর ধারণা Python কোর্সের পর্ব ৩২-এ)। প্রতিটি assignment-এ সে মানের type দেখে: nn.Parameter হলে _parameters অভিধানে, অন্য একটি nn.Module হলে _modules-এ, আর register_buffer দিয়ে আসা tensor _buffers-এ। এর বাইরে সব কিছু (list, সাধারণ tensor, সংখ্যা) সাধারণ attribute; PyTorch সেগুলো দেখেও না। parameters(), state_dict(), .to(device), .train() সবাই শুধু এই তিন অভিধান ধরে পুরো গাছে হাঁটে।

Stepper-এর প্রতিটি দাবি ডেস্কটপে চালিয়ে দেখা হয়েছে (script-এ ঠিক ওপরের Tiny class, আর super().__init__() ছাড়া একটি Forgot class):

~/bazarghar-dl$ uv run python registry.py
_modules   : ['fc']
_parameters: ['scale']
_buffers   : ['mu']
state_dict : ['scale', 'mu', 'fc.weight', 'fc.bias']
'extra' in __dict__: True | 'mu2': True
double() পরে: torch.float64 torch.float32 torch.float32
AttributeError: cannot assign module before Module.__init__() call

শেষ লাইনটির শিক্ষা: super().__init__() সবসময় __init__-এর প্রথম লাইন। আর দ্বিতীয় শেষ লাইনটি একটি চুপচাপ বাগের রূপ: GPU-তে model পাঠালে (model.to("cuda")) নিবন্ধিত না হওয়া tensor CPU-তেই থেকে যায়, আর forward-এ “Expected all tensors to be on the same device” ধরনের error আসে। Device-এর বিস্তারিত পর্ব ১২ (GPU, mixed precision আর গতি — device, AMP আর profiling)-এ।

৩ · nn.Linear-এর ভেতর — weight (out, in), y = xWᵀ + b

nn.Linear(in_features, out_features) হলো সবচেয়ে মৌলিক layer. এর দুটি parameter: weight, আকার (out, in), আর bias, আকার (out,). হিসাব:

y = x Wᵀ + b

এখানে x হলো input-এর batch, আকার (N, in), যেখানে N একসঙ্গে কতগুলো উদাহরণ; W হলো weight; Wᵀ তার transpose, আকার (in, out); b bias, যা broadcasting-এ প্রতিটি সারিতে যোগ হয়। ফল y-এর আকার (N, out). পর্ব ০৩-এ আমরা উল্টো রীতি নিয়েছিলাম: W-এর আকার (in, out) আর y = XW + b. দুটি গাণিতিকভাবে একই; PyTorch (out, in) রাখে, কারণ তখন W-এর প্রতিটি সারি একটি output neuron-এর সব weight. NumPy-তে PyTorch-এর weight ব্যবহার করতে গেলে এই transpose ভুলে যাওয়া খুব সাধারণ বাগ, আর in = out হলে আকারও মিলে যায়, তাই error আসে না।

Default initialization. নতুন nn.Linear তৈরি হলে weight এলোমেলো মানে ভরা হয়। লেখার সময়ের PyTorch docs অনুযায়ী weight আর bias দুটিই সমবণ্টন U(−k, k) থেকে আসে, যেখানে k = 1/√in; ভেতরের কোডে এটি kaiming_uniform_(a=√5) নামে লেখা, যা গণিতে একই সীমা দেয়। আমাদের run-এ in = ৩, তাই সব weight ±০.৫৭৭৪-এর ভেতরে, আর সবচেয়ে বড়টি ০.৫৭০২. Input বেশি হলে weight ছোট হয়, যাতে যোগফল বিস্ফোরিত না হয়। এটি একটি যুক্তিসঙ্গত শুরু, সব ক্ষেত্রে সেরা নয়; Xavier, He আর কেন initialization এত গুরুত্বপূর্ণ, তা পর্ব ১৪ (Weight initialization আর normalization — Xavier, He, BatchNorm আর LayerNorm)-এ।

৪ · Parameter গোনা — প্রতিটি স্তর আলাদা করে

Parameter-এর সংখ্যা জানা দরকার তিন কারণে: memory-র হিসাব (float32-এ প্রতিটি ৪ byte), overfitting-এর ঝুঁকির একটি মোটা আন্দাজ, আর ভুল ধরা (গোনা শূন্য বা অপ্রত্যাশিত হলে কোথাও নিবন্ধন ভুল)। PyTorch-এ এক লাইন: sum(p.numel() for p in model.parameters()); numel() মানে tensor-এ মোট ঘরের সংখ্যা। শুধু শেখার যোগ্যগুলো চাইলে if p.requires_grad জুড়ে দিন, কারণ freeze করা parameter-ও parameters()-এ আসে। পরীক্ষায় প্রায়ই হাতে গুনতে হয়, তাই নিচের ব্লক Linear-এর স্তূপের জন্য একটি ছোট হিসাবযন্ত্র। একটি তালিকা [in, h1, h2, …, out] দিন; প্রতিটি পাশাপাশি জোড়া একটি nn.Linear.

def count_linear_stack(sizes, bias=True, bytes_per=4):
    """sizes = [in, h1, h2, ..., out]; প্রতিটি জোড়া একটি nn.Linear"""
    rows, total = [], 0
    for a, b in zip(sizes, sizes[1:]):
        w, bb = b * a, (b if bias else 0)     # weight (out, in), bias (out,)
        total += w + bb
        rows.append(f"  Linear({a}, {b}): {w:,} + {bb} = {w + bb:,}")
    print(f"{sizes}  bias={bias}")
    print("\n".join(rows))
    print(f"  মোট {total:,} ≈ {total * bytes_per / 1024:,.1f} KiB (float32)")
    return total

count_linear_stack([3, 16, 8, 1])            # বাজারঘরের ডেলিভারি MLP
count_linear_stack([784, 256, 128, 10])      # 28×28 ছবি → ১০টি শ্রেণি
count_linear_stack([784, 256, 128, 10], bias=False)

wide = count_linear_stack([1024, 1024])      # একটি চওড়া স্তর
thin = count_linear_stack([1024, 64, 1024])  # সরু মাঝখান (bottleneck)
print(f"bottleneck-এ parameter {wide / thin:.1f} গুণ কম")

[3, 16, 8, 1]  bias=True
  Linear(3, 16): 48 + 16 = 64
  Linear(16, 8): 128 + 8 = 136
  Linear(8, 1): 8 + 1 = 9
  মোট 209 ≈ 0.8 KiB (float32)
[784, 256, 128, 10]  bias=True
  Linear(784, 256): 200,704 + 256 = 200,960
  Linear(256, 128): 32,768 + 128 = 32,896
  Linear(128, 10): 1,280 + 10 = 1,290
  মোট 235,146 ≈ 918.5 KiB (float32)
[784, 256, 128, 10]  bias=False
  Linear(784, 256): 200,704 + 0 = 200,704
  Linear(256, 128): 32,768 + 0 = 32,768
  Linear(128, 10): 1,280 + 0 = 1,280
  মোট 234,752 ≈ 917.0 KiB (float32)
[1024, 1024]  bias=True
  Linear(1024, 1024): 1,048,576 + 1024 = 1,049,600
  মোট 1,049,600 ≈ 4,100.0 KiB (float32)
[1024, 64, 1024]  bias=True
  Linear(1024, 64): 65,536 + 64 = 65,600
  Linear(64, 1024): 65,536 + 1024 = 66,560
  মোট 132,160 ≈ 516.2 KiB (float32)
bottleneck-এ parameter 7.9 গুণ কম

৫ · Sequential, ModuleList, ModuleDict — আর সাধারণ list-এর ফাঁদ

অনেক layer একসঙ্গে রাখার তিনটি container আছে, প্রতিটি নিজেই একটি nn.Module, তাই ভেতরের সব কিছু নিবন্ধিত হয়:

এখন ফাঁদটি। স্তরের সংখ্যা একটি তালিকা থেকে ঠিক করতে চাইলে স্বাভাবিক Python অভ্যাসে মানুষ list comprehension লেখে। অংশ ২-এর নিয়ম মনে রাখলে বুঝবেন কী হবে: self.layers-এর মান একটি list, Module নয়, তাই PyTorch ভেতরে তাকায় না। ডেস্কটপে দুটি class পাশাপাশি চালানো হলো; দ্বিতীয়টিতে শুধু list-কে nn.ModuleList-এ মোড়ানো।

import torch
from torch import nn

class ListMLP(nn.Module):                   # ভুল: সাধারণ Python list
    def __init__(self, sizes):
        super().__init__()
        self.layers = [nn.Linear(a, b) for a, b in zip(sizes, sizes[1:])]
    def forward(self, x):
        for i, layer in enumerate(self.layers):
            x = layer(x)
            if i < len(self.layers) - 1: x = torch.relu(x)
        return x

class FixedMLP(ListMLP):                    # ঠিক: nn.ModuleList
    def __init__(self, sizes):
        super().__init__(sizes)
        self.layers = nn.ModuleList(self.layers)

torch.manual_seed(0)
for cls in (ListMLP, FixedMLP):
    m = cls([3, 16, 8, 1])
    n = sum(p.numel() for p in m.parameters())
    print(f"{cls.__name__}: forward {tuple(m(torch.zeros(4, 3)).shape)}, "
          f"parameter {n}, state_dict keys {len(m.state_dict())}")
    try:
        torch.optim.SGD(m.parameters(), lr=0.1)
        print("  optimizer তৈরি হলো")
    except ValueError as e:
        print("  ValueError:", e)

সত্যিকারের run (একই project আর সংস্করণ):

~/bazarghar-dl$ uv run python list_trap.py
ListMLP: forward (4, 1), parameter 0, state_dict keys 0
  ValueError: optimizer got an empty parameter list
FixedMLP: forward (4, 1), parameter 209, state_dict keys 6
  optimizer তৈরি হলো

সবচেয়ে বিপজ্জনক অংশ প্রথম লাইনের প্রথম অংশ: forward ঠিকঠাক চলে, আকারও সঠিক (৪, ১)। এখানে optimizer অন্তত error দিয়েছে, কারণ model-এ আর কিছুই ছিল না। কিন্তু কল্পনা করুন model-এ একটি নিবন্ধিত self.head আছে আর শুধু মাঝের স্তরগুলো list-এ: তখন optimizer head-এর parameter পায়, কোনো error নেই, training চলে, loss একটু কমেও, অথচ মাঝের স্তরগুলো চিরকাল শুরুর এলোমেলো weight-এ আটকে থাকে। সেভ করা ফাইলেও তারা নেই, তাই পরের দিন load করা model আলাদা আচরণ করে। ধরার সহজ উপায়: model বানিয়েই parameter গুনুন আর হাতের হিসাবের সঙ্গে মেলান (অংশ ৪)। একই নিয়ম dict-এ খাটে (nn.ModuleDict), আর সরাসরি parameter-এর তালিকার জন্য nn.ParameterList.

৬ · Buffer — শেখা হয় না, কিন্তু model-এর অংশ

আমাদের model input-কে গড় আর standard deviation দিয়ে মানানসই করে (normalization; কেন দরকার, AI-এর ভিত্তি কোর্সের feature engineering-এর পর্বে)। এই দুটি সংখ্যা training ডেটা থেকে একবার হিসাব হয়, gradient দিয়ে শেখানো হয় না। কোথায় রাখবেন? তিনটি পথ:

• nn.Parameter হিসেবে: ভুল। Optimizer এদের বদলাতে থাকবে, যদিও এরা ডেটার স্থির পরিসংখ্যান।
• সাধারণ attribute self.x_mean = …: forward চলে, কিন্তু state_dict-এ যায় না, আর .to("cuda")-তে সরে না। অন্য কম্পিউটারে model load করলে normalization-এর মান হারিয়ে যায়; অংশ ২-এর mu2-এর মতো।
• self.register_buffer("x_mean", …): ঠিক। state_dict-এ যায়, device আর dtype-এর সঙ্গে সরে, কিন্তু parameters()-এ আসে না, তাই optimizer ছোঁয় না।

PyTorch-এর নিজের layer-ও buffer ব্যবহার করে। সবচেয়ে পরিচিত উদাহরণ BatchNorm-এর running_mean আর running_var, যা training-এর সময় চলমান গড় হিসেবে বদলায়, কিন্তু gradient দিয়ে নয় (পর্ব ১৪-এ)। যে buffer সেভ করার দরকার নেই (যেমন প্রতিবার আবার হিসাব করা যায় এমন একটি mask), তার জন্য register_buffer(name, t, persistent=False): ডেস্কটপের একটি পরীক্ষায় এমন buffer named_buffers()-এ এসেছে, কিন্তু state_dict-এ আসেনি।

৭ · state_dict পড়া — আর NumPy-তে হুবহু একই forward

model.state_dict() একটি ক্রমবদ্ধ অভিধান: key হলো ছবি ৯.১-এর পথ, মান হলো tensor. এতে থাকে সব parameter আর persistent buffer; থাকে না model-এর কোড, class-এর নাম, বা optimizer-এর অবস্থা (optimizer-এর নিজের আলাদা state_dict আছে, পর্ব ১০-এ checkpoint-এর সঙ্গে)। অর্থাৎ state_dict হলো “কোন তাকে কোন সংখ্যা”, আর তাকের নকশা আপনার Python class. নিচের stepper আমাদের শেখানো model-এর state_dict-এর আটটি key পড়ে।

এখন একটি জোরালো পরীক্ষা: state_dict-এ যদি সত্যিই পুরো model-এর সংখ্যা থাকে, তাহলে PyTorch ছাড়াই, শুধু NumPy দিয়ে একই prediction পাওয়া উচিত। ডেস্কটপে model-টি ৪০০টি অর্ডারে কয়েকশো ধাপ শেখানো হলো (training loop-এর বিস্তার পর্ব ১০-এ; এখানে training MSE এলো ৪.২১৫, ইচ্ছা করে রাখা noise-এর variance ৪-এর কাছাকাছি), তারপর state_dict সেভ করে প্রতিটি tensor JSON-এ লেখা হলো, আর তিনটি নমুনা অর্ডারের prediction ছাপা হলো:

model.eval()                                # training শেষে
with torch.no_grad():
    print("train MSE:", round(((model(X) - y) ** 2).mean().item(), 3))
torch.save(model.state_dict(), "delivery_mlp.pt")
sd = model.state_dict()
with open("delivery_mlp.json", "w") as f:
    json.dump({k: v.tolist() for k, v in sd.items()}, f, separators=(",", ":"))
print("json bytes:", len(open("delivery_mlp.json").read()))

orders = torch.tensor([[2.0, 1, 0], [8.5, 3, 1], [11.0, 5, 0]])
with torch.no_grad():
    p32 = model(orders)
    p64 = model.double()(orders.double())
print("float32:", [f"{v:.12f}" for v in p32.tolist()])
print("float64:", [f"{v:.12f}" for v in p64.tolist()])

~/bazarghar-dl$ uv run python train_export.py
train MSE: 4.215
json bytes: 4474
float32: ['34.320652008057', '61.145069122314', '65.167137145996']
float64: ['34.320649724125', '61.145068057894', '65.167140847360']

সেই ৪,৪৭৪ byte-এর JSON ফাইলটি এই পাতায় delivery_mlp.json নামে রাখা আছে। নিচের ব্লক ফাইলটি পড়ে প্রতিটি key-এর আকার দেখায়, তারপর অংশ ৩-এর সূত্রে (y = xWᵀ + b) NumPy-তে পুরো forward চালায়, float64 আর float32 দুইভাবে। Eval mode-এ Dropout কিছুই করে না, তাই NumPy-তে তার কোনো লাইন নেই।

import json
import numpy as np

with open("delivery_mlp.json") as f:          # PyTorch-এর state_dict, JSON-এ
    raw = json.load(f)
for k, v in raw.items():
    print(f"{k:15s} {np.shape(v)}")

def linear(x, W, b):                           # nn.Linear: y = x Wᵀ + b
    return x @ W.T + b

def forward(x, dt):                            # eval mode: Dropout কিছুই করে না
    sd = {k: np.array(v, dtype=dt) for k, v in raw.items()}
    z = (x.astype(dt) - sd["x_mean"]) / sd["x_std"]
    h = np.maximum(linear(z, sd["hidden.0.weight"], sd["hidden.0.bias"]), 0)
    h = np.maximum(linear(h, sd["hidden.3.weight"], sd["hidden.3.bias"]), 0)
    return linear(h, sd["head.weight"], sd["head.bias"])[:, 0]

orders = np.array([[2.0, 1, 0], [8.5, 3, 1], [11.0, 5, 0]])
p64, p32 = forward(orders, np.float64), forward(orders, np.float32)
t64 = np.array([34.320649724125, 61.145068057894, 65.167140847360])  # ডেস্কটপ
t32 = np.array([34.320652008057, 61.145069122314, 65.167137145996])  # PyTorch
for o, p in zip(orders, p64):
    print(f"{o[0]:4.1f} km, {int(o[1])} পণ্য, বৃষ্টি {int(o[2])}: {p:.12f} মিনিট")
print(f"float64: max |NumPy − PyTorch| = {np.abs(p64 - t64).max():.1e}")
print(f"float32: max |NumPy − PyTorch| = {np.abs(p32 - t32).max():.1e}")
print(f"float32 বনাম float64: {np.abs(p32 - p64).max():.1e} মিনিট")

x_mean          (3,)
x_std           (3,)
hidden.0.weight (16, 3)
hidden.0.bias   (16,)
hidden.3.weight (8, 16)
hidden.3.bias   (8,)
head.weight     (1, 8)
head.bias       (1,)
 2.0 km, 1 পণ্য, বৃষ্টি 0: 34.320649724125 মিনিট
 8.5 km, 3 পণ্য, বৃষ্টি 1: 61.145068057894 মিনিট
11.0 km, 5 পণ্য, বৃষ্টি 0: 65.167140847360 মিনিট
float64: max |NumPy − PyTorch| = 3.8e-13
float32: max |NumPy − PyTorch| = 3.8e-06
float32 বনাম float64: 3.7e-06 মিনিট

৮ · Save, load আর strict — নাম না মিললে কী হয়, আর weights_only

PyTorch-এর docs যে পথটি সুপারিশ করে: শুধু state_dict সেভ করুন, torch.save(model.state_dict(), path); load-এর সময় আগে একই class দিয়ে model বানান, তারপর model.load_state_dict(torch.load(path)). load_state_dict-এর default strict=True: ফাইলের key আর model-এর key হুবহু এক সেট না হলে, বা কোনো tensor-এর আকার না মিললে, সঙ্গে সঙ্গে RuntimeError. নিচের script তিনটি পরিস্থিতি দেখায়: সঠিক load, কেউ self.head-এর নাম বদলে self.out রেখেছেন, আর head-এ output দুটি করা হয়েছে। শেষে পুরো model object সেভ করে default-এ খোলার চেষ্টা।

import inspect, pickle, torch
from torch import nn
from bazarghar import DeliveryMLP

sd = torch.load("delivery_mlp.pt")           # default আর্গুমেন্টে
print(type(sd).__name__, "| keys:", list(sd.keys()))
print("torch.load default weights_only =",
      inspect.signature(torch.load).parameters["weights_only"].default)
fresh = DeliveryMLP(torch.zeros(3), torch.ones(3))
print(fresh.load_state_dict(sd))             # strict=True default
fresh.eval()
with torch.no_grad():
    print("prediction:", round(fresh(torch.tensor([[8.5, 3.0, 1.0]])).item(), 4))

r = Renamed(torch.zeros(3), torch.ones(3))   # head-এর নাম বদলে out রাখা subclass
try: r.load_state_dict(sd)
except RuntimeError as e: print("RuntimeError:", e)
print("strict=False:", r.load_state_dict(sd, strict=False))

big = DeliveryMLP(torch.zeros(3), torch.ones(3)); big.head = nn.Linear(8, 2)
try: big.load_state_dict(sd)
except RuntimeError as e: print("RuntimeError:", str(e).splitlines()[-1].strip())

torch.save(fresh, "whole_model.pt")           # পুরো object, pickle দিয়ে
try: torch.load("whole_model.pt")
except pickle.UnpicklingError as e: print_key_lines(e)   # তিনটি মূল লাইন ছাপে
m = torch.load("whole_model.pt", weights_only=False)     # শুধু নিজের বিশ্বস্ত ফাইলে
print("weights_only=False:", type(m).__name__)

সত্যিকারের run (Renamed class আর ANSI রং-চিহ্ন মুছে লাইন বাছাইয়ের ছোট function-টি ফাইলে আছে, এখানে জায়গা বাঁচাতে বাদ; দীর্ঘ লাইন “…” দিয়ে ছাঁটা):

~/bazarghar-dl$ uv run python state_io.py
OrderedDict | keys: ['x_mean', 'x_std', 'hidden.0.weight', 'hidden.0.bias', 'hidden.3.weight', 'hidden.3.bias', 'head.weight', 'head.bias']
torch.load default weights_only = None
<All keys matched successfully>
prediction: 61.1451
RuntimeError: Error(s) in loading state_dict for Renamed:
	Missing key(s) in state_dict: "out.weight", "out.bias".
	Unexpected key(s) in state_dict: "head.weight", "head.bias".
strict=False: _IncompatibleKeys(missing_keys=['out.weight', 'out.bias'], unexpected_keys=['head.weight', 'head.bias'])
RuntimeError: size mismatch for head.bias: copying a param with shape torch.Size([1]) from checkpoint, the shape in current model is torch.Size([2]).
  Weights only load failed. This file can still be loaded, to do so you have two options, do those steps only if you trust the source of the checkpoint.
  (1) In PyTorch 2.6, we changed the default value of the `weights_only` argument in `torch.load` from `False` to `True`. …
  WeightsUnpickler error: Unsupported global: GLOBAL bazarghar.DeliveryMLP was not an allowed global by default. …
weights_only=False: DeliveryMLP

সঠিক load: নতুন model-টি শূন্য গড় আর এক standard deviation দিয়ে বানানো হয়েছিল, তবু load-এর পর prediction ৬১.১৪৫১, অংশ ৭-এর float32 মানের সঙ্গে এক: buffer-ও ফাইল থেকে এসেছে। নাম বদল: error বার্তাটি দুই তালিকায় পরিষ্কার বলে কী নেই (Missing) আর কী বাড়তি (Unexpected). strict=False error দেয় না, শুধু তালিকা ফেরত দেয়, আর মিলে যাওয়া key-গুলোই বসায়; ফলে out শুরুর এলোমেলো weight-এ থাকে। তাই strict=False ব্যবহার করলে ফেরত আসা তালিকা অবশ্যই পরীক্ষা করুন; এটি ইচ্ছাকৃত আংশিক load-এর জন্য (যেমন pretrained body নিয়ে নতুন head, পর্ব ২৩-এ transfer learning). আকার: strict=False দিলেও আকারের অমিল error দেয়।

weights_only. torch.save ভেতরে Python-এর pickle ব্যবহার করে, আর pickle ফাইল খোলার সময় ফাইলের নির্দেশমতো Python object বানাতে পারে, এমনকি function ডাকতে পারে। অচেনা উৎসের ফাইল খোলা তাই কোড চালানোর ঝুঁকি (AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ এই ঝুঁকি একটি সত্যিকারের ফাইলে দেখানো হয়েছে)। Run-এর বার্তাই বলছে, PyTorch 2.6 থেকে weights_only-এর default False থেকে True হয়েছে। Signature-এ default None দেখায়, কারণ ভেতরে None-কে সিদ্ধান্তে বদলানো হয় (এই সংস্করণের source-এ TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD নামের একটি environment variable দিয়ে পুরোনো আচরণ জোর করে ফেরানোর ব্যবস্থাও আছে)। ফল: tensor-এর অভিধান (state_dict) default-এ খোলে, কিন্তু আপনার নিজের class-সহ পুরো model খোলে না, কারণ bazarghar.DeliveryMLP নিরাপদ তালিকায় নেই। দুটি পথ: নিজের বিশ্বস্ত ফাইলে weights_only=False, বা class-টিকে torch.serialization.add_safe_globals-এ যোগ করা। অচেনা ফাইলে কোনোটিই নয়।

শেয়ার করার জন্য আরও নিরাপদ বিকল্প safetensors ফরম্যাট, যেখানে শুধু tensor-এর কাঁচা সংখ্যা আর একটি ছোট header থাকে, কোনো কোড নয়; Hugging Face-এর model-এ এটি এখন বহুল ব্যবহৃত। Deployment-এ model পাঠানোর অন্য পথ (ONNX ইত্যাদি) মেশিন লার্নিং কোর্সের পর্ব ৬৮-এ।

৯ · train() আর eval() — শুধু একটি flag, কিন্তু ফল বদলায়

প্রতিটি module-এর একটি boolean attribute আছে, self.training. model.train() গাছের সব module-এ এটি True করে, model.eval() False (eval mode); আর কিছু না। কয়েকটি layer এই flag দেখে আচরণ বদলায়: Dropout training-এ এলোমেলোভাবে কিছু মান শূন্য করে, eval-এ কিছুই করে না; BatchNorm training-এ batch-এর পরিসংখ্যান নেয়, eval-এ জমানো buffer. নতুন model default-এ train mode-এ থাকে। ডেস্কটপে শেখানো model-এ একই অর্ডার (৮.৫ km, ৩টি পণ্য, বৃষ্টি) তিনবার করে চালানো হলো:

import torch
from bazarghar import DeliveryMLP

model = DeliveryMLP(torch.zeros(3), torch.ones(3))
model.load_state_dict(torch.load("delivery_mlp.pt"))
order = torch.tensor([[8.5, 3.0, 1.0]])
torch.manual_seed(7)

model.train()                                 # default অবস্থা
print("training flags:", model.training, model.hidden[2].training)
print("train mode, 3 বার:", [round(model(order).item(), 2) for _ in range(3)])
model.eval()
print("training flags:", model.training, model.hidden[2].training)
print("eval mode, 3 বার:", [round(model(order).item(), 2) for _ in range(3)])
print("eval-এও graph তৈরি হয়? requires_grad =", model(order).requires_grad)
with torch.no_grad():
    print("no_grad-এর ভেতরে requires_grad =", model(order).requires_grad)
drop = torch.nn.Dropout(p=0.5).train()
print("Dropout(0.5) on ones(8):", drop(torch.ones(8)).tolist())

~/bazarghar-dl$ uv run python modes.py
training flags: True True
train mode, 3 বার: [66.34, 52.36, 66.34]
training flags: False False
eval mode, 3 বার: [61.15, 61.15, 61.15]
eval-এও graph তৈরি হয়? requires_grad = True
no_grad-এর ভেতরে requires_grad = False
Dropout(0.5) on ones(8): [0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 0.0]

Train mode-এ একই অর্ডারের উত্তর ৬৬.৩৪, ৫২.৩৬, ৬৬.৩৪ মিনিট: প্রতিবার Dropout আলাদা hidden unit বন্ধ করছে। একজন গ্রাহককে একই অর্ডারে একবার ৫২ আর একবার ৬৬ মিনিট বলা অগ্রহণযোগ্য; eval mode-এ তিনবারই ৬১.১৫, যা সেভ করা model আর NumPy-র মান। একই কারণে শেখানো model-এর ৪০০টি অর্ডারে MSE eval mode-এ ৪.২১৫, কিন্তু train mode-এ মাপলে ডেস্কটপের একটি run-এ এসেছিল ১৮.০৯৮: mode ভুল হলে মাপও ভুল। শেষ লাইনে দেখুন: বেঁচে থাকা মান ১ নয়, ২. একে inverted dropout বলে: training-এ বেঁচে থাকা মানকে 1/(1 − p) দিয়ে গুণ করা হয়, যাতে গড় অপরিবর্তিত থাকে আর eval-এ কিছুই করতে না হয়। আর মাঝের দুটি লাইন একটি সাধারণ ভুল ধারণা ভাঙে: eval() gradient বন্ধ করে না। Prediction-এর সময় model.eval() আর torch.no_grad() (বা torch.inference_mode()) দুটিই লাগে; প্রথমটি layer-এর আচরণের জন্য, দ্বিতীয়টি graph না বানিয়ে memory আর সময় বাঁচানোর জন্য (পর্ব ০৮-এ বিস্তারিত)।

Inverted dropout-এর হিসাবটি NumPy-তে হুবহু লেখা যায়। নিচের ব্লক nn.Dropout-এর মতো একটি ছোট class লেখে, যার নিজের training flag আর train()/eval() আছে, তারপর বহু উদাহরণে মেপে দেখে গড় সত্যিই বদলায় কি না।

import numpy as np

class Dropout:                                  # nn.Dropout-এর NumPy প্রতিচ্ছবি
    def __init__(self, p, rng):
        self.p, self.rng, self.training = p, rng, True
    def train(self): self.training = True; return self
    def eval(self): self.training = False; return self
    def __call__(self, h):
        if not self.training or self.p == 0:
            return h                            # eval: হুবহু ফেরত
        keep = self.rng.random(h.shape) >= self.p
        return h * keep / (1 - self.p)          # inverted dropout: টিকে থাকাদের বড় করা

rng = np.random.default_rng(42)
drop = Dropout(0.5, rng)
h = np.ones(8)
print("train:", drop.train()(h))
print("train:", drop(h))
print("eval :", drop.eval()(h))

big = np.full((10000, 16), 2.0)                 # বহু উদাহরণে গড় কি বদলায়?
drop.train()
for p in (0.1, 0.5):
    drop.p = p
    out = drop(big)
    print(f"p = {p}: শূন্য {np.mean(out == 0):.3f}, গড় {out.mean():.4f} (আসল 2.0)")
print("scale ছাড়া হলে গড়:", (big * (rng.random(big.shape) >= 0.5)).mean().round(4))

train: [2. 0. 2. 2. 0. 2. 2. 2.]
train: [0. 0. 0. 2. 2. 2. 0. 0.]
eval : [1. 1. 1. 1. 1. 1. 1. 1.]
p = 0.1: শূন্য 0.099, গড় 2.0018 (আসল 2.0)
p = 0.5: শূন্য 0.501, গড় 1.9956 (আসল 2.0)
scale ছাড়া হলে গড়: 0.9952

১০ · AI-এর যুগে — AI-এর লেখা model class যাচাই

AI assistant এক মিনিটে একটি nn.Module subclass লিখে দেয়, আর প্রায় সবসময় তা চলে। এই পর্বের বাগগুলো ঠিক সেই ধরনের, যা চলে কিন্তু ভুল: list-এ রাখা layer, সাধারণ attribute-এ রাখা normalization-এর মান, transpose ছাড়া weight, eval ছাড়া prediction. পুরোনো টিউটোরিয়াল থেকে শেখা AI প্রায়ই torch.load(path) লিখে ধরে নেয় পুরো model খুলবে, বা error এলে কোনো সতর্কতা ছাড়াই weights_only=False বসিয়ে দেয়।

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

• Model বানিয়েই মোট parameter গুনেছি আর out × in + out দিয়ে হাতের হিসাবের সঙ্গে মিলিয়েছি
• state_dict().keys() পড়ে দেখেছি প্রতিটি layer আর buffer আছে, কোনো list-এ লুকানো layer নেই
• সেভ করে নতুন instance-এ strict=True দিয়ে load করেছি, আর একই input-এ একই prediction পেয়েছি
• অচেনা ফাইলে weights_only=False দিইনি; শেয়ারের জন্য state_dict বা safetensors বেছেছি
• Prediction-এ eval() আর no_grad() দুটিই আছে; একই input দুবার চালিয়ে উত্তর মিলিয়েছি
• ছোট batch-এ আকার ছেপে দেখেছি, আর API নিজের PyTorch version-এর docs-এ মিলিয়েছি; কোনো আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি