লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — AI-এর ধারণা, অ্যালগরিদম আর ডেটা

সংজ্ঞা: Agent হলো এমন কিছু, যা sensor দিয়ে পরিবেশ দেখে আর actuator দিয়ে কাজ করে। Rational agent প্রতিটি মুহূর্তে এমন কাজ বাছে, যা এ পর্যন্ত দেখা তথ্য আর নিজের জ্ঞান দিয়ে প্রত্যাশিত performance measure সবচেয়ে বাড়ায়। Rational মানে সর্বজ্ঞ নয়: যা জানা ছিল না, তার জন্য দোষ নেই।

পরিবেশ: Partially observable (সব রাস্তার যানজট এখনই দেখা যায় না) আর stochastic (একই রুটে আজ ২০ মিনিট, কাল ৪৫)। তাই একবার plan করে বসে থাকা নয়, চলার সময় নজর আর দরকারে নতুন plan.

সীমা: Performance measure ভুল বাছলে agent ঠিকঠাক ভুল জিনিস বাড়ায়: শুধু “মোট কিলোমিটার কম” দিলে দূরের গ্রাহক সবসময় শেষে পড়েন।

পরীক্ষক যা খোঁজেন: agent আর rational-এর সংজ্ঞা, “সর্বজ্ঞ নয়” কথাটি (১); চারটি PEAS ঘর (১.৫); দুটি পরিবেশ-বৈশিষ্ট্য কারণসহ (১); একটি সীমা (০.৫)। পর্ব ১ · পর্ব ৩৯

যেখানে নম্বর কাটে: rational-কে “সবসময় সঠিক” লেখা; Performance-এ শুধু “ভালো সার্ভিস” লেখা, মাপা যায় এমন কিছু না দেওয়া; sensor আর actuator গুলিয়ে ফেলা।

সংজ্ঞা: AI বড় ক্ষেত্র: যন্ত্র দিয়ে এমন কাজ, যাকে আমরা বুদ্ধিমান আচরণ বলি। তার ভেতরে machine learning, যেখানে নিয়মের সংখ্যা ডেটা থেকে আসে। তার ভেতরে deep learning, অনেক স্তরের neural network. Generative AI নতুন লেখা, ছবি বা শব্দ তৈরি করে; আজকের বেশিরভাগই deep learning-এর ভেতরে।

ছবি (খাতায়): চারটি ঘর একটির ভেতরে আরেকটি: সবচেয়ে বড় বৃত্ত AI, তার ভেতরে ML, তার ভেতরে DL, আর DL-এর ভেতরে একটি অংশ GenAI. AI-এর বৃত্তে ML-এর বাইরে লিখুন: search, logic, planning.

সীমা ও সিদ্ধান্ত: তিন পথ প্রতিদ্বন্দ্বী নয়; বাস্তবে মেশানো হয়, যেমন neural model-এর চারপাশে নিয়মের guardrail. আর “AI মানেই ML” নয়: A* বা STRIPS planner শেখে না, তবু AI.

পরীক্ষক যা খোঁজেন: চারটি সংজ্ঞা আর ভেতর-বাইরের সম্পর্ক ঠিক (১.৫); ছবি (১); তিন পথের ছক অন্তত চার সারি (১.৫); তিনটি উদাহরণ আর একটি সীমা (১)। পর্ব ৩ · পর্ব ৪

যেখানে নম্বর কাটে: GenAI-কে AI-এর বাইরের আলাদা জিনিস আঁকা; ML আর DL-কে সমার্থক লেখা; “neural model বোঝে বা চিন্তা করে” ধরনের দাবি।

সংজ্ঞা: Reproducibility মানে একই কোড, একই ডেটা আর একই পরিবেশে অন্য কেউ হুবহু একই ফল পান। এর শত্রু লুকোনো অবস্থা: যা খাতায় লেখা নেই, অথচ ফল বদলায়।

উদাহরণ: বাজারঘরের ফেরত-model-এর notebook-এ একজন বিশ্লেষক আগে একটি cell-এ outlier বাদ দিয়ে পরে cell-টি মুছে দিয়েছেন। তাঁর kernel-এ ডেটা পরিষ্কার, সহকর্মীর kernel-এ নয়; দুজনের accuracy আলাদা।

সীমা: সব মিলিয়েও হুবহু একই সংখ্যা সবসময় সম্ভব নয়: ভিন্ন CPU বা BLAS-এ floating-point যোগের ক্রম আলাদা হতে পারে, ফলে শেষ দশমিকে তফাত আসে। তাই “হুবহু” না হলে সহনসীমা লিখে রাখুন।

পরীক্ষক যা খোঁজেন: সংজ্ঞা (১); পাঁচটি কারণ (২); প্রতিটির নির্দিষ্ট প্রতিকার, হাতিয়ারের নামসহ (১.৫); একটি সীমা (০.৫)। পর্ব ৮ · পর্ব ১১ · পর্ব ১২

যেখানে নম্বর কাটে: শুধু “seed দিন” লিখে থামা; pip freeze আর lockfile-এর পার্থক্য না জানা; notebook-এর hidden state-এর কথা বাদ দেওয়া।

সংজ্ঞা: Vectorization মানে Python-এর loop না লিখে পুরো array-এর ওপর একটি অপারেশন লেখা, যার loop চলে C-তে। Broadcasting হলো ভিন্ন shape-এর array মেলানোর নিয়ম, কপি না করেই।

নিয়ম: দুটি shape ডান দিক থেকে মেলান। প্রতিটি জোড়া মাত্রা হয় সমান, নয়তো একটি ১. যার মাত্রা কম, তার বাঁয়ে ১ বসে। কোনো জোড়া না মিললে ValueError.

কেন দ্রুত: NumPy array এক dtype-এর সংখ্যার টানা একটি memory-খণ্ড। প্রতিটি উপাদানের জন্য Python object তৈরি, type যাচাই আর interpreter-এর ধাপ লাগে না; compiled loop চলে, প্রায়ই SIMD-সহ।

উদাহরণ ও সীমা: বাজারঘরের ২,০০০ জন গ্রাহককে ৫০০টি গুদামের দূরত্ব দিয়ে মাপতে (2000, 1, 2) − (1, 500, 2) লিখলে মাঝে (2000, 500, 2) আকারের একটি অস্থায়ী array তৈরি হয়, ২০ লাখ float64, প্রায় ১৬ MB. আকার দশগুণ হলে এটিই memory শেষ করে দেয়। তখন টুকরো টুকরো করে (chunk) হিসাব, বা ‖a‖² + ‖b‖² − 2a·b-এর matrix গুণ।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা (১); নিয়ম (১); তিনটি shape-এর সঠিক ফল (১.৫); কেন দ্রুত (০.৫); অস্থায়ী array-এর সীমা (১)। পর্ব ১৫ · পর্ব ১৯ · পর্ব ৫৭

যেখানে নম্বর কাটে: বাঁ দিক থেকে মেলানো; (3,) + (4,)-কে (3, 4) লেখা; “vectorized মানে GPU-তে চলে” লেখা।

সংজ্ঞা: View একই memory-র ওপর নতুন একটি জানালা; একটিতে লিখলে অন্যটিতে দেখা যায়। Copy নতুন memory; আলাদা জীবন।

আউটপুট: b[0] = 99 মূল array-এর index ১ বদলায়; c একটি copy, তাই -1 মূল array-এ যায় না। শেষে a = [0 99 2 3 4 5]. নিশ্চিত হতে np.shares_memory(a, b) → True, np.shares_memory(a, c) → False.

pandas 3: Copy-on-Write সবসময় চালু। df[mask] একটি নতুন, নামহীন বস্তু; তাতে ["y"] = 1 লিখলে মূল টেবিল কখনো বদলায় না (chained assignment), শুধু একটি ChainedAssignmentError সতর্কবার্তা আসে। ঠিক লেখা df.loc[mask, "y"] = 1.

উদাহরণ: বাজারঘরের অর্ডার-টেবিলে ৩টি বা বেশি জিনিসের অর্ডারে ফ্রি ডেলিভারি চিহ্ন বসাতে chained লেখা ব্যবহার করলে কোনো ভুল বার্তা ছাড়াই কলামটি শূন্য থেকে যায় (শুধু সতর্কবার্তা), আর পরের হিসাব চুপচাপ ভুল হয়।

সীমা: View সস্তা, কিন্তু বড় array-এর ছোট slice ধরে রাখলে পুরো বড় array memory-তে থেকে যায়; তখন .copy() নিন।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা (১); কোন indexing কী দেয় (১); সঠিক আউটপুট কারণসহ (১.৫); pandas 3-এর নিয়ম আর loc (১); একটি সীমা (০.৫)। পর্ব ১৪ · পর্ব ২২

যেখানে নম্বর কাটে: a-তে -1 দেখানো; pandas 3-এ পুরোনো SettingWithCopyWarning-এর গল্প লেখা; “সব indexing copy দেয়” লেখা।

সংজ্ঞা: Data cleaning মানে ডেটাকে প্রশ্নের উপযোগী করা, আর প্রতিটি বদল লিখে রাখা। Groupby চলে split-apply-combine নিয়মে: সারিগুলো জেলা ধরে ভাগ, প্রতিটি ভাগে গড়, তারপর ফল একটি টেবিলে জোড়া।

পরিষ্কারের ধাপ:

1. Type: তারিখ pd.to_datetime; “৫ দিন” বা বাংলা অঙ্ক সংখ্যায়, না পারলে NaN, আর কয়টি হলো গোনা।
2. একই জিনিসের ভিন্ন বানান: “চট্টগ্রাম”, “চট্টগ্রাম ” (শেষে ফাঁকা), “Chattogram”. প্রথমে NFC আর ফাঁকা ছাঁটা, তারপর একটি canonical নামের তালিকায় মেলানো।
3. Duplicate: একই order_id দুবার থাকলে গড়ে সেই অর্ডার দুবার গোনা হয়।
4. Missing value: আগে প্রশ্ন, কেন ফাঁকা। একটি courier-এর দিন বেশি ফাঁকা হলে তা এলোমেলো নয় (MAR বা MNAR); গড় দিয়ে ভরালে ছবি বদলে যায়।
5. অসম্ভব মান: ঋণাত্মক দিন, ডেলিভারি অর্ডারের আগে। বাদ দিলে কয়টি বাদ, তা cleaning log-এ।

orders = orders.drop_duplicates("order_id")
full = orders.merge(customers[["customer_id", "district"]],
                    on="customer_id", how="left",
                    validate="many_to_one", indicator=True)
print(full["_merge"].value_counts())          # left_only = no customer row
out = (full.groupby("district")
           .agg(avg_days=("days", "mean"), n=("days", "count"),
                missing=("days", lambda s: s.isna().sum())))

Merge-এর ফাঁদ: গ্রাহক-টেবিলে একই customer_id দুবার থাকলে (ঠিকানা বদলের পুরোনো সারি) প্রতিটি অর্ডার দুবার হয়ে যায় (row explosion), অথচ কোনো ভুল বার্তা আসে না। validate="many_to_one" তখন MergeError দিয়ে থামায়। indicator=True দেখায় কোন অর্ডারের গ্রাহক পাওয়া যায়নি; how="inner" দিলে সেগুলো চুপচাপ হারিয়ে যেত।

সীমা: গড়ের পাশে n না দিলে ৩টি অর্ডারের জেলা আর ৩,০০০টির জেলা একই ওজন পায়। আর জেলাভিত্তিক গড় মিশ্রণের ওপর নির্ভর করে: এক জেলায় ভারী পণ্য বেশি হলে তার গড় খারাপ দেখায়, অথচ প্রতিটি পণ্য-শ্রেণিতে সে ভালো হতে পারে (Simpson’s paradox).

পরীক্ষক যা খোঁজেন: সংজ্ঞা আর split-apply-combine (১.৫); অন্তত চারটি পরিষ্কারের ধাপ, “কেন ফাঁকা” প্রশ্নসহ (৩); merge-এর row explosion আর তার পাহারা (৩); n আর Simpson’s paradox-এর সীমা (২.৫)। পর্ব ২৩ · পর্ব ২৪ · পর্ব ২৫

