Numerical সমস্যার অনুশীলন — search, সম্ভাবনা, metric আর gradient, পূর্ণ সমাধানসহ

(a) shape (2, 3, 4), ndim 3, size 2 x 3 x 4 = 24
(b) sum(axis=0)      : drop position 0 -> (3, 4)
    sum(axis=(0, 2)) : drop 0 and 2    -> (3,)
    a[:, 1, :]       : integer index removes axis 1 -> (2, 4)
    a.T              : reverse all axes -> (4, 3, 2)
(c) flat index = 1 x (3 x 4) + 2 x 4 + 3 = 12 + 8 + 3 = 23 -> value 23

(গ)-র কৌশল: arange দিয়ে বানানো array-তে মান আর সমতল অবস্থান (row-major ক্রমে) একই, তাই সূচক থেকে stride গুনলেই মান। যাচাই: সূচক (০, ০, ০) থেকে (১, ২, ৩) পর্যন্ত মোট ২৪টি ঘর, শেষটি ২৩. ফাঁদ: a[:, 1, :] আর a[:, 1:2, :] এক নয়; slice axis রেখে দেয়, তাই দ্বিতীয়টির shape (২, ১, ৪)।

(a) (3, 1) with (4,) -> (3, 1) with (1, 4) -> (3, 4)
    row 1 = 2 x [10, 20, 30, 40] = [20, 40, 60, 80]
    sum   = (1 + 2 + 3) x (10 + 20 + 30 + 40) = 6 x 100 = 600
(b) (8, 1, 6) with (1, 7, 1) -> (8, 7, 6)
(c) (5, 4) with (1, 5): 4 vs 5 -> error
    (2, 3) with (3, 2): 3 vs 2 -> error
(d) (100, 3) - (100,) -> (100, 3) with (1, 100): 3 vs 100 -> error
    fix: X - X.mean(axis=1, keepdims=True)   # (100, 1)

যোগফলের শর্টকাট: প্রতিটি ঘর x_i × y_j, তাই সব ঘরের যোগ = (∑x)(∑y). (ঘ) সবচেয়ে প্রচলিত বাস্তব ভুল; সারি ৩ হলে আর column ৩ হলে কোড ভুল জিনিস বিয়োগ করেও চলে যেত, error ছাড়াই। তাই keepdims=True অভ্যাস করুন।

(a) 1,000,000 x 8 = 8,000,000 B  (= 8 MB = 7.63 MiB)
    1,000,000 x 4 = 4,000,000 B ; x 1 = 1,000,000 B
(b) 60,000 x 28 x 28 = 47,040,000 values
    uint8  : 47,040,000 B   (about 44.9 MiB)
    float64: 47,040,000 x 8 = 376,320,000 B (about 358.9 MiB)
(c) 32 x 224 x 224 x 3 = 4,816,896 B (about 4.6 MiB)
(d) basic slicing gives a view: 0 new data bytes
    (b.nbytes still reports 500 x 1000 x 8 = 4,000,000)

(খ) দেখায় কেন ছবির dataset অনেক সময় uint8-এ রেখে batch ধরে float-এ বদলানো হয়: পুরোটা একবারে float64 করলে memory আট গুণ। (ঘ)-র ফাঁদ: nbytes view-এর আকার বলে, নতুন বরাদ্দ নয়; np.shares_memory(a, b) True দেয়।

amount: 240, 150, 420, 550, 250, NaN, 290, 600
(a) Khulna    : 550, 290       -> size 2, count 2, sum 840,  mean 420.00
    Chattogram: 150, 250, 600  -> size 3, count 3, sum 1000, mean 333.33
    Dhaka     : 240, 420, NaN  -> size 3, count 2, sum 660,  mean 660/2 = 330.00
(b) fillna(0): (240 + 420 + 0) / 3 = 220.00
(c) pairs: Dhaka-rice, Dhaka-lentil, Ctg-lentil, Ctg-rice, Khulna-rice,
    Khulna-lentil = 6 groups

যাচাই: তিন জেলার sum ৮৪০ + ১,০০০ + ৬৬০ = ২,৫০০, আর NaN বাদে আটটির যোগও ২,৫০০. (ক) আর (খ)-র পার্থক্যটিই আসল শিক্ষা: অজানা দামকে ০ ধরা মানে “বিনা পয়সায় বিক্রি” বলা, আর তাতে ঢাকার গড় ৩৩০ থেকে ২২০-এ নামে। pandas দল সাজায় key-এর Unicode ক্রমে, তাই খুলনা (খ) আগে, ঢাকা (ঢ) শেষে।

(a) L1 = 3 + 4 + 0 = 7 ; L2 = sqrt(9 + 16 + 0) = 5 ; Linf = 4
(b) u.v = 12 + 0 + 0 = 12 ; |v| = sqrt(16 + 0 + 9) = 5
    cos = 12 / (5 x 5) = 0.48 ; angle = arccos(0.48) = 61.3 deg
(c) u - v = (-1, 4, -3)
    euclid    = sqrt(1 + 16 + 9) = sqrt(26) = 5.099
    manhattan = 1 + 4 + 3 = 8

যাচাই: L∞ ≤ L2 ≤ L1 (৪ ≤ ৫ ≤ ৭) সবসময় সত্য, উল্টো এলে হিসাব ভুল। Cosine ০.৪৮ মানে দিক আংশিক মেলে; দৈর্ঘ্য সমান (৫ আর ৫) হলেও দিক আলাদা।

|q| = sqrt(2) = 1.4142
(a) cos(q,a) = 4 / (1.4142 x 2.8284) = 1.0000
    cos(q,b) = 1 / (1.4142 x 1)      = 0.7071
    cos(q,c) = 9 / (1.4142 x 6.4031) = 0.9939
    order: a > c > b
(b) |q-a| = sqrt(2) = 1.4142 ; |q-b| = 1 ; |q-c| = sqrt(16 + 9) = 5
    order: b, a, c
(c) unit vectors: d = sqrt(2 - 2 cos)
    a: 0.0000 ; c: sqrt(2 - 1.9878) = 0.1106 ; b: sqrt(2 - 1.4142) = 0.7654
    order: a, c, b  (same as cosine)

শিক্ষা: Euclidean দৈর্ঘ্য দেখে, cosine শুধু দিক। c দিকের দিক থেকে q-এর কাছাকাছি কিন্তু “বড়”, তাই Euclidean-এ সবচেয়ে দূরে। Embedding খোঁজায় তাই আগে normalize করে নেওয়া হয়; তখন দুটি মাপ একই ক্রম দেয়।

