Groupby আর aggregation — split, apply, combine

আগের পর্বগুলোতে (পর্ব ২০-এ Series, DataFrame আর index; পর্ব ২১-এ ফাইল পড়া; পর্ব ২২-এ বাছাই আর filter; পর্ব ২৩-এ ডেটা পরিষ্কার) বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) অর্ডারের টেবিল হাতে এসেছে আর পরিষ্কার হয়েছে। এবার ব্যবসার আসল প্রশ্নগুলো: কোন জেলায় বিক্রি সবচেয়ে বেশি? প্রতিটি জেলায় কতজন আলাদা ক্রেতা? কোন অর্ডারটি নিজের জেলার গড়ের চেয়ে অনেক বড়? এসব প্রশ্নের উত্তর একটি সাধারণ ছাঁচে আসে: দলে ভাগ, প্রতিটি দলে হিসাব, তারপর ফলগুলো জোড়া। পর্ব ৯-এ এই কাজ খাঁটি Python-এ defaultdict দিয়ে করেছিলেন, আর পর্ব ১৬-এ NumPy-র axis দিয়ে পুরো টেবিলের সারাংশ নিয়েছিলেন। groupby এই দুটিকে মেলায়: দল ঠিক হয় একটি কলামের মান দিয়ে, আর হিসাব চলে compiled কোডে। সব চালানো যায় এমন ব্লক পাতাতেই চলে (ব্রাউজারের Python, pandas 3.0.2); প্রথমবার pandas নামতে কয়েক সেকেন্ড লাগতে পারে।

১ · Split-apply-combine — দলে ভাগ, হিসাব, জোড়া

মাস শেষে একটি চায়ের দোকানের হিসাব খাতার কথা ভাবুন। প্রতিদিনের বিক্রি একটি লম্বা তালিকায় লেখা: কে বাকি নিলেন, কত টাকা। মাস শেষে দোকানি জানতে চান প্রত্যেক ক্রেতার মোট বাকি কত। তিনি তিনটি কাজ করেন: প্রথমে প্রতিটি নামের লেনদেন আলাদা করেন, তারপর প্রত্যেকের লেনদেন যোগ করেন, শেষে নাম আর মোট বাকির একটি ছোট তালিকা বানান। এই তিনটি ধাপের নাম split (ভাগ), apply (প্রয়োগ) আর combine (জোড়া)।

নামটি জনপ্রিয় করেন পরিসংখ্যানবিদ Hadley Wickham, ২০১১ সালে Journal of Statistical Software-এ প্রকাশিত “The Split-Apply-Combine Strategy for Data Analysis” প্রবন্ধে, R-এর plyr package-এর সঙ্গে। ধারণাটি নতুন নয় (SQL-এর GROUP BY আর spreadsheet-এর pivot table অনেক আগের), কিন্তু Wickham তিনটি ধাপকে আলাদা নাম দিয়ে দেখান যে অনেক আলাদা চেহারার কাজ আসলে একই ছাঁচ। pandas-এর অফিসিয়াল docs-এর groupby অধ্যায়ের শিরোনামেও “split-apply-combine” শব্দগুচ্ছটি আছে, যদিও সেখানে Wickham-এর নাম নেই। pandas-এ এক লাইনে:

df.groupby("district")["amount"].sum()
#  └─ split ─┘  └ কোন কলাম ┘  └ apply ┘   combine হয় নিজে থেকে

এখানে district হলো groupby-এর key: যে কলামের মান দেখে ঠিক হয় কোন সারি কোন দলে যাবে। নিচের stepper-এ ছয়টি অর্ডারের একটি ছোট টেবিলে তিনটি ধাপ আলাদা করে দেখুন (দাম বোঝার সুবিধার জন্য টাকায়)।

একটি গুরুত্বপূর্ণ খুঁটিনাটি: df.groupby("district") লিখলে সঙ্গে সঙ্গে কোনো হিসাব হয় না। ফল একটি DataFrameGroupBy object, যা শুধু মনে রাখে কোন key-তে ভাগ হবে। হিসাব হয় তখনই, যখন আপনি তার ওপর sum, agg বা transform ডাকেন। তাই একই GroupBy object একটি নামে রেখে বারবার ব্যবহার করা যায়।

২ · প্রথম হিসাবগুলো — sum, mean, count, size আর nunique

প্রতিটি দলে একটি সংখ্যা ফেরত দেয় এমন হিসাবকে বলে aggregation, যা পর্ব ১৬-এ NumPy-তে দেখেছেন। groupby-তে সবচেয়ে বেশি লাগে এগুলো:

count আর size-এর পার্থক্য সাক্ষাৎকারের প্রিয় প্রশ্ন, আর বাস্তবে ভুলের বড় উৎস। বাজারঘরের অর্ডারের টেবিলে delivery_days কলামে দুটি ঘর ফাঁকা (অর্ডার ৫ আর ৮ এখনো পৌঁছায়নি), আর payment-এ একটি (অর্ডার ৮)। “প্রতিটি জেলায় কয়টি অর্ডার?” প্রশ্নের উত্তর size; “কয়টি অর্ডারের ডেলিভারির সময় জানা আছে?” প্রশ্নের উত্তর count. নিচের কোডে দুটি পাশাপাশি, সঙ্গে আরও দুটি ফাঁদ: key-তে NaN থাকলে কী হয়, আর nunique বনাম count.

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

df = pd.read_csv("orders.csv")
print("ফাঁকা ঘর:", df[["delivery_days", "payment"]].isna().sum().tolist())

g = df.groupby("district")
side = pd.DataFrame({
    "size": g.size(),                        # সারি গোনে, NaN-সহ
    "count": g["delivery_days"].count(),     # শুধু ভরা ঘর গোনে
    "mean_days": g["delivery_days"].mean(),  # NaN বাদ দিয়ে গড়
})
print(side)

print(g.count().loc["ঢাকা"].tolist())   # প্রতিটি কলামের আলাদা count

print(df.groupby("payment").size().to_dict())
print(df.groupby("payment", dropna=False).size().to_dict())

print(g["customer_id"].nunique().to_dict())
print(g["customer_id"].count().to_dict())

ফাঁকা ঘর: [2, 1]
           size  count  mean_days
district
খুলনা         2      2       4.50
চট্টগ্রাম     3      3       2.67
ঢাকা          5      4       1.50
সিলেট         2      1       3.00
[5, 5, 5, 5, 5, 4, 4, 5]
{'COD': 4, 'bKash': 4, 'card': 3}
{'COD': 4, 'bKash': 4, 'card': 3, nan: 1}
{'খুলনা': 1, 'চট্টগ্রাম': 2, 'ঢাকা': 3, 'সিলেট': 1}
{'খুলনা': 2, 'চট্টগ্রাম': 3, 'ঢাকা': 5, 'সিলেট': 2}

একাধিক key

key একটি তালিকাও হতে পারে: df.groupby(["district", "category"]) প্রতিটি (জেলা, পণ্যের ধরন) জোড়াকে একটি দল ধরে। ফলের index তখন দুই স্তরের, যার নাম MultiIndex: প্রথম স্তরে জেলা, দ্বিতীয় স্তরে category. যে জোড়া ডেটায় নেই (যেমন সিলেট আর ইলেকট্রনিক্স), সেটি ফলেও নেই। পরের অংশের কোডে এর আউটপুট দেখবেন, আর পর্ব ২৫-এ unstack দিয়ে এমন ফলকে চওড়া টেবিলে রূপ দেওয়া হবে।

৩ · agg — অনেক হিসাব একসঙ্গে, নিজের দেওয়া নামে

একটি রিপোর্টে প্রায়ই একসঙ্গে কয়েকটি সংখ্যা লাগে: অর্ডারের সংখ্যা, মোট বিক্রি, গড় পরিমাণ, আলাদা ক্রেতা। প্রতিটির জন্য আলাদা groupby লিখে জোড়া দেওয়ার বদলে agg (aggregate) একবারে সব করে। এর তিনটি রূপ:

• তালিকা: g["amount"].agg(["min", "max", "mean"]) একটি কলামে তিনটি হিসাব, ফলের কলামের নাম হয় function-এর নাম।
• dict: g.agg({"amount": "sum", "qty": "mean"}) কোন কলামে কোন হিসাব।
• Named aggregation: g.agg(total=("amount", "sum")). বাঁয়ে ফলের কলামের নাম, ডানে (কোন কলাম, কোন হিসাব) জোড়া। pandas 0.25 (২০১৯) থেকে আছে, আর রিপোর্টের জন্য সবচেয়ে পরিষ্কার রূপ, কারণ ফলের কলামের নাম আপনিই ঠিক করেন।

নিচের কোডে বাজারঘরের জেলাভিত্তিক রিপোর্ট। টাকা পয়সায় পূর্ণসংখ্যা হিসেবে রাখা (পর্ব ৯), শুধু ছাপার সময় টাকায়।

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

df = pd.read_csv("orders.csv")
df["amount"] = df["qty"] * df["price_paisa"]      # পয়সায়, পূর্ণসংখ্যা
print(df[["district", "qty", "amount"]].head(3))

g = df.groupby("district")
print(type(g).__name__, "| গ্রুপ:", g.ngroups)
print(g["amount"].sum())