যেখানে নম্বর কাটে: সব ফাঁকা ঘর গড় দিয়ে ভরানোর পরামর্শ; কারণ না খুঁজে সারি মুছে ফেলা; merge-এর পরে সারির সংখ্যা না মেলানো; শুধু গড়, n ছাড়া।

সংজ্ঞা: একটি chart বিভ্রান্তিকর, যখন ছবির দেখানো পার্থক্য ডেটার আসল পার্থক্যের সঙ্গে মেলে না। Tufte-এর lie factor এটি মাপে: ছবির পরিবর্তন ÷ ডেটার পরিবর্তন; সৎ chart-এ প্রায় ১।

সীমা: Line chart-এ শূন্য থেকে axis বাধ্যতামূলক নয়; সেখানে পরিবর্তনের আকারই প্রশ্ন। নিয়ম মুখস্থ নয়, প্রশ্ন দেখে বিচার।

পরীক্ষক যা খোঁজেন: সংজ্ঞা (১); তিনটি কৌশল উদাহরণসহ (২); বিকল্প আর line chart-এর ব্যতিক্রম (১)। পর্ব ২৯ · পর্ব ৩২

যেখানে নম্বর কাটে: “সব chart-এ axis শূন্য থেকে” লেখা; রং বা 3D-কে একমাত্র সমস্যা বলা।

সংজ্ঞা: চারটিই একই graph search loop: frontier থেকে একটি node বের করা, goal কি না দেখা, না হলে তার প্রতিবেশীদের frontier-এ রাখা। পার্থক্য শুধু কোন node আগে বের হয়।

এখানে b = branching factor, d = সবচেয়ে অগভীর goal-এর গভীরতা, m = সর্বোচ্চ গভীরতা, C* = সেরা পথের খরচ, ε = সবচেয়ে ছোট ধাপ-খরচ।

উদাহরণ (ছবি ৭৭.১): UCS খরচের ক্রমে খোলে: S(০), E(১), A(২), F(৩), B(৪), C(৬), D(৭), G(১১), মোট ৮টি। A* খোলে S, A, B, C, D, G, মোট ৬টি; E-র f = ১ + ১১ = ১২, যা সেরা পথের ১১-এর বেশি, তাই কানাগলিতে ঢোকেই না। দুটিই S-A-C-G, খরচ ১১ পায় (গ-০২-এর কোডে চালানো)। BFS ধাপ গোনে, খরচ নয়: তিন ধাপের S-A-C-G (১১) আর S-B-D-G (১২)-এর কোনটি আগে পাবে, তা প্রতিবেশীর ক্রমের ওপর নির্ভর করে। DFS যেকোনো একটি পথ দেয়।

সীমা ও সিদ্ধান্ত: ধাপের খরচ সমান হলে BFS; খরচ আলাদা হলে UCS; ভালো admissible heuristic থাকলে A*; memory খুব কম হলে iterative deepening (DFS-এর memory, BFS-এর নিশ্চয়তা)। বাজারঘরের ডেলিভারি রুটে সরলরেখার দূরত্ব একটি স্বাভাবিক h, তাই A*.

পরীক্ষক যা খোঁজেন: সংজ্ঞা আর এক loop, চার frontier (৩); ছক, অন্তত পাঁচ সারি, শর্তসহ (৩); একটি graph-এ সঠিক trace (২); কখন কোনটি (২)। পর্ব ৩৯ · পর্ব ৪০ · পর্ব ৪১

যেখানে নম্বর কাটে: BFS-কে শর্ত ছাড়া “optimal” লেখা; DFS-এর memory O(b^d) লেখা; A*-কে “সবসময় দ্রুততম” বলা; UCS-এ goal test node তৈরির সময় করা (তাহলে সস্তা পথ হারাতে পারে)।

সংজ্ঞা: A* (Hart, Nilsson ও Raphael, ১৯৬৮) প্রতিটি node-কে f(n) = g(n) + h(n) দিয়ে মাপে: g = শুরু থেকে n পর্যন্ত আসল খরচ, h = n থেকে লক্ষ্যের অনুমান। সবচেয়ে ছোট f আগে খোলে।

A*(start, goal, h):
    frontier ← priority queue ordered by f;  push start with g = 0
    best_g[start] ← 0
    while frontier not empty:
        n ← pop node with smallest f
        if g(n) > best_g[n]: continue            # stale copy, skip
        if n = goal: return path to n            # test when EXPANDED
        for each neighbour m of n with step cost c:
            g' ← g(n) + c
            if g' < best_g[m] (or m unseen):
                best_g[m] ← g';  parent[m] ← n
                push m with f = g' + h(m)
    return failure

দুই শর্ত: Admissible: প্রতিটি n-এ h(n) ≤ h*(n), যেখানে h* আসল সবচেয়ে কম বাকি খরচ। Consistent: প্রতিটি রাস্তা n → m (খরচ c)-এ h(n) ≤ c + h(m), আর h(goal) = ০; এটি ত্রিভুজ-অসমতা। Consistent হলে admissible-ও হয়, আর graph search-এ কোনো node আবার খুলতে হয় না।

কেন সেরা পথ (যুক্তির রূপরেখা): ধরা যাক A* একটি খারাপ goal G₂ ফেরত দিল, খরচ g(G₂) > C*. G₂ বের হওয়ার মুহূর্তে সেরা পথের কোনো একটি node n এখনো frontier-এ আছে। Admissible বলে f(n) = g(n) + h(n) ≤ g(n) + h*(n) = C* < g(G₂) = f(G₂). তাহলে priority queue n-কে G₂-র আগে বের করত। বিরোধ; তাই G₂ আগে বের হতে পারে না।

নিচের কোডটি ছবি ৭৭.১-এর graph-এ একই function দিয়ে UCS (h = ০) আর A* চালায়, আর প্রতিটি খোলা node-এর g ও f ছাপে।

import heapq
G = {"S": {"A": 2, "B": 5, "E": 1}, "A": {"S": 2, "B": 2, "C": 4},
     "B": {"S": 5, "A": 2, "D": 3}, "C": {"A": 4, "D": 1, "G": 5},
     "D": {"B": 3, "C": 1, "G": 4}, "G": {"C": 5, "D": 4},
     "E": {"S": 1, "F": 2}, "F": {"E": 2}}           # E, F: a cheap dead end
H = {"S": 10, "A": 8, "B": 6, "C": 5, "D": 4, "G": 0, "E": 11, "F": 13}

def search(start, goal, h):
    frontier = [(h(start), 0, start, [start])]          # (f, g, node, path)
    best_g, order = {start: 0}, []
    while frontier:
        f, g, node, path = heapq.heappop(frontier)
        if g > best_g.get(node, float("inf")):
            continue                                    # stale entry
        order.append(f"{node}(g={g},f={f})")
        if node == goal:                                # test on expansion
            return path, g, order
        for nxt, cost in G[node].items():
            g2 = g + cost
            if g2 < best_g.get(nxt, float("inf")):
                best_g[nxt] = g2
                heapq.heappush(frontier, (g2 + h(nxt), g2, nxt, path + [nxt]))

for name, h in [("UCS", lambda n: 0), ("A*", lambda n: H[n])]:
    path, cost, order = search("S", "G", h)
    print(f"{name}: path={'-'.join(path)} cost={cost} expanded={len(order)}")
    print("   ", " ".join(order))

UCS: path=S-A-C-G cost=11 expanded=8
    S(g=0,f=0) E(g=1,f=1) A(g=2,f=2) F(g=3,f=3) B(g=4,f=4) C(g=6,f=6) D(g=7,f=7) G(g=11,f=11)
A*: path=S-A-C-G cost=11 expanded=6
    S(g=0,f=10) A(g=2,f=10) B(g=4,f=10) C(g=6,f=11) D(g=7,f=11) G(g=11,f=11)

h বাড়িয়ে বললে: ধরুন h(A) = ২০ (আসল ৯)। তখন A-র f = ২২, একই কোডে চালালে A* S-এর পরে B, E আর D খোলে, A-কে কখনো খোলে না, আর S-B-D-G (খরচ ১২) ফেরত দেয়; সেরা পথের নিশ্চয়তা চলে যায়। ইচ্ছে করে বাড়ানো হয় weighted A*-এ (f = g + w·h, w > ১): দ্রুত, কিন্তু পথ সর্বোচ্চ w গুণ লম্বা হতে পারে।

সীমা: A*-এর সমস্যা সময়ের চেয়ে memory: সব খোলা আর frontier-এর node রাখে। বড় সমস্যায় IDA*-এর মতো memory-কম রূপ লাগে।

পরীক্ষক যা খোঁজেন: f = g + h-এর মানে (১); pseudocode, expand-এর সময় goal test আর ভালো g পেলে হালনাগাদসহ (৩); দুই সংজ্ঞা (২); optimality-র যুক্তি (২); বাড়িয়ে বলার ফল আর weighted A* (১); memory-র সীমা (১)। পর্ব ৪১

যেখানে নম্বর কাটে: goal test push-এর সময়; consistent আর admissible-কে একই বলা; “h যত বড়, তত ভালো” লেখা (admissible সীমার ভেতরে বড় h ভালো, সীমা ছাড়ালে নয়); ভালো g পেলে হালনাগাদ বাদ।

সংজ্ঞা: Minimax দুই খেলোয়াড়ের zero-sum, perfect information খেলায় MAX-এর সেরা চাল বের করে, ধরে নিয়ে যে MIN-ও নিখুঁত খেলবে: leaf-এর মান ওপরে ওঠে, MAX-এ সবচেয়ে বড়, MIN-এ সবচেয়ে ছোট। Alpha-beta একই উত্তর দেয়, কম node দেখে। α = MAX-এর এ পর্যন্ত নিশ্চিত সেরা, β = MIN-এর এ পর্যন্ত নিশ্চিত সেরা (সবচেয়ে ছোট)।

AB(node, α, β, maximizing):
    if node is terminal or depth limit: return utility(node)
    if maximizing:
        v ← −∞
        for each child c:
            v ← max(v, AB(c, α, β, false))
            α ← max(α, v)
            if α ≥ β: break            # β cut: MIN above won't allow this
        return v
    else:
        v ← +∞
        for each child c:
            v ← min(v, AB(c, α, β, true))
            β ← min(β, v)
            if α ≥ β: break            # α cut: MAX above has better already
        return v
call: AB(root, −∞, +∞, true)

import math
# depth-2 tree: MAX at the root, three MIN children, three leaves each
TREE = [[4, 9, 6], [2, 8, 7], [5, 3, 10]]
seen = []                                    # leaves actually evaluated

def alphabeta(node, alpha, beta, is_max):
    if isinstance(node, int):                # leaf: utility
        seen.append(node)
        return node
    if is_max:
        v = -math.inf
        for child in node:
            v = max(v, alphabeta(child, alpha, beta, False))
            alpha = max(alpha, v)
            if alpha >= beta:
                break                        # MIN above will never allow this
        return v
    v = math.inf
    for child in node:
        v = min(v, alphabeta(child, alpha, beta, True))
        beta = min(beta, v)
        if alpha >= beta:
            print(f"  prune after leaf {child}: alpha={alpha}, beta={beta}")
            break                            # MAX above already has better
    return v

root = alphabeta(TREE, -math.inf, math.inf, True)
plain = max(min(c) for c in TREE)
print("alpha-beta value:", root, "| plain minimax:", plain)
print("leaves evaluated:", seen, f"({len(seen)} of 9)")

  prune after leaf 2: alpha=4, beta=2
  prune after leaf 3: alpha=4, beta=3
alpha-beta value: 4 | plain minimax: 4
leaves evaluated: [4, 9, 6, 2, 5, 3] (6 of 9)

