বড় ডেটায় pandas — dtype, category, chunk আর Polars-এর পরিচয়

মডিউল ৪-এর আগের পর্বগুলোতে pandas দিয়ে বাজারঘরের টেবিল পড়া, বাছাই, পরিষ্কার, groupby, join আর সময়ের হিসাব দেখেছেন (পর্ব ২০ থেকে পর্ব ২৬)। সেখানে টেবিল ছিল কয়েকশো বা কয়েক হাজার সারির। কিন্তু দোকান বড় হলে এক বছরের অর্ডার হয় কয়েক কোটি সারি, আর একদিন ল্যাপটপ বলে বসে MemoryError, অথবা একটি ছোট হিসাব চলে দশ মিনিট। এই পর্ব সেই মুহূর্তের জন্য। NumPy-র দিক থেকে গতি আর মেমরির মূল নিয়ম (মাপার নিয়ম, dtype, overflow, temporary array) আছে পর্ব ১৯-এ; এখানে সেগুলো আবার শেখানো হবে না, শুধু pandas-এর টেবিলে প্রয়োগ, আর তার পরের ধাপ: Polars আর DuckDB.

১ · “বড় ডেটা” আসলে কত বড় — RAM আর মেমরি মাপা

চায়ের দোকানের হিসাব খাতা পকেটে ধরে। পাইকারি আড়তের দশ বছরের খাতা ধরে না; তার জন্য আলমারি লাগে, আর সব খাতা একসঙ্গে টেবিলে খুলে বসা যায় না। কম্পিউটারে “টেবিল” হলো RAM. pandas পুরো DataFrame RAM-এ রাখে, তাই ডেটা “বড়” কি না তার প্রথম মাপকাঠি ফাইলের আকার নয়, RAM-এ তোলার পর তার আকার। আর এই দুটি প্রায়ই মেলে না: ৩০০ MB-এর একটি CSV RAM-এ ২০০ MB-ও হতে পারে, ১ GB-ও হতে পারে, নির্ভর করে কলামের dtype-এর ওপর।

pandas-এর স্রষ্টা Wes McKinney ২০১৭ সালের একটি লেখায় বলেছিলেন, তাঁর অভিজ্ঞতায় pandas-এ আরামে কাজ করতে ডেটার আকারের প্রায় ৫ থেকে ১০ গুণ RAM লাগত (সেটি তখনকার pandas-এর জন্য একটি মোটা দাগের অভিজ্ঞতা, কোনো নিয়ম নয়)। কারণ শুধু টেবিল নয়: প্রতিটি filter, নতুন কলাম বা merge সাময়িকভাবে নতুন কপি বানাতে পারে। pandas 3-এ Copy-on-Write একমাত্র আচরণ হওয়ায় অনেক অপ্রয়োজনীয় কপি কমেছে, তবু বাড়তি জায়গা লাগে। তাই প্রথম কাজ: মাপা।

pandas-এ মাপার দুটি পথ। df.memory_usage() প্রতিটি কলামের byte দেয়; df.info() সারাংশ দেয়। দুটিরই একটি গুরুত্বপূর্ণ বিকল্প আছে: deep. পুরোনো ধাঁচের object কলামে প্রতিটি ঘরে থাকে শুধু একটি pointer (৬৪-বিট যন্ত্রে ৮ byte), আর আসল লেখাটি থাকে আলাদা একটি Python object-এ (boxed object). deep=True না দিলে pandas শুধু pointer-গুলো গোনে, লেখাগুলো নয়, তাই হিসাব অনেক কম দেখায়। deep=True দিলে প্রতিটি object-এর আকারও যোগ হয়; এটি একটু ধীর, কারণ সত্যিই প্রতিটি ঘর ঘুরে দেখতে হয়।

df.memory_usage(deep=True)          # কলাম ধরে byte, index-সহ
df.memory_usage(deep=True).sum() / 1e6   # মোট, MB-তে (10^6 byte)
df.info(memory_usage="deep")        # সারাংশ; শেষ লাইনে মোট

একটি সূক্ষ্মতা: info()-এর শেষ লাইনে “MB” লেখা থাকলেও pandas সেখানে ১০২৪ দিয়ে ভাগ করে (আসলে MiB). তাই লেখকের ল্যাপটপে ২ লাখ সারির একটি টেবিলে memory_usage(deep=True).sum() / 1e6 দিল ১৩.৯৩, আর info দেখাল “13.3 MB”; দুটিই ঠিক, একক আলাদা। ছোট টেবিলে এটি নগণ্য, কিন্তু রিপোর্টে দুটি সংখ্যা পাশাপাশি লিখলে বিভ্রান্তি হয়।

টেবিল একাই RAM-এর অর্ধেকের বেশি নিলে প্রথম groupby বা merge-এই সমস্যা হতে পারে। তখন এই পর্বের ক্রমে ভাবুন: ছোট করা, কম পড়া, ভাগ করে পড়া, তারপর টুল বদলানো।

২ · সংখ্যার কলাম ছোট করা — downcast আর nullable dtype

বাজারঘরের অর্ডারে qty (পরিমাণ) ১ থেকে ৫, delivery_days ১ থেকে ৭. অথচ pandas এগুলো ডিফল্টে রাখে int64-এ, প্রতিটি সংখ্যায় ৮ byte, যা প্রায় ৯২ হাজার কোটি কোটি (৯.২ × ১০^১৮) পর্যন্ত ধরে। ১ থেকে ৭ রাখতে int8 (−১২৮ থেকে ১২৭, ১ byte) যথেষ্ট। এক কোটি সারিতে এই এক কলামেই ৮০ MB বনাম ১০ MB. বাজারের ব্যাগে এক কেজি চাল আনতে বস্তা লাগে না।