summary = g.agg(
    orders=("order_id", "count"),
    total=("amount", "sum"),
    avg_qty=("qty", "mean"),
    customers=("customer_id", "nunique"),
).sort_values("total", ascending=False)
summary["total_tk"] = summary["total"] // 100     # শুধু ছাপার জন্য টাকা
print(summary)

flat = df.groupby("district", as_index=False).agg(total=("amount", "sum"))
print(flat.columns.tolist(), flat.shape)
print(df.groupby(["district", "category"])["amount"].sum().head(4))
print(df.groupby("district")["amount"].agg(["min", "max"]).loc["ঢাকা"].tolist())

    district  qty  amount
0       ঢাকা    1  120000
1  চট্টগ্রাম    2   70000
2       ঢাকা    1  450000
DataFrameGroupBy | গ্রুপ: 4
district
খুলনা         460000
চট্টগ্রাম     265000
ঢাকা         1090000
সিলেট         160000
Name: amount, dtype: int64
           orders    total  avg_qty  customers  total_tk
district
ঢাকা            5  1090000     1.60          3     10900
খুলনা           2   460000     1.50          1      4600
চট্টগ্রাম       3   265000     1.33          2      2650
সিলেট           2   160000     1.50          1      1600
['district', 'total'] (4, 2)
district   category
খুলনা      ইলেকট্রনিক্স    300000
           পোশাক           160000
চট্টগ্রাম  পোশাক           150000
           বই              115000
Name: amount, dtype: int64
[90000, 450000]

key কি index হবে, নাকি সাধারণ কলাম? — as_index আর reset_index

default-এ groupby-এর key ফলের index হয়ে যায় (ওপরের summary-তে district বাঁ দিকের index, কলাম নয়)। এটি .loc["ঢাকা"] দিয়ে খোঁজার জন্য সুবিধাজনক। কিন্তু ফলটি CSV-তে লিখতে, আরেকটি টেবিলের সঙ্গে জুড়তে, বা chart-এ পাঠাতে প্রায়ই key-কে সাধারণ কলাম হিসেবে চাই। দুটি উপায়:

• df.groupby("district", as_index=False): শুরু থেকেই key কলাম হিসেবে থাকে; ওপরে flat-এর কলাম ['district', 'total'], shape (4, 2), index সাধারণ 0, 1, 2, 3.
• summary.reset_index(): হিসাবের পরে index-কে কলামে নামিয়ে আনে। একাধিক key-এর MultiIndex থাকলে সব স্তরই কলাম হয়।

দুটির ফল একই; কোনটি পড়তে সহজ, সেটিই বেছে নিন। একটি খুঁটিনাটি: as_index=False দিয়ে size() ডাকলে ফল একটি DataFrame, যার গণনার কলামের নাম size; আর as_index=True-তে Series.

৪ · transform — দলের ফল প্রতিটি সারিতে ফেরত

agg-এর ফল ছোট: চারটি জেলায় চারটি সারি। কিন্তু অনেক প্রশ্নের উত্তর প্রতিটি অর্ডারের জন্য আলাদা চাই: “এই অর্ডারটি নিজের জেলার মোট বিক্রির কত ভাগ?” বা “এই অর্ডারটি জেলার গড় অর্ডারের চেয়ে কত বড়?” এখানে দলের ফলটিকে দলের প্রতিটি সারির পাশে বসাতে হয়। transform ঠিক এটি করে: হিসাব দলের ভেতরে, কিন্তু ফল মূল টেবিলের মতোই লম্বা আর একই index-এ। তাই ফলটি সরাসরি নতুন কলাম হিসেবে বসানো যায়।

এটি আসলে পর্ব ১৫-এর broadcasting-এর দলভিত্তিক রূপ: সেখানে একটি সারির মোট পুরো সারিতে ছড়িয়ে দিয়েছিলেন, এখানে একটি দলের গড় দলের সব সারিতে। নিচে ধাপে ধাপে দেখুন।

এবার বাজারঘরের ১২টি অর্ডারে একই কাজ: প্রতিটি অর্ডার নিজের জেলার মোট বিক্রির কত ভাগ, আর জেলার গড় অর্ডার থেকে কত টাকা দূরে। শেষ চার লাইনে পরের অংশের filter.

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

df = pd.read_csv("orders.csv")
df["amount"] = df["qty"] * df["price_paisa"]
g = df.groupby("district")["amount"]

print("agg:", g.sum().shape, "| transform:", g.transform("sum").shape)

df["district_total"] = g.transform("sum")         # প্রতিটি সারিতে নিজের জেলার মোট
df["share"] = df["amount"] / df["district_total"]
df["vs_avg_tk"] = (df["amount"] - g.transform("mean")) / 100  # গড় থেকে দূরত্ব, টাকা
cols = ["order_id", "district", "amount", "share", "vs_avg_tk"]
print(df[cols].head(6).round(3))

