Sequence-এর জন্য 1D convolution আর time series-এ deep learning

এই মডিউলের আগের পর্বগুলোতে (পর্ব ২৮ Recurrent neural network, পর্ব ২৯ LSTM আর GRU, পর্ব ৩০ Seq2seq) sequence পড়া হয়েছে এক ধাপ করে, একটি hidden state হাতে নিয়ে। এই পর্ব অন্য পথ দেখায়: পর্ব ২০-এর convolution-কে এক মাত্রায় নামানো। ছবির জানালা এবার সময়ের জানালা। প্রশ্ন দুটি: জানালা ভবিষ্যৎ দেখছে না তো? আর এত কিছুর পরে deep model আসলে সরল পদ্ধতিকে হারায় কি? পাতার চারটি ব্লক ব্রাউজারের Python আর NumPy-তে চলে; প্রথমবার প্যাকেজ নামতে কয়েক সেকেন্ড লাগে। PyTorch-এর সব আউটপুট ডেস্কটপের সত্যিকারের run থেকে, CPU-তে।

১ · Sequence-এ জানালা — 1D convolution

ছবিতে kernel দুই অক্ষে সরত। Sequence-এ সরে একটিতে: সময়। Input-এর shape (N, C, T): N-টি উদাহরণ, প্রতিটি সময়ে C-টি channel, T-টি সময়-ধাপ। বাজারঘরে C হতে পারে আজকের অর্ডার, সপ্তাহের বার আর ঈদের দূরত্ব; টেক্সটে C হলো embedding-এর মাত্রা। একটি স্তরের weight-এর shape (O, C, k), যেখানে O output channel আর k kernel-এর দৈর্ঘ্য। তাই:

parameter = O · C · k + O  ·  T_out = ⌊(T + 2p − d(k − 1) − 1)/s⌋ + 1

দ্বিতীয়টি পর্ব ২০-এর সূত্রই, এক অক্ষে। nn.Conv1d(10, 32, 3)-এ ৩২ × ১০ × ৩ + ৩২ = ৯৯২টি parameter. হাতে একটি ছোট হিসাব: x = [2, 4, 6, 8, 10] আর kernel [1, 0, −1], padding ছাড়া। প্রথম জানালা [2, 4, 6] দেয় ১·২ + ০·৪ − ১·৬ = −৪; দ্বিতীয় আর তৃতীয়ও −৪. Output-এ ৫ − ৩ + ১ = ৩টি সংখ্যা। ধীরে বাড়তে থাকা অর্ডারের ওপর এই kernel স্থির −৪ দেয়, অর্থাৎ এটি একটি trend-খোঁজা filter. CNN-এ এমন filter কেউ হাতে বসায় না; backpropagation ডেটা থেকে শেখে। একটি সতর্কতা: PyTorch-এর nn.LSTM(batch_first=True) নেয় (N, T, C), আর nn.Conv1d নেয় (N, C, T). দুটি পাশাপাশি লিখলে transpose(1, 2) লাগে; ভুল অক্ষ অনেক সময় ক্র্যাশও করে না। Windowing আর padding-এর ভিত্তি পর্ব ২৭ (Sequence ডেটা) আর পর্ব ১১-এ।

২ · Causal convolution — জানালা যেন ভবিষ্যৎ না দেখে

ছবিতে ডান পাশ দেখায় কোনো দোষ নেই। সময়ে আছে। মঙ্গলবারের অনুমান করতে বুধবারের অর্ডার দেখলে মডেল আসলে উত্তরপত্র দেখছে। যে convolution-এর output y[t] শুধু x[t] আর তার আগের মান দিয়ে তৈরি, তাকে বলে causal convolution. উপায় একটাই: kernel-এর পুরো চওড়া, (k − 1)·d ঘর, শুধু বাঁয়ে শূন্য বসানো।

চোখে না দেখে পরীক্ষা করবেন কীভাবে? Impulse test: সব শূন্য, শুধু এক দিনে ১. Causal হলে সেই দিনের আগে কোনো output নড়বে না। দ্বিতীয় পরীক্ষা: ভবিষ্যতের মান বদলে দেখা, অতীতের output বদলায় কি না। দুটিই নিচে, হাতে লেখা convolution-এ।

import numpy as np
np.set_printoptions(precision=2, suppress=True, linewidth=72)

def conv1d(x, w, d=1, left=0, right=0):
    """x (T,), w (k,). দুই পাশে শূন্য বসিয়ে, dilation-সহ জানালা চালানো।"""
    xp = np.r_[np.zeros(left), x, np.zeros(right)]
    idx = d * np.arange(len(w))                # kernel-এর ঘরগুলোর দূরত্ব
    T_out = len(xp) - idx[-1]
    return np.array([w @ xp[t + idx] for t in range(T_out)])

