NumPy array — shape, dtype আর list-এর চেয়ে কেন দ্রুত

১ · বাজারঘরের বিক্রির খাতা — list থেকে NumPy array

বাজারঘর (এই কোর্সের কাল্পনিক অনলাইন দোকান) প্রতিদিন চারটি জেলায় পণ্য পাঠায়: ঢাকা, চট্টগ্রাম, খুলনা আর রাজশাহী। হিসাব বিভাগ প্রতিটি জেলার প্রতিদিনের বিক্রি হাজার টাকায় লিখে রাখে। এক সপ্তাহে তাই একটি ছক তৈরি হয়: ৪টি সারি (জেলা) আর ৭টি কলাম (শনিবার থেকে শুক্রবার)। এই পুরো মডিউলে এই ছকটিই আমাদের সঙ্গী; পরের পর্বগুলোতে এর ভেতর থেকে বেছে নেওয়া, এর ওপর হিসাব করা আর এর ছবি আঁকা হবে।

Python-এ এমন ছক রাখার প্রথম উপায় list-এর ভেতরে list. পর্ব ০৯-এ দেখেছেন, এটি কাজ করে, কিন্তু লাখ লাখ সংখ্যায় ধীর হয়ে যায়। সেখানে একটি মাপও নিয়েছিলেন। এই পর্বে প্রশ্নটি আরও গভীরে নেওয়া হবে: NumPy-র ndarray (n-dimensional array, অর্থাৎ যত খুশি মাত্রার array) মেমরিতে ঠিক কী রাখে, আর সেখান থেকেই কেন গতি আসে।

নিচের ছবিতে মেমরির এই দুই রূপ পাশাপাশি। ওপরে Python list: প্রতিটি ঘরে শুধু একটি ঠিকানা (pointer), আর আসল সংখ্যাটি মেমরির অন্য কোথাও একটি পূর্ণ Python int object. এমন object-কে বলে boxed object — সংখ্যাটি একটি “বাক্সে” মোড়া, বাক্সের গায়ে type, কতজন ব্যবহার করছে তার হিসাব (reference count) আর আকারের তথ্য। নিচে ndarray: একটি ছোট header, আর একটি টানা buffer-এ ৮ বাইট করে কাঁচা সংখ্যা।

২ · ndarray-এর ভেতরে — buffer, shape, strides আর dtype

বাজারঘরের সপ্তাহের ছকটিকে NumPy কীভাবে রাখে, এবার সংখ্যা ধরে দেখা যাক। ছকে ৪ × ৭ = ২৮টি সংখ্যা, প্রতিটি int64, অর্থাৎ ৬৪ বিট = ৮ বাইট। তাই buffer-এর আকার ২৮ × ৮ = ২২৪ বাইট। সংখ্যাগুলো সারি ধরে বসানো: আগে ঢাকার ৭ দিন, তারপর চট্টগ্রামের ৭ দিন, এভাবে। এই সাজানোর নাম row-major বা C order — শেষ মাত্রাটি (দিন) সবচেয়ে দ্রুত বদলায়।

এখন প্রশ্ন: “খুলনার মঙ্গলবারের বিক্রি” buffer-এর কোথায়? এখানেই strides-এর কাজ। Strides হলো প্রতিটি মাত্রায় এক ধাপ এগোতে কত বাইট সরতে হয় তার তালিকা। আমাদের ছকে পরের দিনে যেতে এক ঘর, অর্থাৎ ৮ বাইট; পরের জেলায় যেতে পুরো একটি সারি, অর্থাৎ ৭ × ৮ = ৫৬ বাইট। তাই strides = (56, 8). যেকোনো ঘরের ঠিকানা:

offset = i × s₀ + j × s₁

এখানে i সারির নম্বর (জেলা, ০ থেকে শুরু), j কলামের নম্বর (দিন), s₀ = ৫৬ আর s₁ = ৮ বাইট। Offset মানে buffer-এর শুরু থেকে কত বাইট দূরে। নিচের stepper-এ একই সূত্র কয়েকটি ঘরে চালিয়ে দেখুন — শেষ ধাপে একটি চমক আছে।

        শনি রবি সোম মঙ্গল বুধ বৃহ শুক্র