চালের ক্রম: সেরা চাল আগে দেখলে কাটা বেশি। তৃতীয় MIN-এ 3 যদি প্রথমে আসত, তাহলে 5 আর 10 দুটিই কাটা পড়ত। নিখুঁত ক্রমে খরচ মোটামুটি O(b^m/2), মানে একই সময়ে প্রায় দ্বিগুণ গভীরতা; এলোমেলো ক্রমে কম লাভ, সবচেয়ে খারাপ ক্রমে কোনো কাটা নেই, O(b^m). পর্ব ৪২-এর tic-tac-toe-তে ভালো ক্রমে ৭,২৭৫টি node, খারাপ ক্রমে ৪২,০৯৪টি।

সীমা: বড় খেলায় শেষ পর্যন্ত যাওয়া যায় না; গভীরতার সীমায় evaluation function মান অনুমান করে, আর সীমার ঠিক ওপারের বিপদ দেখা যায় না (horizon effect). দানের খেলায় minimax নয়, expectiminimax.

পরীক্ষক যা খোঁজেন: α আর β-এর মানে (১.৫); pseudocode, দুই শাখা আর α ≥ β শর্তসহ (৩); সঠিক trace, কাটা leaf 8, 7 আর 10 (২.৫); মান একই থাকে, এ কথা (১); চালের ক্রম আর O(b^m/2) (১); সীমা (১)। পর্ব ৪২

যেখানে নম্বর কাটে: “alpha-beta আনুমানিক উত্তর দেয়” লেখা; α আর β উল্টো; MIN শাখায় α হালনাগাদ করা; root-এর মান ভুল (5 বা 2).

সংজ্ঞা: একটি CSP-তে কয়েকটি variable, প্রতিটির domain (সম্ভাব্য মান), আর constraint. একটি arc X → Y arc consistent, যদি X-এর প্রতিটি মানের জন্য Y-তে অন্তত একটি মান থাকে যা নিয়ম মানে। AC-3 (Mackworth, ১৯৭৭) সব arc-কে consistent করে, যা টেকে না সেই মান মুছে।

AC-3(csp):
    queue ← all arcs (Xi, Xj)
    while queue not empty:
        (Xi, Xj) ← pop(queue)
        if REVISE(Xi, Xj):
            if domain(Xi) is empty: return false     # no solution
            for each neighbour Xk of Xi, Xk ≠ Xj:
                push (Xk, Xi)                        # Xi shrank: recheck
    return true

REVISE(Xi, Xj):
    removed ← false
    for each x in domain(Xi):
        if no y in domain(Xj) satisfies the constraint: delete x; removed ← true
    return removed

উদাহরণ: তিনটি পাশাপাশি জেলা X, Y, Z-কে আলাদা রং দিতে হবে; X = {R}, Y = {R, G}, Z = {R, G, B}.

from collections import deque
# three neighbouring districts, all must get different colours
D = {"X": {"R"}, "Y": {"R", "G"}, "Z": {"R", "G", "B"}}
NB = {"X": ["Y", "Z"], "Y": ["X", "Z"], "Z": ["X", "Y"]}
ok = lambda a, b: a != b                     # binary constraint

def revise(xi, xj):
    removed = {a for a in D[xi] if not any(ok(a, b) for b in D[xj])}
    D[xi] -= removed
    return removed

def ac3():
    queue = deque((xi, xj) for xi in NB for xj in NB[xi])
    checks = 0
    while queue:
        xi, xj = queue.popleft()
        checks += 1
        removed = revise(xi, xj)
        if removed:
            print(f"arc {xi}->{xj}: remove {sorted(removed)} from {xi}")
            if not D[xi]:
                return False, checks         # empty domain: no solution
            for xk in NB[xi]:
                if xk != xj:
                    queue.append((xk, xi))   # neighbours must be re-checked
    return True, checks

result, checks = ac3()
print("consistent:", result, "| arcs checked:", checks)
print({v: sorted(d) for v, d in D.items()})

arc Y->X: remove ['R'] from Y
arc Z->X: remove ['R'] from Z
arc Z->Y: remove ['G'] from Z
consistent: True | arcs checked: 9
{'X': ['R'], 'Y': ['G'], 'Z': ['B']}

জটিলতা আর সীমা: c-টি binary constraint আর domain-এর আকার d হলে AC-3 O(c·d³). Arc consistency সমাধানের নিশ্চয়তা দেয় না: তিনটি পরস্পর-সংলগ্ন জেলা, প্রত্যেকের domain {R, G}, প্রতিটি arc consistent, অথচ তিন রঙের দরকারে সমাধান নেই। তাই বাস্তবে AC-3 backtracking-এর ভেতরে চলে (MAC), বা CP-SAT-এর মতো solver.

পরীক্ষক যা খোঁজেন: CSP-এর তিন অংশ আর arc consistency (১); pseudocode, REVISE আর পুনরায় queue-তে তোলাসহ (২); একটি সঠিক trace (১); জটিলতা বা “নিশ্চয়তা নেই”-এর উদাহরণ (১)। পর্ব ৪৩

যেখানে নম্বর কাটে: একটি মান মোছার পর প্রতিবেশীর arc আবার না তোলা; (Xi, Xj) আর (Xj, Xi)-কে একই arc ধরা; “AC-3 সবসময় সমাধান দেয়” লেখা।

সংজ্ঞা: Propositional logic-এ জগৎ শুধু সত্য বা মিথ্যা বাক্যের (proposition) সমষ্টি। First-order logic জগৎকে দেখে বস্তু, তাদের সম্পর্ক (predicate) আর function হিসেবে, আর quantifier ∀ (সব) ও ∃ (অন্তত একটি) দিয়ে একসঙ্গে অনেক বস্তুর কথা বলে।

উদাহরণ: Propositional: Ret3_Rahim → ¬COD_Rahim, Ret3_Mitu → ¬COD_Mitu, … প্রতিটি গ্রাহকের জন্য একটি করে। FOL: ∀x (ReturnedMoreThan3(x) → ¬CODAllowed(x)), সব গ্রাহকের জন্য একটিই।

সাধারণ ভুল: ∀-এর সঙ্গে সাধারণত →, ∃-এর সঙ্গে ∧. “অন্তত একজন গ্রাহক মিনিকেট চাল কিনেছেন” ঠিক রূপ ∃x (Customer(x) ∧ Ordered(x, Miniket)). ভুল রূপ ∃x (Customer(x) → Ordered(x, Miniket)) জগতে একটিও অ-গ্রাহক বস্তু থাকলেই সত্য, কারণ মিথ্যা শর্তের → সত্য। আর ক্রম: ∀x∃y Ordered(x, y) (প্রত্যেকে কিছু না কিছু কিনেছেন) আর ∃y∀x Ordered(x, y) (একটি পণ্য সবাই কিনেছেন) আলাদা কথা।

সীমা: দুটিই নিশ্চিত সত্য-মিথ্যার ভাষা; “সম্ভবত ফেরত দেবেন” বলতে পারে না। সেজন্য সম্ভাবনা (অংশ ঙ)।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা (১); ছক, অন্তত চার সারি (১.৫); নিয়মটি দুই ভাষায় (১); quantifier-এর ভুল বা ক্রমের উদাহরণ (১); সীমা (০.৫)। পর্ব ৪৫ · পর্ব ৪৬

যেখানে নম্বর কাটে: ∀x (Customer(x) ∧ …) লেখা (সব বস্তুকে গ্রাহক বানিয়ে দেয়); FOL-কে “propositional-এর চেয়ে দ্রুত” বলা; semi-decidable-কে “undecidable, তাই অকেজো” লেখা।

সংজ্ঞা: Forward chaining জানা তথ্য থেকে সামনে যায়: যে নিয়মের সব শর্ত সত্য, তা চালিয়ে নতুন তথ্য যোগ করে, যতক্ষণ নতুন কিছু আসে (data-driven). Backward chaining একটি লক্ষ্য থেকে পেছনে যায়: লক্ষ্য যে নিয়মের ফল, তার প্রতিটি শর্তকে উপ-লক্ষ্য বানায় (goal-driven).

Rule base (বাজারঘরের ফেরত-নীতির একটি ছোট অংশ): R1: Paid ∧ Delivered → Complete. R2: Complete ∧ Within7Days → Eligible. R3: Eligible ∧ Damaged → FullRefund. তথ্য: Paid, Delivered, Within7Days, Damaged.

সীমা: দুটিই Horn clause-এর জ্ঞানে complete. Forward-এ একাধিক নিয়ম একসঙ্গে প্রস্তুত হলে কোনটি আগে, সেই conflict resolution ফল বদলাতে পারে। Backward chaining পুনরাবৃত্ত নিয়মে (A ← B, B ← A) অসীম loop-এ পড়তে পারে, যদি আগে দেখা লক্ষ্য মনে না রাখে।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা (১); দুটি সঠিক trace (২); ছক (১); কখন কোনটি আর একটি সীমা (১)। পর্ব ৪৭ · পর্ব ৪৫

যেখানে নম্বর কাটে: backward-কে “উল্টো ক্রমে forward” বলা; backward trace-এ উপ-লক্ষ্য না দেখানো; “forward সবসময় ধীর” লেখা।

সংজ্ঞা: Classical planning-এ শুরুর অবস্থা জানা, প্রতিটি কাজের ফল নিশ্চিত, আর লক্ষ্য একটি শর্ত; উত্তর একটি কাজের ক্রম (plan). STRIPS (Fikes ও Nilsson, ১৯৭১) প্রতিটি কাজ লেখে precondition, add list আর delete list দিয়ে। MDP-তে কাজের ফল সম্ভাবনায়: P(s′ ∣ s, a), সাথে reward R আর discount factor γ; উত্তর একটি policy π(s), প্রতিটি অবস্থায় কী করতে হবে।

Action: Deliver(p, area)
  Precondition: At(Rider, area) ∧ Carrying(p) ∧ Dest(p, area)
  Add list:     Delivered(p)
  Delete list:  Carrying(p)

Action: Drive(from, to)
  Precondition: At(Rider, from) ∧ Road(from, to)
  Add list:     At(Rider, to)
  Delete list:  At(Rider, from)

তালিকায় না থাকা সব তথ্য আগের মতো থাকে; এভাবেই STRIPS frame problem সহজ করে।

একই সমস্যা MDP হিসেবে: অবস্থা = (রাইডারের এলাকা, কোন পার্সেল বাকি)। Drive(মিরপুর, ফার্মগেট): ০.৮ সম্ভাবনায় ফার্মগেট, ০.২ সম্ভাবনায় যানজটে মিরপুরেই থাকা। Reward: প্রতি ধাপে −১ (সময়), প্রতিটি পৌঁছানো পার্সেলে +১০. উত্তর: প্রতিটি অবস্থার জন্য কোন রাস্তা নেবেন।

সীমা ও সিদ্ধান্ত: MDP-র সম্ভাবনা আর reward কোথা থেকে আসবে, সেটিই কঠিন; ভুল সম্ভাবনায় নিখুঁত policy-ও ভুল। আবার classical plan অনিশ্চিত জগতে ভাঙে। বাজারঘরে প্রায়ই সহজ পথটিই যথেষ্ট: দিনের শুরুতে classical plan, চলার সময় নজর, দরকারে replan; যানজটের সম্ভাবনা ভালোভাবে জানা থাকলে তবেই MDP.

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা, plan বনাম policy (২); সঠিক STRIPS schema, তিন তালিকা (২); MDP-র পাঁচ উপাদান উদাহরণে (২); ছক, অন্তত পাঁচ সারি (৩); সীমা ও সিদ্ধান্ত (১)। পর্ব ৪৯ · পর্ব ৫৪

যেখানে নম্বর কাটে: delete list বাদ দেওয়া (তাহলে রাইডার একসঙ্গে দুই জায়গায়); MDP-র উত্তরকে “পথ” বলা; γ-এর মানে না বলা; “MDP সবসময় classical planning-এর চেয়ে ভালো” লেখা।

সংজ্ঞা: Bayes-এর উপপাদ্য: P(H ∣ E) = P(E ∣ H) × P(H) ÷ P(E). এখানে P(H) prior (প্রমাণের আগে বিশ্বাস), P(E ∣ H) likelihood, P(E) evidence (সব সম্ভাবনা মিলিয়ে প্রমাণটি দেখার সম্ভাবনা), আর P(H ∣ E) posterior.