print(df.groupby("district")["share"].sum().round(6).tolist())

big = df.groupby("district").filter(lambda t: len(t) >= 3)
print("৩+ অর্ডারের জেলা:", big["district"].unique().tolist(), len(big))
keep = df.groupby("district")["order_id"].transform("size") >= 3
print("একই ফল mask দিয়ে:", df[keep].shape == big.shape)

agg: (4,) | transform: (12,)
   order_id   district  amount  share  vs_avg_tk
0         1       ঢাকা  120000  0.110   -980.000
1         2  চট্টগ্রাম   70000  0.264   -183.333
2         3       ঢাকা  450000  0.413   2320.000
3         4      খুলনা  160000  0.348   -700.000
4         5      সিলেট   40000  0.250   -400.000
5         6       ঢাকা   90000  0.083  -1280.000
[1.0, 1.0, 1.0, 1.0]
৩+ অর্ডারের জেলা: ['ঢাকা', 'চট্টগ্রাম'] 8
একই ফল mask দিয়ে: True

agg আর transform-এর পার্থক্য এক নজরে

নিচের ছবিতে একই ছয় সারির টেবিল থেকে তিনটি পথের ফলের আকার। কোন পথ নেবেন, তা নির্ভর করে উত্তরটি কার জন্য: দলের জন্য (agg), প্রতিটি সারির জন্য (transform), নাকি দল বাছাইয়ের জন্য (filter).

৫ · filter — পুরো দল রাখা বা বাদ দেওয়া

পর্ব ২২-এর boolean mask সারি ধরে বাছাই করে: “৳১,০০০-এর বেশি অর্ডারগুলো”। কিন্তু কখনো শর্তটি দলের ওপর: “যে জেলাগুলোতে অন্তত ৩টি অর্ডার এসেছে, সেগুলোর সব অর্ডার”। অল্প ডেটার জেলার গড় অনির্ভরযোগ্য, তাই বিশ্লেষণের আগে এমন জেলা বাদ দেওয়া একটি সাধারণ কাজ। GroupBy filter প্রতিটি দলকে (একটি ছোট DataFrame) একটি function-এ দেয়; function True ফেরত দিলে দলের সব সারি থাকে, False দিলে সব বাদ। ফল মূল টেবিলের একটি অংশ, মূল index আর ক্রমসহ।

big = df.groupby("district").filter(lambda t: len(t) >= 3)

এখানে lambda (নামহীন ছোট function, Python কোর্সে বিস্তারিত) প্রতিটি দলে একবার চলে। দল কম হলে এটি ঠিক আছে। দল হাজার হাজার হলে ওপরের কোডের শেষ লাইনের পথটি দ্রুত: transform("size") দিয়ে প্রতিটি সারিতে নিজের দলের আকার বসিয়ে একটি সাধারণ boolean mask বানানো। দুটির ফল একই (True), কিন্তু mask-এর পথে কোনো Python function প্রতিটি দলে ডাকা হয় না। এটিই পরের অংশের বিষয়।

৬ · apply — সবচেয়ে নমনীয়, সবচেয়ে ধীর

GroupBy apply সবচেয়ে সাধারণ হাতিয়ার: প্রতিটি দলকে (DataFrame বা Series হিসেবে) আপনার যেকোনো Python function-এ দেয়, আর ফল যা-ই আসুক (একটি সংখ্যা, একটি Series, একটি পুরো DataFrame) pandas জোড়া লাগানোর চেষ্টা করে। নমনীয়তার দাম গতি। sum, mean বা transform("sum")-এর মতো built-in হিসাব pandas-এর ভেতরে compiled কোডে সব দল একবারে সেরে ফেলে; apply-এ প্রতিটি দলের জন্য একটি ছোট DataFrame বা Series তৈরি হয় আর একবার Python function ডাকা হয়। দল ৮টি হলে খরচ সামান্য; দল ২০,০০০টি হলে ২০,০০০ বার।

লেখকের যন্ত্রে সত্যিকারের run (Python 3.14.4, pandas 3.1.1, NumPy 2.5.4, Windows): seed 42 দিয়ে বানানো ২,০০,০০০টি কাল্পনিক অর্ডার, ৮টি জেলা আর প্রায় ২০,০০০ ক্রেতা। প্রতিটি কাজ দুইভাবে করে ফল মিলিয়ে দেখা হয়েছে, আর কয়েকবার চালিয়ে সবচেয়ে কম সময়টি নেওয়া হয়েছে (পর্ব ১৯-এর benchmark-এর নিয়ম)।

~/bazarghar-ai$ python apply_timing.py

g = df.groupby("district")["amount"]                   # ৮টি দল
g.apply(lambda s: s.sum())      বনাম   g.sum()

