PyTorch tensor — shape, dtype, device আর broadcasting

AI-এর ভিত্তি কোর্সের পর্ব ১৩ থেকে পর্ব ১৯ পর্যন্ত NumPy array, indexing, broadcasting, linear algebra আর memory-র গতি এসেছে; সেখানে PyTorch-এর প্রথম তুলনা দেখা গেছে পর্ব ৬৮-এ। এই কোর্সের পর্ব ০৩-এ NumPy-তে MLP-এর shape মিলিয়েছেন, আর পর্ব ০৫-এ নিজের tensor autograd বানিয়ে PyTorch-এর backward()-এর সঙ্গে মিলিয়েছেন। এবার মডিউল ২ শুরু: PyTorch-কে ভেতর থেকে চেনা। প্রথম প্রশ্ন সবচেয়ে সাধারণ, কিন্তু deep learning-এর বাগের বড় অংশ এখান থেকেই আসে: একটি tensor আসলে কী, memory-তে কীভাবে থাকে, আর দুটি tensor-এর shape মিলবে কি না তা আগে থেকে কীভাবে বলবেন? PyTorch ব্রাউজারে চলে না, তাই PyTorch-এর সব ফল ডেস্কটপের সত্যিকারের run থেকে নেওয়া। পাতার তিনটি ব্লক ব্রাউজারের Python-এ NumPy দিয়ে একই নিয়ম দেখায়; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে।

১ · Tensor কী — তৈরি, seed আর shape

Tensor হলো একই ধরনের সংখ্যার বহুমাত্রিক array, NumPy-র ndarray-এর খুব কাছের আত্মীয়। তফাত দুটি: tensor GPU-র মতো অন্য device-এ থাকতে পারে, আর পর্ব ০৫-এর মতো gradient রাখতে পারে। একটি scalar-এর ndim ০, একটি vector-এর ১, একটি টেবিলের ২, আর ছবির একটি batch-এর সাধারণত ৪: (N, C, H, W), অর্থাৎ ছবির সংখ্যা, channel, উচ্চতা, প্রস্থ। shape প্রতিটি অক্ষের মাপ, ndim অক্ষের সংখ্যা, numel() মোট ঘর।

ডেস্কটপে uv দিয়ে একটি আলাদা project বানিয়ে PyTorch-এর CPU build install করা হয়েছে, পর্ব ০৫-এর মতোই (uv-এর পরিচয় AI-এর ভিত্তি কোর্সের পর্ব ৭-এ)। প্রথম script বাজারঘরের দুটি অর্ডারের (দূরত্ব km, পণ্যের সংখ্যা) একটি ছোট tensor বানায়, তারপর সাধারণ তৈরির function আর seed দেখে।

import sys, numpy as np, torch
print("python", sys.version.split()[0], "| torch", torch.__version__, "| numpy", np.__version__)

t = torch.tensor([[12.5, 3.0], [4.0, 1.0]])     # দূরত্ব km, পণ্যের সংখ্যা
print(t, t.shape, t.ndim, t.numel(), t.dtype)
print(torch.zeros(2, 3).dtype, torch.arange(5), torch.arange(5).dtype)
print(torch.linspace(0, 1, 5))

g = torch.Generator().manual_seed(42)            # নিজের seed-ওয়ালা generator
a = torch.rand(2, 3, generator=g)
g.manual_seed(42)
b = torch.rand(2, 3, generator=g)
print(a)
print("same seed, same numbers:", torch.equal(a, b))
torch.manual_seed(42)                            # global generator
print(torch.randn(3))
print(torch.full((2, 2), 7), torch.eye(2, dtype=torch.int64))
x = torch.empty(3)                               # মান অনির্ধারিত, শুধু জায়গা
print("empty shape:", x.shape, "| zeros_like:", torch.zeros_like(a).shape)

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

~/bazarghar-dl$ uv run python t1_create.py
python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.4
tensor([[12.5000,  3.0000],
        [ 4.0000,  1.0000]]) torch.Size([2, 2]) 2 4 torch.float32
torch.float32 tensor([0, 1, 2, 3, 4]) torch.int64
tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])
tensor([[0.8823, 0.9150, 0.3829],
        [0.9593, 0.3904, 0.6009]])
same seed, same numbers: True
tensor([0.3367, 0.1288, 0.2345])
tensor([[7, 7],
        [7, 7]]) tensor([[1, 0],
        [0, 1]])
empty shape: torch.Size([3]) | zeros_like: torch.Size([2, 3])

কয়েকটি জিনিস লক্ষ করুন। torch.Size আসলে Python-এর tuple-এর একটি রূপ, তাই t.shape[0] বা tuple(t.shape) স্বাভাবিকভাবে চলে। দশমিক সংখ্যা থেকে float32 এসেছে, NumPy-র মতো float64 নয়; arange(5) পূর্ণসংখ্যা দিয়েছে int64-এ। linspace(0, 1, 5) দুই প্রান্তসহ পাঁচটি সমান দূরত্বের বিন্দু। empty শুধু জায়গা নেয়, মান যা খুশি থাকতে পারে, তাই তার মান কখনো ছাপিয়ে বিশ্বাস করবেন না।