হিসাব: P(E) = ০.৯০ × ০.০২ + ০.০৫ × ০.৯৮ = ০.০১৮ + ০.০৪৯ = ০.০৬৭. তাই P(ভুয়া ∣ সতর্কতা) = ০.০১৮ ÷ ০.০৬৭ ≈ ০.২৬৯, মানে প্রায় ২৭%.

ব্যাখ্যা: ৬৭টি সতর্কতার মধ্যে মাত্র ১৮টি সত্যি ভুয়া। “৯০% ধরে” শুনে অনেকে ভাবেন সতর্কতা মানে ৯০% নিশ্চিত; এটিই base rate fallacy: ভুয়া বিরল (২%), তাই বিশাল সৎ অংশের ছোট ভুল-হারও সংখ্যায় বড়। ডাক্তারের বিরল রোগের পরীক্ষায় একই ঘটনা।

সীমা: উত্তরটি prior-এর ওপর দাঁড়িয়ে; ঈদের মৌসুমে ভুয়ার হার বদলালে একই ব্যবস্থার posterior-ও বদলায়। আর একই প্রমাণ দুবার গুনলে বিশ্বাস অকারণে বাড়ে।

পরীক্ষক যা খোঁজেন: সূত্র আর চার নাম (১.৫); সঠিক হিসাব ০.২৬৯ (১.৫); natural frequency-র ছক বা গাছ (১); fallacy-র ব্যাখ্যা আর সীমা (১)। পর্ব ৫০ · পর্ব ৩৫

যেখানে নম্বর কাটে: উত্তর ০.৯০ লেখা (P(E ∣ H) আর P(H ∣ E) গুলিয়ে ফেলা); P(E)-তে শুধু ভুয়ার অংশ নেওয়া; ছক না দিয়ে শুধু সংখ্যা।

সংজ্ঞা: HMM-এ অবস্থা দেখা যায় না, দেখা যায় শুধু তার ছাপ। তিনটি সংখ্যার সেট: শুরুর সম্ভাবনা π, transition A (অবস্থা থেকে অবস্থা), আর emission B (অবস্থা থেকে দেখা জিনিস)। Viterbi (Andrew Viterbi, ১৯৬৭) দেখা ক্রমের জন্য সবচেয়ে সম্ভাব্য একক লুকানো পথ বের করে, dynamic programming দিয়ে।

VITERBI(obs o1..oT, states S, π, A, B):
    for each s in S:  δ1(s) ← π(s) · B(s, o1)
    for t = 2..T:
        for each s in S:
            δt(s) ← max over p of [ δt−1(p) · A(p, s) ] · B(s, ot)
            ψt(s) ← the p that gave the max          # backpointer
    last ← argmax over s of δT(s)
    path ← [last];  for t = T down to 2: prepend ψt(path[0])
    return path, δT(last)

উদাহরণের সংখ্যা (কাল্পনিক): π: Free ০.৬, Jam ০.৪. A: Free→Free ০.৭, Free→Jam ০.৩, Jam→Free ০.৪, Jam→Jam ০.৬. B: Free-এ fast ০.৮, slow ০.২; Jam-এ fast ০.৩, slow ০.৭.

S = ["Free", "Jam"]                                # hidden road state
start = {"Free": 0.6, "Jam": 0.4}
trans = {"Free": {"Free": 0.7, "Jam": 0.3}, "Jam": {"Free": 0.4, "Jam": 0.6}}
emit = {"Free": {"fast": 0.8, "slow": 0.2}, "Jam": {"fast": 0.3, "slow": 0.7}}
obs = ["fast", "slow", "slow"]                     # observed delivery times

V = [{s: start[s] * emit[s][obs[0]] for s in S}]   # best score ending in s
back = [{}]
for t in range(1, len(obs)):
    V.append({}); back.append({})
    for s in S:
        prev = max(S, key=lambda p: V[t - 1][p] * trans[p][s])
        V[t][s] = V[t - 1][prev] * trans[prev][s] * emit[s][obs[t]]
        back[t][s] = prev                          # backpointer
for t, row in enumerate(V):
    print(t, obs[t], {s: round(v, 5) for s, v in row.items()})

last = max(S, key=lambda s: V[-1][s])
path = [last]
for t in range(len(obs) - 1, 0, -1):
    path.insert(0, back[t][path[0]])
print("best path:", " -> ".join(path), "| prob:", round(V[-1][last], 5))

alpha = {s: start[s] * emit[s][obs[0]] for s in S}  # forward: SUM, not max
for o in obs[1:]:
    alpha = {s: sum(alpha[p] * trans[p][s] for p in S) * emit[s][o] for s in S}
print("P(observations), all paths:", round(sum(alpha.values()), 5))

0 fast {'Free': 0.48, 'Jam': 0.12}
1 slow {'Free': 0.0672, 'Jam': 0.1008}
2 slow {'Free': 0.00941, 'Jam': 0.04234}
best path: Free -> Jam -> Jam | prob: 0.04234
P(observations), all paths: 0.10248

T = ক্রমের দৈর্ঘ্য, N = অবস্থার সংখ্যা। সব পথ গুনলে N^T; trellis-এর প্রতিটি ঘর একবার হিসাব করাতেই লাভ।

সীমা: লম্বা ক্রমে সংখ্যা এত ছোট হয় যে float-এ শূন্য হয়ে যায় (underflow); তাই বাস্তবে log-এ গুণের বদলে যোগ। আর Markov অনুমান (পরের অবস্থা শুধু এখনকার ওপর) রাস্তার মতো জিনিসে আংশিক সত্য।

পরীক্ষক যা খোঁজেন: HMM-এর তিন অংশ (১.৫); pseudocode, δ, ψ আর backtrack সহ (৩); উদাহরণের সঠিক পথ আর অন্তত একটি ঘরের হিসাব (২.৫); forward-এর সঙ্গে পার্থক্য (২); log-space-এর সীমা (১)। পর্ব ৫৩

যেখানে নম্বর কাটে: প্রতিটি ধাপে আলাদা করে সবচেয়ে বড় অবস্থা বেছে পথ বানানো (greedy; এখানে কাকতালীয়ভাবে মেলে, সাধারণভাবে নয়); backpointer বাদ; max আর ∑ গুলিয়ে ফেলা।

সংজ্ঞা: Bellman optimality equation (Richard Bellman, ১৯৫৭): V*(s) = max_a ∑_s′ P(s′ ∣ s, a) [R(s, a, s′) + γ V*(s′)]. একটি অবস্থার মান = সেরা কাজের প্রত্যাশিত তাৎক্ষণিক reward আর পরের অবস্থার discount করা মানের যোগ। Value iteration এই সমীকরণকে একটি হালনাগাদের নিয়ম বানায়।

VALUE-ITERATION(S, A, P, R, γ, θ):
    V(s) ← 0 for all s
    repeat:
        Δ ← 0
        for each non-terminal s:
            v_new ← max over a of Σ P(s′|s,a) · [R(s,a,s′) + γ·V(s′)]
            Δ ← max(Δ, |v_new − V(s)|)
        V ← all v_new                               # one sweep
    until Δ < θ
    π(s) ← argmax over a of Σ P(s′|s,a) · [R + γ·V(s′)]
    return V, π

# corridor of cells 0..3; cell 3 is the shop (terminal)
# a move succeeds with prob 0.8, otherwise the rider stays put
STATES, GOAL, GAMMA, STEP, PRIZE = [0, 1, 2, 3], 3, 0.9, -1, 10
ACTIONS = {"L": -1, "R": +1}

def outcomes(s, a):
    s2 = min(max(s + ACTIONS[a], 0), 3)
    return [(0.8, s2), (0.2, s)]

def reward(s2):
    return STEP + (PRIZE if s2 == GOAL else 0)

def q(s, a, V):
    return sum(p * (reward(s2) + GAMMA * V[s2]) for p, s2 in outcomes(s, a))

V = {s: 0.0 for s in STATES}
for sweep in range(1, 100):
    new = {s: 0.0 if s == GOAL else max(q(s, a, V) for a in ACTIONS) for s in STATES}
    delta = max(abs(new[s] - V[s]) for s in STATES)
    V = new
    if sweep <= 3:
        print(f"sweep {sweep}:", [round(V[s], 3) for s in STATES])
    if delta < 1e-6:
        break
print(f"converged after {sweep} sweeps:", [round(V[s], 3) for s in STATES])
policy = {s: max(ACTIONS, key=lambda a: q(s, a, V)) for s in STATES if s != GOAL}
print("policy:", policy)

sweep 1: [-1.0, -1.0, 7.0, 0.0]
sweep 2: [-1.9, 3.86, 8.26, 0.0]
sweep 3: [1.437, 5.642, 8.487, 0.0]
converged after 15 sweeps: [4.291, 6.276, 8.537, 0.0]
policy: {0: 'R', 1: 'R', 2: 'R'}

কেন মেলে: γ < ১ হলে Bellman হালনাগাদ একটি contraction: প্রতি sweep-এ V* থেকে সবচেয়ে বড় দূরত্ব বড়জোর আগের γ গুণ থাকে (γ = ০.৯ হলে প্রতিবার অন্তত ১০% কমে), তাই একটি অনন্য V*-তে পৌঁছায়।

সীমা: P আর R জানতে হয়, আর প্রতিটি অবস্থা গুনতে হয়। P জানা না থাকলে অভিজ্ঞতা থেকে শেখা, যেমন Q-learning (reinforcement learning); অবস্থা আংশিক দেখা গেলে POMDP.

পরীক্ষক যা খোঁজেন: Bellman equation প্রতিটি প্রতীকের মানেসহ (২); pseudocode, থামার শর্ত আর policy বের করাসহ (৩); উদাহরণের অন্তত একটি ঘরের হিসাব আর policy (২); policy iteration-এর তুলনা (২); γ বা সীমা (১)। পর্ব ৫৪

যেখানে নম্বর কাটে: max-এর ভেতরে না রেখে বাইরে ∑ লেখা; γ বাদ; terminal অবস্থার মান হালনাগাদ করতে থাকা; policy-কে “পথ” বলা।

সংজ্ঞা: Gradient descent একটি loss-কে ছোট করার পুনরাবৃত্ত পদ্ধতি: gradient ∇L সবচেয়ে খাড়া ওপরের দিক দেখায়, তাই তার উল্টো দিকে ছোট একটি পা: w ← w − η ∇L(w). η হলো learning rate. পাহাড়ে কুয়াশায় দাঁড়িয়ে পায়ের নিচের ঢাল দেখে নামার মতো।

GRADIENT-DESCENT(X, y, η, max_steps, tol):
    w ← initial values (e.g. zeros)
    for step = 1..max_steps:
        g ← ∇L(w) computed on all rows          # batch GD
        w ← w − η · g                            # update ALL weights together
        if ‖g‖ < tol: stop                      # or: validation loss stops improving
    return w
# SGD / mini-batch: compute g on one row / a small random batch each step

প্রথম ধাপ হাতে: L = (১/n) ∑ (wx + b − y)². শুরুতে অনুমান সব ০, তাই ভুল e = (−৩, −৫, −৭, −৯), L = (৯ + ২৫ + ৪৯ + ৮১) ÷ ৪ = ৪১. ∂L/∂w = (২/n) ∑ e·x = (২/৪)(−৩ − ১০ − ২১ − ৩৬) = −৩৫; ∂L/∂b = (২/৪)(−২৪) = −১২. নতুন w = ০ − ০.০৫ × (−৩৫) = ১.৭৫, b = ০.৬.

# fit y = w*x + b by gradient descent on MSE
xs = [1, 2, 3, 4]
ys = [3, 5, 7, 9]                  # exactly y = 2x + 1
n = len(xs)