w = np.array([0.2, 0.3, 0.5])                  # শেষ ঘর জানালার সবচেয়ে নতুন দিনে
imp = np.zeros(12); imp[5] = 1.0               # t = 5-এ একটি ধাক্কা
causal = conv1d(imp, w, left=2)                # (k-1)d = 2, সবটা বাঁয়ে
centred = conv1d(imp, w, left=1, right=1)      # দুই পাশে 1: আকার একই
print("impulse", imp)
print("causal ", causal)
print("centred", centred)
print("first nonzero t: causal", np.flatnonzero(causal)[0],
      "| centred", np.flatnonzero(centred)[0])

rng = np.random.default_rng(31)                # ভবিষ্যৎ বদলালে অতীতের output বদলায়?
x = rng.poisson(200, 16).astype(float)
x2 = x.copy(); x2[9:] += 50                    # শুধু t >= 9 বদলানো হলো
for name, kw in [("causal", dict(left=2)), ("centred", dict(left=1, right=1))]:
    a, b = conv1d(x, w, **kw), conv1d(x2, w, **kw)
    print(f"{name:8s} first changed output at t =", np.flatnonzero(a != b)[0])

imp2 = np.zeros(21); imp2[10] = 1.0
y = conv1d(imp2, w, d=4, left=8)               # k = 3, d = 4: বাঁয়ে 8
print("d = 4, left pad 8: length", len(y), "| nonzero at", np.flatnonzero(y))