ঢাকা     26  74  65  50  50  80  26
চট্টগ্রাম  68  34  26  56  88  71  73
খুলনা    70  75  55  28  78  51  55
রাজশাহী   45  32  84  74  65  48  77
buffer: 28টি ঘর × 8 বাইট = 224 বাইট, সারি ধরে টানা

offset = 0 × 56 + 1 × 8 = 8 বাইট
ঘর নম্বর = 8 ÷ 8 = 1
মান = 74   # ঢাকা, রবিবার

offset = 1 × 56 + 0 × 8 = 56 বাইট
ঘর নম্বর = 56 ÷ 8 = 7   # ঢাকার ৭টি ঘর পেরিয়ে
মান = 68   # চট্টগ্রাম, শনিবার

offset = 2 × 56 + 3 × 8 = 112 + 24 = 136 বাইট
ঘর নম্বর = 136 ÷ 8 = 17
মান = 28

sales.T[3, 2]   # মঙ্গলবার, খুলনা
offset = 3 × 8 + 2 × 56 = 24 + 112 = 136 বাইট
মান = 28   # একই ঘর, একই buffer
কিছুই কপি হয়নি, শুধু strides উল্টেছে

এই কারণেই NumPy-তে অনেক কাজ প্রায় বিনা খরচে হয়: shape বা strides বদলানো মানে header-এর কয়েকটি সংখ্যা বদলানো, ২২৪ বাইট বা ২২৪ মেগাবাইট ডেটা নয়। যে নতুন array একই buffer ভাগ করে নেয়, তাকে বলে view; view আর copy-র পূর্ণ নিয়ম, আর কখন একটি view বদলালে মূল array-ও বদলে যায়, তা পর্ব ১৪-এ (Indexing আর slicing) আসবে।

৩ · Array বানানোর পথ — np.array থেকে eye

ndarray বানানোর কয়েকটি পরিচিত পথ আছে। প্রতিটির নিজস্ব জায়গা — কোনোটি আগে থেকে থাকা ডেটা থেকে, কোনোটি খালি ছক তৈরির জন্য, কোনোটি সংখ্যার ধারা বানাতে।

arange আর linspace-এর পার্থক্য মনে রাখার মতো। arange ধাপ ধরে চলে আর শেষ মান বাদ দেয়, Python-এর range-এর মতো। কিন্তু float ধাপে floating-point-এর ক্ষুদ্র ভুলের কারণে কয়টি সংখ্যা আসবে তা নিশ্চিত নয়: np.arange(0.1, 0.4, 0.1) চারটি সংখ্যা দেয় [0.1 0.2 0.3 0.4], যদিও ০.৪ বাদ পড়ার কথা (Python 3.14.4 আর NumPy 2.5.4-এ নিজে চালিয়ে দেখা)। NumPy-র docs-ও তাই বলে: অপূর্ণসংখ্যার ধাপে linspace ব্যবহার করুন, কারণ সেখানে সংখ্যা কয়টি তা আপনি নিজে বলে দেন।

এবার বাজারঘরের সপ্তাহের ছকটি বানানো যাক। rng.integers(20, 90, size=(4, 7)) ২০ থেকে ৮৯-এর মধ্যে (৯০ বাদ) এলোমেলো পূর্ণসংখ্যা দেয়, seed ৪২ থাকায় প্রত্যেক পাঠক একই সংখ্যা পাবেন। প্রথমবার “চালান” চাপলে ব্রাউজারে Python আর NumPy লোড হতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np

rng = np.random.default_rng(42)
# Bazarghar: 4 districts x 7 days, sales in thousand taka
sales = rng.integers(20, 90, size=(4, 7))
print(sales)
print("shape:", sales.shape, "ndim:", sales.ndim, "size:", sales.size)
print("dtype:", sales.dtype, "itemsize:", sales.itemsize,
      "nbytes:", sales.nbytes, "strides:", sales.strides)