(a) outer: 3 u^2 with u = 3x^2 + 1 ; inner: du/dx = 6x
    f'(x) = 3 (3x^2 + 1)^2 x 6x
    f'(1) = 3 x 4^2 x 6 = 3 x 16 x 6 = 288
(b) sigma(0) = 0.5 -> 0.5 x 0.5 = 0.25 (the largest possible value)
(c) dL/dw = 2 (wx - y) x = 2 (2 - 5) x 2 = -12
    negative slope -> increasing w lowers L

যাচাই (ক): f(১.০০১) − f(০.৯৯৯) কে ০.০০২ দিয়ে ভাগ করলে প্রায় ২৮৮ আসে; চেকারে 288.0. (খ)-র ০.২৫ মনে রাখার মতো: sigmoid-এর ঢাল কখনো ০.২৫ ছাড়ায় না, তাই অনেক স্তরে গুণ হতে হতে gradient ছোট হয়ে যায় (vanishing gradient).

(a) f'(x) = 2x - 4 ; minimum at x = 2
    x1 = 0     - 0.1 x (0 - 4)    = 0.4
    x2 = 0.4   - 0.1 x (0.8 - 4)  = 0.72
    x3 = 0.72  - 0.1 x (1.44 - 4) = 0.976 ; f(x3) = 2.0486
    gap to 2 shrinks by (1 - 2 eta): 2 -> 1.6 -> 1.28 -> 1.024
    eta = 1.0: factor -1   -> 4, 0, 4  (bounces forever)
    eta = 1.1: factor -1.2 -> 4.4, -0.88, 5.456 (diverges)
(b) grad = (2x, 20y)
    eta 0.05: (1,1) -> (0.9, 0) -> (0.81, 0)
    eta 0.1 : (1,1) -> (0.8, -1) -> (0.64, 1)   y bounces
    y factor = 1 - 20 eta ; stable when |1 - 20 eta| < 1 -> eta < 0.1

যাচাই: f(০.৪) = ৩.৫৬, f(০.৭২) = ২.৬৩৮৪, f(০.৯৭৬) = ২.০৪৮৬, প্রতি ধাপে কমছে, সর্বনিম্ন f(২) = ১-এর দিকে। (খ) দেখায়, খাড়া দিকটিই (এখানে y, বক্রতা ২০) η-এর সীমা ঠিক করে; চ্যাপ্টা x-দিক তখন ধীরে এগোয়। Feature scaling কেন দরকার, তার সংখ্যায় উত্তর এটিই।

(a) P(R)       = (18 + 4) / 200 = 22 / 200 = 0.11
    P(R | COD) = 18 / 120 = 0.15
    P(R | pre) = 4 / 80   = 0.05
(b) P(COD | R) = 18 / 22 = 0.8182
(c) independent would need P(R | COD) = P(R): 0.15 != 0.11 -> not independent
check: P(R) = 0.6 x 0.15 + 0.4 x 0.05 = 0.09 + 0.02 = 0.11

(খ) আর (ক)-র দ্বিতীয়টি গুলিয়ে ফেলা সবচেয়ে প্রচলিত ভুল: “COD হলে ফেরত” ১৫%, কিন্তু “ফেরত হলে COD” ৮২%. দুটি আলাদা প্রশ্ন। সতর্কতা: এই সম্পর্ক কারণ প্রমাণ করে না; COD-এর ক্রেতারা অন্য দিক থেকেও আলাদা হতে পারেন।

(a) fraud  : 10,000 x 0.02 = 200 -> flagged 200 x 0.90 = 180
    honest : 9,800             -> flagged 9,800 x 0.05 = 490
    P(F | flag) = 180 / (180 + 490) = 180 / 670 = 0.2687
(b) odds after first = 180 : 490 = 0.3673
    likelihood ratio  = 0.90 / 0.05 = 18
    new odds = 0.3673 x 18 = 6.612 -> P = 6.612 / 7.612 = 0.8686

৯০% নির্ভুল শুনে “সতর্ক মানেই প্রতারণা” ভাবা base rate উপেক্ষার ভুল: প্রতারণা বিরল, তাই সৎ অর্ডারের ছোট ৫%-ও সংখ্যায় বড় (৪৯০)। প্রথম সতর্কবার্তার পরের সম্ভাবনা দ্বিতীয় প্রমাণের prior হয়ে যায়। (খ)-র “স্বাধীন” শর্তটি বাস্তবে প্রায়ই সত্য নয়; দুটি নিয়ম একই সংকেত দেখলে এত বড় লাফ আসে না।

(a) P(0) = 0.9^10 = 0.3487
    P(1) = 10 x 0.1 x 0.9^9 = 0.3874
    P(2) = C(10,2) x 0.1^2 x 0.9^8 = 45 x 0.01 x 0.4305 = 0.1937
    P(X >= 2) = 1 - P(0) - P(1) = 1 - 0.3487 - 0.3874 = 0.2639
    mean = np = 1 ; var = np(1 - p) = 0.9
(b) e^-3 = 0.0498
    P(0) = 0.0498 ; P(1) = 3 x 0.0498 = 0.1494 ; P(2) = 4.5 x 0.0498 = 0.2240
    P(X <= 2) = 0.0498 + 0.1494 + 0.2240 = 0.4232
    P(3) = 4.5 x 0.0498 = 0.2240 -> P(X <= 3) = 0.6472
    P(X >= 4) = 1 - 0.6472 = 0.3528
    two hours: lambda = 6 -> P(0) = e^-6 = 0.00248

“অন্তত” প্রশ্নে পরিপূরক (১ − বাকিগুলো) দিয়ে করা দ্রুত আর নিরাপদ। Poisson-এ সময়ের দৈর্ঘ্য বদলালে λ-ও একই অনুপাতে বদলায়; দুই ঘণ্টার উত্তর (০.০৪৯৮)²-ও, কারণ দুই স্বাধীন ঘণ্টাই খালি।

(a) z = (60 - 48) / 8 = 1.5 ; P(Z > 1.5) = 1 - 0.9332 = 0.0668
(b) z = -1 to +1 -> 0.8413 - 0.1587 = 0.6827
(c) x = 48 + 1.645 x 8 = 48 + 13.16 = 61.16 hours

