ছবি মানেই array — pixel, channel আর ছোট image processing

আগের পাঁচটি পর্বে NumPy-র মূল যন্ত্রগুলো এসেছে: পর্ব ১৩-এ array, shape আর dtype; পর্ব ১৪-এ indexing, slicing, view আর copy; পর্ব ১৫-এ vectorization আর broadcasting; পর্ব ১৬-এ ufunc, axis আর random; পর্ব ১৭-এ dot product আর matrix. এই পর্বে নতুন কোনো যন্ত্র নয়, সেই যন্ত্রগুলোর প্রথম বড় প্রয়োগ। ছবি এমন এক ধরনের ডেটা, যেখানে array-র প্রতিটি ধারণা চোখে দেখা যায়: ভুল slicing করলে ছবি উল্টে যায়, ভুল dtype হলে আকাশে কালো দাগ পড়ে। কোডগুলো পাতাতেই চলবে, প্রথমবার NumPy আর matplotlib নামতে কয়েক সেকেন্ড লাগতে পারে। ছবি কীভাবে বিট হয় (resolution, colour depth, compression) তার কম্পিউটার-বিজ্ঞানের দিকটি আছে কম্পিউটার ফান্ডামেন্টালস কোর্সের ছবি, শব্দ আর ভিডিও যেভাবে ডেটা হয় পর্বে।

১ · ছবি মানেই সংখ্যার grid — pixel, grayscale আর RGB

বড় কোনো জাতীয় অনুষ্ঠানে স্টেডিয়ামের গ্যালারিতে হাজার হাজার মানুষ রঙিন কার্ড তুলে একটি বিশাল ছবি বানান, এমন দৃশ্য হয়তো দেখেছেন। প্রত্যেকের হাতে একটিমাত্র রঙের কার্ড, কাছ থেকে দেখলে শুধু রঙের ছোপ, দূর থেকে দেখলে পুরো ছবি। ডিজিটাল ছবিও ঠিক তাই। প্রতিটি “আসন” একটি pixel (picture element), আর প্রতিটি pixel-এর রং কয়েকটি সংখ্যা দিয়ে লেখা। আসনগুলো সারি আর কলামে সাজানো, তাই পুরো ছবি একটি সংখ্যার টেবিল, মানে একটি NumPy array.

সাদা-কালো (grayscale) ছবি সবচেয়ে সরল: প্রতিটি pixel-এ একটি সংখ্যা, উজ্জ্বলতা। 0 মানে কালো, 255 মানে সাদা, মাঝের মানগুলো ধূসরের নানা ধাপ। H সারি (height, উচ্চতা) আর W কলাম (width, প্রস্থ) হলে ছবির shape (H, W). খেয়াল করুন ক্রমটি: আগে সারি, তারপর কলাম, ঠিক matrix-এর মতো। তাই a[y, x] লিখলে প্রথম সংখ্যা ওপর থেকে কত নম্বর সারি, দ্বিতীয়টি বাঁ থেকে কত নম্বর কলাম। গণিতের graph-এ আমরা আগে x লিখি; ছবির array-তে আগে y. আর y নিচের দিকে বাড়ে, ওপরের দিকে নয়।

রঙিন (RGB) ছবিতে প্রতিটি pixel-এ তিনটি সংখ্যা: লাল (Red), সবুজ (Green) আর নীল (Blue) আলো কতটা। [255, 0, 0] খাঁটি লাল, [255, 255, 0] হলুদ (লাল আর সবুজ আলো মিশে), [0, 0, 0] কালো, [255, 255, 255] সাদা। তিনটি সংখ্যা থাকার জায়গা একটি তৃতীয় মাত্রা, তাই shape (H, W, 3). শেষ মাত্রার প্রতিটি স্তরকে বলে একটি channel: a[:, :, 0] পুরো ছবির লাল channel, নিজেই একটি (H, W) grayscale ছবি। কিছু ফাইলে চতুর্থ একটি channel থাকে, alpha বা স্বচ্ছতা; তখন shape (H, W, 4), আর এটি একটি পরিচিত ফাঁদ (অংশ ৭)।

প্রতিটি মান কেন 0–255 — uint8

বেশির ভাগ ছবির ফাইল প্রতিটি channel-এর মান রাখে এক বাইটে, মানে ৮ বিটে। ৮ বিটে ২^৮ = ২৫৬টি আলাদা মান রাখা যায়, 0 থেকে 255. NumPy-তে এই dtype-এর নাম uint8: unsigned (ঋণাত্মক নেই) integer, 8 বিট। একটি pixel-এর তিন channel মিলে ২৪ বিট, তাই “24-bit colour” কথাটি শুনে থাকবেন; ২৫৬ × ২৫৬ × ২৫৬ ≈ ১ কোটি ৬৮ লাখ রং। uint8-এর লাভ মেমরিতে: float64-এর তুলনায় আট ভাগের এক ভাগ জায়গা। ক্ষতি গণিতে, যা অংশ ৩-এ দেখবেন। কিছু পেশাদার ক্যামেরা, চিকিৎসার ছবি (যেমন X-ray) বা উপগ্রহের ছবি ১০, ১২ বা ১৬ বিট ব্যবহার করে; তখন dtype uint16 আর পরিসর বড়। আর মেশিন লার্নিং-এর জন্য ছবিকে প্রায়ই float32-এ 0.0–1.0 পরিসরে আনা হয়, ২৫৫ দিয়ে ভাগ করে।