week = np.array([[26, 74, 65], [68, 34, 26]])   # from a list of lists
print("from lists ->", week.dtype, week.shape)
print("zeros:", np.zeros(3), np.zeros(3).dtype)
print("ones int8:", np.ones(3, dtype=np.int8))
print("full:", np.full((2, 2), 60))
print("arange:", np.arange(7))
print("linspace:", np.linspace(0, 0.2, 5))
print(np.eye(3, dtype=np.int64))

[[26 74 65 50 50 80 26]
 [68 34 26 56 88 71 73]
 [70 75 55 28 78 51 55]
 [45 32 84 74 65 48 77]]
shape: (4, 7) ndim: 2 size: 28
dtype: int64 itemsize: 8 nbytes: 224 strides: (56, 8)
from lists -> int32 (2, 3)
zeros: [0. 0. 0.] float64
ones int8: [1 1 1]
full: [[60 60]
 [60 60]]
arange: [0 1 2 3 4 5 6]
linspace: [0.   0.05 0.1  0.15 0.2 ]
[[1 0 0]
 [0 1 0]
 [0 0 1]]

৪ · shape, ndim, size, itemsize, nbytes — মেমরির হিসাব

পাঁচটি attribute প্রতিদিন কাজে লাগে, আর এদের মধ্যে সরল সম্পর্ক আছে:

• shape: প্রতি মাত্রায় কতগুলো ঘর, একটি tuple. বিক্রির ছকে (4, 7).
• ndim: মাত্রার সংখ্যা = shape-এর দৈর্ঘ্য। এখানে ২। একটি রঙিন ছবি সাধারণত ৩ মাত্রার (উচ্চতা, প্রস্থ, রং), পর্ব ১৮-এ দেখবেন।
• size: মোট ঘর = shape-এর সংখ্যাগুলোর গুণফল। ৪ × ৭ = ২৮।
• itemsize: একটি ঘর কত বাইট — dtype থেকেই আসে। int64-এ ৮।
• nbytes: buffer-এর মোট আকার = size × itemsize = ২৮ × ৮ = ২২৪।

পরীক্ষায় আর বাস্তবে এই হিসাব প্রায়ই লাগে। ধরুন বাজারঘর একদিন ৬৪টি জেলাতেই পণ্য পাঠাবে, আর এক বছরের (৩৬৫ দিন) দৈনিক বিক্রি রাখতে চায়:

শেষ সারিটি একটি বাস্তব শিক্ষা: ছবিকে ০ থেকে ১-এর float-এ নিলে মেমরি আট গুণ হয়ে যায়। অনেক deep learning কাজে তাই float32 ব্যবহার হয় (চার গুণ)। একটি সূক্ষ্ম কথা: nbytes শুধু buffer-এর হিসাব, header-এর শ-খানেক বাইট এতে নেই; আর কোনো view-এর nbytes তার নিজের ঘরগুলোর হিসাব দেয়, যদিও buffer অন্যের সঙ্গে ভাগ করা। মেমরি মাপার পূর্ণ খুঁটিনাটি পর্ব ১৯-এ (NumPy-র গতি)।

৫ · dtype বাস্তবে — int8 থেকে float64, bool আর platform-এর default

dtype (data type) বলে দেয় buffer-এর প্রতিটি ঘর কত বাইটের আর বিটগুলোকে কী হিসেবে পড়তে হবে: চিহ্নসহ পূর্ণসংখ্যা, চিহ্নহীন পূর্ণসংখ্যা, দশমিক সংখ্যা, নাকি সত্য-মিথ্যা। একই ৮টি বিট 10111000 uint8 হিসেবে পড়লে ১৮৪, int8 হিসেবে পড়লে −৭২ — অংশ ৬-এ এর কারণ দেখবেন। Python-এর নিজের int যত বড় খুশি হতে পারে; NumPy-র int-এর আকার বাঁধা।