(খ) “৬৮–৯৫–৯৯.৭” নিয়মের প্রথম সংখ্যা। বাস্তবে ডেলিভারির সময় সাধারণত ডান দিকে লম্বা লেজের (skewed) হয়, তাই normal ধরে ৯৫তম শতাংশ বের করলে কম আসতে পারে; আসল ডেটা থাকলে সরাসরি quantile(0.95) নেওয়াই ভালো।

(a) mean = 30 / 6 = 5
    deviations: -3, -1, -1, 0, 2, 3 ; squares: 9, 1, 1, 0, 4, 9 -> 24
    population var = 24 / 6 = 4.0 ; sample var = 24 / 5 = 4.8
(b) s = sqrt(4.8) = 2.1909 ; SE = 2.1909 / sqrt(6) = 0.8944
(c) margin = 2.5706 x 0.8944 = 2.2992
    CI = 5 - 2.30 to 5 + 2.30 = (2.70, 7.30) days

যাচাই: বিচ্যুতির যোগ (−৩ − ১ − ১ + ০ + ২ + ৩) = ০ হতেই হবে। ফাঁদ দুটি: n − ১-এর বদলে n দিয়ে ভাগ, আর ছোট নমুনায় t-এর বদলে z = ১.৯৬ বসানো, যাতে interval ভুলভাবে সরু হয় (৫ ± ১.৭৫)। “৯৫%” মানে পদ্ধতিটির দীর্ঘমেয়াদি সফলতার হার, এই নির্দিষ্ট interval-এ গড় থাকার ৯৫% সম্ভাবনা নয়।

log2: 0.5 -> -1, 0.25 -> -2, 0.8 -> -0.3219, 0.1 -> -3.3219
(a) H(p) = 0.5 x 1 + 0.25 x 2 + 0.25 x 2 = 1.5 bits
    H(q) = 0.8 x 0.3219 + 0.1 x 3.3219 + 0.1 x 3.3219 = 0.9219 bits
(b) H(p,q) = 0.5 x 0.3219 + 0.25 x 3.3219 + 0.25 x 3.3219 = 1.8219
    KL(p||q) = 1.8219 - 1.5 = 0.3219 bits
    H(q,p) = 0.8 x 1 + 0.1 x 2 + 0.1 x 2 = 1.2
    KL(q||p) = 1.2 - 0.9219 = 0.2781 bits   (not equal: KL is not symmetric)
(c) -ln 0.8 = 0.2231 ; -ln 0.1 = 2.3026

যাচাই: H(p, q) ≥ H(p) সবসময়, সমান শুধু q = p হলে; KL কখনো ঋণাত্মক নয়। (গ) দেখায় কেন cross-entropy loss আত্মবিশ্বাসী ভুলকে কঠোর শাস্তি দেয়: ০.৮ থেকে ০.১-এ নামলে loss দশ গুণের বেশি।

(a) H(4/12) = -(1/3) log2(1/3) - (2/3) log2(2/3) = 0.9183
(b) payment : COD H(3/6) = 1.0 ; prepaid H(1/6) = 0.6500
              weighted = 6/12 x 1.0 + 6/12 x 0.6500 = 0.8250
              IG = 0.9183 - 0.8250 = 0.0933
    district: Dhaka H(2/8) = 0.8113 ; outside H(2/4) = 1.0
              weighted = 8/12 x 0.8113 + 4/12 x 1.0 = 0.8742
              IG = 0.9183 - 0.8742 = 0.0441
    split on payment first (0.0933 > 0.0441)

যাচাই: IG কখনো ঋণাত্মক নয়, আর মূল entropy-র বেশি হতে পারে না। ফাঁদ: শাখার entropy-গুলো ওজন ছাড়া গড় করা; এখানে জেলার দুটি শাখা ৮ আর ৪, তাই ওজন ২/৩ আর ১/৩. বড় সংখ্যক মানের feature (যেমন অর্ডার নম্বর) IG-কে কৃত্রিমভাবে বাড়ায়; সেজন্য gain ratio-র মতো সংশোধন আছে।

(a) BFS: expand S -> generate A, B
         expand A -> B seen, generate C
         expand B -> C seen, generate D
         expand C -> generate G: goal!
    expanded: S, A, B, C ; path S-A-C-G ; cost 2 + 6 + 3 = 11 (3 edges)
(b) DFS: S -> A -> B -> C -> G ; cost 2 + 2 + 2 + 3 = 9
(c) reverse: S -> B -> D -> G ; cost 5 + 4 + 2 = 11

BFS সবচেয়ে কম রাস্তার সংখ্যার পথ দেয় (তিনটি), সবচেয়ে কম খরচের নয়। (খ)-তে DFS ভাগ্যক্রমে সর্বোত্তম পথ পেয়েছে, শুধু বর্ণক্রমের কারণে; (গ)-তে ক্রম উল্টালেই ১১. তাই “DFS সর্বোত্তম” কখনো লিখবেন না।

(a) UCS (pop smallest g):
    S(0)  -> A g=2, B g=5
    A(2)  -> B improved to 2+2 = 4, C g=8
    B(4)  -> C improved to 4+2 = 6, D g=8
    C(6)  -> G g=9
    D(8)  -> G via D = 10, not better
    G(9)  -> goal. path S-A-B-C-G, cost 9
(b) greedy (pop smallest h):
    S(7) -> A(6), B(4) ; B(4) -> C(3), D(2) ; D(2) -> G(0) ; G
    path S-B-D-G, cost 11

UCS-এ G তৈরি হয় C expand-এর সময় (g = ৯), কিন্তু তখনই থামলে চলে না; D (৮) তখনো সস্তা, তাই আগে D খোলে। Goal test expand-এর সময় রাখার কারণ এটিই: frontier-এ সস্তা পথ থাকতে পারে। Greedy মাত্র চারটি node খুলেছে, কিন্তু খরচ ১১; দ্রুত, তবে সর্বোত্তম নয়।

(a) true cost to G: G 0, D 2, C 3, B min(2+3, 4+2) = 5, A 2+5 = 7, S 9
    h <= true: 7<=9, 6<=7, 4<=5, 3<=3, 2<=2 -> admissible
    every edge |h(u) - h(v)| <= cost: S-A 1<=2, A-B 2<=2, C-G 3<=3, ... -> consistent