gc = df.groupby("customer_id")["amount"]               # ~২০,০০০ দল
gc.apply(lambda s: s / s.sum()) বনাম   df["amount"] / gc.transform("sum")
gc.apply(lambda s: s.max() - s.min())  বনাম   gc.max() - gc.min()

cols = df.head(6).groupby("district").apply(lambda t: list(t.columns))

(200000, 3) | গ্রুপ: 8 জেলা, 19999 ক্রেতা
৮ গ্রুপ, apply(lambda s: s.sum())     1.5 ms | sum()    0.4 ms | মিল: True
২০০০০ গ্রুপ, apply দিয়ে ভাগ   704.3 ms | transform দিয়ে    2.1 ms | মিল: True
২০০০০ গ্রুপ, apply(max-min)   292.0 ms | max()-min()    2.0 ms | মিল: True
ধীর / দ্রুত: 3 342 144
apply-এর ভেতরে কলাম: ['customer_id', 'amount']

সিদ্ধান্তের একটি সহজ ক্রম: আগে খুঁজুন built-in নাম আছে কি না ("sum", "mean", "nunique", "first"), তারপর agg/transform-এ সেই নাম, তারপর দুই-তিনটি built-in হিসাবের সাধারণ গণিত (gc.max() - gc.min())। এর কোনোটিতে না হলে, যেমন প্রতিটি দলে একটি ছোট model fit করা বা জটিল নিয়ম, তখন apply; তবে দলের সংখ্যা দেখে নিন আর সময় মেপে নিন। NumPy-তে loop বনাম vectorization-এর যে হিসাব (পর্ব ১৫, পর্ব ১৯) শিখেছেন, এখানেও তা-ই: Python-এর প্রতিটি ডাকের নিজস্ব খরচ আছে।

৭ · key বানানো, সাজানো আর সেরা n — মাস, দামের পরিসর, categorical আর pivot table

groupby-এর key টেবিলে আগে থেকে থাকা কলাম হতে হবে, এমন নয়। মূল টেবিলের সমান দৈর্ঘ্যের যেকোনো Series দিলেই চলে। তাই নতুন কলাম না বানিয়েই “মাস ধরে” বা “দামের পরিসর ধরে” গ্রুপ করা যায়:

• তারিখের অংশ: df.groupby(df["date"].dt.to_period("M")) প্রতিটি মাসকে একটি দল ধরে (তারিখ কলামটি datetime হতে হবে; parse_dates পর্ব ২১-এ)। dt.month-ও চলে, কিন্তু তাতে ভিন্ন বছরের সেপ্টেম্বর মিশে যায়। পুরো সময়-সারির কাজ (resample, rolling) পর্ব ২৬-এ।
• সংখ্যার পরিসর: pd.cut একটি সংখ্যার কলামকে সীমা (bins) দিয়ে ভাগ করে প্রতিটি মানকে একটি পরিসরের নাম দেয়; একে বলে binning. default-এ পরিসর ডান দিকে বন্ধ: bins=[0, 1000, 2000] মানে (0, 1000] আর (1000, 2000], অর্থাৎ ঠিক ১০০০ প্রথম পরিসরে।
• Categorical key: category dtype-এর কলামে সম্ভাব্য মানের একটি নির্দিষ্ট তালিকা থাকে, ডেটায় না থাকলেও (যেমন এখনো কোনো অর্ডার না আসা জেলা “বরিশাল”)। observed=True দিলে শুধু ডেটায় আসা দলগুলো ফলে থাকে; observed=False দিলে তালিকার সব দল, ফাঁকাগুলো 0 বা NaN নিয়ে। pandas 3-এ default observed=True; pandas 2.x-এ default ছিল False, আর 2.1 থেকে স্পষ্ট না লিখলে সতর্কবার্তা আসত। দুই key-এর categorical-এ observed=False সব সম্ভাব্য জোড়া বানায়, যা অনেক বড় আর ফাঁকা ফল দিতে পারে। category dtype-এর মেমরির সুবিধা পর্ব ২৭-এ।

সাজানো আর প্রতি দলের সেরা n

“প্রতিটি জেলার সবচেয়ে বড় ২টি অর্ডার” একটি অতি সাধারণ প্রশ্ন (top-k). দুটি পরিচিত পথ: (১) পুরো টেবিল দামের উল্টো ক্রমে সাজিয়ে groupby("district").head(2); head প্রতিটি দলের প্রথম n সারি রাখে, মূল index আর কলামসহ। (২) একটি কলামের জন্য groupby("district")["amount"].nlargest(2), যার ফলে দুই স্তরের index (জেলা, মূল index). দলের সারাংশ সাজাতে sort_values, আর key-এর ক্রম ছাড়া দ্রুত ফল চাইলে groupby(..., sort=False), যা দলগুলো ডেটায় প্রথম দেখার ক্রমে রাখে।