হাতে হাতে dtype না লিখে pandas-কে বলা যায় “সবচেয়ে ছোট যেটিতে ধরে, সেটি দাও”: এর নাম downcasting.

df["qty"] = pd.to_numeric(df["qty"], downcast="integer")        # int8/16/32
df["order_id"] = pd.to_numeric(df["order_id"], downcast="unsigned")  # uint8/16/32
df["ratio"] = pd.to_numeric(df["ratio"], downcast="float")      # float32

downcast-এর চারটি মান: "integer" (চিহ্নসহ পূর্ণসংখ্যা), "signed" (একই), "unsigned" (শুধু শূন্য বা ধনাত্মক) আর "float". pandas কলামের সর্বনিম্ন আর সর্বোচ্চ মান দেখে বাছে। তিনটি সাবধানতা আছে, আর তিনটিই চুপচাপ ঘটে।

• ভবিষ্যতের হিসাবে overflow: downcast এখনকার মান দেখে। পরে সেই কলামে গুণ করলে ফল সেই ছোট dtype-এই থাকে। লেখকের ল্যাপটপে সত্যিকারের run (pandas 3.1.1): pd.Series([2, 5], dtype="int8") * 100 দিল [-56, -12], কোনো সতর্কবার্তা ছাড়া, কারণ ৫০০ int8-এ ধরে না (পর্ব ১৯-এর integer overflow). sum() অবশ্য নিরাপদ: pandas যোগফল int64-এ করে, তাই একই কলামের ১০০ + ১০০ দিল 200. নিয়ম: গুণ বা টাকার হিসাবের আগে .astype("int64").
• float32-এর নির্ভুলতা: downcast="float" দিলে প্রায় ৭ অঙ্ক থাকে। টাকা কখনো float-এ নয়; এই কোর্সে টাকা সবসময় পূর্ণসংখ্যার পয়সা।
• ফাঁকা ঘর থাকলে কাজ হয় না: NumPy-র integer-এ “নেই” রাখার জায়গা নেই, তাই [3, None, 5] pandas রাখে float64-এ ([3.0, nan, 5.0]), আর downcast="integer" দিলেও সেটি float64-ই থাকে (লেখকের যন্ত্রে সত্যিকারের run).

শেষ সমস্যার সমাধান nullable dtype: বড় হাতের নামের integer, যেমন "Int8", "Int64", আর "boolean". এগুলো মানের পাশে একটি আলাদা “আছে/নেই” mask রাখে, আর ফাঁকা ঘর দেখায় <NA> হিসেবে (pd.NA). লেখকের যন্ত্রে pd.Series([3, None, 5], dtype="Int64") দিল [3, <NA>, 5], যোগফল 8, আর মেমরি ২৭ byte: তিনটি ৮-byte মান আর তিনটি ১-byte mask. "Int8"-এ একই তিনটি মান ৬ byte. df.convert_dtypes() পুরো টেবিলকে এক লাইনে nullable dtype-এ বদলায়। পূর্ণসংখ্যার কলামে ফাঁকা থাকলে (যেমন “ডেলিভারি এখনো হয়নি”) float-এর nan-এর চেয়ে এটি অনেক সৎ: ৩ দিন ৩.০ দিন হয়ে যায় না।

৩ · লেখার কলাম — object, pandas 3-এর str আর category

বাজারঘরের ২ লাখ অর্ডারে জেলার নাম মাত্র ৮টি, পেমেন্টের ধরন ৩টি (COD, bKash, card). অথচ প্রতিটি সারিতে নামটি আবার লেখা। স্কুলের হাজিরা খাতায় প্রতিদিন প্রতিটি ছাত্রের পুরো নাম লেখা হয় না; রোল নম্বর লেখা হয়, আর খাতার প্রথম পাতায় একবার রোল থেকে নামের তালিকা। pandas-এর category dtype ঠিক এটি করে: প্রতিটি আলাদা মান একবার একটি তালিকায় (categories), আর প্রতিটি সারিতে শুধু একটি ছোট পূর্ণসংখ্যার code. Parquet ফাইলের dictionary encoding-ও একই ধারণা (পর্ব ১০)।

pandas 3-এ গল্পে একটি নতুন চরিত্র এসেছে। আগে লেখার কলাম ডিফল্টে object ছিল। pandas 3.0 থেকে ডিফল্ট হলো নতুন str dtype: pyarrow install থাকলে সেটি লেখাগুলো Apache Arrow-এর বিন্যাসে রাখে, একটি টানা byte-এর buffer আর প্রতিটি সারি কোথায় শুরু তার একটি offset-তালিকায়; pyarrow না থাকলে Python object-এই রাখে। নিচের ছবিতে একই চারটি সারি তিনভাবে।

এবার ধাপে ধাপে দেখুন, ছয় সারির একটি জেলা-কলাম কীভাবে category হয়, আর তুলনার সময় pandas আসলে কী তুলনা করে।

1s = pd.Series(["ঢাকা", "খুলনা", "ঢাকা", "সিলেট", "ঢাকা", "খুলনা"])2c = s.astype("category")3c.cat.categories4c.cat.codes5c == "ঢাকা"6# 200,000 rows, same idea

এবার বাজারঘরের ২ লাখ সারির বানানো অর্ডার-টেবিল (seed 42) নিয়ে আগে-পরে মাপুন: চারটি সংখ্যার কলাম downcast, দুটি লেখার কলাম category. প্রথমবার চালালে NumPy আর pandas নামাতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np
import pandas as pd
pd.set_option("display.width", 60)

rng = np.random.default_rng(42)
n = 200_000
districts = ["ঢাকা", "চট্টগ্রাম", "খুলনা", "রাজশাহী",
             "সিলেট", "বরিশাল", "রংপুর", "ময়মনসিংহ"]