(b) S f=0+7=7   -> A f=2+6=8, B f=5+4=9
    A f=8       -> B f=4+4=8 (improved), C f=8+3=11
    B f=8       -> C f=6+3=9 (improved), D f=8+2=10
    C f=9       -> G f=9+0=9
    G f=9 is smaller than D f=10 -> pop G -> goal
    expanded S, A, B, C, G ; path S-A-B-C-G ; cost 9
(c) UCS expanded 6 nodes, A* 5: D was never opened

A* আর UCS একই খরচ (৯) দিয়েছে, যা admissible h-এর প্রতিশ্রুতি। A আর B দুটিরই f = ৮ হলে বর্ণক্রমে A আগে। নিচের stepper-এ প্রতিটি ধাপের frontier দেখুন।

(a) D = max(3, 5) = 5 ; E = max(6, 9) = 9 ; F = max(1, 2) = 2 ; G = max(0, -1) = 0
    B = min(5, 9) = 5 ; C = min(2, 0) = 0 ; root = max(5, 0) = 5 -> move to B
(b) B: D sees 3, 5 -> 5 ; B's beta = 5
       E (alpha -inf, beta 5): leaf 6 -> 6 >= 5 -> prune leaf 9
    root alpha = 5
    C: F (alpha 5): leaves 1, 2 -> F = 2 ; C's beta = 2 <= alpha 5
       -> prune whole G (leaves 0, -1)
    leaves seen: 3, 5, 6, 1, 2 ; pruned: 9, 0, -1 (3 of 8)

যাচাই: ছাঁটাইয়ের পরেও মূলের মান ৫, minimax-এর সমান; alpha-beta উত্তর বদলায় না, শুধু কাজ কমায়। ছাঁটাই হওয়া node-এর “মান” লিখতে হলে সীমা লিখুন: E ≥ ৬, C ≤ ২. Ordering ভালো হলে, অর্থাৎ সেরা চাল আগে এলে, ছাঁটাই আরও বাড়ে।

1. (X,Y): X=3 has no Y > 3     -> X = {1, 2}
2. (Y,X): Y=1 has no X < 1     -> Y = {2, 3}  ((Z,Y) already queued)
3. (Y,Z): Y=3 has no Z > 3     -> Y = {2}     add (X,Y)
4. (Z,Y): Z=1, 2 have no Y < Z -> Z = {3}     (Z has no other neighbour)
5. (X,Y): X=2 has no Y > 2     -> X = {1}
queue empty after 5 revisions: X=1, Y=2, Z=3 (no search needed)

এখানে arc consistency একাই সমাধান দিয়েছে, কারণ শর্তগুলো একটি শিকলের মতো। সাধারণভাবে AC-3 শুধু domain ছোট করে, তারপর backtracking লাগে; কোনো domain খালি হলে বোঝা যায় সমাধানই নেই।

(a) pairs (col i, col j): attack if same row or |row diff| = j - i
    (0,1) 2,0 diff 2 dist 1 no   (0,2) 2,0 diff 2 dist 2 yes
    (0,3) 2,2 same row      yes  (1,2) 0,0 same row      yes
    (1,3) 0,2 diff 2 dist 2 yes  (2,3) 0,2 diff 2 dist 1 no   -> h = 4
(b) neighbours = 4 columns x 3 other rows = 12
    best h = 2: move col 0 to row 3 -> (3,0,0,2), or col 3 to row 3 -> (2,0,0,3)
(c) (3,1,2,0): (0,3) rows 3,0 diff 3 dist 3 yes
                (1,2) rows 1,2 diff 1 dist 1 yes ; other 4 pairs no -> h = 2
    all 12 neighbours have h >= 2 -> no strictly better move: stuck
    (local minimum / plateau)

(গ)-র অবস্থা সমাধান নয় (h ≠ ০), তবু কোনো এক চালে উন্নতি হয় না। এখান থেকে বাঁচার উপায় পর্ব ৪৪-এ দেখেছেন: sideways move-এর অনুমতি, random restart বা simulated annealing.

(a) 2^3 = 8 rows ; false only when (P v Q) = T and R = F
    (P v Q) = T in 3 of the 4 (P,Q) rows -> 3 false rows -> 8 - 3 = 5 true
(b) if Q = T then (P -> Q) = T ; if Q = F then (Q -> P) = T -> true in 4 of 4: valid
(c) KB true:  P Q R
              T T T, T F T      (P = T needs R = T)
              F T T, F T F      (P = F needs Q = T)
    4 models ; Q v R is true in all 4 -> KB entails Q v R

(গ) আসলে resolution-এর একটি ধাপ: (P ∨ Q) আর (¬P ∨ R) থেকে (Q ∨ R). Model গুনে আর resolution করে একই উত্তর আসা যাচাই হিসেবে চমৎকার।

(a) (P -> (Q v R)) ^ ((Q v R) -> P)
    = (~P v Q v R) ^ (~(Q v R) v P)
    = (~P v Q v R) ^ ((~Q ^ ~R) v P)
    = (~P v Q v R) ^ (~Q v P) ^ (~R v P)        -> 3 clauses
(b) ~(~A v (B ^ C))
    = A ^ ~(B ^ C)
    = A ^ (~B v ~C)                              -> 2 clauses

যাচাই: আটটি সারিতে মূল বাক্য আর CNF-এর মান মিলিয়ে দেখুন; নিচের চেকার দুটিতেই True দেয়। ফাঁদ: ¬(B ∧ C)-কে ¬B ∧ ¬C লেখা; De Morgan-এ ∧ বদলে ∨ হয়।

clauses: 1. A v B   2. ~A v C   3. ~B v C   4. ~C  (negated goal)
5. from 2 + 4 (on C): ~A
6. from 3 + 4 (on C): ~B
7. from 1 + 5 (on A): B
8. from 7 + 6 (on B): EMPTY  -> contradiction, so KB entails C

এটি “ক্ষেত্রভেদে প্রমাণ”: দুই পথেই C, আর অন্তত একটি পথ সত্য। চার ধাপের resolution-এ শেষ clause খালি। চেকার আটটি model গুনেও (model checking) একই রায় দেয়।

(a) pass 1: R1 (A,B) -> C ; R2 (C) -> D ; R3 (B,D) -> E ; R4 (E) -> G
            R5 needs F (unknown) ; R6 needs H (unknown)
    pass 2: nothing new -> stop (2 passes)
    facts: A, B, C, D, E, G   (F never derived)
(b) G? -> R4: need E
      E? -> R3: need B, D
        B? fact
        D? -> R2: need C
          C? -> R1: need A, B -> facts
    goals called: G, E, B, D, C, A, B ; R4 succeeds so R5 is never tried