def run(lr, steps):
    w = b = 0.0
    for step in range(1, steps + 1):
        err = [w * x + b - y for x, y in zip(xs, ys)]
        loss = sum(e * e for e in err) / n
        dw = 2 * sum(e * x for e, x in zip(err, xs)) / n
        db = 2 * sum(err) / n
        w, b = w - lr * dw, b - lr * db      # update both together
        if step <= 2 or step == steps:
            print(f"  step {step}: loss={loss:.4f} -> w={w:.4f}, b={b:.4f}")
    return w, b

print("lr = 0.05")
run(0.05, 500)
print("lr = 0.2 (too large)")
run(0.2, 6)

lr = 0.05
  step 1: loss=41.0000 -> w=1.7500, b=0.6000
  step 2: loss=1.1288 -> w=2.0375, b=0.7025
  step 500: loss=0.0000 -> w=2.0001, b=0.9998
lr = 0.2 (too large)
  step 1: loss=41.0000 -> w=7.0000, b=2.4000
  step 2: loss=224.4600 -> w=-9.4000, b=-3.1600
  step 6: loss=201847.5263 -> w=-342.3846, b=-116.3535

Scaling কেন: একই Hessian-এর ছোট eigenvalue মাত্র প্রায় ০.৩০. বড় দিকটি η-কে ছোট রাখতে বাধ্য করে, আর ছোট দিকে তখন খুব ধীরে এগোয়; তাই ৫০০ ধাপ লাগল। কলামের মাপ খুব আলাদা হলে (টাকা বনাম দিন) এই অনুপাত বিশাল হয়: পর্ব ৫৮-এর এক run-এ কাঁচা feature-এ ৫১,৮০৯ ধাপ, standardize করে মাত্র ১০.

সীমা: Loss convex না হলে gradient descent local minimum বা saddle point-এ থামতে পারে; আর linear regression-এ closed form (np.linalg.lstsq) ছোট ডেটায় সহজ।

পরীক্ষক যা খোঁজেন: সংজ্ঞা আর update rule (১.৫); pseudocode, থামার শর্ত আর একসঙ্গে update-সহ (২); সঠিক প্রথম ধাপ: L = ৪১, w = ১.৭৫, b = ০.৬ (৩); বড় η-এর ফল (১.৫); scaling-এর কারণ (১); সীমা বা SGD (১)। পর্ব ৩৪ · পর্ব ৫৮

যেখানে নম্বর কাটে: gradient-এর দিকে যোগ করা (+η∇L); w আগে বদলে সেই নতুন w দিয়ে b-র gradient হিসাব; ২/n-এর ২ বাদ (আলাদা নিয়ম বললে ঠিক আছে, কিন্তু স্পষ্ট লিখতে হয়); “η বড় মানেই দ্রুত” লেখা।

সংজ্ঞা: Naive Bayes একটি generative model: P(y) আর P(x ∣ y) শেখে, তারপর Bayes দিয়ে P(y ∣ x) ∝ P(y) ∏ P(x_j ∣ y). “Naive” মানে শ্রেণি জানা থাকলে feature-গুলো স্বাধীন ধরা। Logistic regression একটি discriminative model: সরাসরি P(y = ১ ∣ x) = σ(w·x + b) শেখে, x কীভাবে তৈরি হয় তা নিয়ে কিছু ধরে না।

গভীর একটি মিল: Multinomial Naive Bayes-এর সিদ্ধান্তও log-এ শব্দ-গোনার একটি linear যোগফল। তাই দুটির সীমারেখা একই ধরনের; পার্থক্য ওজন কীভাবে আসে: NB গোনা থেকে, LR ভুল কমিয়ে। Ng ও Jordan-এর (২০০১) পরিচিত বিশ্লেষণ বলে, generative model কম ডেটায় নিজের সেরা মানে দ্রুত পৌঁছায়, আর discriminative model-এর শেষ ভুল সাধারণত কম; এটি একটি প্রবণতা, নিয়ম নয়।

উদাহরণ: বাংলা SMS-এ “টাকা”, “অফার”, “bKash” প্রায়ই একসঙ্গে আসে; NB এদের তিনটি স্বাধীন প্রমাণ ধরে, তাই সম্ভাবনাকে ০.৯৯৯-এর মতো চরমে ঠেলে দিতে পারে, যদিও শ্রেণির সিদ্ধান্ত ঠিক থাকে। পর্ব ৬৭-এর ১১৯টি রিভিউয়ে macro F1 NB ০.৫৫৪, LR ০.৫৭৪: ছোট ডেটায় প্রায় সমান, ক্রম ভঙ্গুর।

সিদ্ধান্ত: অল্প label-এর বাংলা SMS-এ প্রথম baseline হিসেবে Naive Bayes: দ্রুত, ব্যাখ্যা সহজ, ছোট ডেটায় শক্ত। Label বাড়লে বা সম্ভাবনার মান দিয়ে সিদ্ধান্ত নিতে হলে (যেমন threshold ঠিক করা) logistic regression, একই fold-এ দুটির তুলনা করে।

পরীক্ষক যা খোঁজেন: generative আর discriminative-এর সংজ্ঞা, সূত্রসহ (২); ছক, অন্তত ছয় সারি (৪); সম্পর্কিত feature বা calibration-এর উদাহরণ (২); সিদ্ধান্ত কারণসহ (১); linear সীমারেখার মিল বা ছোট ডেটার প্রবণতা (১)। পর্ব ৫১ · পর্ব ৫৯ · পর্ব ৬৭

যেখানে নম্বর কাটে: “NB ভুল অনুমান করে, তাই কাজ করে না” লেখা; logistic regression-কে regression (সংখ্যা অনুমান) বলা; NB-এর সম্ভাবনাকে বিশ্বাসযোগ্য ঝুঁকি-মান হিসেবে ব্যবহারের পরামর্শ।

সংজ্ঞা: Precision = TP ÷ (TP + FP): “যাদের ভুয়া বললাম, তাদের কত ভাগ সত্যি ভুয়া”। Recall = TP ÷ (TP + FN): “সব ভুয়ার কত ভাগ ধরলাম”। F1 দুটির harmonic mean.

হিসাব: Accuracy = (৩০ + ৯৪০) ÷ ১০০০ = ০.৯৭. Precision = ৩০ ÷ ৪০ = ০.৭৫. Recall = ৩০ ÷ ৫০ = ০.৬০. F1 = ২ × ০.৭৫ × ০.৬০ ÷ (০.৭৫ + ০.৬০) = ০.৯ ÷ ১.৩৫ ≈ ০.৬৬৭. তুলনায়, “কেউ ভুয়া নয়” বলা একটি dummy model-এর accuracy ০.৯৫, অথচ recall ০; তাই এখানে accuracy প্রায় কিছুই বলে না।

কখন কোনটি: ভুয়া সন্দেহে অর্ডার আটকালে সৎ গ্রাহক বিরক্ত হন, তাই precision জরুরি। আবার শুধু হাতে যাচাইয়ের তালিকায় পাঠালে একটি ভুয়াও যেন না ফসকায়, তাই recall. Threshold নামালে recall বাড়ে, precision সাধারণত কমে। দুই ভুলের দাম জানা থাকলে threshold ≈ C_FP ÷ (C_FP + C_FN), যদি model-এর সম্ভাবনা calibrated হয়।

সীমা: বিরল শ্রেণিতে ROC AUC উঁচু দেখাতে পারে অথচ precision কম; পর্ব ৬০-এর এক model-এ ROC AUC ০.৯৪৯, average precision ০.৩৪১. তাই ভারসাম্যহীন ডেটায় PR curve-ও দেখুন।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা সূত্রসহ (১); confusion matrix (১); চারটি সঠিক মান (১.৫); কখন কোনটি আর threshold (১); accuracy-র ফাঁদ বা PR curve (০.৫)। পর্ব ৬০

যেখানে নম্বর কাটে: FP আর FN উল্টো; F1-কে সাধারণ গড় (০.৬৭৫) ধরা; “accuracy ০.৯৭, তাই model ভালো” লেখা।

সংজ্ঞা: Regularization loss-এর সঙ্গে weight-এর আকারের একটি শাস্তি যোগ করে। L2 (ridge): λ∑w_j². L1 (lasso): λ∑∣w_j∣. λ বড় মানে সরল model.

কেন ঠিক শূন্য: loss-এর সমতল-রেখা (contour) বাড়তে বাড়তে যেখানে শাস্তির সীমা প্রথম ছোঁয়, সেটিই সমাধান। হীরার কোণগুলো অক্ষের ওপর, আর কোণে ছোঁয়ার সম্ভাবনা বেশি; কোণে মানে কিছু weight ঠিক ০. বৃত্তের কোনো কোণ নেই। পর্ব ৬১-এর এক run-এ lasso ১০টি অকাজের feature-এর ১০টিই বাদ দিয়েছে।

Bias-variance: λ বাড়ালে variance কমে (ডেটার ছোট নড়াচড়ায় model কম দোলে), bias বাড়ে। সেরা λ বাছাই হয় validation বা cross-validation-এ, test-এ কখনো নয়।

সীমা: শাস্তি weight-এর আকার দেখে, তাই আগে feature scaling না করলে বড় এককের কলাম অন্যায্যভাবে কম শাস্তি পায়। scikit-learn-এ Ridge(alpha=…), Lasso(alpha=…); LogisticRegression-এ default L2, যেখানে C হলো ১/λ-এর মতো, মানে বড় C মানে কম শাস্তি।

পরীক্ষক যা খোঁজেন: দুই সূত্র (১); ছক (১.৫); শূন্যের জ্যামিতিক কারণ (১); bias-variance আর λ বাছাই (১); scaling বা C-এর উল্টো অর্থ (০.৫)। পর্ব ৬১

যেখানে নম্বর কাটে: “L2 feature বাদ দেয়” লেখা; bias-term-কেও শাস্তি দেওয়া স্বাভাবিক বলা; λ test-এ বাছা; C বাড়ালে regularization বাড়ে লেখা।

সংজ্ঞা: Data leakage মানে training বা মূল্যায়নে এমন তথ্য ঢুকে পড়া, যা অনুমানের মুহূর্তে আসলে পাওয়া যাবে না। ফল: validation-এ চমৎকার সংখ্যা, deploy-এর পরে হতাশা।

ধাপ ১, অনুমানের মুহূর্ত ঠিক করা: চেকআউট। তখন যা জানা নেই, তা feature নয়। তাই বাদ: refund_processed আর return_reason (ফেরতের পরে তৈরি, target leakage), আসল ডেলিভারির দিন (ডেলিভারির পরে জানা)। রাখা যায়: প্রতিশ্রুত দিন, দাম, শ্রেণি, জেলা, আর গ্রাহকের আগের অর্ডার থেকে হিসাব করা ইতিহাস (চেকআউটের আগের তারিখ পর্যন্ত)।

ধাপ ২, নকল মুছে তারপর ভাগ: নকল সারি আগে না মুছলে একই অর্ডার দুই দিকে পড়ে। তারপর সময় ধরে: প্রথম ১৫ মাস development, শেষ ৩ মাস তালাবন্ধ test. Development-এর cross-validation-এ গ্রাহক ধরে (GroupKFold) বা সময় ধরে (TimeSeriesSplit), যাতে একই গ্রাহক দুই দিকে না থাকেন।

ধাপ ৩, যা কিছু ডেটা থেকে শেখে, সব pipeline-এর ভেতরে: imputer-এর median, scaler-এর গড়, encoder-এর বিভাগ, feature বাছাই, target encoding. Pipeline-এর fit প্রতিটি fold-এ শুধু সেই fold-এর train অংশে শেখে।

num = ["price", "promised_days", "past_return_rate"]
cat = ["category", "district"]
pre = ColumnTransformer([
    ("num", Pipeline([("imp", SimpleImputer(strategy="median")),
                      ("sc", StandardScaler())]), num),
    ("cat", Pipeline([("imp", SimpleImputer(strategy="most_frequent")),
                      ("oh", OneHotEncoder(handle_unknown="ignore"))]), cat)])