df = pd.DataFrame({
    "order_id": np.arange(1, n + 1, dtype=np.int64),
    "district": rng.choice(districts, n, p=[.35, .2, .1, .1, .08, .05, .06, .06]),
    "payment": rng.choice(["COD", "bKash", "card"], n, p=[.5, .35, .15]),
    "qty": rng.integers(1, 6, n, dtype=np.int64),
    "price_paisa": rng.integers(5_000, 500_000, n, dtype=np.int64),
    "delivery_days": rng.integers(1, 8, n, dtype=np.int64),
})
print("str dtype:", repr(df["district"].dtype))
print("shallow MB:", round(df.memory_usage().sum() / 1e6, 2),
      "| deep MB:", round(df.memory_usage(deep=True).sum() / 1e6, 2))

small = df.copy()
for c in ["order_id", "qty", "price_paisa", "delivery_days"]:
    small[c] = pd.to_numeric(small[c], downcast="integer")
for c in ["district", "payment"]:
    small[c] = small[c].astype("category")
mem = pd.DataFrame({"before": df.memory_usage(deep=True, index=False),
                    "after": small.memory_usage(deep=True, index=False)}) / 1e6
mem["dtype"] = small.dtypes.astype(str)
print(mem.round(2))
print("total MB:", round(mem["before"].sum(), 2), "->", round(mem["after"].sum(), 2))
print("district as object MB:",
      round(df["district"].astype(object).memory_usage(deep=True) / 1e6, 2))
print("codes:", small["district"].cat.codes.dtype, small["district"].cat.codes.head(3).tolist())
print("same data?", (small["district"].astype(str) == df["district"]).all(),
      int(small["price_paisa"].sum()) == int(df["price_paisa"].sum()))

str dtype: <StringDtype(storage='python', na_value=nan)>
shallow MB: 8.0 | deep MB: 21.35
               before  after     dtype
order_id         1.60    0.8     int32
district        12.94    0.2  category
payment          5.77    0.2  category
qty              1.60    0.2      int8
price_paisa      1.60    0.8     int32
delivery_days    1.60    0.2      int8
total MB: 25.11 -> 2.4
district as object MB: 12.94
codes: int8 [7, 1, 3]
same data? True True

category-র আরও দুটি আচরণ মনে রাখুন। প্রথমত, pandas 3-এ category কলামে groupby-এর observed ডিফল্টে True: শুধু ডেটায় থাকা category-গুলোর ফল আসে (আগে সব category আসত, খালিগুলোসহ, আর pandas 2.x সতর্ক করত)। দ্বিতীয়ত, আলাদা categories-ওয়ালা দুটি কলাম pd.concat করলে ফল আর category থাকে না; লেখকের যন্ত্রে pandas 3.1.1-এ ফল হলো str. বড় ডেটা টুকরো টুকরো পড়ে জোড়া লাগালে (অংশ ৫) এই কারণে আবার astype("category") লাগতে পারে, অথবা আগে থেকে একই categories ঠিক করে দিতে হয় (pd.CategoricalDtype([...]))।

৪ · কম পড়া — usecols, পড়ার সময়েই dtype, আর nrows

বাজার থেকে শুধু ডিম আনতে বললে পুরো দোকান কিনে আনার দরকার নেই। টেবিল ছোট করার সবচেয়ে সস্তা পথ হলো যা লাগবে না, তা RAM-এ না তোলা। pd.read_csv-এর তিনটি parameter এখানে কাজের (পড়া-লেখার সাধারণ পরিচয় আছে পর্ব ২১-এ):

• usecols: শুধু এই কলামগুলো পড়া হয়। CSV-তে ফাইলের প্রতিটি লাইন তবু পড়তে হয়, কিন্তু বাকি কলাম থেকে কোনো Python বা pandas মান তৈরি হয় না। Parquet-এ (কলাম ধরে রাখা ফাইল) বাদ দেওয়া কলামগুলো ডিস্ক থেকে পড়াই হয় না।
• dtype: পড়ার সময়েই বলে দিন কোন কলাম কোন dtype. পরে বদলালে আগে বড় dtype-এ পুরো কলাম তৈরি হয়, তারপর ছোটটি; চূড়ায় দুটিই একসঙ্গে থাকে। পড়ার সময় বললে সেই চূড়া এড়ানো যায়।
• nrows: প্রথম কয়েকটি সারি পড়ে কলামের নাম, ধরন আর অদ্ভুত মান দেখে নিন, তারপর পুরো ফাইলের পরিকল্পনা করুন।

নিচে বাজারঘরের ১২০টি অর্ডারের একটি ছোট CSV পাতার ভেতরেই রাখা আছে (orders.csv নামে)। এত ছোট ফাইলে সংখ্যাগুলো KB-তে, কিন্তু অনুপাতটিই আসল কথা, আর সেটি বড় ফাইলেও প্রায় একই থাকে।

import pandas as pd
pd.set_option("display.width", 60)

def kb(frame):
    return round(frame.memory_usage(deep=True).sum() / 1024, 1)

full = pd.read_csv("orders.csv")                      # সব কলাম, অনুমিত dtype
print("all columns:", full.shape, kb(full), "KB")
print({str(k): v for k, v in full.dtypes.astype(str).value_counts().items()})

lean = pd.read_csv(
    "orders.csv",
    usecols=["district", "payment", "qty", "price_paisa"],
    dtype={"district": "category", "payment": "category",
           "qty": "int8", "price_paisa": "int32"},
)
print("usecols + dtype:", lean.shape, kb(lean), "KB")
print({c: str(t) for c, t in lean.dtypes.items()})

peek = pd.read_csv("orders.csv", nrows=5)              # শুধু প্রথম ৫ সারি
print("nrows=5:", peek.shape)
print(peek[["order_id", "district", "qty"]].head(3))