float32 নাকি float64? float64-এর নির্ভুলতা অনেক বেশি, তাই পরিসংখ্যান, অর্থের হিসাব আর scikit-learn-এর বেশিরভাগ কাজে এটিই স্বাভাবিক পছন্দ। float32 অর্ধেক মেমরি নেয়, আর GPU-তে সাধারণত অনেক দ্রুত, তাই deep learning-এ এটি প্রচলিত (আরও ছোট float16 বা bfloat16-ও ব্যবহার হয়, ভাবনার প্রশ্ন ৩ দেখুন)। কিন্তু float32-এ ১,৬৭,৭৭,২১৬ (২^২৪)-এর বেশি প্রতিটি পূর্ণসংখ্যা ঠিকঠাক রাখা যায় না, তাই বড় টাকার যোগফল বা id কখনো float32-এ নয়। টাকার হিসাবে সবচেয়ে নিরাপদ হলো পয়সায় int64, যা পর্ব ০৯-এ দেখেছেন।

Default int platform-এর ওপর নির্ভর করে। dtype না বললে NumPy পূর্ণসংখ্যার জন্য “platform-এর default int” নেয়। NumPy 2.0 থেকে সব ৬৪-বিট যন্ত্রে, Windows-সহ, এটি int64; আগে Windows-এ ছিল int32, যা অনেক বাগের উৎস ছিল বলে NumPy-র release notes নিজেই বলেছে। কিন্তু এই কোর্সের ব্রাউজারের Python (Pyodide) ৩২-বিট WebAssembly-তে চলে, তাই সেখানে default int হলো int32. ওপরের কোডে week array-টি তাই ব্রাউজারে int32 দেখিয়েছে, আর আপনার ল্যাপটপে একই লাইন দেবে int64. অন্যদিকে rng.integers নিজের default int64 সব জায়গায় একই রাখে।

লেখা (string) নিয়েও একটি কথা। np.array(["Dhaka", "Khulna"])-এর dtype <U6 — প্রতিটি ঘরে ঠিক ৬টি Unicode অক্ষরের জায়গা, যা সবচেয়ে লম্বা লেখার মাপে বাঁধা। পরে লম্বা নাম বসালে চুপচাপ কেটে যায়। NumPy-র আসল শক্তি সংখ্যায়; লেখাভরা টেবিলের জন্য pandas (মডিউল ৪) বেশি উপযোগী।

৬ · মিশ্র type-এ upcasting আর ছোট int-এর নীরব overflow

দুটি ভিন্ন dtype-এর array দিয়ে হিসাব করলে NumPy-কে ফলের dtype ঠিক করতে হয়। নিয়মটির নাম type promotion, আর ছোট type থেকে বড় type-এ ওঠাকে বলে upcasting. মূল নীতি: এমন একটি dtype বেছে নেওয়া হয়, যা দুই পক্ষের সব মান ধারণ করতে পারে। int8 + int16 → int16; পূর্ণসংখ্যা + দশমিক → দশমিক; bool + int → int. List থেকে বানানোর সময়ও একই নিয়ম: np.array([1, 2.5, True]) দেয় float64, আর একটি লেখা ঢুকে গেলে পুরো array-ই লেখা হয়ে যায়।

সবচেয়ে অবাক করা নিয়মটি ধাপে ধাপে দেখুন: int32-এর বিক্রির একক আর float32-এর দাম গুণ করলে ফল float32 নয়, float64.

1units = np.array([3, 5], dtype=np.int32)2price = np.array([12.5, 8.0], dtype=np.float32)3kind = np.result_type(units, price)4total = units * price5print((price * 2.5).dtype)

এবার উল্টো দিকের বিপদ। ছোট dtype-এর array-র হিসাবে ফল সীমা পেরোলে NumPy ফলকে বড় type-এ তোলে না — সংখ্যাটি চুপচাপ উল্টো প্রান্তে ঘুরে যায়। একে বলে integer overflow. Python-এর নিজের int-এ এটা কখনো হয় না, তাই Python থেকে আসা মানুষ প্রায়ই অবাক হন। খুলনার এক সপ্তাহের অর্ডার-সংখ্যা কেউ “মেমরি বাঁচাতে” int8-এ রেখেছিলেন; ঈদের সপ্তাহে অর্ডার দ্বিগুণ হলো:

import numpy as np