Pivot table মানে দুই key-এর grouped aggregation

Spreadsheet-এর pivot table-এর সঙ্গে পরিচিত হলে জেনে রাখুন, pd.pivot_table আসলে দুই key-এর groupby, যার একটি key সারিতে আর আরেকটি কলামে ছড়ানো। pivot_table(df, index="district", columns="category", values="amount", aggfunc="sum") আর groupby(["district", "category"])["amount"].sum().unstack() একই টেবিল দেয়। pivot, melt, stack আর টেবিলের আকার বদলের পুরো আলোচনা পর্ব ২৫-এ।

নিচে এই অংশের সবকিছু বাজারঘরের ১২টি অর্ডারে, লেখকের যন্ত্রে সত্যিকারের run (Python 3.14.4, pandas 3.1.1). কোডটি ওপরের যেকোনো ব্লকে বসিয়ে ব্রাউজারেও চালাতে পারেন; সংখ্যাগুলো একই আসার কথা।

import pandas as pd
pd.set_option("display.width", 60)
df = pd.read_csv("orders.csv", parse_dates=["date"])
df["amount"] = df["qty"] * df["price_paisa"]

print(df.groupby(df["date"].dt.to_period("M"))["amount"].sum())     # মাস
band = pd.cut(df["amount"] // 100, bins=[0, 1000, 2000, 5000],
              labels=["<=1000", "1001-2000", "2001-5000"])
print(df.groupby(band)["order_id"].count())                         # দামের পরিসর

df["district_c"] = pd.Categorical(df["district"],
                    categories=["ঢাকা", "চট্টগ্রাম", "খুলনা", "সিলেট", "বরিশাল"])
print(df.groupby("district_c", observed=True).size().to_dict())
print(df.groupby("district_c", observed=False).size().to_dict())
print(df.groupby("district_c").size().index.tolist())               # default

top2 = df.sort_values("amount", ascending=False).groupby("district").head(2)
print(top2[["district", "order_id", "amount"]]
      .sort_values(["district", "amount"], ascending=[True, False]))
print(df.groupby("district")["amount"].nlargest(1))

pt = pd.pivot_table(df, index="district", columns="category",
                    values="amount", aggfunc="sum", fill_value=0)