a = (full["qty"] * full["price_paisa"]).sum()
b = (lean["qty"].astype("int64") * lean["price_paisa"]).sum()
print("same total paisa?", a == b, a)

all columns: (120, 10) 26.3 KB
{'int64': 5, 'str': 5}
usecols + dtype: (120, 4) 1.4 KB
{'district': 'category', 'qty': 'int8', 'price_paisa': 'int32', 'payment': 'category'}
nrows=5: (5, 10)
   order_id district  qty
0      1001     ঢাকা    4
1      1002    সিলেট    3
2      1003  রাজশাহী    2
same total paisa? True 88188000

বড় ফাইলে একই কৌশল কেমন দেখায়? লেখকের ল্যাপটপে ৫০ লাখ সারি আর ১০ কলামের একটি বানানো অর্ডার-ফাইল (CSV ৩১২ MB) নিয়ে সত্যিকারের run (Python 3.14.4, pandas 3.1.1, প্রতিটি সারি একবার মাপা):

~/bazarghar-ai$ python read_less.py
pandas 3.1.1
all columns             0.21 s    539 MB
all, engine=pyarrow     0.30 s    649 MB
usecols (4 columns)     0.48 s    215 MB
usecols + dtype         0.62 s     35 MB

শেষ লাইনের dtype হলো কোডের মতোই: দুটি category, int8 আর int32. মেমরিতে ফল পরিষ্কার: ৫৩৯ MB থেকে ৩৫ MB, প্রায় ১৫ ভাগের এক ভাগ। কিন্তু সময়ের দিকটি সৎভাবে দেখুন: এই run-এ usecols আর dtype দিয়ে পড়া একটু ধীর হয়েছে, কারণ লেখা থেকে category বানাতে বাড়তি কাজ লাগে। তাই “কম পড়া” মূলত মেমরির ওষুধ; সময় বাঁচাতে আসল লাফ আসে ফাইলের ধরন বদলালে (অংশ ৮)। আর লক্ষ করুন, এই যন্ত্রে ৩১২ MB CSV পড়তে মাত্র ০.২ সেকেন্ড লেগেছে; আপনার যন্ত্রে, বা পুরোনো pandas-এ, সংখ্যাটি অনেক আলাদা হতে পারে। এটি একটি যন্ত্রের একটি run, কোনো সাধারণ ফল নয়।

৫ · টুকরো টুকরো পড়া — chunksize আর আংশিক যোগফল ঠিকভাবে জোড়া

ফাইল যদি RAM-এই না ধরে? তখন বোর্ড পরীক্ষার খাতা দেখার মতো করুন: পরীক্ষকেরা খাতা বান্ডিলে ভাগ করে দেখেন, প্রতিটি বান্ডিলের মোট নম্বর আর খাতার সংখ্যা একটি কাগজে লেখেন, শেষে সব কাগজ জুড়ে মোট গড় বের করেন। pandas-এ এর নাম chunking: pd.read_csv(..., chunksize=100_000) পুরো ফাইল একবারে না দিয়ে ১ লাখ সারির একেকটি DataFrame একে একে দেয়। যেকোনো সময় RAM-এ থাকে শুধু একটি টুকরো আর আপনার জমানো ছোট হিসাব।

with pd.read_csv("orders.csv", chunksize=100_000) as reader:
    for chunk in reader:          # প্রতিটি chunk একটি সাধারণ DataFrame
        ...                       # ছোট আংশিক ফল জমান

ফাঁদটি এখানে। ধরুন প্রশ্ন “গড় ডেলিভারি কত দিন?”. সহজ মনে হয় প্রতিটি টুকরোর গড় বের করে, শেষে সেই গড়গুলোর গড় নেওয়া। এটি ভুল, যদি না সব টুকরোর আকার সমান হয় (আর groupby-তে প্রতিটি দলের সারি প্রতিটি টুকরোয় সমান হয়, যা প্রায় কখনো হয় না)। শেষ টুকরো প্রায় সবসময় ছোট। গড় এমন একটি হিসাব যা সরাসরি জোড়া যায় না; জোড়া যায় sum আর count. তাই প্রতিটি টুকরো থেকে sum আর count রাখুন, শেষে মোট sum ÷ মোট count. এমন জোড়া-যোগ্য হিসাবকে বলে partial aggregate.

সঠিক গড় = (S₁ + S₂ + … + S_k) ÷ (n₁ + n₂ + … + n_k)

এখানে S_i হলো i-তম টুকরোর যোগফল আর n_i তার সারির সংখ্যা। আর গড়ের গড় হলো (S₁/n₁ + … + S_k/n_k) ÷ k, যা প্রতিটি টুকরোকে সমান গুরুত্ব দেয়, তার সারি যত কমই হোক। পাতার orders.csv-এর ১২০টি অর্ডারকে ৫০টি করে ভাগ করলে টুকরো হয় ৫০, ৫০ আর ২০টির; আর শেষ ২০টি অর্ডার ঈদের ভিড়ের, ডেলিভারি অনেক দেরিতে। ধাপে ধাপে দেখুন।

1total, count, means = 0, 0, []2for ch in pd.read_csv(..., chunksize=50):3    total += ch["delivery_days"].sum(); count += len(ch)4    means.append(ch["delivery_days"].mean())5right = total / count6wrong = sum(means) / len(means)

এবার একই হিসাব সত্যি চালিয়ে দেখুন, আর জেলা ধরেও। জেলা ধরে প্রতিটি টুকরো থেকে groupby(...).agg(["sum", "count"]) (পর্ব ২৪) রাখা হয়, শেষে সব টুকরোর ছোট টেবিল pd.concat করে জেলা ধরে আবার যোগ করা হয়।

import pandas as pd
pd.set_option("display.width", 60)