pipe = Pipeline([("pre", pre), ("model", LogisticRegression(max_iter=1000))])
scores = cross_validate(pipe, X_dev, y_dev, groups=dev["customer_id"],
                        cv=GroupKFold(n_splits=5), scoring="roc_auc")

(scikit-learn 1.8; একটি ছোট বানানো টেবিলে কোনো সতর্কবার্তা ছাড়াই চলেছে। past_return_rate হিসাব করতে হবে শুধু সেই অর্ডারের আগের তারিখের ডেটা দিয়ে।)

ধাপ ৪, মূল্যায়ন: আগে baseline (সবসময় “ফেরত নয়”, একটি সরল নিয়ম), তারপর logistic regression, দরকারে gradient boosting, সবাই একই fold-এ। ফেরত বিরল হলে ROC AUC-এর পাশে average precision আর খরচে বাছা threshold-এ recall. Hyperparameter খোঁজাও (GridSearchCV) pipeline-এর ভেতরে, development অংশে।

ভুল ক্রমের দাম কত বড় হতে পারে, নিচের ব্লক দেখায়: বিশুদ্ধ এলোমেলো ডেটায় (কোনো সংকেত নেই) ভাগের আগে পুরো ডেটা দেখে feature বাছাই করলে, আর বাছাই pipeline-এর ভেতরে রাখলে।

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(42)
X = rng.normal(size=(60, 2000))          # pure noise: 2000 random columns
y = np.array([0, 1] * 30)                # labels unrelated to X
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# WRONG: pick the 20 "best" columns using ALL rows, then cross-validate
X_sel = SelectKBest(f_classif, k=20).fit_transform(X, y)
leaky = cross_val_score(LogisticRegression(), X_sel, y, cv=cv)

# RIGHT: selection lives inside the pipeline, refit on each training fold
pipe = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression())
honest = cross_val_score(pipe, X, y, cv=cv)

print(f"selection before split : {leaky.mean():.3f}")
print(f"selection inside folds : {honest.mean():.3f}")
print("chance level            : 0.500")

selection before split : 0.883
selection inside folds : 0.433
chance level            : 0.500

সীমা: অতীতের ডেটা ভবিষ্যৎ ঠিক বলবে, তার নিশ্চয়তা নেই (ঈদ, নতুন courier), তাই deploy-এর পরে drift-এর নজরদারি (জ-০৪)। আর model-এর সিদ্ধান্ত নিজেই ডেটা বদলায়: “ঝুঁকিপূর্ণ” অর্ডারে COD বন্ধ করলে সেগুলোর ফেরতের label আর আসে না।

পরীক্ষক যা খোঁজেন: leakage-এর সংজ্ঞা আর অনুমানের মুহূর্ত (১.৫); বাদ দেওয়া তিনটি কলাম কারণসহ (১.৫); সময় আর গ্রাহক ধরে ভাগ, তালাবন্ধ test (২); pipeline-এর ভেতরে fit, ছবি বা কোডসহ (২); baseline, metric আর tuning-এর জায়গা (২); deploy-এর পরের সীমা (১)। পর্ব ৫৬ · পর্ব ৬২ · পর্ব ৬৪ · পর্ব ৬৬

যেখানে নম্বর কাটে: পুরো ডেটায় scaler বা imputer fit করে পরে ভাগ; এলোমেলো সারি-ভাগে একই গ্রাহক দুই দিকে; আসল ডেলিভারির দিন রেখে দেওয়া; test দেখে threshold বা model বাছা; “accuracy ০.৯৮” লিখে baseline না দেওয়া।

সংজ্ঞা: k-means সারিগুলোকে k-টি দলে ভাগ করে, যাতে প্রতিটি বিন্দু থেকে তার দলের কেন্দ্রের (centroid) দূরত্বের বর্গের মোট, মানে inertia, যত কম হয়। দুই ধাপের loop (Lloyd-এর পদ্ধতি): assign আর update.

K-MEANS(X, k):
    choose k initial centres (k-means++ in practice)
    repeat:
        for each point x: label(x) ← index of nearest centre      # assign
        for each cluster j: centre_j ← mean of points with label j  # update
    until labels (or centres) stop changing
    return labels, centres
# each step never increases inertia, so it stops; but maybe at a local minimum

নিচে বাজারঘরের ছয়জন কাল্পনিক গ্রাহক: (মাসে অর্ডার, গড় ঝুড়ি শত টাকায়)। শুরুর কেন্দ্র ইচ্ছে করে খারাপ বাছা, দুটিই ছোট দলের কাছে। পাতার ভেতরের Python-এ scikit-learn-এর KMeans একটি অদরকারি সতর্কবার্তা ছাপে, তাই এখানে NumPy-তে হাতে লেখা।

import numpy as np
# six customers: (orders per month, average basket in hundred taka)
X = np.array([[1, 2], [2, 1], [2, 3], [8, 8], [9, 7], [7, 9]], dtype=float)
C = np.array([[1.0, 1.0], [2.0, 3.0]])        # deliberately poor start

for it in range(1, 10):
    d = ((X[:, None, :] - C[None, :, :]) ** 2).sum(axis=2)   # (6, 2)
    labels = d.argmin(axis=1)                                # assign
    inertia = d[np.arange(len(X)), labels].sum()
    newC = np.array([X[labels == k].mean(axis=0) for k in range(2)])  # update
    print(f"iter {it}: labels={labels.tolist()} inertia={inertia:.2f} "
          f"centres={newC.round(2).tolist()}")
    if np.allclose(newC, C):
        break
    C = newC

iter 1: labels=[0, 0, 1, 1, 1, 1] inertia=189.00 centres=[[1.5, 1.5], [6.5, 6.75]]
iter 2: labels=[0, 0, 0, 1, 1, 1] inertia=18.94 centres=[[1.67, 2.0], [8.0, 8.0]]
iter 3: labels=[0, 0, 0, 1, 1, 1] inertia=6.67 centres=[[1.67, 2.0], [8.0, 8.0]]

k আর অনুমান: k আগে দিতে হয়; elbow বা silhouette দিয়ে বাছা, তবে শেষ বিচার ব্যবসার কাজে। k-means গোল, কাছাকাছি আকারের দল ধরে নেয়, আর দূরত্ব-নির্ভর বলে scaling লাগে। বাঁকা আকারের দলে DBSCAN ভালো (পর্ব ৬৫-এ দুটি বাঁকা চাঁদে ARI ০.২৪৭ বনাম ১.০০০)।

সীমা ও সিদ্ধান্ত: দুটিই label ছাড়া শেখে, আর scaling না করলে দুটিতেই টাকার কলাম সব দখল করে। প্রায়ই একসঙ্গে চলে: আগে PCA, তারপর clustering, বা দলগুলো দুই মাত্রায় এঁকে দেখা। Cluster কোনো লুকানো “সত্য” নয়।

পরীক্ষক যা খোঁজেন: উদ্দেশ্য (inertia) আর দুই ধাপ (১.৫); pseudocode, থামার শর্তসহ (২); সঠিক trace, অন্তত প্রথম দুই ধাপ (২.৫); k বাছাই আর অনুমান (১); PCA বনাম clustering ছক (২); সীমা (১)। পর্ব ৬৫

যেখানে নম্বর কাটে: “k-means সবসময় সেরা ভাগ দেয়” লেখা; PCA-কে clustering-এর একটি পদ্ধতি বলা; scaling-এর কথা বাদ; cluster-এর নম্বরকে অর্থপূর্ণ label ধরা।

সংজ্ঞা: দুটিই ensemble: অনেক model-এর মিলিত সিদ্ধান্ত। Bagging (Breiman, ১৯৯৬) ফেরত রেখে নেওয়া (bootstrap) অনেক নমুনায় আলাদা আলাদা গভীর গাছ শেখায়, তারপর গড় বা ভোট নেয়। Boosting ছোট গাছ একটির পর একটি বানায়; প্রতিটি নতুন গাছ আগের সবার মিলিত ভুলের দিক শেখে, ছোট ধাপে যোগ হয়।

বাড়তি এলোমেলোতা কেন: B-টি গাছের গড়ের variance = ρσ² + (১ − ρ)σ²/B, যেখানে σ² একটি গাছের variance আর ρ দুটি গাছের correlation. B বাড়ালে দ্বিতীয় পদ মিলিয়ে যায়, কিন্তু ρσ² থাকে। Random forest (Breiman, ২০০১) প্রতিটি ভাগে feature-এর একটি এলোমেলো উপসেট দেখে; সবচেয়ে জোরালো feature সব গাছের মাথায় বসতে পারে না, তাই ρ কমে। পর্ব ৬৬-এর সংখ্যায় σ² = ০.০৪, B = ১০০: ρ = ০.৩-এ গড়ের variance ০.০১২২৮, ρ = ০.৮-এ ০.০৩২০৮.

সীমা: ensemble-এর ব্যাখ্যা একটি গাছের চেয়ে কঠিন। আর ছোট বা সরল ডেটায় এরা logistic regression-কে নিশ্চিতভাবে হারায় না: পর্ব ৬৬-এ ২৫টি জোড়া ভাগে random forest বনাম interaction-সহ logistic-এর পার্থক্য মাত্র +০.০০২।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা (১); ছক (১.৫); variance-এর সূত্র বা ρ কমানোর যুক্তি (১.৫); সীমা (১)। পর্ব ৬৬ · পর্ব ৬১

যেখানে নম্বর কাটে: boosting-কে “সমান্তরালে অনেক গাছ” লেখা; random forest-কে শুধু “অনেক গাছ” বলা, feature উপসেটের কথা বাদ; “random forest কখনো overfit করে না” লেখা।

সংজ্ঞা: TF-IDF প্রতিটি শব্দকে একটি ঘর দেয়: শব্দটি লেখায় কতবার (tf) × কত দুর্লভ (idf). scikit-learn-এর default-এ idf = ln((১ + n)/(১ + df)) + ১, তারপর প্রতিটি সারির L2 দৈর্ঘ্য ১. Embedding লেখাকে কয়েকশো ঘরের একটি dense vector-এ বসায়, যা অনেক লেখা থেকে শেখা; একই প্রসঙ্গে বসা শব্দ কাছাকাছি আসে।

উদাহরণ: দুটি বাক্যে একটি শব্দও এক নয়, তাই TF-IDF-এ cosine ঠিক ০; পর্ব ৬৯-এ এমনই দেখা গেছে। Embedding “দেরি” আর “সময়মতো পৌঁছায়নি”-কে কাছে আনতে পারে, কারণ এ ধরনের শব্দ একই প্রসঙ্গে আসে। পর্ব ৬৯-এর ২০টি প্রশ্নে recall@3: TF-IDF ০.৫৫০, ছোট LSA embedding ০.৭৩৩, multilingual-e5-small ০.৬১৭; ছোট, একই লেখকের বানানো ডেটা, তাই এই ক্রম ভঙ্গুর।

সীমা ও সিদ্ধান্ত: Embedding পণ্যের কোড বা দুর্লভ নামের মতো হুবহু শব্দে কখনো TF-IDF-এর চেয়ে খারাপ, আর বাংলায় model-এর মান model ধরে আলাদা। বাজারঘরের রিভিউ-খোঁজে দুটি মিলিয়ে (hybrid search), আর নিজের প্রশ্নের সেটে recall মেপে বাছাই।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা, idf-এর সূত্রসহ (১.৫); ছক (১.৫); উদাহরণের সঠিক ব্যাখ্যা (১); সীমা ও সিদ্ধান্ত (১)। পর্ব ৬৭ · পর্ব ৬৯ · পর্ব ৩৩

যেখানে নম্বর কাটে: “embedding অর্থ বোঝে” লেখা; TF-IDF-কে বাক্যের ক্রম ধরতে পারে বলা; embedding-কে সবসময় ভালো বলা।

সংজ্ঞা: একটি neuron তিনটি কাজ করে: input-এর weighted sum, তার সঙ্গে bias, তারপর একটি activation function. Perceptron (Rosenblatt, ১৯৫৮) একটি step activation-এর neuron; এর সীমারেখা একটি সরল রেখা (বা সমতল)।