impulse [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
causal  [0.  0.  0.  0.  0.  0.5 0.3 0.2 0.  0.  0.  0. ]
centred [0.  0.  0.  0.  0.5 0.3 0.2 0.  0.  0.  0.  0. ]
first nonzero t: causal 5 | centred 4
causal   first changed output at t = 9
centred  first changed output at t = 8
d = 4, left pad 8: length 21 | nonzero at [10 14 18]

এবার PyTorch. একই NumPy হিসাব nn.Conv1d-এর সঙ্গে মেলানো, তারপর padding-এর চারটি লেখার ধরন, আর শেষে আসল ক্ষতি: তিন স্তরের একই ছোট network, শুধু padding আলাদা, বাজারঘরের ছয় জেলার series-এ এক দিন সামনের অনুমান। সত্যিকারের run (ডেস্কটপ, CPU-তে; লেখার সময়ের সংস্করণ: Python 3.14.4, torch 2.15.0, numpy 2.5.4):

~/bazarghar-dl$ uv run python conv1d_check.py
torch 2.15.0+cpu
weight (4, 2, 3) | bias (4,) | params 28
left pad 8: output (1, 4, 20) | max |torch - numpy| = 1.2e-07
impulse at t=10, k=3, d=4
  F.pad left 8        len 21 nonzero at [10, 14, 18]
  padding=8           len 29 nonzero at [10, 14, 18]
  padding=8 + chomp 8 len 21 nonzero at [10, 14, 18]
  padding='same'      len 21 nonzero at [6, 10, 14]
one-step MASE on the last 112 days, padding=causal: 0.949
one-step MASE on the last 112 days, padding=same  : 0.060
one-step seasonal naive MASE: 1.626

পড়ুন: weight (4, 2, 3): ৪ output, ২ channel, k = ৩; NumPy-র সঙ্গে পার্থক্য শুধু float32-এর গোলের ঘরে। padding=8 দুই পাশেই বসায়, তাই দৈর্ঘ্য ২৯; ডানের ৮ ঘর কেটে দিলে (এই কাটার নাম chomp) তবেই causal, যা F.pad সরাসরি দেয়। padding="same" সাড়া শুরু করে t = ৬-এ, ধাক্কার চার দিন আগে। শেষ তিন লাইন আসল শিক্ষা: leak-যুক্ত model-এর MASE ০.০৬০, যেন প্রায় নির্ভুল। কারণ এক ধাপ সামনের target-টিই তার input-এ আছে। Backtest-এ এই ফাঁস ধরা পড়ে না, কারণ সেখানে “ভবিষ্যৎ” ফাইলেই আছে; production-এ আগামীকালের মান থাকে না, আর model ভেঙে পড়ে। অবিশ্বাস্য ভালো ফল দেখলে আগে leakage খুঁজুন (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)।

৩ · Dilation — অল্প স্তরে লম্বা দৃষ্টি

Dilation ছাড়া k = ৩-এর প্রতিটি স্তর receptive field-এ ২ যোগ করে। ৫৬ দিন দেখতে ২৮টি স্তর লাগত। পর্ব ২০-এর dilation-এ kernel-এর ঘরগুলোর মাঝে ফাঁক থাকে, আর স্তরের পর স্তরে d দ্বিগুণ করলে দৃষ্টিও প্রায় দ্বিগুণ হয়। সেই পর্বের সূত্রে stride ১ হলে jump ১ থাকে, আর ফাঁকটি (k − 1)-এর সঙ্গে গুণ হয়:

r = 1 + (k − 1) · ∑ d_i   (d_i = i-তম স্তরের dilation)

সূত্র নিজে না মেনে মেপে দেখা যাক। নিচের ব্লক একটি impulse পাঠায় পুরো stack-এর মধ্যে (np.convolve শুধু অতীত থেকে নেয়, তাই causal), আর গোনে কত দিন আগের মান শেষ output-এ পৌঁছায়।

import numpy as np
import matplotlib.pyplot as plt

def offsets(dils, k=3):                 # impulse পাঠিয়ে মাপা: কত দিন আগের মান পৌঁছায়
    x = np.zeros(200); x[0] = 1.0
    for d in dils:
        kern = np.zeros(d * (k - 1) + 1); kern[::d] = 1.0
        x = np.convolve(x, kern)[:len(x)]   # সবটা অতীত থেকে: causal
    return np.flatnonzero(x)

def r_formula(dils, k=3):
    return 1 + sum((k - 1) * d for d in dils)

print("stack               k   r  measured  inputs seen")
cases = [("plain 1,1,1,1", [1] * 4, 3), ("dilated 1,2,4,8", [1, 2, 4, 8], 3),
         ("two conv per block", [1, 1, 2, 2, 4, 4, 8, 8], 3),
         ("same d 2,2,2,2", [2] * 4, 3), ("k=2, 1,2,4,8", [1, 2, 4, 8], 2)]
for name, dils, k in cases:
    o = offsets(dils, k)
    print(f"{name:18s} {k:2d} {r_formula(dils, k):3d} {o.max() + 1:7d} {len(o):9d}")
print("same d sees offsets:", offsets([2] * 4)[:6], "... only even days")

layers = np.arange(1, 11)
plain = 1 + 2 * layers                  # d = 1 সব স্তরে
dilated = 2 ** (layers + 1) - 1         # d = 1, 2, 4, ...
for days in (56, 365):
    print(f"layers to cover {days} days: dilated", layers[dilated >= days][0],
          "| plain", int(np.ceil((days - 1) / 2)))
fig, ax = plt.subplots(figsize=(6, 3))
ax.semilogy(layers, dilated, "o-", label="dilated, d = 1, 2, 4, ...")
ax.semilogy(layers, plain, "s-", label="plain, d = 1")
ax.axhline(56, color="gray", ls="--", label="56-day lookback")
ax.set(xlabel="layers (k = 3)", ylabel="receptive field (days)")
ax.legend(fontsize=8)
plt.show()

stack               k   r  measured  inputs seen
plain 1,1,1,1       3   9       9         9
dilated 1,2,4,8     3  31      31        31
two conv per block  3  61      61        61
same d 2,2,2,2      3  17      17         9
k=2, 1,2,4,8        2  16      16        16
same d sees offsets: [ 0  2  4  6  8 10] ... only even days
layers to cover 56 days: dilated 5 | plain 28
layers to cover 365 days: dilated 8 | plain 182

৪ · TCN — causal, dilated আর residual একসঙ্গে

“Temporal convolutional network” বা TCN নামটি ছড়ায় Bai, Kolter আর Koltun-এর ২০১৮ সালের একটি প্রবন্ধে। তাঁদের বর্ণনায় এটি কোনো একক আবিষ্কার নয়, পুরোনো উপাদানের একটি সরল জোড়া: causal আর dilated convolution, পর্ব ১৭-এর residual connection, প্রতি স্তরে dropout আর weight normalization (পর্ব ১৪-এর normalization পরিবারের একটি)। আমাদের সংস্করণে weight normalization বাদ, কোড ছোট রাখতে।

Residual কেন? একটি block এমনিতেই y + x শেখে: কিছু শেখার না থাকলে y শূন্যের কাছে থাকলেই চলে, আর x অক্ষত যায়। আট স্তরের convolution-এ gradient-ও এই সোজা পথে সহজে ফেরে। লক্ষ করুন, এখানে “গভীরতা” T-এর ওপর নির্ভর করে না; ৫৬ দিন হোক বা ৫০০, gradient-এর পথের দৈর্ঘ্য স্তরের সংখ্যায় বাঁধা। RNN-এর backpropagation through time-এর সঙ্গে এখানেই বড় তফাত।

নিচে এই পুরো forward pass NumPy-তে। শেখানো হচ্ছে না, weight এলোমেলো; লক্ষ্য shape আর causal গুণ যাচাই। einsum-এর অক্ষরগুলো: output channel o, input channel c, batch n, সময় t.

import numpy as np
rng = np.random.default_rng(31)
relu = lambda a: np.maximum(a, 0)
def causal(x, W, b, d):                  # x (N, C, T), W (O, C, k), b (O,)
    k, T = W.shape[2], x.shape[2]
    xp = np.pad(x, ((0, 0), (0, 0), ((k - 1) * d, 0)))
    y = sum(np.einsum("oc,nct->not", W[:, :, i], xp[:, :, i * d:i * d + T]) for i in range(k))
    return y + b[None, :, None]

def layer(c_in, c_out, k=3):             # এলোমেলো weight আর শূন্য bias
    return rng.normal(0, 0.5 / np.sqrt(c_in * k), (c_out, c_in, k)), np.zeros(c_out)

blocks = [(d, layer(10 if d == 1 else 32, 32), layer(32, 32),
           layer(10, 32, k=1) if d == 1 else None) for d in (1, 2, 4, 8)]

def tcn(x, trace=False):
    for d, l1, l2, skip in blocks:
        y = relu(causal(relu(causal(x, *l1, d)), *l2, d))   # দুটি causal conv
        x = relu(y + (causal(x, *skip, 1) if skip else x))  # residual connection
        if trace: print(f"block d={d}: {x.shape}")
    return x

x = rng.normal(size=(2, 10, 56))         # (batch, channels, time): 2টি জানালা, 56 দিন
print("input:", x.shape)
out = tcn(x, trace=True)
h = out[:, :, -1]                        # শুধু শেষ দিনের সারাংশ
fut = rng.normal(size=(2, 28, 10))       # আগামী 28 দিনের জানা ক্যালেন্ডার
hf = np.concatenate([np.repeat(h[:, None], 28, axis=1), fut], axis=2)
A, B = rng.normal(0, 0.1, (42, 64)), rng.normal(0, 0.1, (64, 1))
yhat = (relu(hf @ A) @ B)[:, :, 0]       # প্রতিটি দিনের জন্য একই ছোট MLP
print("h:", h.shape, "| h + future:", hf.shape, "| forecast:", yhat.shape)
x2 = x.copy(); x2[:, :, 40:] += 1.0      # 40 নম্বর দিন থেকে বদলানো
o2 = tcn(x2)
print("t < 40 unchanged:", np.array_equal(out[:, :, :40], o2[:, :, :40]),
      "| t = 55 changed:", not np.allclose(out[:, :, 55], o2[:, :, 55]))

input: (2, 10, 56)
block d=1: (2, 32, 56)
block d=2: (2, 32, 56)
block d=4: (2, 32, 56)
block d=8: (2, 32, 56)
h: (2, 32) | h + future: (2, 28, 42) | forecast: (2, 28)
t < 40 unchanged: True | t = 55 changed: True

PyTorch-এ একই জিনিস অল্প কোডে (ডেস্কটপ run-এর কোড, এখানে শুধু নামগুলো একটু পরিষ্কার করে):

class CausalConv(nn.Module):
    def __init__(self, c_in, c_out, k, d):
        super().__init__()
        self.pad = (k - 1) * d
        self.conv = nn.Conv1d(c_in, c_out, k, dilation=d)
    def forward(self, x):
        return self.conv(F.pad(x, (self.pad, 0)))     # শুধু বাঁয়ে

class Block(nn.Module):
    def __init__(self, c_in, c, k, d, p=0.1):
        super().__init__()
        self.c1, self.c2 = CausalConv(c_in, c, k, d), CausalConv(c, c, k, d)
        self.drop = nn.Dropout(p)
        self.skip = nn.Conv1d(c_in, c, 1) if c_in != c else nn.Identity()
    def forward(self, x):
        y = self.drop(F.relu(self.c1(x)))
        y = self.drop(F.relu(self.c2(y)))
        return F.relu(y + self.skip(x))

৫ · কয়েক দিন সামনে — multi-horizon output

গুদামের লোক শুধু আগামীকাল জানতে চান না, আগামী ২৮ দিন চান। মেশিন লার্নিং কোর্সের পর্ব ৫২ দুটি পথ দেখিয়েছে: recursive (আগামীকালের অনুমানকে input বানিয়ে পরের দিন) আর direct (প্রতিটি দিনের জন্য সরাসরি অনুমান)। Neural network-এ তৃতীয় একটি স্বাভাবিক পথ আছে: একসঙ্গে সব দিন।

আমরা শেষেরটি নিই, ছবি ৩১.১-এর মতো। এই ধাঁচ forecasting-এর গবেষণায় পরিচিত; MQ-RNN (Wen ও সহকর্মী, ২০১৭)-এর মতো কাজে এমন “প্রতি দিনের decoder” পাওয়া যায়। আরও তিনটি সিদ্ধান্ত: (১) log1p নিয়ে প্রতিটি জানালা থেকে তার ৫৬ দিনের গড় বিয়োগ, যাতে ঢাকার কয়েকশো আর বরিশালের কয়েক ডজন অর্ডার একই আকারে আসে আর ধীর বৃদ্ধি সমস্যা না করে; পরিসংখ্যান শুধু জানালার ভেতরের, তাই ফাঁস নেই। (২) Loss L1 (পর্ব ১৩), কারণ metric-ও absolute error. (৩) সব জেলার জানালা একসঙ্গে: global model, মেশিন লার্নিং কোর্সের পর্ব ৫২-এর মতো।

৬ · আগে baseline — seasonal naive আর MASE

Backtest আর metric নতুন করে শেখানো হবে না। Rolling-origin backtest-এর জন্য মেশিন লার্নিং কোর্সের পর্ব ৫২, আর MASE ও baseline-এর জন্য পর্ব ৫১ দেখুন। এক লাইনে: origin পর্যন্ত জানা ডেটায় শিখে পরের ২৮ দিন অনুমান, তারপর origin সামনে সরিয়ে আবার। MASE = test-এর MAE ÷ training-এ এক-ধাপ seasonal naive-এর MAE; ধরুন test-এর MAE ১৬ আর scale ২০, তাহলে MASE ০.৮. ডেটাও মেশিন লার্নিং কোর্সের পর্ব ৫২-এর: একই seed, ছয় জেলার ৭৩০ দিনের কাল্পনিক অর্ডার, তাই সেখানকার টেবিল চেনা লাগবে। নিচের ব্লকে baseline দুটি। এদের কোনো শেখা নেই, তাই আপনার ব্রাউজারেই ডেস্কটপের সংখ্যা হুবহু আসবে।

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from bazar_orders import make_orders, DISTRICTS
wide = make_orders().pivot(index="date", columns="district", values="orders")[DISTRICTS]
dates, Y = wide.index, wide.to_numpy(dtype=float)
T, H = Y.shape[0], 28
origins = [T - H * (4 - i) for i in range(4)]        # চারটি origin, প্রতিটি 28 দিনের test

def mase(pred, o):                                   # scale শুধু origin-এর আগের ডেটায়
    scale = np.abs(Y[7:o] - Y[:o - 7]).mean(axis=0)
    return np.abs(pred - Y[o:o + H]).mean(axis=0) / scale

def seasonal_naive(o):
    return Y[o - 7:o][np.arange(H) % 7]              # গত সপ্তাহটি বারবার

def naive(o):
    return np.tile(Y[o - 1], (H, 1))                 # গতকালের মান বারবার

print(wide.shape, "| districts:", len(DISTRICTS))
print("first day    naive  s-naive  s-naive by district")
sn, nv = [], []
for o in origins:
    m = mase(seasonal_naive(o), o); sn.append(m.mean()); nv.append(mase(naive(o), o).mean())
    print(dates[o].date(), f"{nv[-1]:6.3f} {sn[-1]:7.3f} ", m.round(2))
print(f"mean of folds: naive {np.mean(nv):.3f} | seasonal naive {np.mean(sn):.3f}")

o = origins[0]
fig, ax = plt.subplots(figsize=(6.4, 2.8))
ax.plot(dates[o - 21:o + H], Y[o - 21:o + H, 0], label="Dhaka actual")
ax.plot(dates[o:o + H], seasonal_naive(o)[:, 0], "--", label="seasonal naive")
ax.axvline(dates[o], color="gray", lw=1)
ax.set(ylabel="orders per day", title="Fold 1: the forecast repeats a week, Eid does not")
ax.tick_params(axis="x", labelsize=7); ax.legend(fontsize=8)
plt.show()

(730, 6) | districts: 6
first day    naive  s-naive  s-naive by district
2026-03-11  1.588   1.604  [1.61 1.69 2.13 1.38 1.45 1.36]
2026-04-08  0.854   0.902  [1.15 0.72 0.92 0.71 0.85 1.06]
2026-05-06  1.807   1.724  [2.32 1.84 1.27 2.2  1.25 1.45]
2026-06-03  1.143   1.797  [2.2  1.5  1.59 2.07 1.43 2.  ]
mean of folds: naive 1.348 | seasonal naive 1.507

৭ · মুখোমুখি — TCN, LSTM, boosting আর baseline

চারটি পদ্ধতি, একই চার fold, একই MASE. নিয়মগুলো আগে থেকে ঠিক করা:

• TCN: ৪ block, ৩২ channel, k = ৩, d = 1, 2, 4, 8 (r = ৬১). LSTM: এক স্তর, ৩২ hidden (পর্ব ২৯). দুটিরই input একই ৫৬ দিন × ১০ channel, একই head.
• HistGradientBoosting: পর্ব ৫২-এর ধাঁচে, একটি direct global model; lag ১, ২, ৩, ৭, ১৪, ২১, ২৮, ৭ আর ২৮ দিনের গড়, জেলা, h, লক্ষ্য দিনের বার আর ঈদের দূরত্ব। একই log-স্কেল, একই absolute-error loss, ৩০০ iteration, কোনো tuning নয়।
• শেখানো: AdamW, one-cycle schedule (পর্ব ১৫), gradient clipping. প্রতিটি target origin-এর আগে শেষ। Epoch-এর সংখ্যা (৫) বেছে নেওয়া হয়েছে প্রথম fold-এর আগের দুটি origin-এ, test fold ছুঁয়ে নয়। প্রতিটি fold-এ নতুন করে শেখানো, ৩টি seed.

সত্যিকারের run (ডেস্কটপ, CPU-তে ৪টি thread; একটি local run):

~/bazarghar-dl$ uv run python backtest.py
Python 3.14.4 | torch 2.15.0+cpu | numpy 2.5.4 | pandas 3.1.1
scikit-learn 1.9.1 | CPU, 4 threads
series (730, 6) | lookback 56 | horizon 28 | folds 4 | seeds [0, 1, 2]
fold first days: ['2026-03-11', '2026-04-08', '2026-05-06', '2026-06-03']
params TCN 25889 | LSTM 8449
  HistGB + lags seed 0: [1.151 0.854 0.959 0.732] mean 0.924
  HistGB + lags seed 1: [1.195 0.868 0.956 0.723] mean 0.935
  HistGB + lags seed 2: [1.197 0.866 0.943 0.71 ] mean 0.929
  LSTM seed 0: [1.179 0.843 1.242 0.67 ] mean 0.983
  LSTM seed 1: [1.344 0.841 1.45  0.684] mean 1.080
  LSTM seed 2: [1.14  0.843 1.227 0.683] mean 0.973
  TCN seed 0: [1.229 0.854 1.302 0.648] mean 1.008
  TCN seed 1: [1.195 0.852 1.275 0.668] mean 0.997
  TCN seed 2: [1.3   0.849 1.373 0.66 ] mean 1.046

model            fold1  fold2  fold3  fold4   MASE seed-sd  s/fold
seasonal naive   1.604  0.902  1.724  1.797  1.507   0.000    0.00
HistGB + lags    1.181  0.863  0.953  0.721  0.929   0.006    2.35
LSTM             1.221  0.842  1.307  0.679  1.012   0.059    1.82
TCN              1.241  0.852  1.316  0.659  1.017   0.025    6.92
MASE by forecast week (mean of folds and seeds):
  seasonal naive   1.304  1.831  1.630  1.263
  HistGB + lags    0.844  1.198  0.905  0.771
  LSTM             0.890  1.255  1.085  0.818
  TCN              0.865  1.296  1.066  0.840

কে জিতল. এই run-এ HistGradientBoosting: MASE ০.৯২৯, LSTM ১.০১২, TCN ১.০১৭. সবাই seasonal naive-এর ১.৫০৭-কে অনেক ব্যবধানে হারিয়েছে। TCN আর LSTM-এর ০.০০৫ পার্থক্য seed-এর ওঠানামার (০.০২৫, ০.০৫৯) চেয়ে অনেক ছোট, তাই এদের মধ্যে কোনো বিজয়ী ঘোষণা করা যায় না।

Fold ধরে দেখলে ছবিটা অন্য রকম. শান্ত fold ৪-এ TCN (০.৬৫৯) আর LSTM (০.৬৭৯), boosting-এর (০.৭২১) চেয়ে ভালো; fold ২-এ তিনটি প্রায় সমান। পুরো পার্থক্যটি এসেছে ঈদের fold ৩ থেকে: boosting ০.৯৫৩, deep model দুটি প্রায় ১.৩১. এর একটি সম্ভাব্য ব্যাখ্যা: ইতিহাসে ঈদ এসেছে মাত্র তিনবার। Tree এত অল্প উদাহরণেও “ঈদের দুদিনের মধ্যে” একটি তীক্ষ্ণ split বানাতে পারে, আর ৫ epoch-এর একটি মসৃণ network সেই খাড়া পতন কম শেখে। এই ব্যাখ্যা এখানে পরীক্ষা করা হয়নি; ঈদের feature বদলে বা বেশি tuning করে ফল বদলাতে পারে।

সপ্তাহ ধরে পড়ুন. সাধারণত ভাবা হয়, যত দূরের দিন তত বেশি ভুল। শেষের টেবিল তা বলছে না: boosting-এর চার সপ্তাহের MASE ০.৮৪৪, ১.১৯৮, ০.৯০৫, ০.৭৭১. দ্বিতীয় সপ্তাহ সবার জন্য কঠিন, কারণ প্রথম fold-এর ঈদ ঠিক সেখানে পড়ে। তৃতীয় সপ্তাহে deep model দুটি (প্রায় ১.০৭–১.০৯) boosting-এর চেয়ে বেশি পিছিয়ে, কারণ সেখানে তৃতীয় fold-এর ঈদের আগের ভিড় পড়ে। অর্থাৎ এই ডেটায় ক্যালেন্ডারের ঘটনা দূরত্বের চেয়ে বেশি প্রভাব ফেলছে। শুধু গড় MASE দেখলে এই তথ্য হারিয়ে যেত; তাই ভুলকে fold, সপ্তাহ আর জেলা ধরে ভেঙে দেখা অভ্যাস করুন।

সময়. প্রতি fold-এ LSTM ১.৮২ সেকেন্ড, boosting ২.৩৫, TCN ৬.৯২. “Convolution সমান্তরাল, তাই RNN-এর চেয়ে দ্রুত” কথাটি এখানে মেলেনি: এই ছোট আকারে, CPU-তে, TCN সবচেয়ে ধীর, আর তার parameter-ও (২৫,৮৮৯) LSTM-এর (৮,৪৪৯) তিন গুণ। লম্বা sequence আর GPU-তে অনুপাত আলাদা হতে পারে। দাবি নয়, মাপুন।

৮ · Boosting না deep model — তিনটি ক্ষেত্রে সিদ্ধান্ত

কোনো সূত্র নেই, তবে চারটি প্রশ্ন আছে। নিচের তিনটি ক্ষেত্রই কাল্পনিক; সিদ্ধান্তগুলো শুরুর অনুমান, চূড়ান্ত রায় নয়।

নতুন forecasting model-এর নাম শুনলে. N-BEATS (Oreshkin ও সহকর্মী, ২০১৯–২০) শুধু fully connected স্তরের গভীর residual stack. Temporal Fusion Transformer (Lim ও সহকর্মী, ২০১৯–২১) জানা ভবিষ্যৎ আর স্থির feature আলাদা করে নেয়, আর attention যোগ করে। PatchTST (Nie ও সহকর্মী, ২০২৩) series-কে টুকরো করে Transformer-এ দেয় (Transformer আসছে পর্ব ৩৫-এ)। অন্যদিকে Zeng ও সহকর্মীদের ২০২৩ সালের প্রবন্ধ দেখায়, কিছু benchmark-এ একটি খুব সরল linear model অনেক Transformer-কে হারিয়েছে, আর এই বিতর্ক এখনো চলছে। এদের নিজ নিজ প্রবন্ধের স্কোর নিজের ডেটায় খাটবে এমন ধরে নেবেন না; সবাইকে একই backtest-এ আনুন।

৯ · টেক্সটে 1D CNN — “ভালো না” ধরা

টেক্সটও একটি sequence. শব্দগুলো embedding হয়ে (N, E, T), আর E-টি মাত্রা হয় channel. Kim-এর ২০১৪ সালের প্রবন্ধ এই রূপটি জনপ্রিয় করে: k = ৩, ৪, ৫-এর মতো কয়েক দৈর্ঘ্যের filter, তারপর প্রতিটি filter-এ সময় ধরে max, শেষে linear স্তর। k = ২-এর একটি filter একটি দুই-শব্দের নকশা খোঁজে, আর max বলে “নকশাটি কোথাও আছে কি না”। তাই “ভালো না” বাক্যের যেখানেই থাকুক, ধরা পড়ে। এখানে causal হওয়ার দরকার নেই: পুরো বাক্যটি আগেই হাতে আছে।

ডেটা আবার কাল্পনিক ও সাজানো: বিষয় + বিশেষণ, চার ধরনে (“পণ্য ভালো”, “পণ্য ভালো না”, “পণ্য ভালো একদম না”, “না পণ্য ভালো”), মাঝে এলোমেলো অপ্রাসঙ্গিক শব্দ। পরীক্ষা কঠিন করতে ২০টি বিষয়-বিশেষণ জোড়া training থেকে পুরো বাদ, সেগুলো শুধু test-এ। Baseline: পর্ব ২৭-এর bag of embeddings, আর AI-এর ভিত্তি কোর্সের পর্ব ৬৭-এর ধাঁচে TF-IDF + logistic regression, শব্দ আর bigram নিয়ে।

class TextCNN(nn.Module):
    def __init__(self, V, E=32, F_=32, ks=(2, 3, 4), p=0.3):
        super().__init__()
        self.emb = nn.Embedding(V, E, padding_idx=0)
        self.convs = nn.ModuleList(nn.Conv1d(E, F_, k) for k in ks)
        self.ks, self.drop = ks, nn.Dropout(p)
        self.fc = nn.Linear(F_ * len(ks), 2)
    def forward(self, x):                                # x (N, T)
        e, pooled = self.emb(x).transpose(1, 2), []      # (N, E, T)
        for k, c in zip(self.ks, self.convs):
            a = F.relu(c(F.pad(e, (0, k - 1))))          # ছোট review-ও যেন চলে
            a = a.masked_fill(~(x != 0).unsqueeze(1), 0.0)   # pad-এ শুরু হওয়া জানালা বাদ
            pooled.append(a.max(dim=2).values)           # (N, F): সময় ধরে max
        return self.fc(self.drop(torch.cat(pooled, 1)))

সত্যিকারের run (CPU-তে, তিন seed; TF-IDF-এ একটি fit; “X” মানে যেকোনো বিশেষণ; সময় এক fit-এর):

~/bazarghar-dl$ uv run python text_cnn.py
unique reviews 2408 | train 1936 | test 472 | positive share 0.49
examples: ['না ব্যাটারি মজবুত আগের', 'আগের গতকাল ব্যাগ সুন্দর', 'পণ্য দুর্বল']
x torch.Size([1936, 6]) | vocab 37
Python 3.14.4 | torch 2.15.0+cpu
bag of embeddings    acc 0.471 ±0.012 | plain 0.79 | X না 0.18 | X একদম না 0.23 | না X 0.80 |  0.69 s | params 1250
1D CNN (k=2,3,4)     acc 1.000 ±0.000 | plain 1.00 | X না 1.00 | X একদম না 1.00 | না X 1.00 |  3.89 s | params 10690
TF-IDF 1-2gram + LR  acc 0.998 ±0.000 | plain 1.00 | X না 1.00 | X একদম না 1.00 | না X 0.99 |  0.04 s 
পণ্য ভালো না       P(positive): CNN 0.00 | bag 0.67
না পণ্য ভালো       P(positive): CNN 1.00 | bag 0.67
ব্যাগ খারাপ না     P(positive): CNN 1.00 | bag 0.47
না ব্যাগ খারাপ     P(positive): CNN 0.00 | bag 0.47
জুতা মজবুত একদম না P(positive): CNN 0.00 | bag 0.48

পড়ুন: Bag of embeddings-এর accuracy ০.৪৭১, মুদ্রা টসের চেয়েও কম। সে সব শব্দ গড় করে, তাই “পণ্য ভালো না” আর “না পণ্য ভালো”-র জন্য হুবহু একই সম্ভাবনা দেয় (০.৬৭ আর ০.৬৭)। “X না” ধরনে তার ঠিক মাত্র ১৮%: ভালো শব্দ দেখে ভালো বলে দিচ্ছে। 1D CNN সব ধরনে ১.০০০, না দেখা জোড়াতেও, কারণ “ভালো না”-র নকশা বিষয় থেকে স্বাধীন। কিন্তু উচ্ছ্বসিত হবেন না. TF-IDF bigram-ও ০.৯৯৮ পেয়েছে, ০.০৪ সেকেন্ডে, CNN-এর ৩.৮৯ সেকেন্ডের প্রায় শতভাগের এক ভাগ। ডেটা সাজানো, শব্দভান্ডার মাত্র ৩৭ ঘরের, তাই ১.০০০ দেখে আসল review-এ এমন ফল আশা করা ভুল। আসল বাংলায় বানানের ভিন্নতা, ব্যাকরণের বৈচিত্র্য আর না দেখা শব্দে CNN-এর সুবিধা pretrained embedding (পর্ব ৪১) থেকে আসতে পারে, কিন্তু সেটি নিজের ডেটায় মেপে দেখতে হবে। আধুনিক text classification-এর পুরো পথ পর্ব ৪২-এ।

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

AI assistant TCN বা forecasting কোড মিনিটে লিখে দেয়, আর চলেও। সমস্যা হলো, এই কোডের সবচেয়ে বড় ভুলগুলো ক্র্যাশ করে না, ফলকে আরও সুন্দর দেখায়।

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

• Impulse test চালিয়েছি; ধাক্কার আগে কোনো output নড়েনি
• Receptive field হাতে হিসাব করে জানালার দৈর্ঘ্যের সঙ্গে মিলিয়েছি, আর সব dilation একই নয় কি না দেখেছি
• Scaling, feature আর target-এ origin-এর পরের কোনো তথ্য নেই
• Seasonal naive আর boosting একই fold-এ পাশে রেখেছি, একাধিক seed আর fold-এর সংখ্যা দেখেছি
• অবিশ্বাস্য ভালো ফল পেলে আগে leakage খুঁজেছি, উদযাপন পরে
• Conv1d, F.pad আর উদ্ধৃত প্রবন্ধ নিজের চোখে docs আর মূল লেখায় মিলিয়েছি; সময় নিজের মেশিনে মেপেছি