cols = ["district", "delivery_days"]
parts, means = [], []
for i, ch in enumerate(pd.read_csv("orders.csv", usecols=cols, chunksize=50)):
    m = ch["delivery_days"].mean()
    print(f"chunk {i}: {len(ch)} rows, sum {ch['delivery_days'].sum()}, mean {m:.3f}")
    means.append(m)
    parts.append(ch.groupby("district")["delivery_days"].agg(["sum", "count"]))

total = pd.concat(parts).groupby(level=0).sum()       # আংশিক যোগফল জোড়া
full = pd.read_csv("orders.csv", usecols=cols)

print("ভুল : chunk-এর গড়ের গড় =", round(sum(means) / len(means), 3))
print("ঠিক : মোট sum / মোট count =",
      round(total["sum"].sum() / total["count"].sum(), 3))
print("যাচাই: পুরো ফাইলের গড়   =", round(full["delivery_days"].mean(), 3))

wrong = pd.concat([p["sum"] / p["count"] for p in parts]).groupby(level=0).mean()
by = pd.DataFrame({
    "combined": total["sum"] / total["count"],
    "full": full.groupby("district")["delivery_days"].mean(),
    "mean_of_means": wrong,
}).round(3)
print(by)

chunk 0: 50 rows, sum 109, mean 2.180
chunk 1: 50 rows, sum 102, mean 2.040
chunk 2: 20 rows, sum 141, mean 7.050
ভুল : chunk-এর গড়ের গড় = 3.757
ঠিক : মোট sum / মোট count = 2.933
যাচাই: পুরো ফাইলের গড়   = 2.933
           combined   full  mean_of_means
district
খুলনা         2.688  2.688          3.405
চট্টগ্রাম     2.826  2.826          3.494
ঢাকা          2.891  2.891          3.967
রাজশাহী       3.333  3.333          4.222
সিলেট         3.050  3.050          3.583

বড় ফাইলে একই পদ্ধতি: লেখকের ল্যাপটপে ৫০ লাখ সারির CSV থেকে দুটি কলাম, ১৫ লাখ সারির টুকরোয় (সত্যিকারের run, pandas 3.1.1). প্রতিটি টুকরো RAM-এ প্রায় ৩৫ MB, পুরো কাজ প্রায় ১.১ সেকেন্ড, আর জোড়া লাগানো ফল পুরো ফাইলের ফলের সঙ্গে হুবহু মিলেছে:

~/bazarghar-ai$ python chunks.py
chunk 0: rows 1,500,000  MB  34.6
chunk 1: rows 1,500,000  MB  34.6
chunk 2: rows 1,500,000  MB  34.6
chunk 3: rows   500,000  MB  11.5
time s: 1.12
            combined    full  mean_of_means
district
Barishal      4.0006  4.0006         4.0039
Chattogram    4.0002  4.0002         4.0000
Dhaka         3.9995  3.9995         3.9998
combined == full: True

এখানে এলোমেলো ডেটায় গড়ের গড়ের ভুল চোখে পড়ার মতো নয় (৪.০০০৬ বনাম ৪.০০৩৯), আর ঠিক সেটিই বিপজ্জনক: ছোট পরীক্ষায় “প্রায় মিলে গেছে” দেখে কোড বিশ্বাস করলে, যেদিন টুকরোগুলো সময় ধরে সাজানো থাকবে আর শেষ টুকরোয় ঈদ পড়বে, সেদিন ভুল বড় হবে। কোন হিসাব সরাসরি জোড়া যায়, মনে রাখুন: sum, count, min, max জোড়া যায়; mean জোড়া যায় sum আর count দিয়ে; variance জোড়া যায় sum, sum of squares আর count দিয়ে (বা আরও স্থিতিশীল সূত্রে); median আর nunique সরাসরি জোড়া যায় না, তার জন্য সব মান, বা আনুমানিক কৌশল লাগে।

৬ · Vectorised বনাম apply আর iterrows — আর eval, query

পর্ব ১৫-এ দেখেছেন, NumPy-তে পুরো array-এর ওপর একবারে কাজ (vectorization) Python loop-এর চেয়ে অনেক দ্রুত। pandas-এর কলামও ভেতরে array, তাই একই নিয়ম খাটে। কিন্তু pandas-এ দুটি জনপ্রিয় পথ দেখতে “pandas-এর” হলেও ভেতরে Python loop:

• df.apply(f, axis=1): প্রতিটি সারির জন্য একটি Series বানিয়ে আপনার Python function ডাকে। সারি যত, Python call তত, আর প্রতিটি সারির Series বানানোর খরচ আলাদা।
• df.iterrows(): প্রতিটি সারি একটি Series হিসেবে দেয়; আরও ধীর, আর মিশ্র dtype-এর সারিতে সংখ্যাগুলোর dtype বদলে যেতে পারে (pandas-এর নথিতে সতর্ক করা)। দরকার হলে itertuples() অনেক দ্রুত।

বাজারঘরের নিয়ম: মোট = পরিমাণ × দাম + ডেলিভারি চার্জ, ঢাকায় ৬০ টাকা (৬০০০ পয়সা), বাইরে ১২০ টাকা। ১০ হাজার সারিতে চারটি পথ মেপে দেখুন। প্রতিটি পথ একবারই মাপা; আগে পর্ব ১৯-এর নিয়ম মনে রাখুন, একবারের সময় শুধু মাত্রার আন্দাজ দেয়।

import time
import numpy as np
import pandas as pd

rng = np.random.default_rng(42)
n = 10_000
df = pd.DataFrame({
    "qty": rng.integers(1, 6, n),
    "price_paisa": rng.integers(5_000, 500_000, n),
    "district": rng.choice(["ঢাকা", "খুলনা", "সিলেট"], n),
})
# নিয়ম: মোট = qty × দাম + ডেলিভারি চার্জ (ঢাকায় 6000 পয়সা, বাইরে 12000)