XOR কেন নয়: XOR-এ (০, ১) আর (১, ০) এক দলে, (০, ০) আর (১, ১) অন্য দলে। কাগজে চারটি বিন্দু এঁকে দেখুন: কোনো একটি সরল রেখা দুই দলকে আলাদা করতে পারে না; XOR linearly separable নয়। পর্ব ৬৮-এর run-এ perceptron AND শিখেছে ৬টি epoch-এ, কিন্তু XOR-এ ১২ epoch পরেও প্রতিবার ৪টি ভুল।

সমাধান: দুটি hidden neuron, একটি OR আর একটি AND; output = OR এবং না AND. অর্থাৎ hidden layer নতুন feature বানায়, যেখানে সমস্যাটি linear হয়ে যায়। কিন্তু মাঝে activation না থাকলে দুটি linear স্তর একটিতে মিশে যায়: (xA)B = x(AB). তাই non-linearity (ReLU, sigmoid, tanh) অপরিহার্য।

Backpropagation: chain rule দিয়ে loss-এর gradient output থেকে পেছনের প্রতিটি weight পর্যন্ত, স্তর ধরে ধরে, একবারে হিসাব করার পদ্ধতি; তারপর gradient descent.

সীমা: Neural network-এর loss convex নয়; শুরুর weight আর learning rate ফল বদলায়। আর মস্তিষ্কের neuron-এর সঙ্গে মিল খুবই আলগা।

পরীক্ষক যা খোঁজেন: neuron-এর তিন কাজ (১); XOR-এর যুক্তি, ছবিসহ (১.৫); hidden layer আর activation-এর দরকার, (xA)B = x(AB) সহ (১.৫); backprop-এর সংজ্ঞা (১)। পর্ব ৬৮

যেখানে নম্বর কাটে: “বেশি neuron দিলেই XOR শেখে” লেখা, non-linearity বাদ; backpropagation-কে একটি আলাদা শেখার নিয়ম বলা, chain rule-এর কথা না বলা।

সংজ্ঞা: একটি LLM আগের সব token দেখে পরের token-এর একটি সম্ভাবনা-বণ্টন দেয়, তা থেকে একটি বাছে, তারপর আবার একই কাজ (autoregressive). Bigram model-এর সঙ্গে পার্থক্য: প্রসঙ্গ অনেক লম্বা, আর গোনা টেবিলের বদলে শেখা Transformer network.

তিন অংশ: Token: শব্দ বা শব্দাংশ; একই অর্থের বাক্য ভাষাভেদে আলাদা সংখ্যক token (পর্ব ৭০-এ লেখকের যন্ত্রে ইংরেজিতে ১৪, বাংলায় একটি tokenizer-এ ৬১, আরেকটিতে ১৮), আর দাম ও context window token-এ মাপা। Attention: softmax(QKᵀ/√d_k)V, মানে প্রতিটি token অন্যদের থেকে ওজন দিয়ে তথ্য মেশায়; causal mask ভবিষ্যতের token দেখতে দেয় না। Temperature: বণ্টনকে তীক্ষ্ণ (কম) বা চ্যাপ্টা (বেশি) করে; greedy decoding সবসময় সবচেয়ে সম্ভাব্যটি নেয়।

তিন সীমা: (১) Hallucination: প্রশিক্ষণের লক্ষ্য সম্ভাব্য লেখা, সত্য লেখা নয়; বাজারঘরের নীতির প্রশ্নে আত্মবিশ্বাসী কিন্তু বানানো উত্তর আসতে পারে। (২) জ্ঞানের একটি শেষ তারিখ আছে, আর গণনা বা উৎস নিজে যাচাই করে না। (৩) Prompt injection: খুঁজে আনা লেখায় লুকোনো নির্দেশ model মানতে পারে। RAG প্রাসঙ্গিক নথি এনে উত্তরকে উৎসে বাঁধতে সাহায্য করে, কিন্তু hallucination পুরো দূর করে না, আর injection-এর নতুন দরজাও খোলে।

পরীক্ষক যা খোঁজেন: পরের token অনুমানের সংজ্ঞা (১); token, attention, temperature (২); তিনটি সীমা উদাহরণসহ (১.৫); RAG-এর সীমা (০.৫)। পর্ব ৭০ · পর্ব ৫৩

যেখানে নম্বর কাটে: “LLM বোঝে বা ভাবে” তথ্য হিসেবে লেখা; temperature ০ মানে “সঠিক উত্তর” লেখা; token আর শব্দকে এক ধরা।

সংজ্ঞা: দায়িত্বশীল AI মানে model-এর ক্ষতি আগে খোঁজা, মাপা, কমানো, নথিতে রাখা, আর ক্ষতিগ্রস্তের অভিযোগের পথ রাখা; একবারের স্বাক্ষর নয়, কাজের অভ্যাস।

পরিস্থিতির ঝুঁকি: ভুল “না” একজন সৎ গ্রাহককে সুবিধা থেকে বঞ্চিত করে; ভুল “হ্যাঁ” দোকানের টাকা আটকায়। খাতার label নিজেই পক্ষপাতদুষ্ট হতে পারে: পর্ব ৭২-এর কাল্পনিক উদাহরণে একটি এলাকায় courier-এর দেরিকে গ্রাহকের দেরি লেখা হয়েছিল, ফলে সময়মতো টাকা দেওয়া গ্রাহকদের অনুমোদনের হার (TPR) এক দলে ০.৮৯০, অন্য দলে ০.৪৫৩.

Trade-off: দলগুলোর base rate আলাদা হলে calibration আর সমান ভুলের হার একসঙ্গে মেলানো যায় না (Kleinberg ও সহকর্মী; Chouldechova); তাই কোন সংজ্ঞা বেছে নিলেন, তা লিখে দায় নিতে হয়। আর সুরক্ষিত কলাম মুছে ফেলাই যথেষ্ট নয়: পর্ব ৭২-এ জেলার কলাম মুছলে অনুমোদনের অনুপাত ০.৪০৫ থেকে মাত্র ০.৪৯০, কারণ এলাকার কোড প্রায় একই তথ্য বহন করে। Re-weighting সেখানে TPR-এর ফাঁক ০.৩৪৭ থেকে ০.০৯৩-এ নামিয়েছে।

সীমা: চেকলিস্ট আইনি পরামর্শ নয়; প্রযোজ্য আইন বিশেষজ্ঞের সঙ্গে মেলাতে হয়। আর কখনো সঠিক সিদ্ধান্ত হলো model চালু না করা।

সিদ্ধান্ত: সীমিত পরিসরে চালু, প্রতিটি “না”-তে মানুষের পর্যালোচনা, মাসিক দলভিত্তিক রিপোর্ট, আর TPR-এর ফাঁক আগে-লেখা সীমা ছাড়ালে থামানো।

পরীক্ষক যা খোঁজেন: পরিস্থিতির ক্ষতি আর দুই ভুলের দাম (১.৫); ডেটা, সম্মতি আর label-এর পক্ষপাত (২); proxy আর দলভিত্তিক মাপ, অন্তত দুটি metric-এর নামসহ (২); গোপনীয়তা, ব্যাখ্যা আর আপিল (১.৫); নথি আর চালুর পরের নজরদারি (১.৫); trade-off বা “চালু না করা”-র বিকল্প (১.৫)। পর্ব ৭২ · পর্ব ৭১ · পর্ব ৭৪

যেখানে নম্বর কাটে: “লিঙ্গ বা এলাকার কলাম মুছে দিলেই ন্যায্য” লেখা; শুধু মোট accuracy দেওয়া; চালুর পরের নজরদারি বাদ; আপিলের পথ না রাখা; কোনো নির্দিষ্ট আইনের ধারা বানিয়ে লেখা।

সংজ্ঞা: Data drift: input-এর বণ্টন বদলায় (P(x)), যেমন ঈদে অর্ডারের দাম বেড়ে যাওয়া। Concept drift: input আর ফলের সম্পর্ক বদলায় (P(y ∣ x)), যেমন নতুন ফেরত-নীতির পরে একই ধরনের অর্ডার আগের চেয়ে বেশি ফেরত আসা।

ধরার উপায়: Data drift input দেখেই: PSI বা KS test, train-এর বণ্টনের সঙ্গে তুলনা। Concept drift-এ input একই থাকতে পারে; পর্ব ৭৪-এর কাল্পনিক উদাহরণে PSI প্রায় ০.০১, অথচ accuracy ০.৭৩ থেকে ০.৪৮. তাই এটি ধরা পড়ে শুধু দেরিতে আসা আসল label দিয়ে (label delay).

সীমা: সব সতর্কতা সমস্যা নয়: ঈদের মাসে drift প্রত্যাশিত। Retrain-এর নিয়ম আগে লিখে রাখুন, আর নতুন model-কে পুরোনোর সঙ্গে একই সময়ের ডেটায় তুলনা করুন।

পরীক্ষক যা খোঁজেন: দুই সংজ্ঞা P(x) আর P(y ∣ x) দিয়ে (১.৫); মাপার উপায় (১); concept drift-এ label লাগে (১); মৌসুমি সতর্কতার সীমা (০.৫)। পর্ব ৭৪

যেখানে নম্বর কাটে: দুটিকে এক বলা; “PSI কম, তাই model ঠিক আছে” লেখা।

কথোপকথনে একজন বিচারক মানুষ আর যন্ত্র আলাদা করতে পারেন কি না, অর্থাৎ বাইরের আচরণ। ভেতরে বোঝাপড়া আছে কি না, তা মাপে না; আর মানুষকে বোকা বানানোর কৌশলেও পাস করা যায়। পর্ব ২ · পর্ব ১

পরের প্রশ্ন: Chinese room-এর যুক্তি কী? — নিয়ম মেনে চিহ্ন সাজালেই অর্থ বোঝা হয় না, এই দাবি (Searle, ১৯৮০); এ নিয়ে বিতর্ক এখনো চলে।

না। যা জানে আর যা দেখেছে, তা দিয়ে প্রত্যাশিত performance সবচেয়ে বাড়ায়; অজানা ঘটনায় ফল খারাপ হতে পারে। Rational মানে সর্বজ্ঞ নয়। পর্ব ১

পরের প্রশ্ন: কেন performance measure আগে লিখতে হয়? — নইলে agent যা মাপা হয় তা-ই বাড়ায়, যা চাওয়া হয়েছিল তা নয় (Goodhart).

সাধারণ ব্যাখ্যা: প্রতিশ্রুতির তুলনায় ফল কম, সমস্যা বড় হলে হিসাবের বিস্ফোরণ, আর expert system-এর রক্ষণাবেক্ষণের ভার; ফলে অর্থায়ন আর আগ্রহ কমে। সময় আর কারণ নিয়ে ইতিহাসবিদদের মধ্যে ভিন্নমত আছে। পর্ব ২

পরের প্রশ্ন: আবার আসবে? — নিশ্চিত বলা যায় না; প্রত্যাশা আর মাপা ফলের ফাঁক কত, সেটিই দেখার বিষয়।

প্রতিটি প্রকল্পের package আলাদা রাখতে venv, আর প্রতিটি package-এর হুবহু version (transitive dependency-সহ) ধরে রাখতে lockfile, যাতে অন্য যন্ত্রে একই পরিবেশ আসে। পর্ব ৭ · পর্ব ১২

পরের প্রশ্ন: pip freeze কি lockfile-এর সমান? — পুরো নয়: শুধু এখনকার পরিবেশের তালিকা, hash বা platform-এর তথ্য ছাড়া; uv lock সমাধানের পুরো ছবি রাখে।

এক dtype-এর সংখ্যার টানা memory, আর loop চলে compiled কোডে; প্রতিটি উপাদানে Python object বা type যাচাই লাগে না। পর্ব ১৩ · পর্ব ১৯

পরের প্রশ্ন: কখন কাজ করবে না? — খুব ছোট array-তে overhead বেশি, আর যেখানে প্রতিটি ধাপ আগের ফলের ওপর নির্ভর করে, সেখানে vectorize করা কঠিন; তখন সাধারণ loop বা numba.