একই KB, দুই কৌশল। Forward chaining সব জানা fact থেকে যা বের করা যায় সব করে (এখানে G-ও, কিন্তু প্রশ্ন না থাকলেও); backward chaining লক্ষ্য থেকে শুধু দরকারি নিয়ম খোঁজে, তাই R5, R6 ছোঁয় না। পাস গোনায় সতর্কতা: “কিছু নতুন এল না” বোঝাতেই শেষ পাসটি লাগে।

(a) 0.3 x 0.6 x 0.6 x 0.7 = 0.0756
(b) P(D) = 0.3x0.4x0.9 + 0.3x0.6x0.6 + 0.7x0.4x0.5 + 0.7x0.6x0.1
         = 0.108 + 0.108 + 0.140 + 0.042 = 0.398
    P(R | D) = (0.108 + 0.108) / 0.398 = 0.5427
(c) P(D | R) = 0.4 x 0.9 + 0.6 x 0.6 = 0.72
    P(C | R) = 0.72 x 0.7 + 0.28 x 0.05 = 0.518 -> P(R, C) = 0.3 x 0.518 = 0.1554
    P(C) = 0.398 x 0.7 + 0.602 x 0.05 = 0.2786 + 0.0301 = 0.3087
    P(R | C) = 0.1554 / 0.3087 = 0.5034
(d) full joint: 2^4 - 1 = 15 ; network: R 1 + J 1 + D 4 + C 2 = 8

প্রমাণ যত দূরের, বিশ্বাসের হালনাগাদ তত দুর্বল: সরাসরি দেরি দেখলে বৃষ্টির সম্ভাবনা ০.৩ থেকে ০.৫৪, শুধু অভিযোগ দেখলে ০.৫০. যাচাই: P(R | D) > P(R), কারণ দেরি বৃষ্টির পক্ষে প্রমাণ।

(a) day 1 = row "sun" = (0.6, 0.3, 0.1)
    day 2 = 0.6 x (0.6,0.3,0.1) + 0.3 x (0.3,0.4,0.3) + 0.1 x (0.2,0.3,0.5)
          = (0.36+0.09+0.02, 0.18+0.12+0.03, 0.06+0.09+0.05) = (0.47, 0.33, 0.20)
(b) T = [[0.7, 0.3], [0.2, 0.8]] (buy, not)
    P(buy after 2 | buy) = 0.7 x 0.7 + 0.3 x 0.2 = 0.49 + 0.06 = 0.55
    stationary: pi_buy x 0.3 = pi_not x 0.2 and pi_buy + pi_not = 1
    -> pi_buy = 0.2 / (0.3 + 0.2) = 0.4 ; pi_not = 0.6
    check: 0.4 x 0.7 + 0.6 x 0.2 = 0.28 + 0.12 = 0.40

যাচাই: প্রতিটি বণ্টনের যোগ ১ (০.৪৭ + ০.৩৩ + ০.২০)। দুই-অবস্থার শর্টকাট “যত বেরোয় তত ঢোকে”: π_কেনা × ০.৩ = π_না × ০.২. শুরু যা-ই হোক, দীর্ঘমেয়াদে ৪০% সপ্তাহে কেনা, এই ধরনের chain-এ শুরুর অবস্থা ধীরে ধীরে ভুলে যাওয়া হয়।

(a) EU(extra)  = 0.4 x 50 + 0.6 x (-20) = 20 - 12 = 8
    EU(normal) = 0.4 x 10 + 0.6 x 5     = 4 + 3   = 7   -> choose extra (8)
(b) with a perfect forecast: high -> extra (50), low -> normal (5)
    value = 0.4 x 50 + 0.6 x 5 = 20 + 3 = 23
    VPI = 23 - 8 = 15 (thousand taka)

অর্থ: একটি নিখুঁত চাহিদার পূর্বাভাসের জন্য সর্বোচ্চ ১৫ হাজার টাকা দেওয়া যুক্তিসংগত, তার বেশি নয়। আর বাস্তবের পূর্বাভাস নিখুঁত নয়, তাই তার মূল্য আরও কম। EU ৮ বনাম ৭ খুব কাছাকাছি; সম্ভাবনা সামান্য বদলালেই সিদ্ধান্ত উল্টে যায়, তাই sensitivity দেখা দরকার। লাভের সংখ্যাগুলো কাল্পনিক।

t=1 (late)  : B 0.6 x 0.8 = 0.48 ; Q 0.4 x 0.2 = 0.08
t=2 (ontime): B max(0.48x0.7, 0.08x0.4) = 0.336 (from B) x 0.2 = 0.0672
              Q max(0.48x0.3, 0.08x0.6) = 0.144 (from B) x 0.8 = 0.1152
t=3 (late)  : B max(0.0672x0.7, 0.1152x0.4) = max(0.04704, 0.04608)
                = 0.04704 (from B) x 0.8 = 0.037632
              Q max(0.0672x0.3, 0.1152x0.6) = 0.06912 (from Q) x 0.2 = 0.013824
best end: B (0.03763) -> back: B <- B <- B
path B, B, B ; probability 0.03763

ফাঁদ: প্রতিটি দিনে আলাদাভাবে বড় মানটি বেছে নেওয়া। t = ২-তে Q-এর মান (০.১১৫২) বড়, তবু সেরা পুরো পথ সেখানে B দিয়ে যায়, কারণ t = ৩-এ B-তে পৌঁছানোর হিসাবে B থেকে আসা পথটি সামান্য এগিয়ে (০.০৪৭০৪ বনাম ০.০৪৬০৮)। এজন্যই pointer রেখে শেষ থেকে পেছনে যেতে হয়।

Q(s,a) = sum P(s'|s,a) [R + 0.9 V(s')]
sweep 1 (V0 = 0 everywhere):
  A: go   = 0.8(-1 + 0) + 0.2(-1 + 0) = -1.0 ; wait = 0 -> V1(A) = 0   (wait)
  B: go   = 0.8(10 + 0) + 0.2(-1 + 0) = 7.8  ; wait = 0 -> V1(B) = 7.8 (go)
sweep 2 (uses V1: A 0, B 7.8):
  A: go   = 0.8(-1 + 0.9x7.8) + 0.2(-1 + 0) = 0.8 x 6.02 - 0.2 = 4.616
     wait = 0 + 0.9 x 0 = 0              -> V2(A) = 4.616 (go)
  B: go   = 0.8(10 + 0) + 0.2(-1 + 0.9x7.8) = 8 + 1.204 = 9.204
     wait = 0 + 0.9 x 7.8 = 7.02         -> V2(B) = 9.204 (go)