def charge(d):
    return 6_000 if d == "ঢাকা" else 12_000

def timed(label, f):
    t0 = time.perf_counter()
    out = f()
    print(f"{label:22s} {(time.perf_counter() - t0) * 1000:8.1f} ms")
    return np.asarray(out, dtype=np.int64)

v = timed("vectorised column", lambda: df["qty"] * df["price_paisa"]
          + np.where(df["district"] == "ঢাকা", 6_000, 12_000))
m = timed("Series.map + vector", lambda: df["qty"] * df["price_paisa"]
          + df["district"].map({"ঢাকা": 6_000, "খুলনা": 12_000, "সিলেট": 12_000}))
a = timed("apply(axis=1)", lambda: df.apply(
    lambda r: r["qty"] * r["price_paisa"] + charge(r["district"]), axis=1))
it = timed("iterrows loop", lambda: [r["qty"] * r["price_paisa"] + charge(r["district"])
                                     for _, r in df.iterrows()])
print("all equal?", all(np.array_equal(v, x) for x in (m, a, it)))
print("first 3:", v[:3])

vectorised column           1.6 ms
Series.map + vector         1.7 ms
apply(axis=1)             121.1 ms
iterrows loop             329.0 ms
all equal? True
first 3: [ 178655  463932 1056268]

দুটি ছোট হাতিয়ারের কথা নোট হিসেবে। df.eval("amount = qty * price_paisa") একটি লেখা expression-কে পুরো কলামে চালায়, আর df.query("payment == 'bKash' and qty > 2") boolean mask-এর একটি পড়তে সহজ রূপ (বাছাইয়ের বিস্তারিত পর্ব ২২-এ)। numexpr package install থাকলে pandas এগুলো তার মাধ্যমে চালাতে পারে, যা বড় টেবিলে অস্থায়ী array কমিয়ে কিছু গতি দেয়; pandas-এর নথি নিজেই বলে, ছোট টেবিলে বা সরল expression-এ এর লাভ নেই, বরং ধীর হতে পারে। তাই এগুলো মূলত পড়তে সহজ লেখার জন্য বাছুন, গতির জন্য হলে নিজে মেপে।

৭ · pandas যখন যথেষ্ট নয় — Polars, eager আর lazy

সব কৌশলের পরেও কখনো pandas ধীর থাকে: ফাইল RAM-এর কাছাকাছি, groupby চলে মিনিটের পর মিনিট, আর আপনার যন্ত্রের অনেকগুলো CPU core বসে থাকে, কারণ pandas-এর বেশির ভাগ কাজ এক core-এ চলে। তখন একটি জনপ্রিয় বিকল্প Polars: Rust ভাষায় লেখা একটি DataFrame library, Ritchie Vink ২০২০ সালের দিকে শুরু করেন। Polars ডেটা রাখে Apache Arrow-এর কলাম-বিন্যাসে, কাজ ভাগ করে সব core-এ, আর তার সবচেয়ে বড় পার্থক্য: সে আপনার পুরো প্রশ্নটি আগে দেখে, তারপর চালায়।

লেখার সময়ে PyPI-তে Polars-এর সর্বশেষ স্থির version 2.1.0 (2.0 এসেছে সম্প্রতি, আর তাতে কিছু ভাঙা পরিবর্তন আছে; পুরোনো টিউটোরিয়ালের কোড না-ও চলতে পারে)। Polars ব্রাউজারের এই Python-এ নেই, তাই এই অংশের সব আউটপুট লেখকের ল্যাপটপের সত্যিকারের run (Python 3.14.4, Polars 2.1.0), ৫০ লাখ সারির সেই বানানো অর্ডার-ফাইল দিয়ে (ইংরেজি জেলার নামে, যাতে টেবিল সরু থাকে)। Install: uv pip install polars (পর্ব ৭)।

Polars-এ দুই রকম কাজ। Eager পথে pl.read_parquet বা pl.read_csv সঙ্গে সঙ্গে পুরো ডেটা পড়ে একটি DataFrame দেয়, আর প্রতিটি লাইন তখনই চলে, pandas-এর মতো। কাজ লেখা হয় expression দিয়ে: pl.col("qty") * pl.col("price_paisa") একটি “কলামের হিসাবের বর্ণনা”, যা Polars নিজে সমান্তরালে চালায়। pandas-এর মতো df["col"] দিয়ে সারি-সারি কাজের বদলে এই expression-ই Polars-এর ভাষা।

# eager.py
import polars as pl

df = pl.read_parquet("orders_5m.parquet",
                     columns=["district", "payment", "qty", "price_paisa"])
print(type(df).__name__, df.shape)
out = (df.filter(pl.col("payment") == "bKash")
         .group_by("district")
         .agg(pl.len().alias("orders"),
              (pl.col("qty") * pl.col("price_paisa")).sum().alias("total_paisa"))
         .sort("total_paisa", descending=True))
print(out.head(3))

~/bazarghar-ai$ python eager.py
DataFrame (5000000, 4)
shape: (3, 3)
┌────────────┬────────┬──────────────┐
│ district   ┆ orders ┆ total_paisa  │
│ ---        ┆ ---    ┆ ---          │
│ str        ┆ u32    ┆ i64          │
╞════════════╪════════╪══════════════╡
│ Dhaka      ┆ 613043 ┆ 465377500781 │
│ Chattogram ┆ 350995 ┆ 266146716184 │
│ Rajshahi   ┆ 174837 ┆ 132192024106 │
└────────────┴────────┴──────────────┘

লক্ষ করুন: Polars-এ index নেই, groupby-র নাম group_by, আর pl.len() প্রতিটি দলের সারি গোনে (Polars 2-এ group_by(...).count() সরানো হয়েছে)। ঢাকার bKash অর্ডারে মোট ৪৬৫,৩৭৭,৫০০,৭৮১ পয়সা, মানে প্রায় ৪৬৫ কোটি টাকা; বানানো ডেটা, তাই সংখ্যাটি শুধু উদাহরণ।