Channels-last বনাম channels-first

ছবি ১৮.১-এর নিচের অংশে যা দেখছেন, তা একই তথ্যের আরেক রকম সাজানো। Pillow, matplotlib, imageio আর OpenCV-এর মতো সাধারণ ছবির লাইব্রেরি channel রাখে শেষে: (H, W, C), যাকে বলে channels-last. Deep learning-এর কিছু লাইব্রেরি, যেমন PyTorch, সাধারণত channel রাখে আগে: (C, H, W), আর একসঙ্গে অনেক ছবি হলে সামনে আরেকটি মাত্রা N (ছবির সংখ্যা), মানে (N, C, H, W). TensorFlow/Keras-এর default সাধারণত channels-last, (N, H, W, C). এগুলো লাইব্রেরি আর সংস্করণভেদে বদলাতে পারে, তাই যে লাইব্রেরি ব্যবহার করবেন তার docs দেখে নিন। এক রূপ থেকে আরেক রূপে যেতে a.transpose(2, 0, 1) (বা np.moveaxis(a, -1, 0)) যথেষ্ট, কোনো সংখ্যা বদলায় না, শুধু অক্ষের ক্রম। এখানে deep learning শেখানো হবে না; শুধু মনে রাখুন, “shape মিলছে না” ধরনের error-এর একটি বড় উৎস এই ক্রম।

২ · NumPy দিয়ে নিজের ছবি বানানো — gradient আর নকশা

ছবি বোঝার সবচেয়ে ভালো উপায় নিজে একটি বানানো, pixel ধরে ধরে। দুটি ছবি বানাব। প্রথমটি একটি gradient (রঙের ঢাল): লাল channel বাঁ থেকে ডানে 0 থেকে 255 পর্যন্ত বাড়বে, নীল channel ওপর থেকে নিচে। দ্বিতীয়টি একটি জ্যামিতিক নকশা: ধূসর দাবার ছক, মাঝে একটি কমলা বৃত্ত। কোনো দেশের পতাকা নয়, শুধু আকার আর রঙের অনুশীলন।

দুটি কৌশল কাজে লাগবে। এক, broadcasting (পর্ব ১৫): np.linspace(0, 255, W) একটি দৈর্ঘ্য-W সারি, যা প্রতিটি সারিতে একই মান বসায়; আর [:, None] দিয়ে দৈর্ঘ্য-H একটি কলাম বানালে তা প্রতিটি কলামে একই মান বসায়। দুই, np.mgrid: এটি দুটি array দেয়, একটিতে প্রতিটি pixel-এর সারি নম্বর, আরেকটিতে কলাম নম্বর। তখন বৃত্তের শর্ত (y − 30)² + (x − 45)² ≤ 18² পুরো ছবির ওপর একবারে হিসাব হয়, আর ফল একটি boolean mask (পর্ব ১৪), যা দিয়ে বৃত্তের ভেতরের সব pixel একসঙ্গে রং করা যায়।

import numpy as np
import matplotlib.pyplot as plt

H, W = 60, 90                                   # 60 সারি, 90 কলাম
# ১) RGB gradient: লাল বাঁ থেকে ডানে, নীল ওপর থেকে নিচে বাড়ে
grad = np.zeros((H, W, 3), dtype=np.uint8)
grad[:, :, 0] = np.linspace(0, 255, W).astype(np.uint8)           # প্রতিটি সারিতে একই
grad[:, :, 2] = np.linspace(0, 255, H).astype(np.uint8)[:, None]  # প্রতিটি কলামে একই