Sweep ১-এর পরে A-তে “wait” সেরা দেখায়, কারণ তখনো G-এর পুরস্কারের খবর A পর্যন্ত পৌঁছায়নি; প্রতি sweep-এ মূল্য এক ধাপ পেছনে ছড়ায়। Synchronous মানে sweep ২-এর সব হিসাবে V₁-এর মান, নতুন V₂(B) নয়। আরও sweep দিলে মানগুলো স্থির বিন্দুর দিকে যায়।

(a) (1,1) A sqrt(4+1) = 2.236   (2,1) A sqrt(1+1) = 1.414
    (1,2) A sqrt(4+0) = 2.000   (4,4.5) B sqrt(1+6.25) = 2.693
    (5,4) B sqrt(4+4) = 2.828   (4,5) B sqrt(1+9) = 3.162   (3,3) B 1.000
    sorted: (3,3)B 1.000, (2,1)A 1.414, (1,2)A 2.000, (1,1)A 2.236, (4,4.5)B 2.693
(b) k=1: B ; k=3: B, A, A -> A ; k=5: B, A, A, A, B -> A (3 to 2)
(c) weights 1/d: B 1/1 = 1.000 ; A 1/1.414 + 1/2 = 0.707 + 0.5 = 1.207 -> A

k = ১-এ একটিমাত্র কাছের বিন্দু (৩, ৩) রায় দেয়, যা noise-এর প্রতি সংবেদনশীল; k বাড়ালে রায় স্থির হয়, কিন্তু খুব বড় k-তে বড় শ্রেণি জিতে যায়। দুই শ্রেণিতে বিজোড় k নিলে ভোটে টাই হয় না।

X = [[1,1],[1,2],[1,3]] , y = [2,3,5]
(a) XtX = [[3, 6], [6, 14]] ; Xty = [2+3+5, 2+6+15] = [10, 23]
(b) det = 3 x 14 - 6 x 6 = 6
    inv = (1/6) [[14, -6], [-6, 3]]
    theta = (1/6) [14x10 - 6x23, -6x10 + 3x23] = (1/6) [2, 9] = [0.3333, 1.5]
(c) predictions 1.8333, 3.3333, 4.8333
    residuals    0.1667, -0.3333, 0.1667   (sum = 0)
    SSE = 0.0278 + 0.1111 + 0.0278 = 0.1667
    mean y = 10/3 ; SST = 1.7778 + 0.1111 + 2.7778 = 4.6667
    R2 = 1 - 0.1667 / 4.6667 = 0.9643

যাচাই: intercept থাকলে residual-এর যোগ শূন্য, আর রেখাটি (x̄, ȳ) = (২, ৩.৩৩৩) বিন্দু দিয়ে যায় (০.৩৩৩ + ১.৫ × ২ = ৩.৩৩৩)। তিনটি বিন্দু থেকে কারণ-সম্পর্ক বলা যায় না, আর R² এত ছোট ডেটায় সহজেই বড় আসে।

(a) p = sigma(0) = 0.5 for all
    p - y = -0.5, 0.5, -0.5
    dw = mean((p - y) x) = (-0.5x2 + 0.5x0 - 0.5x1) / 3 = -1.5 / 3 = -0.5
    db = mean(p - y)     = (-0.5 + 0.5 - 0.5) / 3        = -0.1667
    w = 0 - 0.5 x (-0.5) = 0.25 ; b = 0 - 0.5 x (-0.1667) = 0.0833
(b) p(x=2) = sigma(0.5833) = 0.6418 ; p(x=0) = sigma(0.0833) = 0.5208
    p(x=1) = sigma(0.3333) = 0.5826
    loss before = ln 2 = 0.6931
    loss after  = (-ln 0.6418 - ln(1 - 0.5208) - ln 0.5826) / 3
                = (0.4434 + 0.7357 + 0.5403) / 3 = 0.5731

ঋণাত্মক gradient মানে w বাড়ালে loss কমে, তাই বিয়োগ করলে w ধনাত্মক হয়েছে। লক্ষ করুন x = ০-এর বিন্দুর p ০.৫ থেকে ০.৫২-এ উঠেছে, অর্থাৎ ওই একটির loss বেড়েছে; gradient descent গড় loss কমায়, প্রতিটি বিন্দুর নয়।

(a) mean prediction = (4 + 6 + 5 + 7 + 3) / 5 = 5
    bias^2   = (5 - 6)^2 = 1
    variance = (1 + 1 + 0 + 4 + 4) / 5 = 2   (spread around 5)
    expected test MSE = 1 + 2 + 1 = 4
    check: mean (p - 6)^2 = (4 + 0 + 1 + 1 + 9) / 5 = 3 = bias^2 + variance
(b) sum xy = 2 + 8 + 21 = 31 ; sum x^2 = 1 + 4 + 9 = 14
    lambda 0 : 31 / 14 = 2.2143 (ordinary least squares)
    lambda 1 : 31 / 15 = 2.0667
    lambda 14: 31 / 28 = 1.1071

(ক)-তে variance-এ n দিয়ে ভাগ, কারণ এটি পাঁচটি model-এর পুরো সংগ্রহ। Noise কোনো model কমাতে পারে না, তাই ৪-এর নিচে নামা অসম্ভব এই বিন্দুতে। (খ)-তে λ যত বড়, w তত শূন্যের দিকে; λ = ∑x² হলে w ঠিক অর্ধেক। Ridge সামান্য bias বাড়িয়ে variance কমায়; সঠিক λ বাছতে হয় validation দিয়ে, test দিয়ে নয়।

(a) accuracy    = (40 + 890) / 1000 = 0.93
    precision   = 40 / (40 + 60)    = 0.40
    recall      = 40 / (40 + 10)    = 0.80
    F1          = 2 x 0.4 x 0.8 / (0.4 + 0.8) = 0.64 / 1.2 = 0.5333
    specificity = 890 / (890 + 60)  = 0.9368
(b) all honest: (890 + 60) / 1000 = 0.95  > 0.93 of the real model