Lazy পথে pl.scan_parquet বা pl.scan_csv কিছুই পড়ে না; শুধু একটি LazyFrame দেয়, যা আসলে “কী করতে হবে” তার একটি পরিকল্পনা (query plan). প্রতিটি .filter, .with_columns, .group_by সেই পরিকল্পনায় একটি ধাপ যোগ করে। .collect() ডাকলে Polars-এর query optimizer পুরো পরিকল্পনাটি দেখে আগে সাজায়, তারপর চালায়। Polars 2-এ lazy query-র collect() ডিফল্টে streaming engine-এ চলে, যা ডেটা টুকরো টুকরো প্রক্রিয়া করে, অনেকটা অংশ ৫-এর chunk-এর মতো, কিন্তু নিজে থেকেই। নিচের ধাপে দেখুন একটি প্রশ্ন scan থেকে collect পর্যন্ত কীভাবে এগোয়।

q = pl.scan_parquet(
      "orders_5m.parquet")
type(q) → LazyFrame
plan: Parquet SCAN
      10/10 columns

q = q.filter(
  pl.col("payment") == "bKash")
plan: FILTER payment == bKash
        Parquet SCAN
এখনো ০টি সারি পড়া

.with_columns(
   (qty * price_paisa)
   .alias("amount_paisa"))
.group_by("district").agg(
   len, sum, mean)
.sort("total_paisa")

লাগবে: district, payment,
  qty, price_paisa,
  delivery_days
plan: Parquet SCAN
  PROJECT 5/10 COLUMNS
বাকি ৫টি কলাম পড়াই হবে না

Parquet SCAN
  PROJECT 5/10 COLUMNS
  SELECTION:
  col("payment") == "bKash"
  ESTIMATED ROWS: 5000000
filter এখন পড়ার ধাপেই

streaming engine, সব core
৫০ লাখ সারি → শুধু bKash
→ DataFrame, 8 rows
  (প্রতি জেলা ১টি)
Dhaka  613043 orders
       465377500781 paisa

Stepper-এর পরিকল্পনাটি বানানো নয়; Polars নিজেই q.explain() দিয়ে দেখায়। লেখকের ল্যাপটপে সত্যিকারের run (Polars 2.1.0):

~/bazarghar-ai$ python polars_lazy.py
Polars 2.1.0
LazyFrame
SORT BY [descending: [true]] [col("total_paisa")]
  AGGREGATE[maintain_order: false]
    [len().alias("orders"), col("amount_paisa").sum().alias("total_paisa"), col("delivery_days").mean().round().alias("avg_days")] BY [col("district")]
    FROM
    simple π 3/3 ["district", "amount_paisa", ... 1 other column]
       WITH_COLUMNS:
       [(col("qty") * col("price_paisa")).alias("amount_paisa")]
        simple π 4/4 ["district", "qty", ... 2 other columns]
          Parquet SCAN [orders_5m.parquet]
          PROJECT 5/10 COLUMNS
          SELECTION: col("payment") == "bKash"
          ESTIMATED ROWS: 5000000
…  (এরপর collect()-এর ফল, ৮টি সারির টেবিল)

পরিকল্পনাটি নিচ থেকে ওপরে পড়ুন: scan (কলাম আর filter-সহ), তারপর নতুন কলাম, তারপর aggregate, শেষে sort. π (pi) চিহ্নটি relational algebra-র projection, মানে কলাম বাছাই; database-এর query optimizer ঠিক এভাবেই কাজ করে (DBMS কোর্সের query optimization পর্ব)। একটি সাবধানতা Polars 2-এর নথি থেকে: streaming engine-এ group_by আর join-এর ফলের সারির ক্রম নিশ্চিত নয়, তাই ক্রম দরকার হলে স্পষ্ট .sort দিন, যেমন এখানে দেওয়া।

৮ · একই প্রশ্ন, আট পথে — pandas, Polars আর DuckDB-এর একটি মাপ

তুলনার আগে আরেকটি টুল: DuckDB. এটি একটি in-process analytical database: আলাদা server লাগে না, Python-এর ভেতরেই চলে, আর CSV বা Parquet ফাইলের ওপর সরাসরি SQL চালায়। SQL যাঁরা জানেন (DBMS কোর্সের GROUP BY পর্ব), তাঁদের জন্য এটি সবচেয়ে কম নতুন শেখার পথ। লেখার সময়ে PyPI-তে DuckDB-এর version 2.0.0, আর এটি লেখকের যন্ত্রে uv pip install duckdb-এ সহজেই install হয়েছে।

# duck.py
import duckdb

print(duckdb.sql("""
    SELECT district, COUNT(*) AS orders, SUM(qty * price_paisa) AS total_paisa
    FROM 'orders_5m.parquet' WHERE payment = 'bKash'
    GROUP BY district ORDER BY total_paisa DESC LIMIT 3
"""))

~/bazarghar-ai$ python duck.py
┌────────────┬────────┬──────────────┐
│  district  │ orders │ total_paisa  │
│  varchar   │ int64  │    int128    │
├────────────┼────────┼──────────────┤
│ Dhaka      │ 613043 │ 465377500781 │
│ Chattogram │ 350995 │ 266146716184 │
│ Rajshahi   │ 174837 │ 132192024106 │
└────────────┴────────┴──────────────┘