# ২) জ্যামিতিক নকশা: দাবার ছক, ওপরে একটি কমলা বৃত্ত
yy, xx = np.mgrid[0:H, 0:W]                     # প্রতিটি pixel-এর সারি আর কলাম নম্বর
board = ((yy // 15 + xx // 15) % 2).astype(np.uint8) * 200 + 30   # 30 বা 230
pat = np.stack([board, board, board], axis=-1)  # ধূসর ছক, 3টি channel
circle = (yy - 30) ** 2 + (xx - 45) ** 2 <= 18 ** 2
pat[circle] = [245, 130, 20]                    # বৃত্তের ভেতরের সব pixel কমলা

print("grad:", grad.shape, grad.dtype, "nbytes =", grad.nbytes)
print("বাঁ-ওপরের কোণ :", grad[0, 0])
print("ডান-নিচের কোণ :", grad[-1, -1])
print("বৃত্তের pixel কতটি:", int(circle.sum()))
print("pat-এর মাঝের pixel:", pat[30, 45], " কোণের pixel:", pat[0, 0])

fig, ax = plt.subplots(1, 2, figsize=(7, 2.6))
ax[0].imshow(grad)
ax[0].set_title("RGB gradient (60 x 90)")
ax[1].imshow(pat)
ax[1].set_title("Checkerboard + circle")
for a in ax:
    a.set_xlabel("column (x)")
ax[0].set_ylabel("row (y)")
plt.tight_layout()
plt.show()

grad: (60, 90, 3) uint8 nbytes = 16200
বাঁ-ওপরের কোণ : [0 0 0]
ডান-নিচের কোণ : [255   0 255]
বৃত্তের pixel কতটি: 1009
pat-এর মাঝের pixel: [245 130  20]  কোণের pixel: [30 30 30]

৩ · উজ্জ্বলতা, contrast আর উল্টানো — uint8-এর উপচে পড়া

ছবি উজ্জ্বল করা মানে প্রতিটি মানে একটি সংখ্যা যোগ; ছবির ভাষায় brightness. Contrast বাড়ানো মানে মাঝের ধূসর (128) থেকে দূরত্বকে গুণ করে বাড়ানো, যাতে অন্ধকার আরও অন্ধকার আর উজ্জ্বল আরও উজ্জ্বল হয়। উল্টানো (negative) মানে 255 − মান: কালো সাদা হয়, সাদা কালো। তিনটিই একটি সূত্র, যা broadcasting-এর কারণে পুরো ছবিতে একবারে চলে:

উজ্জ্বল = a + b  ·  contrast = (a − 128) × k + 128  ·  উল্টানো = 255 − a

এখানে a ছবির array, b যোগ করার সংখ্যা, আর k contrast-এর গুণক (১-এর বেশি হলে contrast বাড়ে)। গণিত সোজা, ফাঁদ dtype-এ। uint8-এ ২৫৫-এর ওপরে কোনো মান নেই। চায়ের দোকানের পুরোনো তিন অঙ্কের মিটারের কথা ভাবুন: ৯৯৯-এর পর ০০০। uint8-এর মিটার ২৫৫-এর পর ০-তে ফেরে। একে বলে integer overflow বা wrap-around, আর NumPy array-র হিসাবে এটি ঘটে কোনো error বা সতর্কবার্তা ছাড়াই। নিচের ধাপে একটি মানের ভেতরে কী ঘটে দেখুন।

1a = np.array([250], dtype=np.uint8)2s = a + 10          # binary যোগ3# ৮ বিটের বাইরেরটি বাদ4w = a.astype(np.int16) + 105safe = np.clip(w, 0, 255).astype(np.uint8)

এবার পুরো একটি ধূসর ঢালে (ramp) একই কাজ করে চোখে দেখি: বাঁ থেকে ডানে 0 থেকে 254 পর্যন্ত মান, তার সঙ্গে 80 যোগ, একবার সরাসরি uint8-এ আর একবার clip করে। সঙ্গে একটি pixel-এ উজ্জ্বলতা, উল্টানো আর contrast-ও।

import numpy as np
import matplotlib.pyplot as plt

px = np.array([250, 128, 5], dtype=np.uint8)    # একটি pixel-এর R, G, B
print("px + 10           :", px + 10)            # uint8-এ উপচে পড়ে
wide = px.astype(np.int16) + 10                 # আগে চওড়া dtype
print("int16-এ + 10      :", wide)
print("clip করে uint8    :", np.clip(wide, 0, 255).astype(np.uint8))
print("উল্টানো 255 - px  :", 255 - px)
c = (px.astype(np.float32) - 128) * 1.5 + 128   # contrast 1.5 গুণ
print("contrast x1.5     :", np.clip(c, 0, 255).round().astype(np.uint8))

ramp = np.tile(np.arange(0, 256, 2, dtype=np.uint8), (24, 1))  # 24 x 128 ধূসর ঢাল
wrap = ramp + 80                                               # ভুল পথ
safe = np.clip(ramp.astype(np.int16) + 80, 0, 255).astype(np.uint8)
print("ramp", ramp.shape, ramp.dtype, "| ডান দিকের মান:", ramp[0, -3:])
print("wrap:", wrap[0, -3:], " safe:", safe[0, -3:])

fig, ax = plt.subplots(3, 1, figsize=(6, 3.2))
for a, im, t in zip(ax, [ramp, wrap, safe],
                    ["original", "+80 in uint8 (wraps)", "+80 with np.clip"]):
    a.imshow(im, cmap="gray", vmin=0, vmax=255)
    a.set_title(t, fontsize=9)
    a.set_axis_off()
plt.tight_layout()
plt.show()

px + 10           : [  4 138  15]
int16-এ + 10      : [260 138  15]
clip করে uint8    : [255 138  15]
উল্টানো 255 - px  : [  5 127 250]
contrast x1.5     : [255 128   0]
ramp (24, 128) uint8 | ডান দিকের মান: [250 252 254]
wrap: [74 76 78]  safe: [255 255 255]

৪ · রঙিন থেকে ধূসর — ওজন দেওয়া গড়

রঙিন ছবিকে grayscale করার সবচেয়ে সহজ চিন্তা: তিনটি channel-এর সাধারণ গড়। কাজ চলে, কিন্তু চোখে ঠিক লাগে না। কারণ মানুষের চোখ তিনটি রঙে সমান সংবেদনশীল নয়; একই শক্তির সবুজ আলো আমাদের কাছে লালের চেয়ে উজ্জ্বল, আর নীল সবচেয়ে কম উজ্জ্বল মনে হয়। তাই টেলিভিশনের যুগ থেকেই ধূসর মান হিসাব করা হয় ওজন দেওয়া গড় দিয়ে। সবচেয়ে পরিচিত ওজনগুলো ITU-R BT.601 নামের মানদণ্ডের (standard-definition টেলিভিশনের জন্য), যার শিকড় আরও পুরোনো NTSC রঙিন টেলিভিশনে:

Y = 0.299 R + 0.587 G + 0.114 B

এখানে Y হলো উজ্জ্বলতার মান, আর R, G, B তিনটি channel. তিনটি ওজনের যোগফল ঠিক ১, তাই সাদা (255, 255, 255) থেকে ধূসর মান 255-ই আসে। সূক্ষ্ম দিকটি সৎভাবে বলা দরকার: মানদণ্ডে এই ওজন বসানো হয় gamma-সংশোধিত মানের ওপর, আর তার ফলকে বলে luma, পদার্থবিদ্যার আসল আলোর উজ্জ্বলতা (luminance) নয়। HD টেলিভিশনের BT.709 মানদণ্ডে ওজন আলাদা (প্রায় 0.2126, 0.7152, 0.0722). Pillow-এর convert("L") ডকুমেন্টেশন অনুযায়ী BT.601-এর ওজনই ব্যবহার করে। ছোট কাজে এই পার্থক্য প্রায় চোখে পড়ে না; নিখুঁত রঙের কাজে (ছবি সম্পাদনা, চিকিৎসার ছবি) পড়ে। নিচের ধাপে অংশ ২-এর কমলা pixel ধরে হিসাবটি দেখুন।

1r, g, b = 245, 130, 202y  = 0.299 * r3y += 0.587 * g4y += 0.114 * b5gray = np.uint8(round(y))

পুরো ছবিতে এই হিসাব এক লাইনে হয়, matrix-গুণের সাহায্যে (পর্ব ১৭): (H, W, 3) আকারের array-কে দৈর্ঘ্য-৩ ওজনের vector দিয়ে @ করলে শেষ মাত্রাটি গুণ-যোগে মিশে যায়, ফল (H, W):

w = np.array([0.299, 0.587, 0.114])
gray = np.round(img @ w).astype(np.uint8)     # (H, W, 3) @ (3,) → (H, W)
# একই কাজ: (img * w).sum(axis=-1)

অংশ ৭-এর সত্যিকারের run-এ এই এক লাইনের ফল Pillow-এর convert("L")-এর সঙ্গে প্রতিটি pixel-এ মিলেছে, সর্বোচ্চ পার্থক্য ছিল ১, যা আসে Pillow-এর পূর্ণসংখ্যার আনুমানিক হিসাব আর rounding-এর ছোট তফাত থেকে।

৫ · কাটা, উল্টানো, ছোট করা আর সাদা-কালো — আসল অঙ্কের ছবিতে

এবার বানানো ছবি নয়, আসল ডেটা। scikit-learn-এর সঙ্গে আসে load_digits: হাতে লেখা ০ থেকে ৯-এর ১,৭৯৭টি ছোট ছবি। scikit-learn-এর docs অনুযায়ী এগুলো UCI Machine Learning Repository-র “Optical Recognition of Handwritten Digits” ডেটাসেটের একটি অংশের কপি। মূল ৩২ × ৩২ সাদা-কালো ছবিকে ৪ × ৪ ব্লকে ভাগ করে প্রতিটি ব্লকের কালো বিন্দু গুনে ৮ × ৮ বানানো হয়েছিল, তাই প্রতিটি মান 0 থেকে 16. ডেটা package-এর ভেতরেই থাকে, তাই কোনো network লাগে না। প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগতে পারে।

এই অংশের চারটি কাজই পর্ব ১৪-এর indexing আর slicing, নতুন কিছু নয়, শুধু এখন অর্থ চোখে দেখা যায়। Slicing-এ a[start:stop:step] প্রতিটি অক্ষে আলাদা করে লেখা হয়, কমা দিয়ে।

উল্টানো, crop আর striding তিনটিই view দেয়, নতুন copy নয়: একই মেমরির সংখ্যা, শুধু অন্যভাবে পড়া। তাই ১২ মেগাপিক্সেলের ছবি উল্টাতে কোনো সময়ই প্রায় লাগে না। কিন্তু view বদলালে মূল ছবিও বদলায়; আলাদা রাখতে চাইলে .copy(). Downsampling বা ছবি ছোট করার সবচেয়ে সস্তা পথ striding, তবে এটি মাঝের pixel-গুলো ফেলে দেয়, ফলে সূক্ষ্ম নকশায় (যেমন শাড়ির চিকন ডোরা) অদ্ভুত ঢেউয়ের মতো দাগ (aliasing) আসতে পারে। ভালো পথ হলো প্রতিটি ব্লকের গড় নেওয়া, অনুশীলন ৪-এ দেখবেন। Thresholding একটি ধূসর ছবিকে দুই মানে ভাঙে: কাগজ আর কালি, পটভূমি আর বস্তু। নিচের কোডে চারটিই একসঙ্গে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

digits = load_digits()                  # scikit-learn-এর সঙ্গে আসা ডেটা
print("images:", digits.images.shape, digits.images.dtype)
print("মানের পরিসর:", digits.images.min(), "থেকে", digits.images.max())

img = digits.images[0]                  # প্রথম ছবি, 8 x 8
print("label:", digits.target[0])
print(img.astype(int))

bw = (img > 8).astype(np.uint8)         # thresholding: 8-এর বেশি হলে 1
flip = img[:, ::-1]                     # বাঁ-ডান উল্টানো, শুধু slicing
crop = img[1:7, 2:6]                    # মাঝের 6 x 4 অংশ
print("সাদা-কালো:\n", bw)
small = img[::2, ::2]                   # striding: প্রতি দুইটির একটি
print("crop:", crop.shape, "| small:", small.shape)
print("flip কি view?", np.shares_memory(flip, img))

fig, ax = plt.subplots(1, 4, figsize=(8, 2.4))
for a, im, t in zip(ax, [img, bw, flip, crop],
                    ["digit (8x8)", "threshold > 8", "flipped", "crop 6x4"]):
    a.imshow(im, cmap="gray_r")
    a.set_title(t, fontsize=9)
    a.set_axis_off()
plt.tight_layout()
plt.show()

images: (1797, 8, 8) float64
মানের পরিসর: 0.0 থেকে 16.0
label: 0
[[ 0  0  5 13  9  1  0  0]
 [ 0  0 13 15 10 15  5  0]
 [ 0  3 15  2  0 11  8  0]
 [ 0  4 12  0  0  8  8  0]
 [ 0  5  8  0  0  9  8  0]
 [ 0  4 11  0  1 12  7  0]
 [ 0  2 14  5 10 12  0  0]
 [ 0  0  6 13 10  0  0  0]]
সাদা-কালো:
 [[0 0 0 1 1 0 0 0]
 [0 0 1 1 1 1 0 0]
 [0 0 1 0 0 1 0 0]
 [0 0 1 0 0 0 0 0]
 [0 0 0 0 0 1 0 0]
 [0 0 1 0 0 1 0 0]
 [0 0 1 0 1 1 0 0]
 [0 0 0 1 1 0 0 0]]
crop: (6, 4) | small: (4, 4)
flip কি view? True

৬ · 3×3 convolution — ঝাপসা করা আর কিনারা খোঁজা

এতক্ষণের প্রতিটি কাজ ছিল এক pixel-এর কাজ: প্রতিটি মান নিজের ওপর নির্ভর করে বদলেছে। কিন্তু “এখানে কি একটি কিনারা আছে?” প্রশ্নের উত্তর এক pixel জানে না; পাশের pixel-গুলোর সঙ্গে তুলনা লাগে। Convolution সেই কাজের হাতিয়ার। একটি ছোট সংখ্যার টেবিল, যাকে বলে kernel বা filter, ছবির ওপর জানালার মতো সরতে থাকে। প্রতিটি অবস্থানে জানালার নিচের ৯টি pixel-কে kernel-এর ৯টি সংখ্যা দিয়ে গুণ করে যোগ করা হয়, আর সেই যোগফল হয় ফলের ছবির একটি pixel.

ক্রিকেট মাঠে পিচ পরীক্ষার কথা ভাবুন: আম্পায়ার পিচের একটি ছোট অংশে হাত রেখে দেখেন, তারপর একটু সরে আবার দেখেন। হাতের তালু হলো kernel, আর তার সংখ্যাগুলো ঠিক করে কোন বৈশিষ্ট্য খোঁজা হচ্ছে।

• Blur (ঝাপসা): নয়টি ঘরেই 1/9. প্রতিটি নতুন pixel তার চারপাশের ৯টির গড়, তাই হঠাৎ পরিবর্তন মসৃণ হয়ে যায়, ছোট দানা (noise) কমে।
• Sobel-x (খাড়া কিনারা): বাঁ কলামে −1, −2, −1; মাঝে 0; ডানে 1, 2, 1. সমান অংশে বাঁ আর ডান কাটাকাটি হয়ে ফল 0; বাঁ থেকে ডানে উজ্জ্বলতা বাড়লে ফল বড় ধনাত্মক, কমলে বড় ঋণাত্মক। এভাবে edge detection হয়। Sobel operator-এর নাম Irwin Sobel-এর নামে; প্রচলিত বিবরণ অনুযায়ী তিনি আর Gary Feldman ১৯৬৮ সালে Stanford-এ ধারণাটি উপস্থাপন করেছিলেন।

নিচের ধাপে অংশের কোডের ১২ × ১২ ছবিটি ধরুন: কালো জমিনে মাঝে একটি উজ্জ্বল বর্গ (মান 200), সারি আর কলাম ৩ থেকে ৮. Kernel বসানো হচ্ছে ফলের e[4, 1] ঘরের জন্য, মানে ছবির সারি ৪–৬ আর কলাম ১–৩-এর জানালায়, যেখানে বর্গের বাঁ কিনারা শুরু।

1patch = img[4:7, 1:4]2সারি ১: (-1)(0) + (0)(0) + (1)(200)3সারি ২: (-2)(0) + (0)(0) + (2)(200)4সারি ৩: (-1)(0) + (0)(0) + (1)(200)5blur = patch.sum() / 96patch = img[4:7, 3:6]   # দুই ঘর ডানে

এখন পুরো ছবিতে। কোডে দুটি loop আছে, কিন্তু তা pixel ধরে নয়, kernel-এর ৯টি ঘর ধরে: প্রতিটি ঘরের জন্য পুরো ছবির একটি সরানো slice-কে সেই ঘরের সংখ্যা দিয়ে গুণ করে যোগ করা হয়। ৯টি vectorized ধাপ, ছবি যত বড়ই হোক। ফল যাচাই করা হয়েছে SciPy-র তৈরি function দিয়ে।

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import correlate2d

img = np.zeros((12, 12))                 # কালো জমিন
img[3:9, 3:9] = 200                      # মাঝে একটি উজ্জ্বল বর্গ

def conv3x3(a, k):
    """3x3 kernel ঘুরিয়ে বসানো, 'valid': ফল (H-2) x (W-2)."""
    H, W = a.shape
    out = np.zeros((H - 2, W - 2))
    for i in range(3):                   # kernel-এর 9টি ঘর
        for j in range(3):
            out += k[i, j] * a[i:i + H - 2, j:j + W - 2]
    return out

blur = np.ones((3, 3)) / 9               # গড় করা kernel
sobel_x = np.array([[-1, 0, 1],
                    [-2, 0, 2],
                    [-1, 0, 1]])         # বাঁ থেকে ডানে মান বদল খোঁজে

b = conv3x3(img, blur)
e = conv3x3(img, sobel_x)
print("ফলের shape:", b.shape)
print("blur সারি 4:", b[4].round(1))
print("edge সারি 4:", e[4])
print("scipy-র সঙ্গে মেলে?", np.allclose(e, correlate2d(img, sobel_x, "valid")))

fig, ax = plt.subplots(1, 3, figsize=(7.5, 2.6))
for a, im, t in zip(ax, [img, b, e], ["input 12x12", "blur 3x3", "Sobel-x edges"]):
    a.imshow(im, cmap="gray")
    a.set_title(t, fontsize=9)
    a.set_axis_off()
plt.tight_layout()
plt.show()

ফলের shape: (10, 10)
blur সারি 4: [  0.   66.7 133.3 200.  200.  200.  200.  133.3  66.7   0. ]
edge সারি 4: [   0.  800.  800.    0.    0.    0.    0. -800. -800.    0.]
scipy-র সঙ্গে মেলে? True

Convolutional network এই সংখ্যাগুলো নিজে শেখে

উপরের দুটি kernel মানুষ ভেবেচিন্তে বানিয়েছে। কয়েক দশক ধরে কম্পিউটার ভিশন এভাবেই চলেছে: বিশেষজ্ঞরা কিনারা, কোণ আর নকশা খোঁজার filter হাতে নকশা করতেন। Convolutional neural network (CNN) ধারণাটি উল্টে দেয়: kernel-এর ৯টি সংখ্যা শুরুতে প্রায় এলোমেলো, আর প্রশিক্ষণের সময় ডেটা থেকে ধাপে ধাপে ঠিক হয়। অনেক kernel পাশাপাশি আর অনেক স্তর পরপর থাকে, তাই প্রথম স্তর হয়তো কিনারা খোঁজে, পরের স্তর কিনারা মিলিয়ে কোণ, তার পরেরটি আরও বড় আকার। প্রকাশিত বিভিন্ন গবেষণায় দেখা গেছে, প্রশিক্ষিত network-এর প্রথম স্তরের অনেক kernel দেখতে হাতে বানানো edge filter-এর মতোই হয়। তবে network “কী দেখছে” তা মানুষের মতো বোঝে, এমন দাবি করা যায় না; এগুলো শেখা সংখ্যা, যা কখনো খুব অদ্ভুত কারণেও সঠিক উত্তর দেয়। ধারণাটির হাতে-কলমে রূপ পর্ব ৬৮-এ (neural network-এর ধারণা) আসবে, আর CNN-এর পুরো গল্প পরের একটি deep learning কোর্সের বিষয়।

৭ · মেমরি আর আসল ফাইল — H × W × C × বাইট, Pillow আর imageio

একটি ফোন-ছবি মেমরিতে কত বড়

ছবির array-র মেমরি হিসাব একটি গুণ মাত্র:

বাইট = H × W × C × (প্রতি মানের বাইট)

এখানে C হলো channel-এর সংখ্যা (grayscale-এ ১, RGB-তে ৩, RGBA-তে ৪), আর প্রতি মানের বাইট uint8-এ ১, float32-এ ৪, float64-এ ৮. ফোনের ক্যামেরার “১২ মেগাপিক্সেল” মানে প্রায় ১ কোটি ২০ লাখ pixel, যেমন ৪০০০ × ৩০০০. নিচের সংখ্যাগুলো লেখকের যন্ত্রে সূত্র দিয়েই হিসাব করা (অংশের শেষের run-এ ছাপা হয়েছে); এখানে ১ MiB = ১০,৪৮,৫৭৬ বাইট।

গ্যালারিতে একই ছবির JPEG ফাইল হয়তো কয়েক MB, কারণ ফাইলটি সংকুচিত; খুললেই তা পুরো array. তাই ১০০টি ফোন-ছবি float32-এ একসঙ্গে মেমরিতে নিলে ১৩ GiB-এর বেশি লাগে, যা সাধারণ ল্যাপটপে আঁটে না। বাস্তবের তিনটি সমাধান: ছবি আগে ছোট করা (model প্রায়ই ২২৪ × ২২৪-এর মতো ছোট ইনপুট নেয়), একসঙ্গে সব না খুলে ছোট ছোট দলে (batch) পড়া, আর যতক্ষণ সম্ভব uint8-এ রাখা, float-এ রূপান্তর একেবারে শেষ মুহূর্তে।

আসল ফাইল পড়া — একটি সত্যিকারের run

ব্রাউজারের Python-এ ফাইল পড়ার চেয়ে নিজের যন্ত্রে করাটাই বাস্তব কাজের কাছাকাছি। তাই লেখক নিজের যন্ত্রে একটি venv-এ (পর্ব ৭) Python 3.14.4, NumPy 2.5.4, Pillow 13.0.0 আর imageio 2.38.1 (লেখার সময়ের সংস্করণ) নিয়ে একটি ছোট script চালিয়েছেন। ছবিটি script নিজেই বানায়: ১২০ × ১৬০-এর একটি সবুজ-নীল gradient আর একটি হলুদ বৃত্ত, কোনো মানুষের ছবি বা অন্যের তোলা ছবি নয়। তারপর PNG হিসেবে সেভ করে Pillow আর imageio দুটি দিয়েই আবার পড়ে।

import numpy as np
from PIL import Image
import imageio.v3 as iio

# ... 120 x 160 uint8 ছবি img বানানো (gradient + বৃত্ত) ...
Image.fromarray(img).save("pattern.png")

im = Image.open("pattern.png")
print("Pillow:", im.size, im.mode)
a = np.asarray(im)
print("array:", a.shape, a.dtype, "nbytes =", a.nbytes)
print("মাঝের pixel:", a[60, 80], " কোণের pixel:", a[0, 0])

b = iio.imread("pattern.png")
print("imageio:", b.shape, b.dtype, "একই?", np.array_equal(a, b))

g_pil = np.asarray(im.convert("L"))
g_own = np.round(a @ np.array([0.299, 0.587, 0.114])).astype(np.uint8)
diff = np.abs(g_pil.astype(int) - g_own.astype(int))
print("gray:", g_pil.shape, g_pil.dtype, "সর্বোচ্চ পার্থক্য:", diff.max())

সত্যিকারের run-এর আউটপুট (ফোল্ডারের পথ বদলে নিরপেক্ষ করা হয়েছে; শেষ দুটি লাইন একই script-এর মেমরি অংশ থেকে):

~/bazarghar-ai/images$ python make_and_read.py
ফাইলের আকার: 1055 bytes
Pillow: (160, 120) RGB
array: (120, 160, 3) uint8 nbytes = 57600
মাঝের pixel: [250 200  30]  কোণের pixel: [0 0 0]
imageio: (120, 160, 3) uint8 একই? True
gray: (120, 160) uint8 সর্বোচ্চ পার্থক্য: 1
12 MP: 36,000,000 bytes = 34.3 MiB (uint8), 137.3 MiB (float32)
48 MP: 144,000,000 bytes = 137.3 MiB (uint8), 549.3 MiB (float32)

সবচেয়ে গুরুত্বপূর্ণ লাইনটি দ্বিতীয়টি: Pillow-এর im.size দেয় (160, 120), মানে (প্রস্থ, উচ্চতা), অথচ NumPy array-র shape (120, 160, 3), মানে (উচ্চতা, প্রস্থ, channel). একই ছবি, উল্টো ক্রম। Pillow-এর resize((w, h))-ও প্রস্থ আগে নেয়। এই একটি ফাঁদ থেকে অনেক “ছবি কাত হয়ে গেছে” বা “shape মিলছে না” বাগ আসে। বাকি লাইনগুলো যা বলে: ৫৭,৬০০ বাইটের array-টি ডিস্কে মাত্র ১,০৫৫ বাইটের PNG, কারণ মসৃণ gradient খুব ভালো সংকুচিত হয়; Pillow আর imageio হুবহু একই array দিয়েছে; আর নিজের BT.601 হিসাব Pillow-এর convert("L")-এর সঙ্গে সর্বোচ্চ ১ মানের তফাতে মিলেছে।

একই যন্ত্রে আরেকটি ছোট run-এ একই ছবিকে JPEG (quality 90) হিসেবে সেভ করে আবার পড়া হয়েছিল:

~/bazarghar-ai/images$ python jpeg_check.py
JPEG: 3485 bytes (120, 160, 3) uint8
PNG বনাম JPEG সর্বোচ্চ পার্থক্য: 159  গড়: 1.93
RGBA হিসেবে: (120, 160, 4)

এখানে দুটি শিক্ষা। এক, JPEG একটি lossy compression: সেভ করে আবার পড়লে সংখ্যা বদলে যায়। গড় পার্থক্য প্রায় ২, কিন্তু হলুদ বৃত্ত আর নীল-সবুজ জমিনের তীক্ষ্ণ কিনারায় কোনো একটি মান ১৫৯ পর্যন্ত সরেছে; JPEG রঙের তথ্য সাধারণত উজ্জ্বলতার চেয়ে কম রেজোলিউশনে রাখে, তাই রঙের কিনারায় ভুল বেশি। মজার ব্যাপার, এই কৃত্রিম ছবিতে JPEG ফাইল PNG-এর চেয়েও বড় হয়েছে; ফটোগ্রাফে সাধারণত উল্টো। দুই, convert("RGBA") করলে চতুর্থ channel আসে; কিছু PNG ফাইল নিজেই RGBA, আর তখন (H, W, 3) ধরে নেওয়া কোড ভেঙে যায়। নিরাপদ অভ্যাস: Image.open(path).convert("RGB"), তারপর shape যাচাই।

৮ · AI-এর যুগে — AI সহকারীর লেখা ছবির কোড যাচাই

“এই ছবিটা একটু উজ্জ্বল করে grayscale করে দাও” লিখলে একটি AI সহকারী মুহূর্তে কোড দেবে, আর ছবি একটা আসবেও। সমস্যা হলো ছবির কোডের ভুল প্রায়ই চোখে ধরা পড়ে না: কয়েকটি pixel কালো হয়ে গেল, বা ছবি সামান্য কাত, বা model-এ পাঠানো ছবির channel উল্টো। AI সহকারীরা ছবির কাজে প্রায়ই যা করে:

• uint8 ছবিতে সরাসরি img + 50 বা img * 1.2 লেখে, overflow বা dtype বদলের কথা না ভেবে; বা float ছবি 0–255 পরিসরে রেখে imshow-এ পাঠায়।
• Pillow-এর size (প্রস্থ, উচ্চতা) আর NumPy-র shape (উচ্চতা, প্রস্থ) গুলিয়ে ফেলে; RGBA বা grayscale ফাইলেও তিনটি channel ধরে নেয়।
• OpenCV-র ছবি (যা সাধারণত BGR ক্রমে channel রাখে) আর Pillow-এর RGB মিশিয়ে ফেলে, ফলে লাল আর নীল অদলবদল হয়; deep learning-এ পাঠানোর আগে channels-first-এ নিতে ভোলে।
• পুরোনো বা বানানো API লেখে: সরিয়ে দেওয়া scipy.misc.imread, পুরোনো Image.ANTIALIAS (এখন Image.Resampling.LANCZOS), বা NumPy 2-এ সরানো np.float; warning চাপা দেয়, আর শুধু train ডেটায় মাপা ফল দেখায়।

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

• প্রতিটি ধাপের পরে shape, dtype, min() আর max() ছেপে দেখেছি
• uint8-এ যোগ, বিয়োগ বা গুণের আগে চওড়া dtype, পরে np.clip; ২৫০-এর কাছাকাছি একটি pixel দিয়ে হাতে মিলিয়েছি
• ফাইল খোলার পরে .convert("RGB") বা channel-সংখ্যা যাচাই; Pillow-এর (প্রস্থ, উচ্চতা) আর NumPy-র (উচ্চতা, প্রস্থ) আলাদা রেখেছি
• লাইব্রেরি বদলের জায়গায় channel-এর ক্রম (RGB না BGR) আর অক্ষের ক্রম (channels-last না first) যাচাই করেছি
• প্রতিটি অচেনা function আর parameter নিজের NumPy, Pillow আর SciPy সংস্করণের অফিসিয়াল docs-এ মিলিয়েছি; কোনো warning লুকানো হয়নি
• মানুষের ছবি বা EXIF-সহ আসল ফাইল কোনো AI টুলে দিইনি; নিজের বানানো বা লাইসেন্স-স্পষ্ট ছবি দিয়ে পরীক্ষা করেছি