Seed-এর দুটি পথ আছে। torch.manual_seed(42) পুরো program-এর global random অবস্থা বদলায়; অন্য কোনো library বা কোডের অংশ মাঝখানে একটি random সংখ্যা নিলে আপনার ক্রম সরে যায়। নিজের Generator বানিয়ে generator=g দিলে ক্রমটি শুধু আপনার: একই seed দিলে একই সংখ্যা (torch.equal True হয়েছে)। পর্ব ১১ (Dataset আর DataLoader — batching, shuffling আর বাংলা ডেটা)-এ shuffle-এর জন্য এই কৌশলই লাগবে। পুনরুৎপাদনযোগ্যতার পুরো আলোচনা মেশিন লার্নিং কোর্সের পর্ব ৪-এ।

২ · dtype আর device — কী ধরনের সংখ্যা, কোথায় রাখা

dtype বলে প্রতিটি ঘর কত বাইটের আর বিটগুলো কীভাবে পড়তে হবে (NumPy-র dtype-এর পুরো আলোচনা AI-এর ভিত্তি কোর্সের পর্ব ১৩-এ)। Deep learning-এ float32 সাধারণ পছন্দ: float64-এর অর্ধেক memory, আর neural network-এর শেখার জন্য তার নির্ভুলতা সাধারণত যথেষ্ট। দুই বাইটের দুটি রূপ, float16 আর bfloat16, বড় model-এ গতি আর memory বাঁচাতে ব্যবহার হয়; এদের পুরো ব্যবহার পর্ব ১২ (GPU, mixed precision আর গতি — device, AMP আর profiling)-এ। এখানে শুধু পার্থক্যটি সংখ্যায় দেখি।

import numpy as np, torch

print(torch.tensor([1, 2]).dtype, torch.tensor([1.0]).dtype,
      torch.tensor([True]).dtype, torch.from_numpy(np.array([1.0])).dtype)