print("int8 range:", np.iinfo(np.int8).min, "to", np.iinfo(np.int8).max)
# Khulna: orders per day for one week, stored "to save memory"
orders = np.array([92, 86, 87, 73, 65, 93, 113], dtype=np.int8)
eid = orders * 2                        # Eid week: orders double
print("orders    :", orders)
print("orders * 2:", eid, eid.dtype)    # silent wrap-around, no warning
print("92 * 2 = 184 -> 184 - 256 =", 184 - 256)

total = orders.sum()                    # sum widens the accumulator
print("orders.sum():", total, "| dtype:", total.dtype)
try:
    orders + 200                        # 200 itself does not fit in int8
except OverflowError as e:
    print("OverflowError:", e)

safe = orders.astype(np.int64) * 2      # widen first, then multiply
print("safe      :", safe, safe.dtype)
print("int8 * 1.5 ->", (orders * 1.5).dtype)

int8 range: -128 to 127
orders    : [ 92  86  87  73  65  93 113]
orders * 2: [ -72  -84  -82 -110 -126  -70  -30] int8
92 * 2 = 184 -> 184 - 256 = -72
orders.sum(): 609 | dtype: int32
OverflowError: Python integer 200 out of bounds for int8
safe      : [184 172 174 146 130 186 226] int64
int8 * 1.5 -> float64

কেন ১৮৪ হয়ে যায় −৭২? NumPy-র চিহ্নসহ পূর্ণসংখ্যা two's complement পদ্ধতিতে রাখা হয়: ৮ বিটে সর্বোচ্চ বিটটির মান −১২৮, বাকি সাতটির ৬৪, ৩২, ১৬, ৮, ৪, ২, ১। ১৮৪-এর বিট 10111000; চিহ্নহীন পড়লে ১২৮ + ৩২ + ১৬ + ৮ = ১৮৪, কিন্তু চিহ্নসহ পড়লে −১২৮ + ৩২ + ১৬ + ৮ = −৭২। সহজ সূত্র: ফল ১২৭-এর বেশি হলে ২৫৬ বিয়োগ করুন। বিটের পূর্ণ গল্প আছে কম্পিউটার আর্কিটেকচার কোর্সের পূর্ণসংখ্যার প্রকাশ পর্বে।

৭ · reshape, ravel, flatten আর transpose — একই ডেটা, নতুন চোখে

reshape মানে একই সংখ্যাগুলোকে অন্য shape-এ দেখা। শর্ত একটাই: মোট ঘরের সংখ্যা (size) বদলাতে পারবে না। ২৮টি সংখ্যা (2, 14), (14, 2), (4, 7) বা (28,) হতে পারে, কিন্তু (5, 6) নয়। একটি মাত্রায় -1 লিখলে NumPy নিজে হিসাব করে নেয়: reshape(-1) মানে “এক সারিতে সব”, reshape(2, -1) মানে “দুই সারি, কলাম যত লাগে”। Row-major ক্রমে সংখ্যাগুলো যে সারিতে buffer-এ আছে, সেই সারিতেই নতুন shape-এর ঘরগুলো ভরে। নিচে ছয়টি সংখ্যা দিয়ে দেখুন।

ঘর     0   1   2   3   4   5
মান    26  74  65  50  50  80
offset 0   8   16  24  32  40
# ঢাকার প্রথম ছয় দিনের বিক্রি

shape   (6,)  →  (2, 3)
strides (8,)  →  (24, 8)   # এক সারি = 3 × 8
buffer  একই, কিছু কপি হয়নি

[[26 74 65]
 [ .  .  . ]]

[[26 74 65]
 [50 50 80]]
[1, 2] → 1 × 24 + 2 × 8 = 40 → 80

flat.reshape(3, 2)        r.T  (r = reshape(2, 3))
[[26 74]                  [[26 50]
 [65 50]                   [74 50]
 [50 80]]                  [65 80]]
একই shape (3, 2), ভিন্ন সংখ্যা-বিন্যাস

এক মাত্রায় নামানোর দুটি পথ: ravel() পারলে একটি view দেয় (কপি নয়), আর flatten() সবসময় নতুন কপি দেয়। তাই ravel দ্রুত আর মেমরি-সাশ্রয়ী, কিন্তু তার ফল বদলালে মূল array-ও বদলাতে পারে; flatten-এর ফল নিশ্চিন্তে বদলানো যায়। Transpose (.T) সারি আর কলাম অদলবদল করে — অংশ ২-এ দেখেছেন, এটি শুধু strides উল্টায়। বাজারঘরের ছকে তার মানে “জেলা × দিন” থেকে “দিন × জেলা”।