একই তিনটি সংখ্যা, Polars-এর মতোই। DuckDB যোগফল রেখেছে int128-এ, overflow-এর ভয় ছাড়া। এবার পুরো প্রশ্নটি (ফাইল পড়া + bKash বাছাই + জেলা ধরে মোট আর সংখ্যা) আটটি পথে মাপা হলো। প্রতিটি পথ একবার মাপা, ফাইল আগে একবার পড়ে নেওয়ার পর (তাই অপারেটিং সিস্টেমের file cache গরম); সত্যিকারের run:

~/bazarghar-ai$ python bench.py
Python 3.14.4 | pandas 3.1.1 | polars 2.1.0 | duckdb 2.0.0
pandas read_csv (all columns)        0.21 s
groupby mean only: pandas           0.150 s
groupby mean only: polars           0.007 s
in-memory MB: pandas 539 | polars 379
--- whole query (read + filter + groupby) ---
pandas CSV, all columns              0.51 s
pandas CSV, usecols+dtype+pyarrow    0.55 s
pandas Parquet, 4 columns            0.29 s
polars eager read_csv                0.22 s
polars lazy scan_csv                 0.11 s
polars lazy scan_parquet             0.02 s
duckdb SQL on CSV                    0.27 s
duckdb SQL on Parquet                0.03 s
same totals: True

কী বলা যায়, আর কী বলা যায় না:

• শুধু groupby-তে (ডেটা আগে থেকেই RAM-এ) এই run-এ Polars প্রায় ২০ গুণ দ্রুত (০.১৫০ বনাম ০.০০৭ সেকেন্ড)। এর বড় অংশ সব core ব্যবহার; কম core-এর যন্ত্রে পার্থক্য কম হবে।
• পুরো প্রশ্নে সবচেয়ে বড় লাফ এসেছে ফাইলের ধরন থেকে: Parquet-এর ওপর lazy Polars বা DuckDB প্রায় ০.০২–০.০৩ সেকেন্ড, কারণ তারা শুধু দরকারি কলাম পড়ে, আর Parquet-এর ভেতরের পরিসংখ্যান দেখে টুকরো বাদ দিতে পারে। pandas-ও Parquet-এ (৪ কলাম) CSV-র চেয়ে দ্রুত হয়েছে।
• সব পথের ফল হুবহু এক (শেষ লাইন)। মাপার আগে এটিই প্রথম শর্ত।
• যা বলা যায় না: “Polars সবসময় ২০ গুণ দ্রুত”। এটি একটি যন্ত্রের একটি run, একটি বানানো টেবিলে, একটি প্রশ্নে। ছোট ডেটায় পার্থক্য প্রায় অদৃশ্য। নিজের ডেটায়, নিজের প্রশ্নে মাপুন।

৯ · সিদ্ধান্তের চেকলিস্ট — pandas-এ থাকা, ভাগ করা, না টুল বদলানো

pandas বনাম Polars নিয়ে আলোচনা প্রায়ই দলাদলিতে গড়ায়। বাস্তবে প্রশ্নটি “কোনটি ভালো” নয়, “আমার এই কাজে কোনটি যথেষ্ট”। দুই পক্ষের যুক্তি ভাবনার প্রশ্ন ৪-এ। নিচের ক্রমে ভাবুন; আগের ধাপে কাজ হলে পরের ধাপে যাওয়ার দরকার নেই।

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

“আমার ২০ GB CSV pandas-এ ধীর, দ্রুত করে দাও” লিখলে একটি AI সহকারী সাধারণত চটপটে একটি উত্তর দেবে। সেই উত্তর আপনার ডেটা দেখেনি, আপনার যন্ত্রে চলেনি, আর প্রায়ই পুরোনো টিউটোরিয়ালের ওপর দাঁড়ানো। এই বিষয়ে AI সহকারীরা প্রায়ই যা করে:

• chunk-এ ভাগ করে প্রতিটি chunk-এর mean() নেয়, তারপর সেগুলোর গড়: দেখতে ঠিক, উত্তর ভুল। median বা nunique-ও একইভাবে “জোড়া” দেয়।
• পুরোনো API লেখে: pandas 2.0-এ সরানো df.append, pandas 3-এ আর কাজ না করা chained assignment (df[df.qty > 2]["flag"] = 1), বা Polars 2-এ সরানো group_by(...).count(); অথবা এমন parameter বানায় যা ওই function-এ নেই।
• মেমরি বাঁচাতে সব integer-কে int8 বা int32 করে দেয়, পরের গুণে overflow-এর কথা না ভেবে; টাকাকে float32 করে।
• “Polars ১০ গুণ দ্রুত” বা “category সবসময় ভালো” বলে না-মাপা দাবি করে; id-জাতীয় কলামেও category বসায়।
• astype-এর warning বা SettingWithCopyWarning-এর পুরোনো সমাধান হিসেবে warnings.filterwarnings("ignore") বসিয়ে সমস্যা ঢেকে দেয়।

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

• ছোট একটি ফাইলে chunk-এর ফল আর পুরো ফাইল একবারে পড়ার ফল মিলিয়েছি; গড় এসেছে মোট sum ÷ মোট count থেকে
• প্রতিটি downcast-এর পর পরের হিসাবগুলোর (গুণ, যোগ) সর্বোচ্চ মান dtype-এ ধরে কি না দেখেছি; টাকা পূর্ণসংখ্যার পয়সায় আর int64-এ
• আগে-পরে memory_usage(deep=True) আর সময় নিজে মেপেছি; AI-এর বলা গুণফল বিশ্বাস করিনি
• প্রতিটি অচেনা function আর parameter আমার pandas বা Polars version-এর অফিসিয়াল নথিতে মিলিয়েছি (pandas.pydata.org, docs.pola.rs)
• কোনো warning চাপা দেওয়া হয়নি; প্রতিটি warning পড়ে কারণ বুঝেছি
• গ্রাহকের আসল ডেটা, ফোন নম্বর বা ঠিকানা AI-তে পেস্ট করিনি; বানানো নমুনা দিয়েছি