যাচাই: ৪০ + ১০ + ৬০ + ৮৯০ = ১,০০০. (খ) শ্রেণির ভারসাম্যহীনতার ক্লাসিক ফাঁদ: কোনো প্রতারণা না ধরা “model” accuracy-তে জেতে। Precision ০.৪ মানে সতর্ক হওয়া পাঁচটির তিনটিই সৎ ক্রেতা, তাই সতর্কবার্তার পরে মানুষের যাচাই দরকার।

pairs = 4 x 5 = 20
pos 0.9 : beats all 5                         -> 5
pos 0.8 : beats 0.7, 0.55, 0.3, 0.2, 0.1      -> 5
pos 0.55: beats 0.3, 0.2, 0.1 ; ties 0.55 (0.5) ; loses to 0.7 -> 3.5
pos 0.4 : beats 0.3, 0.2, 0.1 ; loses to 0.7, 0.55            -> 3
AUC = (5 + 5 + 3.5 + 3) / 20 = 16.5 / 20 = 0.825

অর্থ: এলোমেলোভাবে একটি ফেরত আর একটি না-ফেরত অর্ডার নিলে ৮২.৫% ক্ষেত্রে model ফেরতটিকে বেশি score দেয়। AUC কোনো threshold বাছে না আর score-এর মাপ (calibration) দেখে না, শুধু ক্রম দেখে। ফাঁদ: সমান score-কে পুরো জয় বা পুরো হার ধরা।

(a) squared distances to c1, c2:
    (1,1): 0, 1 -> c1      (2,1): 1, 0 -> c2      (1,2): 1, 2 -> c1
    (5,4): 25, 18 -> c2    (6,5): 41, 32 -> c2    (5,6): 41, 34 -> c2
    inertia = 0 + 0 + 1 + 18 + 32 + 34 = 85
(b) c1 = mean((1,1),(1,2)) = (1, 1.5)
    c2 = mean((2,1),(5,4),(6,5),(5,6)) = (18/4, 16/4) = (4.5, 4)
    inertia = 0.25 + 0.25 + 15.25 + 0.25 + 3.25 + 4.25 = 23.5
(c) (2,1): to c1 1 + 0.25 = 1.25 ; to c2 6.25 + 9 = 15.25 -> moves to c1
    labels: {(1,1),(2,1),(1,2)} and {(5,4),(6,5),(5,6)}

খারাপ শুরু (দুটি centroid পাশাপাশি) এক ধাপেই অনেকটা সেরে উঠেছে; প্রতিটি ধাপে inertia কমে বা সমান থাকে, বাড়ে না। বাস্তবে k-means++ শুরু আর কয়েকবার চালানো (n_init) খারাপ local minimum এড়ায়।

(a) total = 4.5 + 2.0 + 1.0 + 0.3 + 0.2 = 8.0
    ratio      : 0.5625, 0.25, 0.125, 0.0375, 0.025
    cumulative : 0.5625, 0.8125, 0.9375, 0.975, 1.0
    90% needs 3 components (0.8125 < 0.90 <= 0.9375)
(b) trace = 7, det = 10 - 4 = 6 -> l^2 - 7l + 6 = 0 -> l = 6, 1
    PC1 = 6 / 7 = 85.7% ; direction (2, 1)/sqrt(5)

২ × ২-এর শর্টকাট: eigenvalue-গুলোর যোগ = trace, গুণফল = determinant. Standardize করা ডেটায় (correlation matrix) eigenvalue-গুলোর যোগ feature-এর সংখ্যার সমান, তাই সেখানে “১-এর বেশি eigenvalue” একটি প্রচলিত হাতের নিয়ম। Scale না করলে বড় এককের feature (যেমন টাকায় দাম) PCA-কে দখল করে নেয়।

n = 4 ; df: dam 2, kom 1, bhalo 2
(a) idf(dam)   = ln(5/3) + 1 = 0.5108 + 1 = 1.5108 ; tf 2 -> 3.0217
    idf(kom)   = ln(5/2) + 1 = 0.9163 + 1 = 1.9163 ; tf 1 -> 1.9163
    idf(bhalo) = ln(5/3) + 1 = 1.5108              ; tf 1 -> 1.5108
(b) length = sqrt(3.0217^2 + 1.9163^2 + 1.5108^2)
           = sqrt(9.1306 + 3.6722 + 2.2826) = sqrt(15.0854) = 3.8840
    dam = 3.0217 / 3.8840 = 0.7780 ; kom = 0.4934 ; bhalo = 0.3890

“কম” একবারই এসেছে, তবু idf বেশি বলে ওজন “ভালো”-র চেয়ে বেশি: যে শব্দ কম রিভিউয়ে থাকে, সে বেশি পার্থক্য করে। যাচাই: ০.৭৭৮² + ০.৪৯৩৪² + ০.৩৮৯² ≈ ১. ফাঁদ: পাঠ্যবইয়ের log(n ÷ df) সূত্র আর scikit-learn-এর smooth সূত্র আলাদা সংখ্যা দেয়; প্রশ্নে কোনটি বলা আছে দেখুন।

pass 1:
  x1: 1 x (0 + 0) = 0 <= 0 -> update w = (2, 1), b = 1
  x2: -1 x (-2 - 1 + 1) = 2 > 0 -> ok
  x3: -1 x (2 - 2 + 1) = -1 <= 0 -> update w = (2,1) - (1,-2) = (1, 3), b = 0
pass 2:
  x1: 1 x (2 + 3) = 5 ; x2: -1 x (-1 - 3) = 4 ; x3: -1 x (1 - 6) = 5 -> no update
final w = (1, 3), b = 0 (2 updates; all margins positive: converged)

শুরুতে w = ০ হলে প্রথম বিন্দুর মান ঠিক ০, আর “≤ ০” নিয়মে সেটিও ভুল ধরা হয়; “< ০” লিখলে প্রথম হালনাগাদই হতো না। ডেটা রেখা দিয়ে আলাদা করা যায় বলে perceptron সসীম ধাপে থামে; XOR-এর মতো ডেটায় কখনো থামত না।

(a) z = 0.5 ; h = sigma(0.5) = 0.6225 ; y_hat = 0.6225
    L = 0.5 x (0.6225 - 1)^2 = 0.5 x 0.1425 = 0.07127
(b) dL/dy_hat = y_hat - y = -0.37754
    dL/dw2 = -0.37754 x h = -0.23500 ; dL/db2 = -0.37754
    dL/dh  = -0.37754 x w2 = -0.37754 ; dh/dz = h(1 - h) = 0.23500
    dL/dz  = -0.37754 x 0.23500 = -0.08872
    dL/dw1 = -0.08872 x x = -0.08872 ; dL/db1 = -0.08872