import numpy as np

rng = np.random.default_rng(42)
sales = rng.integers(20, 90, size=(4, 7))   # 4 districts x 7 days
print("sales         ", sales.shape, "strides", sales.strides)

t = sales.T                                 # 7 days x 4 districts
print("sales.T       ", t.shape, "strides", t.strides)
print("T shares memory:", np.shares_memory(sales, t))

two = sales.reshape(2, 14)                  # 28 numbers, 2 rows of 14
print("reshape(2, 14)", two.shape, "strides", two.strides)
print("reshape(-1)   ", sales.reshape(-1).shape)
print("reshape(2, -1)", sales.reshape(2, -1).shape)

r = sales.ravel()
f = sales.flatten()
print("ravel shares memory:  ", np.shares_memory(sales, r))
print("flatten shares memory:", np.shares_memory(sales, f))
print("sales.T.ravel()[:8]:", t.ravel()[:8])
print("its memory shared:  ", np.shares_memory(sales, t.ravel()))

try:
    sales.reshape(5, 6)
except ValueError as e:
    print("ValueError:", e)

sales          (4, 7) strides (56, 8)
sales.T        (7, 4) strides (8, 56)
T shares memory: True
reshape(2, 14) (2, 14) strides (112, 8)
reshape(-1)    (28,)
reshape(2, -1) (2, 14)
ravel shares memory:   True
flatten shares memory: False
sales.T.ravel()[:8]: [26 68 70 45 74 34 75 32]
its memory shared:   False
ValueError: cannot reshape array of size 28 into shape (5,6)

৮ · Array কেন দ্রুত — memory layout, Python-এর খরচ আর SIMD

“NumPy দ্রুত, কারণ C-তে লেখা” — কথাটি সত্য, কিন্তু অসম্পূর্ণ। গতি আসে তিনটি জিনিস একসঙ্গে থাকায়:

1. প্রতি সংখ্যায় Python-এর খরচ নেই। Python loop-এর প্রতি ধাপে interpreter-কে object-এর type দেখতে হয়, গুণের নিয়ম খুঁজতে হয়, ফলের জন্য নতুন boxed object বানাতে হয়, পুরোনোটির reference count কমাতে হয়। NumPy dtype একবার দেখে, তারপর সেই dtype-এর জন্য লেখা একটি compiled C loop পুরো buffer-এর ওপর চালায়। এটিই vectorization-এর মূল কথা; broadcasting-সহ এর পূর্ণ রূপ পর্ব ১৫-এ।
2. টানা মেমরি। CPU মেমরি থেকে একটি একটি বাইট আনে না, একসঙ্গে একটি ছোট খণ্ড (সাধারণত ৬৪ বাইটের cache line) আনে। টানা buffer-এ একটি খণ্ডেই আটটি int64 চলে আসে, আর পরের খণ্ডটি কী হবে তা CPU আগেই আন্দাজ করে আনতে পারে। List-এর ছড়ানো object-এ এই সুবিধা কম। বিস্তারিত আছে cache-এর মৌলিক ধারণা পর্বে।
3. SIMD. আধুনিক CPU একটি instruction-এ একাধিক সংখ্যার ওপর একই কাজ করতে পারে — SIMD (Single Instruction, Multiple Data). NumPy-র অনেক মৌলিক loop যন্ত্রের SIMD সুবিধা ব্যবহারের জন্য লেখা। তবে কোন কাজে, কোন CPU-তে, কতটা লাভ — তা ভিন্ন হয়; আর ব্রাউজারের WebAssembly-তে এই সুবিধা ডেস্কটপের সমান হবে, এমন নিশ্চয়তা নেই। তাই SIMD-কে একটি সম্ভাব্য বাড়তি লাভ ধরুন, নিশ্চিত গুণফল নয়। দেখুন SIMD আর vector পর্ব।