Axis 0 বরাবর ভেঙে ফেলা, মানে সারিগুলো মিলিয়ে প্রতিটি কলামের গড়। (n, d) থেকে ফল (d,). পর্ব ১৬

পরের প্রশ্ন: keepdims=True কেন? — ফল (1, d) থাকে, তাই broadcasting-এ নিরাপদে X থেকে বিয়োগ করা যায়।

loc label দিয়ে, iloc অবস্থান দিয়ে। Slice-এ loc-এর শেষ সীমা অন্তর্ভুক্ত, iloc-এ নয়। পর্ব ২২

পরের প্রশ্ন: মান বসাতে কোনটি? — df.loc[mask, "col"] = …; pandas 3-এ chained assignment কখনো মূল টেবিল বদলায় না।

না। Histogram একটি সংখ্যার কলামের বণ্টন দেখায়, bin-এ ভাগ করে, bar-গুলো গায়ে গায়ে; bar chart বিভাগের তুলনা। পর্ব ২৯

পরের প্রশ্ন: Bin বদলালে কী হয়? — ছবির আকার বদলায়; খুব কম bin-এ দুই চূড়া হারায়, খুব বেশি bin-এ কোলাহল। কয়েকটি bin দেখে নিন, বা ECDF.

Cosine দিক দেখে, দৈর্ঘ্য নয়; লম্বা আর ছোট রিভিউ একই বিষয়ের হলে কাছে আসে। Normalize করা vector-এ cosine আর dot product এক। পর্ব ৩৩

পরের প্রশ্ন: কখন কাজ করবে না? — যখন মাত্রাটাই তথ্য, যেমন খরচের পরিমাণ; তখন Euclidean বা অন্য দূরত্ব।

সব ফল সমান সম্ভাব্য হলে; দুই ফলে ১ bit, যখন p = ০.৫. নিশ্চিত ফলে ০. পর্ব ৩৮

পরের প্রশ্ন: Information gain কোথায় লাগে? — Decision tree প্রশ্ন বাছে যে ভাগ entropy সবচেয়ে বেশি কমায়।

Memory কম থাকলে আর সমাধান গভীরে অনেক থাকলে; DFS-এর memory O(bm), BFS-এর O(b^d). পর্ব ৪০

পরের প্রশ্ন: কখন DFS ব্যর্থ? — অসীম শাখা বা চক্রে আটকায়, আর সবচেয়ে ছোট পথের নিশ্চয়তা দেয় না; iterative deepening দুই সমস্যাই মেটায়।

শুধু চার দিকে, প্রতি ঘরে খরচ ১ হলে যেকোনো পথে অন্তত ততগুলো আনুভূমিক আর উল্লম্ব পা লাগে; দেয়াল শুধু বাড়ায়। তাই কখনো বাড়িয়ে বলে না। পর্ব ৪১

পরের প্রশ্ন: কখন admissible নয়? — কোনাকুনি চলা গেলে (এক কোনাকুনি পা দুই Manhattan ঘর পেরোয়); তখন octile বা Chebyshev দূরত্ব।

একবারের চড়াই local maximum-এ থামতে পারে; নতুন এলোমেলো জায়গা থেকে শুরু করলে অন্য চূড়ায় ওঠার সুযোগ। পর্ব ৪৪

পরের প্রশ্ন: কখন কাজ করবে না? — ভালো চূড়ার আশপাশ খুব ছোট বা landscape বিশাল সমতল হলে; তখন অনেক restart লাগে, বা annealing.

না। → একটি বাক্যের ভেতরের connective; ⊨ দুটি বাক্যের সম্পর্ক: KB যেসব model-এ সত্য, তার প্রতিটিতে α-ও সত্য। পর্ব ৪৫

পরের প্রশ্ন: Model checking কখন অচল? — Symbol বাড়লে 2ⁿ জগৎ; তখন inference rule, resolution বা SAT solver.

KB ⊨ α মানে KB ∧ ¬α অসম্ভব (unsatisfiable). তাই ¬α যোগ করে খালি clause পেলে প্রমাণ শেষ। পর্ব ৪৫

পরের প্রশ্ন: FOL-এ কি সবসময় থামে? — না; α সত্য হলে প্রমাণ মেলে, না হলে খোঁজ শেষ না-ও হতে পারে (semi-decidable).

কাজের পরে যা আর সত্য নয়, তা মুছতে: রাইডার Drive(মিরপুর, ফার্মগেট) করলে At(মিরপুর) মোছে। না মুছলে রাইডার একসঙ্গে দুই জায়গায়। পর্ব ৪৯

পরের প্রশ্ন: Delete list ভুলে গেলে কাজে লাগে কোথায়? — Heuristic বানাতে: শিথিল সমস্যার plan-এর দৈর্ঘ্য একটি ভালো অনুমান (relaxed plan).

Feature-গুলো জোরালোভাবে সম্পর্কিত হলে একই প্রমাণ বারবার গোনা হয়; আর ভালো calibrated সম্ভাবনা দরকার হলে। পর্ব ৫১

পরের প্রশ্ন: তাহলে কেন এখনো ব্যবহার হয়? — দ্রুত, কম ডেটায় শক্ত, ব্যাখ্যা সহজ; ভালো baseline.

এখনকার অবস্থা জানা থাকলে অতীত পরের ধাপের সম্ভাবনা বদলায় না। গ্রাহক তিন মাস ধরে নিষ্ক্রিয়, না কি মাত্র এক মাস, তা যদি ফেরার সম্ভাবনা বদলায়, তবে শুধু “Dormant” অবস্থা যথেষ্ট নয়। পর্ব ৫৩

পরের প্রশ্ন: তাহলে কী করবেন? — অবস্থায় বাড়তি তথ্য রাখা (কত মাস ধরে), বা উচ্চতর ক্রমের model.

একই টাকা সবার কাছে সমান মূল্যবান নয়; ছোট দোকানের কাছে বড় ক্ষতি ধ্বংসাত্মক। Concave utility (যেমন log) ঝুঁকি-বিমুখতা ধরে, তাই expected value বেশি হলেও কম ঝুঁকির বিকল্প জিততে পারে। পর্ব ৫৪

পরের প্রশ্ন: Certainty equivalent কী? — যে নিশ্চিত টাকা পেলে ঝুঁকির জুয়ার সমান খুশি; expected value থেকে এর পার্থক্য risk premium.

Validation-এ সিদ্ধান্ত নেওয়া হয় (model, সেটিং, threshold), তাই সেখানে নম্বর আশাবাদী হয়ে যায়; test শেষে একবার খোলা হয় সৎ অনুমানের জন্য। পর্ব ৫৬

পরের প্রশ্ন: Validation-এ বারবার বাছলে? — সেখানেও overfit হয়; পর্ব ৬১-এ ৫০০টি এলোমেলো model-এর সেরাটি validation-এ ০.৭০, নতুন ডেটায় ০.৪৯৬.

দূরত্বে বড় এককের কলাম (টাকা) ছোট এককের কলামকে (দিন) ডুবিয়ে দেয়; পর্ব ৫৭-এ scaling ছাড়া accuracy প্রায় “সবসময় বেশি শ্রেণি” বলার সমান (০.৫২৫)। পর্ব ৫৭

পরের প্রশ্ন: কখন k-NN কাজ করবে না? — অনেক মাত্রায় সব দূরত্ব প্রায় সমান হয়ে যায় (curse of dimensionality), আর বড় ডেটায় অনুমান ধীর।

Sigmoid-এর সঙ্গে MSE convex থাকে না, আর আত্মবিশ্বাসী ভুলে gradient প্রায় শূন্য, শেখা থেমে যায়। Log loss convex, gradient সরল: Xᵀ(σ(Xw) − y)/n. পর্ব ৫৯

পরের প্রশ্ন: ০.৫ threshold কি পবিত্র? — না; দুই ভুলের দাম আর calibration দেখে বাছা।

Train-এ ভালো, validation-এ অনেক খারাপ; learning curve-এ দুই রেখার মাঝে বড় ফাঁক। পর্ব ৬১

পরের প্রশ্ন: আরও ডেটা কখন সাহায্য করে না? — দুটি রেখাই উঁচু ভুলে মিলে গেলে সমস্যা bias; তখন আরও নমনীয় model বা ভালো feature লাগে।

fit ডেটা থেকে শেখে (গড়, বিভাগ), transform শেখা মান প্রয়োগ করে, fit_transform দুটো একসঙ্গে, শুধু train-এ। পর্ব ৬৪

পরের প্রশ্ন: Test-এ fit_transform কেন ভুল? — Test-এর গড় দিয়ে scale হয়, train-এর সঙ্গে মাপ মেলে না, আর test থেকে শেখা হয়ে যায়; Pipeline এই ভুল আটকায়।

বিরল শ্রেণির অনুপাত প্রতিটি fold-এ সমান রাখতে; পর্ব ৫৬-এ ৫% ফেরতের ডেটায় এলোমেলো ভাগে test-এ ১ থেকে ৮টি ফেরত এসেছে, stratify দিলে প্রতিবার ৫টি। পর্ব ৫৬ · পর্ব ৬৬

পরের প্রশ্ন: কখন এলোমেলো k-fold ভুল? — সময়ের ডেটায় (ভবিষ্যৎ দিয়ে অতীত শেখা) আর একই গ্রাহকের অনেক সারিতে; তখন TimeSeriesSplit বা GroupKFold.

Python-এর \w কার-চিহ্ন ধরে না, তাই “ভালো” ভেঙে টুকরো হয়, “আপনার” হয়ে যায় “আপন”. NFC, অদৃশ্য অক্ষর মোছা আর বাংলা block-সহ regex লাগে। পর্ব ৬৭ · পর্ব ৫১

পরের প্রশ্ন: বানান-ভুল আর Banglish-এ কী সাহায্য করে? — Char n-gram: শব্দের অংশ মেলে, তাই ভিন্ন বানানও কাছে আসে।

সস্তা হিসাব, আর ধনাত্মক দিকে gradient ১, তাই অনেক স্তরেও sigmoid-এর মতো gradient মিলিয়ে যায় না (vanishing gradient কম)। পর্ব ৬৮

পরের প্রশ্ন: কখন সমস্যা? — কোনো neuron-এর input সবসময় ঋণাত্মক হলে gradient ০, সে আর শেখে না (“মৃত” ReLU); তাই leaky ReLU-র মতো রূপ।

না। এতে প্রায় সবসময় সবচেয়ে সম্ভাব্য token বাছা হয়, তাই উত্তর কম এলোমেলো; সম্ভাব্য আর সত্য এক নয়। পর্ব ৭০

পরের প্রশ্ন: তাহলে উত্তর সবসময় হুবহু একই? — প্রায়ই, তবে system ও hardware-ভেদে ছোট তফাতের কথা শোনা যায়; নিশ্চিত হতে নিজে চালিয়ে দেখুন।

Model card (কোন ভাষা ও ডেটায় শেখা, মূল্যায়ন, সীমা), licence-এর শর্ত, ওজনের ফরম্যাট (safetensors), আর revision বা commit hash. পর্ব ৭১

পরের প্রশ্ন: Licence কেন এত জরুরি? — যেমন cc-by-nc-4.0 বাণিজ্যিক ব্যবহার নিষেধ করে; দোকানের পণ্যে তা চলে না (আইনি পরামর্শ নয়)।

Demographic parity: প্রতিটি দলে অনুমোদনের হার সমান। Equal opportunity: যাঁরা আসলে যোগ্য, তাঁদের অনুমোদনের হার (TPR) প্রতিটি দলে সমান। পর্ব ৭২

পরের প্রশ্ন: সব ন্যায্যতার সংজ্ঞা একসঙ্গে মেলানো যায় না কেন? — দলগুলোর base rate আলাদা হলে calibration আর সমান ভুলের হার একসঙ্গে মেলে না; তাই কোনটি বেছে নিলেন, লিখে দায় নিতে হয়।