i, f = torch.tensor([3, 4]), torch.tensor([0.5, 0.5])
print("int64 + float32 ->", (i + f).dtype, "| int64 / int64 ->", (i / i).dtype)
print("int64 // 2 ->", i // 2, "| bool sum ->", torch.tensor([True, False, True]).sum())

for dt in (torch.float32, torch.float16, torch.bfloat16, torch.float64):
    fi = torch.finfo(dt)
    print(f"{str(dt):15s} bytes={dt.itemsize} max={fi.max:.3g} eps={fi.eps:.3g}")
print("70000 in float16 :", torch.tensor(70000.0).half())
print("70000 in bfloat16:", torch.tensor(70000.0).bfloat16())
print("1 + 1e-3 in bf16 :", torch.tensor(1.001).bfloat16())

W = torch.ones(2, 2)                          # float32
x64 = torch.ones(2, dtype=torch.float64)
try:
    W @ x64
except RuntimeError as e:
    print("RuntimeError:", e)
print("fix:", (W @ x64.float()).dtype)

print("cuda available:", torch.cuda.is_available())
device = "cuda" if torch.cuda.is_available() else "cpu"
y = W.to(device)
print("W.device:", W.device, "| y.device type:", y.device.type, "| same object:", y is W)
print("to(float16):", W.to(torch.float16).dtype, "| W still:", W.dtype)

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

~/bazarghar-dl$ uv run python t2_dtype.py
torch.int64 torch.float32 torch.bool torch.float64
int64 + float32 -> torch.float32 | int64 / int64 -> torch.float32
int64 // 2 -> tensor([1, 2]) | bool sum -> tensor(2)
torch.float32   bytes=4 max=3.4e+38 eps=1.19e-07
torch.float16   bytes=2 max=6.55e+04 eps=0.000977
torch.bfloat16  bytes=2 max=3.39e+38 eps=0.00781
torch.float64   bytes=8 max=1.8e+308 eps=2.22e-16
70000 in float16 : tensor(inf, dtype=torch.float16)
70000 in bfloat16: tensor(70144., dtype=torch.bfloat16)
1 + 1e-3 in bf16 : tensor(1., dtype=torch.bfloat16)
RuntimeError: addmv input tensors must have the same dtype, but got Double, Float, and Double
fix: torch.float32
cuda available: False
W.device: cpu | y.device type: cpu | same object: True
to(float16): torch.float16 | W still: torch.float32

dtype বেছে নেওয়া: from_numpy NumPy-র float64 ধরে রেখেছে; NumPy থেকে আনা ডেটা model-এ দেওয়ার আগে .float() না করলে ঠিক ওপরের error আসে। Error-এর ভাষায় Double মানে float64, Float মানে float32; addmv হলো matrix-vector গুণের ভেতরের কাজের নাম। Type promotion: int64 আর float32 মিশলে ফল float32; পূর্ণসংখ্যাকে / দিয়ে ভাগ করলেও float আসে, // দিলে পূর্ণসংখ্যা থাকে। bool যোগ করলে True-এর সংখ্যা গোনা হয়, accuracy গোনার পরিচিত কৌশল।

float16 বনাম bfloat16: দুটিই দুই বাইট, কিন্তু বিট ভাগ ভিন্ন। float16-এর সবচেয়ে বড় মান প্রায় ৬৫,৫০৪, তাই ৭০,০০০ ধরতে না পেরে inf হয়ে গেছে, যা overflow. bfloat16 float32-এর মতোই বিশাল পরিসর রাখে (সর্বোচ্চ প্রায় 3.39 × 10³⁸), কিন্তু নির্ভুলতা কম: ৭০,০০০ হয়ে গেছে ৭০,১৪৪, আর ১.০০১ হয়ে গেছে ঠিক ১. eps হলো ১-এর পরের সবচেয়ে কাছের সংখ্যার দূরত্ব (machine epsilon): bfloat16-এ ০.০০৭৮১, অর্থাৎ ১-এর কাছে মোটামুটি দুই-তিনটি অর্থপূর্ণ অঙ্ক পর্যন্তই ভরসা, তাই ১.০০১ আর ১ আলাদা থাকে না। এক কথায়: float16 নির্ভুল কিন্তু পরিসর ছোট, bfloat16 পরিসর বড় কিন্তু মোটা দাগের।

Device: এই project-এ CPU build, তাই torch.cuda.is_available() False আর device "cpu". সাধারণ ছাঁচ হলো একটি device চলক রেখে সব জায়গায় সেটিই ব্যবহার। tensor ইতিমধ্যে সেই device আর dtype-এ থাকলে .to() একই object ফেরত দেয় (same object: True); না থাকলে নতুন কপি বানায়, আর মূল tensor যেমন ছিল তেমন থাকে (W still float32 দেখাচ্ছে)। তাই x.to(device) লিখে ফল কোনো নামে না রাখলে কিছুই বদলায় না। দুটি tensor ভিন্ন device-এ থাকলে একসঙ্গে হিসাব হয় না; RuntimeError আসে। CUDA build আর GPU থাকলে "cuda", Apple-এর যন্ত্রে "mps" device পাওয়া যায়। পুরো device ব্যবস্থাপনা আর সময় মাপা পর্ব ১২-এ।

৩ · Memory-তে tensor — storage, stride আর contiguous

Computer-এর memory একটিই লম্বা সারি। একটি (২, ৩) tensor-এর ছয়টি সংখ্যা সেই সারিতে পাশাপাশি থাকে, প্রথম সারির পরে দ্বিতীয় সারি; একে বলে row-major বা C-order. তাহলে [i, j] ঘরটি কোথায়? উত্তর দেয় stride: প্রতিটি অক্ষে এক ঘর এগোতে storage-এ কত ঘর লাফাতে হয়। (২, ৩)-এর stride (৩, ১): পরের সারিতে যেতে ৩ ঘর, পরের কলামে ১ ঘর। তাই ঠিকানা = i × ৩ + j × ১. PyTorch-এর stride() ঘর গোনে; NumPy-র .strides একই জিনিস বাইটে গোনে (memory layout-এর পুরো আলোচনা AI-এর ভিত্তি কোর্সের পর্ব ১৯-এ)।

এই কারণেই transpose, slicing আর permute প্রায় বিনা খরচের: এরা নতুন storage বানায় না, পুরোনো storage-এর ওপর নতুন shape আর stride নিয়ে একটি view দেয়। একটি tensor-কে contiguous বলা হয় যখন তার ঘরগুলো সারি ধরে পড়লে storage-এর ক্রমে, কোনো ফাঁক ছাড়া পড়া হয়; সংজ্ঞাটি stride দিয়ে যাচাই করা যায়: শেষ অক্ষের stride ১, আর প্রতিটি অক্ষের stride তার ডানের অক্ষের stride × মাপ। নিচের ব্লক NumPy দিয়ে এটি দেখায়, কারণ NumPy-র strides PyTorch-এর মতোই কাজ করে।

import numpy as np

a = np.arange(6, dtype=np.int64).reshape(2, 3)   # প্রতিটি ঘর 8 বাইট
t = a.T                                           # transpose: নতুন strides, একই memory
print("a  :", a.shape, "strides", a.strides, "C-contiguous", a.flags.c_contiguous)
print("a.T:", t.shape, "strides", t.strides, "C-contiguous", t.flags.c_contiguous)
print("same memory:", np.shares_memory(a, t))
for i, j in [(0, 1), (1, 0), (2, 1)]:             # ঠিকানা = i*stride0 + j*stride1
    off = i * t.strides[0] + j * t.strides[1]
    print(f"a.T[{i},{j}] = {t[i, j]} → offset {off} bytes = element {off // 8}")
print("memory order:", a.ravel(), "| a.T row by row:", t.ravel())

try:
    np.reshape(t, 6, copy=False)                  # torch-এর view-এর মতো: কপি নিষেধ
except ValueError as e:
    print("ValueError:", e)
c = np.ascontiguousarray(t)                       # torch-এর .contiguous()-এর মতো
print("copy:", c.strides, c.flags.c_contiguous, "| shares memory:", np.shares_memory(c, a))

x = np.zeros((8, 32, 32, 3), dtype=np.float32)    # N, H, W, C
p = x.transpose(0, 3, 1, 2)                       # N, C, H, W
print("NCHW strides (bytes):", p.strides, "→ elements:", tuple(s // 4 for s in p.strides))
print("contiguous:", p.flags.c_contiguous, "| reshape copies:",
      not np.shares_memory(p.reshape(8, -1), x))

a  : (2, 3) strides (24, 8) C-contiguous True
a.T: (3, 2) strides (8, 24) C-contiguous False
same memory: True
a.T[0,1] = 3 → offset 24 bytes = element 3
a.T[1,0] = 1 → offset 8 bytes = element 1
a.T[2,1] = 5 → offset 40 bytes = element 5
memory order: [0 1 2 3 4 5] | a.T row by row: [0 3 1 4 2 5]
ValueError: Unable to avoid creating a copy while reshaping.
copy: (16, 8) True | shares memory: False
NCHW strides (bytes): (12288, 4, 384, 12) → elements: (3072, 1, 96, 3)
contiguous: False | reshape copies: True

৪ · view বনাম reshape, আর shape বদলানোর হাতিয়ার

এবার PyTorch-এ একই জিনিস, সঙ্গে ছবির একটি batch-এর পরিচিত permute. ছবি সাধারণত (H, W, C) ক্রমে পড়া হয়, আর PyTorch-এর convolution চায় (N, C, H, W) (channels-last বনাম channels-first রীতি)। Indexing আর slicing-এর নিয়ম NumPy-র মতোই (AI-এর ভিত্তি কোর্সের পর্ব ১৪); slicing-ও view দেয়, যা script-এর শেষ লাইনে দেখা যাবে।

import torch

x = torch.arange(6)                               # 0..5, int64
m = x.view(2, 3)
print(m, "| stride", m.stride(), "| contiguous", m.is_contiguous())
print("same storage:", m.data_ptr() == x.data_ptr())
m[0, 0] = 100                                     # view-তে লিখলে মূলও বদলায়
print("x after m[0,0]=100:", x)

t = m.t()                                         # transpose: কপি নয়
print("t shape", tuple(t.shape), "| stride", t.stride(), "| contiguous", t.is_contiguous())
try:
    t.view(6)
except RuntimeError as e:
    print("RuntimeError:", str(e)[:120], "…")
r = t.reshape(6)                                  # দরকার হলে কপি করে
print("reshape:", r, "| shares memory:", r.data_ptr() == x.data_ptr())
c = t.contiguous()
print("contiguous():", tuple(c.stride()), c.is_contiguous(), c.view(6))

img = torch.zeros(8, 32, 32, 3)                   # batch, H, W, C (NumPy/PIL ধাঁচ)
p = img.permute(0, 3, 1, 2)                       # PyTorch-এর N, C, H, W
print("permute:", tuple(p.shape), "| stride", p.stride(), "| contiguous", p.is_contiguous())
try:
    p.view(8, -1)
except RuntimeError:
    print("p.view(8, -1) -> RuntimeError")
print("p.reshape(8, -1):", tuple(p.reshape(8, -1).shape), "| flatten(1):", tuple(p.flatten(1).shape))

v = torch.tensor([1.0, 2.0, 3.0])
print(tuple(v.unsqueeze(0).shape), tuple(v.unsqueeze(1).shape), tuple(v[None, :, None].shape))
print(tuple(torch.zeros(1, 3, 1).squeeze().shape), tuple(torch.zeros(1, 3, 1).squeeze(0).shape))
s = v[::2]                                        # slicing-ও view
print("v[::2] stride", s.stride(), "| contiguous", s.is_contiguous(), "| clone shares:",
      s.clone().data_ptr() == v.data_ptr())

সত্যিকারের run:

~/bazarghar-dl$ uv run python t3_views.py
tensor([[0, 1, 2],
        [3, 4, 5]]) | stride (3, 1) | contiguous True
same storage: True
x after m[0,0]=100: tensor([100,   1,   2,   3,   4,   5])
t shape (3, 2) | stride (1, 3) | contiguous False
RuntimeError: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subs …
reshape: tensor([100,   3,   1,   4,   2,   5]) | shares memory: False
contiguous(): (2, 1) True tensor([100,   3,   1,   4,   2,   5])
permute: (8, 3, 32, 32) | stride (3072, 1, 96, 3) | contiguous False
p.view(8, -1) -> RuntimeError
p.reshape(8, -1): (8, 3072) | flatten(1): (8, 3072)
(1, 3) (3, 1) (1, 3, 1)
(3,) (3, 1)
v[::2] stride (2,) | contiguous False | clone shares: False

পুরো error বার্তার শেষ অংশটি হলো “Use .reshape(...) instead.”, অর্থাৎ PyTorch নিজেই সমাধান বলে দেয়। তবু চোখ বুজে reshape বসানোর আগে বুঝুন কী ঘটছে: view-তে লিখলে মূল tensor বদলায় (m[০, ০] = ১০০ লেখার পর x-এর প্রথম ঘরও ১০০), কিন্তু reshape কপি করলে সেই সম্পর্ক ভেঙে যায় (shares memory: False এসেছে)। অর্থাৎ reshape-এর ফলে লিখলে মূল tensor কখনো বদলায়, কখনো বদলায় না, কোনটি হবে তা stride-এর ওপর নির্ভর করে। এই অনিশ্চয়তার কারণেই PyTorch-এর docs বলে, reshape-এর ফল view না কপি তার ওপর নির্ভর করবেন না; নিশ্চিত কপি চাইলে clone(), নিশ্চিত view চাইলে view().

৫ · Broadcasting — shape মেলানোর নিয়ম, ধাপে ধাপে

Broadcasting-এর ধারণা AI-এর ভিত্তি কোর্সের পর্ব ১৫-এ এসেছে, আর পর্ব ০৫-এ দেখেছেন এর backward-এ কেন sum লাগে। PyTorch হুবহু NumPy-র নিয়ম মানে। নিয়ম তিনটি:

নিয়মটি হাতে লিখে NumPy-র সঙ্গে মেলানো যাক। নিচের function আটটি জোড়ার ফলের shape বা error আগে অনুমান করে, তারপর NumPy-তে সত্যিই যোগ করে মেলায়। জোড়াগুলো deep learning-এর পরিচিত দৃশ্য: token-এর feature-এ bias, ছবির channel-এ গড় বিয়োগ, সারির গড় বিয়োগ।

import numpy as np

def predict(s1, s2):                     # broadcasting-এর নিয়ম, হাতে
    n = max(len(s1), len(s2))
    a = (1,) * (n - len(s1)) + tuple(s1)  # ছোটটির বাঁ দিকে 1 বসানো
    b = (1,) * (n - len(s2)) + tuple(s2)
    out = []
    for i, (x, y) in enumerate(zip(a, b)):   # ডান দিক থেকে মিলুক বা না মিলুক
        if x == y or y == 1:
            out.append(x)
        elif x == 1:
            out.append(y)
        else:
            return f"error: dim {i - n} ({x} vs {y})"
    return tuple(out)

pairs = [((3, 1, 4), (2, 4)), ((32, 10, 16), (16,)), ((4, 5), (4,)),
         ((4, 1), (5,)), ((8, 3, 32, 32), (3, 1, 1)), ((8, 3, 32, 32), (3,)),
         ((2, 1, 5), (7, 1)), ((64, 16), (64, 1))]
for s1, s2 in pairs:
    guess = predict(s1, s2)
    try:
        real = (np.zeros(s1) + np.zeros(s2)).shape
    except ValueError:
        real = "error"
    same = guess == real or (str(guess).startswith("error") and real == "error")
    print(f"{s1} + {s2} → {guess}  {'✓' if same else '✗ NumPy: ' + str(real)}")

(3, 1, 4) + (2, 4) → (3, 2, 4)  ✓
(32, 10, 16) + (16,) → (32, 10, 16)  ✓
(4, 5) + (4,) → error: dim -1 (5 vs 4)  ✓
(4, 1) + (5,) → (4, 5)  ✓
(8, 3, 32, 32) + (3, 1, 1) → (8, 3, 32, 32)  ✓
(8, 3, 32, 32) + (3,) → error: dim -1 (32 vs 3)  ✓
(2, 1, 5) + (7, 1) → (2, 7, 5)  ✓
(64, 16) + (64, 1) → (64, 16)  ✓

dim, keepdim আর নিঃশব্দ ভুল

Reduction (sum, mean, max) কোন অক্ষ ধরে হবে তা বলে dim; সেই অক্ষ ফল থেকে বাদ যায়, যদি না keepdim=True দেন (NumPy-তে নাম axis আর keepdims; পর্ব ১৬, AI-এর ভিত্তি)। বাজারঘরের চারটি দোকানের পাঁচটি পণ্যের দাম থেকে প্রতিটি দোকানের গড় বিয়োগ করার সত্যিকারের run (script-এর প্রথম অংশ; শেষাংশ অংশ ৬-এ):

import torch
g = torch.Generator().manual_seed(7)

a = torch.ones(3, 1, 4); b = torch.arange(8.0).view(2, 4)
print("(3,1,4) + (2,4) ->", tuple((a + b).shape))
print(torch.broadcast_shapes((3, 1, 4), (2, 4)), torch.broadcast_shapes((5, 1), (1, 6)))
try:
    torch.ones(3, 4) + torch.ones(3)
except RuntimeError as e:
    print("RuntimeError:", e)

# বাজারঘর: ৪টি দোকান, প্রতিটিতে ৫টি পণ্যের দাম (টাকা)
price = torch.randint(50, 500, (4, 5), generator=g).float()
mu = price.mean(dim=1, keepdim=True)              # (4, 1)
print("mean keepdim:", tuple(mu.shape), "| without keepdim:", tuple(price.mean(dim=1).shape))
print("centred row sums ~0:", (price - mu).sum(dim=1).abs().max().item() < 1e-3)
try:
    price - price.mean(dim=1)
except RuntimeError as e:
    print("RuntimeError:", e)
sq = torch.rand(4, 4, generator=g)
silent = sq - sq.mean(dim=1)                      # (4,4)-(4,) চলে, কিন্তু ভুল
right = sq - sq.mean(dim=1, keepdim=True)
print("square case runs, row sums:", silent.sum(dim=1).abs().max().item() > 1e-3,
      "| keepdim row sums ~0:", right.sum(dim=1).abs().max().item() < 1e-5)

~/bazarghar-dl$ uv run python t4_broadcast.py
(3,1,4) + (2,4) -> (3, 2, 4)
torch.Size([3, 2, 4]) torch.Size([5, 6])
RuntimeError: The size of tensor a (4) must match the size of tensor b (3) at non-singleton dimension 1
mean keepdim: (4, 1) | without keepdim: (4,)
centred row sums ~0: True
RuntimeError: The size of tensor a (5) must match the size of tensor b (4) at non-singleton dimension 1
square case runs, row sums: True | keepdim row sums ~0: True
…

(৪, ৫) দামের টেবিলে price - price.mean(dim=1) ভাগ্যক্রমে error দিয়েছে। কিন্তু টেবিলটি বর্গাকার (৪, ৪) হলে একই কোড চলে যায়: (৪,) গড়টি শেষ অক্ষে বসে প্রতিটি কলাম থেকে ভুল দোকানের গড় বিয়োগ হয়, আর সারির যোগফল আর শূন্য থাকে না (“square case runs, row sums: True” মানে যোগফল শূন্য নয়)। keepdim=True দিলে গড় (৪, ১) থাকে, প্রতিটি সারি নিজের গড় পায়। নিয়মটি মনে রাখুন: reduction-এর ফল আবার মূল tensor-এর সঙ্গে মেলাবেন, তাহলে keepdim দিন। torch.broadcast_shapes কোনো ডেটা ছাড়াই ফলের shape বলে দেয়, যা assert লেখার জন্য সুবিধাজনক।

৬ · matmul, batched matmul আর einsum

Matrix গুণের নিয়ম মেশিন লার্নিং কোর্সের পর্ব ৭ আর AI-এর ভিত্তি কোর্সের পর্ব ১৭-এ আছে: (n, k) @ (k, m) = (n, m), ভেতরের দুটি মাপ সমান হতে হবে। Deep learning-এ প্রায় সবসময় আরও অক্ষ থাকে। @ বা torch.matmul-এর নিয়ম: শেষ দুটি অক্ষে matrix গুণ, আগের সব অক্ষ “batch” অক্ষ, আর সেগুলোতে broadcasting. একটি vector (এক অক্ষ) হলে তাকে সাময়িকভাবে matrix ধরা হয়, পরে সেই অক্ষ বাদ যায়।

einsum একই হিসাব অক্ষের নাম দিয়ে লেখে। "btf,fo->bto" পড়ুন এভাবে: প্রথম tensor-এর অক্ষ b, t, f, দ্বিতীয়টির f, o; তীরের ডানে যে অক্ষ নেই (এখানে f), তার ওপর গুণ করে যোগ। নিয়ম দুটি: দুই input-এ একই অক্ষর মানে সেই অক্ষে মিলিয়ে গুণ; output-এ না থাকা অক্ষর মানে সেই অক্ষ ধরে যোগ। নিচের সত্যিকারের run ডেস্কটপে matmul আর einsum একে অপরের সঙ্গে মেলায় (একই t4_broadcast.py-এর শেষ অংশ):

X = torch.randn(32, 10, 16, generator=g)          # batch, token, feature
W = torch.randn(16, 8, generator=g)
B = torch.randn(32, 16, 8, generator=g)
print("X @ W:", tuple((X @ W).shape), "| bmm:", tuple(torch.bmm(X, B).shape))
e1 = torch.einsum("btf,fo->bto", X, W)
e2 = torch.einsum("btf,bfo->bto", X, B)
print("einsum == matmul:", torch.allclose(e1, X @ W, atol=1e-5), torch.allclose(e2, X @ B, atol=1e-5))
att = torch.einsum("bqf,bkf->bqk", X, X)          # প্রতিটি token জোড়ার dot product
print("scores:", tuple(att.shape), torch.allclose(att, X @ X.transpose(1, 2), atol=1e-4))
try:
    X @ torch.randn(10, 8)
except RuntimeError as e:
    print("RuntimeError:", e)

…
X @ W: (32, 10, 8) | bmm: (32, 10, 8)
einsum == matmul: True True
scores: (32, 10, 10) True
RuntimeError: mm: mat1 and mat2 shapes cannot be multiplied (320x16 and 10x8)

তিনটি allclose-ই True: einsum আর matmul একই সংখ্যা দিয়েছে, float32-এর rounding-এর সীমার ভেতরে; তাই তুলনায় == নয়, allclose ব্যবহার করা হয়েছে। "bqf,bkf->bqk" প্রতিটি batch-এ প্রতিটি token জোড়ার dot product, যা পর্ব ৩২ (Attention — query, key, value আর alignment)-এর score-এর হুবহু আকার; transpose-এর বদলে শুধু অক্ষরের ক্রম বদলেছে। শেষ লাইনের error বার্তায় 320 সংখ্যাটি কোথা থেকে এলো, তা অংশ ৮-এর stepper-এ পড়া হবে। পাতায় একই তুলনা NumPy দিয়ে, বাজারঘরের বিক্রির হিসাবে:

import numpy as np
rng = np.random.default_rng(42)

# বাজারঘর: 3টি দোকান × 5 দিন × 4টি পণ্যের বিক্রির সংখ্যা, আর পণ্যের দাম (টাকা)
qty = rng.integers(0, 10, size=(3, 5, 4)).astype(np.float64)
price = np.array([120.0, 45.0, 300.0, 80.0])
r1 = qty @ price                                  # (3,5,4) @ (4,) → (3,5)
r2 = np.einsum("sdp,p->sd", qty, price)           # একই কাজ, নাম দিয়ে লেখা
print("revenue shape:", r1.shape, "| equal:", np.allclose(r1, r2))
print("shop 0, day 0:", qty[0, 0], "·", price, "=", r1[0, 0])
print("per shop total:", np.einsum("sdp,p->s", qty, price))   # d-ও যোগ হলো

X = rng.normal(size=(2, 3, 4))                    # batch, token, feature
W = rng.normal(size=(4, 5))
Wb = rng.normal(size=(2, 4, 5))                   # প্রতিটি batch-এর নিজের matrix
print("X @ W     :", (X @ W).shape, np.allclose(X @ W, np.einsum("btf,fo->bto", X, W)))
print("batched   :", (X @ Wb).shape, np.allclose(X @ Wb, np.einsum("btf,bfo->bto", X, Wb)))
S = np.einsum("bqf,bkf->bqk", X, X)               # token জোড়ার dot product
print("scores    :", S.shape, np.allclose(S, X @ X.transpose(0, 2, 1)))
print("diag = squared norms:", np.allclose(np.einsum("bqq->bq", S), (X ** 2).sum(-1)))
try:
    X @ rng.normal(size=(3, 5))                   # ভেতরের মাপ 4 ≠ 3
except ValueError as e:
    print("ValueError:", e)

revenue shape: (3, 5) | equal: True
shop 0, day 0: [0. 7. 6. 4.] · [120.  45. 300.  80.] = 2435.0
per shop total: [13395. 11870. 13200.]
X @ W     : (2, 3, 5) True
batched   : (2, 3, 5) True
scores    : (2, 3, 3) True
diag = squared norms: True
ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 4)

কখন কোনটি? সাধারণ matrix গুণে @ পড়তে সহজ আর library-র দ্রুততম পথে যায়। অক্ষ বেশি হলে, অথবা transpose আর sum একসঙ্গে লাগলে einsum ভুলের সুযোগ কমায়, কারণ প্রতিটি অক্ষের নাম চোখের সামনে থাকে। PyTorch-এর einsum ভেতরে সাধারণত matmul-এর মতো কাজেই রূপান্তরিত হয়, তবে খুব জটিল সূত্রে গতি সংস্করণভেদে বদলাতে পারে; গতি গুরুত্বপূর্ণ হলে নিজের যন্ত্রে মেপে দেখুন।

৭ · NumPy-র সঙ্গে আদান-প্রদান আর in-place কাজের ফাঁদ

বাস্তব প্রকল্পে ডেটা প্রায়ই pandas বা NumPy থেকে আসে, আর ফল আবার NumPy-তে ফিরে যায়। এখানে তিনটি নিয়ম মনে রাখার মতো, আর একটি ফাঁদ যা পর্ব ০৫-এর autograd-এর সঙ্গে সরাসরি জড়িত: নামের শেষে underscore থাকা কাজ (add_, mul_, zero_) in-place, অর্থাৎ নতুন tensor না বানিয়ে পুরোনোটাই বদলে দেয়।

import numpy as np, torch

arr = np.array([10.0, 20.0, 30.0])                # float64
t = torch.from_numpy(arr)                          # একই memory
arr[0] = -1.0
print("from_numpy sees change:", t, "| dtype", t.dtype)
c = torch.tensor(arr)                              # সবসময় কপি
arr[1] = -2.0
print("torch.tensor copy:", c)
back = t.numpy(); back[2] = 99.0
print("numpy() shares too:", arr)
print("item():", t.sum().item(), type(t.sum().item()).__name__)

w = torch.tensor([1.0, 2.0], requires_grad=True)
try:
    w.numpy()
except RuntimeError as e:
    print("RuntimeError:", e)
print("detach().numpy():", w.detach().numpy())

x = torch.tensor([1.0, 2.0, 3.0])
x.add_(1); x.mul_(2)                               # trailing underscore = in-place
print("in-place:", x)
w = torch.tensor([0.5, -1.0, 2.0], requires_grad=True)
try:
    w.add_(1)
except RuntimeError as e:
    print("RuntimeError:", e)
w = torch.tensor([0.5, -1.0, 2.0], requires_grad=True)
y = torch.sigmoid(w)                               # backward-এ y-এর মান লাগে
y.mul_(2)                                          # y বদলে গেল
try:
    y.sum().backward()
except RuntimeError as e:
    print("RuntimeError:", str(e)[:150], "…")
w = torch.tensor([0.5, -1.0, 2.0], requires_grad=True)
y = torch.sigmoid(w) * 2                           # out-of-place: নতুন tensor
y.sum().backward()
print("grad ok:", w.grad)
with torch.no_grad():
    w -= 0.1 * w.grad                              # parameter আপডেট: no_grad-এর ভেতরে
print("updated w:", w)

সত্যিকারের run:

~/bazarghar-dl$ uv run python t5_interop.py
from_numpy sees change: tensor([-1., 20., 30.], dtype=torch.float64) | dtype torch.float64
torch.tensor copy: tensor([-1., 20., 30.], dtype=torch.float64)
numpy() shares too: [-1. -2. 99.]
item(): 96.0 float
RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.
detach().numpy(): [1. 2.]
in-place: tensor([4., 6., 8.])
RuntimeError: a leaf Variable that requires grad is being used in an in-place operation.
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [3]], which is output 0 of Sigmoid, …
grad ok: tensor([0.4700, 0.3932, 0.2100])
updated w: tensor([ 0.4530, -1.0393,  1.9790], requires_grad=True)

Memory ভাগ: from_numpy কপি করে না; arr বদলাতেই t বদলেছে। torch.tensor(arr) সবসময় কপি করে, তাই পরের বদল (−২) c-তে নেই। উল্টো দিকে CPU-র tensor-এর .numpy()-ও একই memory দেয়: back[২] = ৯৯ লিখতেই arr বদলেছে। ফলে item() দিয়েছে −১ − ২ + ৯৯ = ৯৬, একটি সাধারণ Python float; loss বা accuracy লগ করার সময় এটিই ব্যবহার করুন, কারণ পুরো tensor রেখে দিলে তার সঙ্গে graph-ও memory-তে থেকে যেতে পারে। GPU-র tensor-এ .numpy() চলে না; আগে .cpu() লাগে।

Autograd আর in-place: gradient রাখা tensor-কে NumPy-তে নিতে আগে detach() লাগে, কারণ NumPy graph চেনে না। দ্বিতীয় error-টি সহজ: যে leaf tensor-এর gradient চাওয়া হয়েছে, তাকে graph-এর বাইরে চুপচাপ বদলানো যায় না। তৃতীয়টি গভীর: sigmoid-এর backward-এ লাগে তার output y, কারণ σ′ = σ(১ − σ). y-কে in-place দ্বিগুণ করায় সেই মান নষ্ট, তাই backward থেমে গেছে। PyTorch এটি ধরে প্রতিটি tensor-এর একটি সংস্করণ-গণনা (version counter) দিয়ে: graph-এ মান রাখার সময়ের সংস্করণ আর backward-এর সময়ের সংস্করণ না মিললে error. সমাধান out-of-place লেখা: y = torch.sigmoid(w) * 2; gradient ২σ(১ − σ), যেমন w = ০.৫-এ ০.৪৭০০. Parameter আপডেট নিজেই in-place, তাই তা torch.no_grad()-এর ভেতরে; পর্ব ০৮ (PyTorch autograd — requires_grad, backward আর gradient-এর ফাঁদ) এই ফাঁদগুলো আরও গভীরে দেখাবে।

৮ · Shape error পড়া আর ডিবাগ করার চেকলিস্ট

Shape error ভয়ের কিছু নয়; বার্তাটিতে সাধারণত উত্তরের অর্ধেক লেখা থাকে। নিচের stepper অংশ ৬-এর সত্যিকারের error ধরে একে একে পড়ে: একটি (৩২, ১০, ১৬) tensor-কে (১০, ৮) weight দিয়ে গুণ করার চেষ্টা।

PyTorch-এর অন্য পরিচিত বার্তাগুলোও একইভাবে পড়া যায়। “The size of tensor a (4) must match the size of tensor b (3) at non-singleton dimension 1” মানে broadcasting-এ অক্ষ ১-এ ৪ আর ৩ মেলেনি, আর কোনোটিই ১ নয় (singleton মানে মাপ ১)। “Expected all tensors to be on the same device” মানে device-এর অমিল, আর “expected … Float but found Double” বা “must have the same dtype” dtype-এর অমিল।

৯ · AI-এর যুগে — AI-এর লেখা tensor কোড যাচাই

AI assistant tensor-এর কোড খুব দ্রুত লেখে, কিন্তু এই পর্বের ভুলগুলো তার জন্যও সবচেয়ে সাধারণ: ভুল dim, ভুলে যাওয়া keepdim, permute-এর পর view, dtype-এর অমিল। এদের অনেকগুলো error দেয় না, শুধু ভুল সংখ্যা দেয়। AI-এর লেখা কোড পড়ার সময় নিচের ধাঁচগুলো খুঁজুন।

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

• সব অক্ষের মাপ আলাদা এমন একটি ছোট tensor-এ চালিয়ে প্রতিটি লাইনের shape ছেপে দেখেছি
• প্রতিটি reduction-এর dim আর keepdim নিজে broadcasting-এর নিয়মে মিলিয়েছি
• permute, transpose আর reshape-এর পর একটি নির্দিষ্ট ঘরের মান মূল tensor-এর সঙ্গে মিলিয়েছি
• dtype আর device ছেপে দেখেছি, NumPy থেকে আসা ডেটায় float64 নেই
• matmul বা einsum-এর ফল অন্য পথে (লুপ বা NumPy) হিসাব করে allclose দিয়ে মিলিয়েছি
• function-এর নাম আর আর্গুমেন্ট নিজের PyTorch সংস্করণের docs-এ খুঁজে পেয়েছি
• কোনো আসল গ্রাহকের ডেটা বা key AI-তে পেস্ট করিনি; উদাহরণে বানানো ছোট ডেটা দিয়েছি