এবার মাপা যাক। একই ২ লাখ বিক্রির সংখ্যা (টাকায়) একটি list-এ আর একটি array-তে; কাজ: প্রতিটিতে ৫% বাড়িয়ে মোট যোগফল। মেমরিও মাপা হবে sys.getsizeof দিয়ে। প্রতিটি মাপ ৫ বার নিয়ে সবচেয়ে কম সময়টি রাখা হয়েছে, কারণ অন্য কাজের বাধায় সময় কেবল বাড়তে পারে, কমতে নয়।

import sys
import time
import numpy as np

N = 200_000
rng = np.random.default_rng(42)
arr = rng.integers(20_000, 90_000, size=N)  # taka, dtype int64
lst = arr.tolist()                          # same numbers as Python ints

objs = sum(sys.getsizeof(x) for x in lst)
print("one Python int:", sys.getsizeof(lst[0]), "bytes")
print("list :", sys.getsizeof(lst), "B pointers +", objs, "B objects")
print("array:", arr.nbytes, "B data, dtype", arr.dtype)

def best_ms(f, repeat=5):
    times = []
    for _ in range(repeat):
        t0 = time.perf_counter()
        result = f()
        times.append(time.perf_counter() - t0)
    return min(times) * 1000, result

t_list, s1 = best_ms(lambda: sum(x * 105 // 100 for x in lst))
t_arr, s2 = best_ms(lambda: int((arr * 105 // 100).sum()))
print(f"list : {t_list:7.2f} ms, total = {s1:,}")
print(f"array: {t_arr:7.2f} ms, total = {s2:,}")
print("same total:", s1 == s2, "| time ratio:", round(t_list / t_arr))

one Python int: 16 bytes
list : 800028 B pointers + 3200000 B objects
array: 1600000 B data, dtype int64
list :   16.00 ms, total = 11,557,184,712
array:    0.60 ms, total = 11,557,184,712
same total: True | time ratio: 27

ব্রাউজার একটি বিশেষ পরিবেশ, তাই লেখকের ল্যাপটপে সাধারণ Python দিয়ে একই কাজ ১ কোটি সংখ্যায় চালানো হয়েছিল। সত্যিকারের run, একবার, Python 3.14.4 আর NumPy 2.5.4 (লেখার সময়ের সর্বশেষ স্থিতিশীল সংস্করণ):

~/bazarghar-ai$ python bench_big.py
Python 3.14.4, NumPy 2.5.4
N = 10,000,000
list :    80.0 MB pointers + 280.0 MB int objects
array:    80.0 MB data, dtype=int64
+5% then total, list :    373.5 ms  -> 577,443,171,617
+5% then total, array:     48.9 ms  -> 577,443,171,617
same answer: True, array faster by about 8x
float32 x1.05 sum:   15.3 ms (40 MB)
float64 x1.05 sum:   26.8 ms (80 MB)

কয়েকটি জিনিস লক্ষ করুন। মেমরি: list-এ ১ কোটি ঠিকানা (৮০ MB) আর ১ কোটি int object (প্রতিটি ২৮ বাইট, ২৮০ MB) — মোট প্রায় ৩৬০ MB; array-তে শুধু ৮০ MB. সাড়ে চার গুণ পার্থক্য। সময়ে এই একটি run-এ array প্রায় ৮ গুণ দ্রুত। এই অনুপাত ওপরের ব্রাউজার-মাপের (দুই run-এ প্রায় ২৭ আর ১২ গুণ) চেয়ে কম। একটি কারণ, ব্রাউজারে WebAssembly-তে চলা Python loop ল্যাপটপের চেয়ে ধীর, তাই সেখানে অনুপাত বাড়ে। আরেকটি কারণ, এখানে array অনেক বড় (৮০ MB), যা CPU-র cache-এ ধরে না, আর arr * 105 // 100 আরও দুটি পূর্ণ মধ্যবর্তী array তৈরি করে। তখন হিসাবের চেয়ে মেমরি থেকে ডেটা আনা-নেওয়াই বড় খরচ, যা loop-এর লাভের একটি অংশ খেয়ে ফেলে। Float-এর শেষ দুই লাইনে অর্ধেক আকারের float32 প্রায় অর্ধেক সময় নিয়েছে — বড় array-তে গতির বড় অংশ আসলে মেমরি থেকে ডেটা আনার খরচ। এগুলো একটি যন্ত্রের একটি run-এর সংখ্যা, সাধারণ নিয়ম নয়; কাজ, array-র আকার আর যন্ত্র বদলালে অনুপাতও বদলায়।

৯ · NumPy 2-এ যা বদলেছে — নতুনদের জন্য জরুরি কয়েকটি

NumPy 2.0 আসে ২০২৪ সালের জুনে। বেশিরভাগ কোড আগের মতোই চলে, কিন্তু ইন্টারনেটের পুরোনো tutorial, Stack Overflow-এর উত্তর আর AI সহকারীর শেখা কোডে NumPy 1-এর অভ্যাস ছড়িয়ে আছে। নিচের বদলগুলো numpy.org-এর 2.0.0 release notes থেকে মিলিয়ে নেওয়া:

নিজের যন্ত্রে এগুলো যাচাই করা হয়েছিল একটি ছোট script দিয়ে। সত্যিকারের run, Python 3.14.4, NumPy 2.5.4:

~/bazarghar-ai$ python numpy2_check.py
NumPy 2.5.4
np.float64(1.5) | str: 1.5 | float: 1.5
np.float: module 'numpy' has no attribute 'float'.
np.float_: `np.float_` was removed in the NumPy 2.0 release. Use `np.float64` instead.
np.NaN: `np.NaN` was removed in the NumPy 2.0 release. Use `np.nan` instead.
np.bool: <class 'numpy.bool'> | default int: int64
str array dtype: <U6
StringDType: StringDType()
int8 + 200: OverflowError: Python integer 200 out of bounds for int8

Error বার্তাগুলো নিজেই সংশোধনের পথ বলে দেয় — এটি NumPy দলের একটি সচেতন নকশা। Scalar-এর নতুন ছাপা রূপ নিয়ে একটি ব্যবহারিক কথা: কোনো list-এর ভেতরে NumPy সংখ্যা থাকলে print([total]) দেখাবে [np.int64(1624)]. ভুল নয়, শুধু দেখতে ভিন্ন; রিপোর্ট বা JSON-এ পাঠানোর আগে int() বা float() দিয়ে Python সংখ্যায় নিন, অথবা f-string-এ ছাপুন। পুরোনো codebase NumPy 2-এ নিতে NumPy-র migration guide দেখুন; Ruff linter-এর NPY201 নিয়ম এমন অনেক পুরোনো নাম নিজে খুঁজে দেয় (Ruff-এর পরিচয় পর্ব ১১-এ)।

১০ · AI-এর যুগে — AI সহকারীর NumPy কোড যাচাই

NumPy কোড লেখায় AI সহকারী খুব কাজের, কারণ এর API বিশাল আর নামগুলো মনে রাখা কঠিন। কিন্তু সহকারীর শেখা ডেটার বড় অংশ NumPy 1-এর যুগের, আর dtype আর shape-এর ভুল নীরব। AI সহকারী প্রায়ই যে ভুলগুলো করে:

AI সহকারীর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• কোড নিজে চালিয়েছি; প্রতিটি array-র shape, dtype আর কয়েকটি ঘরের মান ছেপে মিলিয়েছি
• ছোট dtype থাকলে সবচেয়ে বড় সম্ভাব্য মান দিয়ে চালিয়ে overflow নেই দেখেছি
• প্রতিটি function আর parameter আমার NumPy version-এর অফিসিয়াল docs-এ আছে কি না দেখেছি
• reshape আর transpose-এর পার্থক্য একটি ২ × ৩ উদাহরণে হাতে মিলিয়েছি
• গতির কোনো দাবি থাকলে নিজের ডেটায় কয়েকবার মেপেছি, আর ফল মিলেছে কি না দেখেছি
• কোনো warning চাপা দেওয়া হয়নি; প্রতিটির কারণ পড়েছি
• গ্রাহকের নাম, ফোন নম্বর বা আসল বিক্রির ডেটা AI chatbot-এ পেস্ট করিনি