print(pt // 100)                                                     # টাকায়
same = df.groupby(["district", "category"])["amount"].sum().unstack(fill_value=0)
print("groupby + unstack একই?", same.equals(pt))

date
2026-09    1080000
2026-10     895000
Freq: M, Name: amount, dtype: int64
amount
<=1000       4
1001-2000    5
2001-5000    3
Name: order_id, dtype: int64
{'ঢাকা': 5, 'চট্টগ্রাম': 3, 'খুলনা': 2, 'সিলেট': 2}
{'ঢাকা': 5, 'চট্টগ্রাম': 3, 'খুলনা': 2, 'সিলেট': 2, 'বরিশাল': 0}
['ঢাকা', 'চট্টগ্রাম', 'খুলনা', 'সিলেট']
     district  order_id  amount
8       খুলনা         9  300000
3       খুলনা         4  160000
6   চট্টগ্রাম         7  150000
1   চট্টগ্রাম         2   70000
2        ঢাকা         3  450000
10       ঢাকা        11  250000
11      সিলেট        12  120000
4       সিলেট         5   40000
district
খুলনা      8     300000
চট্টগ্রাম  6     150000
ঢাকা       2     450000
সিলেট      11    120000
Name: amount, dtype: int64
category   ইলেকট্রনিক্স  পোশাক    বই
district
খুলনা              3000   1600     0
চট্টগ্রাম             0   1500  1150
ঢাকা               7000   3000   900
সিলেট                 0   1200   400
groupby + unstack একই? True

৮ · SQL-এর GROUP BY আর pandas — একই ধারণা, দুই ভাষা

ডেটাবেসে একই প্রশ্ন SQL-এ লেখা হয়, আর অনেক কাজে দুই ভাষার মধ্যে যাতায়াত লাগে (পর্ব ২১-এ SQL থেকে DataFrame-এ পড়া)। GROUP BY-এর পূর্ণ আলোচনা আছে ABCL TECH-এর DBMS ও SQL কোর্সের aggregation আর GROUP BY পর্বে, আর transform-এর SQL রূপ আছে window function পর্বে। এখানে শুধু মিলের তালিকা:

SELECT district,
       COUNT(*)                    AS orders,
       SUM(qty * price_paisa)      AS total,
       COUNT(DISTINCT customer_id) AS customers
FROM orders
WHERE payment IS NOT NULL
GROUP BY district
HAVING COUNT(*) >= 3
ORDER BY total DESC;

দুটি পার্থক্য বাস্তবে সবচেয়ে বেশি কামড়ায়: NULL/NaN key (SQL-এর রিপোর্টে “payment অজানা” সারি থাকে, pandas-এ থাকে না, ফলে মোট মেলে না), আর সব-ফাঁকা দলের যোগফল (SQL দেয় NULL, pandas দেয় 0; min_count=1 দিলে NaN). দুই হাতিয়ারের ফল তুলনার আগে এ দুটি দেখে নিন।

৯ · Simpson's paradox — সারাংশ যখন উল্টো কথা বলে

বাজারঘর দুটি কাল্পনিক কুরিয়ার প্রতিষ্ঠানের সঙ্গে কাজ করে: “দ্রুতি” আর “পথিক”। গত মাসে প্রত্যেকে ৫০০টি করে অর্ডার পৌঁছেছে, দুটি জেলায়: ঢাকা (শহর, সহজ রাস্তা) আর বান্দরবান (পাহাড়ি, কঠিন রাস্তা)। ম্যানেজার একটি groupby চালালেন: সময়মতো পৌঁছানোর হার দ্রুতির 75%, পথিকের 84%. সিদ্ধান্ত প্রায় নেওয়া হয়ে গেছে: সামনের মাস থেকে সব অর্ডার পথিককে। তারপর একজন বিশ্লেষক জেলা ধরে আবার groupby চালালেন, আর ফল উল্টে গেল।

প্রতিটি জেলায় আলাদাভাবে দ্রুতি এগিয়ে (95 বনাম 90, 70 বনাম 60), অথচ সব মিলিয়ে পথিক এগিয়ে। কোনো হিসাবে ভুল নেই। এই ঘটনার নাম Simpson's paradox: দলে দলে যে প্রবণতা দেখা যায়, সব দল মেলালে তা দুর্বল হয়ে যায় বা উল্টে যায়। কারণ লুকিয়ে আছে মিশ্রণে: দ্রুতির ৮০% অর্ডার কঠিন বান্দরবানে, পথিকের ৮০% সহজ ঢাকায়। “সব মিলিয়ে” হার আসলে দুই জেলার হারের ওজনসহ গড়, আর ওজন হলো কে কোন জেলায় কত অর্ডার নিয়েছে। এখানে জেলা একটি confounding variable: এটি একসঙ্গে ঠিক করছে কোন কুরিয়ার অর্ডারটি পাবে আর অর্ডারটি সময়মতো পৌঁছানো কতটা কঠিন।

1orders.groupby("courier")["on_time"].mean()2orders.groupby(["district", "courier"])["on_time"].mean()3orders.groupby("courier")["district"].value_counts(normalize=True)4rate.mul(weights, axis=0).sum()   # একই ৫০:৫০ মিশ্রণ

নিচের কোডটি এই হিসাব প্রতিটি অর্ডারের একটি সারি বানিয়ে groupby দিয়ে করে, যাতে আসল কাজের মতো দেখায়: ১,০০০টি সারি, প্রতিটিতে কুরিয়ার, জেলা আর সময়মতো পৌঁছেছে কি না (True/False). boolean কলামের mean হলো True-র ভাগ, মানে হার।

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

# (কুরিয়ার, জেলা, মোট অর্ডার, সময়মতো পৌঁছেছে)
cells = [("দ্রুতি", "ঢাকা", 100, 95), ("দ্রুতি", "বান্দরবান", 400, 280),
         ("পথিক", "ঢাকা", 400, 360), ("পথিক", "বান্দরবান", 100, 60)]
parts = [pd.DataFrame({"courier": c, "district": d,
                       "on_time": [True] * ok + [False] * (n - ok)})
         for c, d, n, ok in cells]
orders = pd.concat(parts, ignore_index=True)     # প্রতিটি সারি একটি অর্ডার
print(len(orders), "টি অর্ডার")

overall = orders.groupby("courier")["on_time"].mean()
print("সব মিলিয়ে:", overall.round(3).to_dict())

by_d = orders.groupby(["district", "courier"])["on_time"].mean()
print(by_d.round(3))

mix = orders.groupby("courier")["district"].value_counts(normalize=True)
print(mix.unstack().round(2))            # কার অর্ডার কোথায়

# দুই কুরিয়ারকে একই জেলা-মিশ্রণে (৫০:৫০) তুলনা
rate = by_d.unstack()                     # সারি = জেলা, কলাম = কুরিয়ার
weights = pd.Series({"ঢাকা": 0.5, "বান্দরবান": 0.5})
print("একই মিশ্রণে:", rate.mul(weights, axis=0).sum().round(3).to_dict())

1000 টি অর্ডার
সব মিলিয়ে: {'দ্রুতি': 0.75, 'পথিক': 0.84}
district   courier
ঢাকা       দ্রুতি     0.95
           পথিক       0.90
বান্দরবান  দ্রুতি     0.70
           পথিক       0.60
Name: on_time, dtype: float64
district  ঢাকা  বান্দরবান
courier
দ্রুতি     0.2        0.8
পথিক       0.8        0.2
একই মিশ্রণে: {'দ্রুতি': 0.825, 'পথিক': 0.75}

তাহলে কোন সংখ্যাটি “ঠিক”?

উত্তরটি পরিসংখ্যান থেকে নয়, ডেটা কীভাবে তৈরি হলো তার জ্ঞান থেকে আসে। এখানে জেলা কুরিয়ার বাছাইয়ের আগেই ঠিক হয়ে থাকে (অর্ডার যেখান থেকে আসে), আর রাস্তার কাঠিন্য সময়ের ওপর সরাসরি প্রভাব ফেলে; তাই কুরিয়ারের দক্ষতা তুলনায় জেলাভিত্তিক (বা একই মিশ্রণের) হারই প্রাসঙ্গিক। কিন্তু যদি দলের ভাগটি নিজেই চিকিৎসা বা সিদ্ধান্তের ফল হতো (যেমন একটি কুরিয়ার নিজের ধীর গতির কারণে অর্ডার হারিয়ে অন্য জেলায় চলে গেল), তাহলে ভাগ করে দেখা উল্টো বিভ্রান্তি আনতে পারত। কোনো যান্ত্রিক নিয়ম নেই; কারণ-ফলের কাঠামো বুঝতে হয়। মডেলের পর্বে আমরা দেখব, এমন spurious correlation একটি মেশিন লার্নিং মডেলকেও ভুল সম্পর্ক শেখাতে পারে।

১০ · AI-এর যুগে — AI সহকারীর লেখা groupby যাচাই

“জেলাভিত্তিক রিপোর্ট বানাও” লিখলে একটি AI সহকারী কয়েক সেকেন্ডে groupby-এর কোড দেবে, আর তা প্রায়ই চলবেও। সমস্যা হলো, groupby-এর ভুল সাধারণত error দেয় না; সংখ্যা আসে, শুধু ভুল সংখ্যা। AI সহকারীরা প্রায়ই যা করে:

• পুরোনো API লেখে: নেস্টেড dict দিয়ে নাম বদল (SpecificationError), সরিয়ে দেওয়া df.append, apply-এর ভেতরে key কলাম পড়া (pandas 3-এ KeyError), বা observed-এর পুরোনো default ধরে নেওয়া; কখনো এমন parameter বানায় যা নেই।
• “কয়টি অর্ডার” জানতে count() ডাকে ফাঁকা ঘরওয়ালা কলামে, বা NaN key চুপচাপ বাদ পড়ার কথা বলে না; ফাঁকা গড়কে fillna(0) দিয়ে “ঠিক” করে।
• যেখানে transform লাগে সেখানে agg করে তারপর ভুল key-তে merge করে, বা প্রতিটি দলে apply(lambda …) লেখে যেখানে built-in হিসাব আছে।
• সব মিলিয়ে একটি হার দেখিয়ে সিদ্ধান্ত দেয় (“পথিক ভালো”), দলগুলোর মিশ্রণ না দেখে; আর দলের আকার (n) ছাড়া ছোট দলের গড়কে সমান গুরুত্ব দেয়।
• মডেলের feature বানাতে পুরো ডেটার দলভিত্তিক গড় (যেমন জেলার গড় বিক্রি) ব্যবহার করে, train আর test ভাগের আগে; এতে test-এর তথ্য train-এ ঢোকে (data leakage; পর্ব ৫৬-এ বিস্তারিত)।

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

• দলের মোটগুলোর যোগ পুরো টেবিলের মোটের সমান কি না দেখেছি; না মিললে NaN key বা আগের কোনো filter খুঁজেছি
• প্রতিটি রিপোর্টে গড়ের পাশে size আর count আছে; কোন কলামের count, তা স্পষ্ট
• ফলের shape দেখেছি: agg মানে দলের সংখ্যা, transform মানে মূল সারির সংখ্যা; একটি দল হাতে হিসাব করে মিলিয়েছি
• apply আছে কি না দেখেছি; built-in বা transform দিয়ে হয় কি না যাচাই করেছি, আর দরকার হলে সময় মেপেছি
• সব মিলিয়ে তুলনার আগে একটি সম্ভাব্য confounding key (জেলা, মাস, পণ্যের ধরন) ধরে দলে দলে দেখেছি
• train/test ভাগের পরে শুধু train থেকে দলের গড় নিয়েছি; নিজের pandas version-এর অফিসিয়াল docs-এ অচেনা parameter মিলিয়েছি; আসল ক্রেতার ডেটা AI-তে পেস্ট করিনি