(c) w2 = 1 + 0.5 x 0.23500 = 1.1175 ; b2 = 0 + 0.5 x 0.37754 = 0.1888
    w1 = 0.5 + 0.5 x 0.08872 = 0.5444 ; b1 = 0.0444
    new h = sigma(0.5888) = 0.6431 ; y_hat = 1.1175 x 0.6431 + 0.1888 = 0.9074
    new L = 0.5 x (0.9074 - 1)^2 = 0.00429

যাচাই: dL/dw₁-কে সংখ্যায় (w₁-কে ±০.০০০০০১ সরিয়ে) মাপলেও −০.০৮৮৭২ আসে; একে gradient check বলে। লুকানো স্তরের gradient আউটপুটের চেয়ে প্রায় চার গুণ ছোট, কারণ h(১ − h) = ০.২৩৫ দিয়ে গুণ; এভাবেই গভীর sigmoid network-এ gradient ক্ষয়ে যায়।

(a) q.k = 1, 0, 1 ; / sqrt(2) -> 0.7071, 0, 0.7071
    exp: 2.0281, 1.0000, 2.0281 ; sum 5.0562
    weights: 0.4011, 0.1978, 0.4011 (sum 1)
    output = 0.4011 (1,0) + 0.1978 (0,1) + 0.4011 (1,1) = (0.8022, 0.5989)
(b) token 2 sees keys 1 and 2 only (key 3 is in the future)

√d_k দিয়ে ভাগ না করলে score ১, ০, ১ থেকে ওজন ০.৪২২, ০.১৫৫, ০.৪২২ হতো, অর্থাৎ বেশি একপেশে; মাত্রা বড় হলে এই প্রভাব অনেক বাড়ে। আউটপুট কোনো একটি value নয়, তিনটির মিশ্রণ।

recall@3: Q1 {d2, d5} in top 3 -> 2/2 = 1.0
          Q2 d4 is 4th          -> 0/1 = 0.0
          Q3 d6, d1 in top 3    -> 2/3 = 0.6667
          mean = (1 + 0 + 0.6667) / 3 = 0.5556
RR      : Q1 rank 1 -> 1 ; Q2 rank 4 -> 0.25 ; Q3 rank 2 -> 0.5
MRR     = (1 + 0.25 + 0.5) / 3 = 0.5833

দুটি metric দুই প্রশ্নের উত্তর দেয়: recall@k বলে “প্রাসঙ্গিকগুলোর কত ভাগ ওপরে এল”, MRR বলে “প্রথম ভালো ফলটি কত ওপরে”। RAG-এ model শুধু ওপরের কয়েকটি নথি পড়ে, তাই Q2-এর মতো চতুর্থ স্থানের নথি কার্যত হারিয়ে যায়।

(a) selection: ka 50/100 = 0.50 ; kha 30/100 = 0.30
    difference = 0.20 ; ratio = 0.30 / 0.50 = 0.60 < 0.8 -> flag
(b) TPR      : ka 45/60 = 0.75 ; kha 27/50 = 0.54 -> gap 0.21
    FPR      : ka 5/40 = 0.125 ; kha 3/50 = 0.06
    precision: ka 45/50 = 0.90 ; kha 27/30 = 0.90 (equal)

একই model এক সংজ্ঞায় “ন্যায্য” (precision সমান) আর অন্য দুটিতে নয় (selection rate আর TPR আলাদা)। Base rate আলাদা হলে (৬০% বনাম ৫০%) সব সংজ্ঞা একসাথে মেলানো সাধারণত সম্ভব নয়; কোনটি গুরুত্বপূর্ণ, তা প্রসঙ্গ ঠিক করে। দল খ-এর নির্ভরযোগ্য আবেদনকারীদের ৪৬% প্রত্যাখ্যাত, এটিই এখানে সবচেয়ে বড় ক্ষতি। চার-পঞ্চমাংশ একটি প্রাথমিক ইঙ্গিত, আইনি রায় নয়।

(a) bin 1: (0.1 - 0.2) ln(0.1/0.2) = (-0.1)(-0.6931) = 0.0693
    bin 2: (0.4 - 0.5) ln(0.4/0.5) = (-0.1)(-0.2231) = 0.0223
    bin 3: (0.5 - 0.3) ln(0.5/0.3) = (0.2)(0.5108)   = 0.1022
    PSI = 0.0693 + 0.0223 + 0.1022 = 0.1938 -> "watch" (0.1 to 0.25)
(b) ln(0 / e) = -infinity -> PSI is undefined; replace 0 by a small epsilon
    (for example 0.0001) or merge bins

প্রতিটি পদ শূন্য বা ধনাত্মক, কারণ (a − e) আর ln(a ÷ e)-এর চিহ্ন একই; তাই কোনো পদ ঋণাত্মক এলে হিসাব ভুল। সীমাগুলো চর্চা থেকে আসা হাতের নিয়ম; drift ধরা পড়লে প্রথম প্রশ্ন “কেন”, যেমন ঈদের মাসে পরিবর্তন প্রত্যাশিত হতে পারে।

1. (4,1,3) with (1,5,1) -> (4, 5, 3)
2. dot 2 + 2 + 4 = 8 ; norms 3 and 3 -> 8 / 9 = 0.8889
3. 0.9 x 0.01 = 0.009 ; 0.1 x 0.99 = 0.099 -> 0.009 / 0.108 = 0.0833
4. log2 4 = 2 bits
5. P = 30/40 = 0.75 ; R = 30/50 = 0.60 ; F1 = 0.9 / 1.35 = 0.6667
6. e^2, e^1, e^0 = 7.389, 2.718, 1 ; sum 11.107 -> 0.6652, 0.2447, 0.0900
7. f'(0) = 2(0 - 3) = -6 ; w = 0 - 0.25 x (-6) = 1.5
8. P(0) = e^-2 = 0.1353 ; P(X >= 2) = 1 - e^-2 (1 + 2) = 0.5940

সবচেয়ে বেশি ভুল হয় ৩ নম্বরে: ৯০% শুনে উত্তর ০.৯ লেখা, অথচ ধনাত্মক ফলের মাত্র ৮% আসলে অসুস্থ। ৭-এ ফাঁদ চিহ্ন; gradient −৬ বিয়োগ করলে w বাড়ে।