Regression and Classification

জিনিসটা কী, কেন দরকার

বেশিরভাগ supervised problem দুইটা প্রশ্নের একটা করে:

• কতটুকু? এই flat এর ভাড়া কত হবে, কাল কয়টা order আসবে, delivery তে কত সময় লাগবে। Answer একটা সংখ্যা। এটা regression।
• কোনটা? Spam কিনা, 10 টা digit এর কোনটা, এই customer চলে যাবে কিনা। Answer একটা category। এটা classification।

এই পার্থক্য ঠিক করে model এর output কী হবে, কোন loss দিয়ে train হবে, আর কীভাবে মাপবে ভালো হলো কিনা। Linear regression তুমি Part 1 এর project এ বানিয়েই ফেলেছ। এই lesson এ আসছে হ্যাঁ/না প্রশ্নের জন্য তার যমজ ভাই, logistic regression: নিচে এখনো একটা সোজা লাইন, কিন্তু চেপে একটা probability বানানো। Neural network classifier এর শেষ layer ঠিক এটাই করে, তাই ভালো করে বোঝা দরকার।

ভেতরে কীভাবে চলে

Linear regression: prediction = w·x + b, train হয় mean squared error দিয়ে। Output যেকোনো সংখ্যা হতে পারে, ভাড়ার জন্য যেটা ঠিক, আর "pass করার probability" র জন্য ভুল।

Logistic regression লাইনটা রাখে, কিন্তু তার output, মানে score z = w·x + b, কে পাঠায় sigmoid এর ভেতর দিয়ে:

sigmoid(z) = 1 / (1 + e^(−z))

বড় positive score → 1 এর কাছে। বড় negative → 0 এর কাছে। Score 0 → ঠিক 0.5। এখন output একটা probability। হ্যাঁ/না answer পেতে একটা threshold এর সাথে তুলনা করো, সাধারণত 0.5 (কখন এটা সরাতে হয় সেটা এই part এর lesson 6 এ)।

Cross-entropy loss। Probability র জন্য squared error ভালো শিক্ষক না। সঠিক label y হলে একটা example এর loss:

loss = −[ y·log(p) + (1 − y)·log(1 − p) ]

Answer 1 আর model বলল p = 0.9, loss ছোট (0.11)। পুরো confident হয়ে বলল p = 0.01, loss বিশাল (4.61)। Cross-entropy confident ভুল কে কঠিন শাস্তি দেয়, ফলে model সাবধানী হতে শেখে। বাড়তি সুবিধা: sigmoid এর ভেতর দিয়ে এর gradient শুধু (p − y)·x, linear regression এর মতোই দেখতে।

দুইয়ের বেশি class। প্রতি class এ একটা score নাও, আর sigmoid এর বদলে softmax (probability lesson থেকে)। Loss একই ধারণা: সঠিক class কে model যে probability দিয়েছে তার −log। ঠিক এই জোড়া, softmax আর cross-entropy, দিয়েই LLM কে পরের token predict করতে শেখানো হয় (Part 4), vocabulary র প্রতিটা token এর জন্য একটা class।

ছবিতে দেখো

Code এ logistic regression

আগের lesson এর student দের উপর logistic regression, cross-entropy তে gradient descent দিয়ে train করা। দুইজন student নিয়ম ভাঙে (4.2 ঘণ্টায় pass, 4.8 এ fail), আসল data যেমন হয়। শেষে একটা ভুল answer এ দুইটা loss পাশাপাশি।

import math

# Same students as last lesson: hours studied -> passed (1) or failed (0).
HOURS = [1.0, 6.5, 2.5, 8.0, 4.0, 5.5, 3.0, 7.0, 4.5, 2.0, 6.0, 3.5, 5.0, 1.5, 4.2, 4.8]
PASS = [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0]   # note 4.2 passed and 4.8 failed: real data is messy
N = len(HOURS)

def sigmoid(z):
    return 1 / (1 + math.exp(-z))

def cross_entropy(p, y):
    return -(y * math.log(p) + (1 - y) * math.log(1 - p))

# Logistic regression: p = sigmoid(w * hours + b), trained with gradient descent on cross-entropy.
w = b = 0.0
for step in range(1, 3001):
    dw = db = 0.0
    for x, y in zip(HOURS, PASS):
        err = sigmoid(w * x + b) - y      # the gradient of cross-entropy through a sigmoid is this simple
        dw += err * x / N
        db += err / N
    w, b = w - 0.5 * dw, b - 0.5 * db
    if step in (1, 100, 3000):
        loss = sum(cross_entropy(sigmoid(w * x + b), y) for x, y in zip(HOURS, PASS)) / N
        print(f"step {step:>4}  w={w:.3f}  b={b:+.3f}  loss={loss:.3f}")

print(f"50/50 point: {-b / w:.2f} hours")
for h in (2.0, 4.0, 4.5, 5.0, 7.0):
    print(f"{h:.1f} hours -> P(pass) = {sigmoid(w * h + b):.2f}")

# Why cross-entropy: compare how two losses punish a confident wrong answer.
print("true label 1, model says:")
for p in (0.9, 0.5, 0.1, 0.01):
    print(f"  p={p:<5} squared error {(1 - p) ** 2:.2f}   cross-entropy {cross_entropy(p, 1):.2f}")

package main

import (
	"fmt"
	"math"
)

// Same students as last lesson: hours studied -> passed (1) or failed (0).
var hours = []float64{1.0, 6.5, 2.5, 8.0, 4.0, 5.5, 3.0, 7.0, 4.5, 2.0, 6.0, 3.5, 5.0, 1.5, 4.2, 4.8}
var pass = []float64{0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0} // note 4.2 passed and 4.8 failed: real data is messy

func sigmoid(z float64) float64 { return 1 / (1 + math.Exp(-z)) }

func crossEntropy(p, y float64) float64 { return -(y*math.Log(p) + (1-y)*math.Log(1-p)) }

func main() {
	n := float64(len(hours))
	// Logistic regression: p = sigmoid(w * hours + b), trained with gradient descent on cross-entropy.
	w, b := 0.0, 0.0
	for step := 1; step <= 3000; step++ {
		dw, db := 0.0, 0.0
		for i, x := range hours {
			err := sigmoid(w*x+b) - pass[i] // the gradient of cross-entropy through a sigmoid is this simple
			dw += err * x / n
			db += err / n
		}
		w, b = w-0.5*dw, b-0.5*db
		if step == 1 || step == 100 || step == 3000 {
			loss := 0.0
			for i, x := range hours {
				loss += crossEntropy(sigmoid(w*x+b), pass[i])
			}
			fmt.Printf("step %4d  w=%.3f  b=%+.3f  loss=%.3f\n", step, w, b, loss/n)
		}
	}

	fmt.Printf("50/50 point: %.2f hours\n", -b/w)
	for _, h := range []float64{2.0, 4.0, 4.5, 5.0, 7.0} {
		fmt.Printf("%.1f hours -> P(pass) = %.2f\n", h, sigmoid(w*h+b))
	}

	// Why cross-entropy: compare how two losses punish a confident wrong answer.
	fmt.Println("true label 1, model says:")
	for _, p := range []float64{0.9, 0.5, 0.1, 0.01} {
		fmt.Printf("  p=%-5v squared error %.2f   cross-entropy %.2f\n", p, (1-p)*(1-p), crossEntropy(p, 1))
	}
}

Output:

step    1  w=0.381  b=+0.000  loss=0.746
step  100  w=0.912  b=-3.678  loss=0.322
step 3000  w=2.579  b=-11.178  loss=0.224
50/50 point: 4.33 hours
2.0 hours -> P(pass) = 0.00
4.0 hours -> P(pass) = 0.30
4.5 hours -> P(pass) = 0.61
5.0 hours -> P(pass) = 0.85
7.0 hours -> P(pass) = 1.00
true label 1, model says:
  p=0.9   squared error 0.01   cross-entropy 0.11
  p=0.5   squared error 0.25   cross-entropy 0.69
  p=0.1   squared error 0.81   cross-entropy 2.30
  p=0.01  squared error 0.98   cross-entropy 4.61

কী দেখলাম:

• Loss 0.746 থেকে 0.224 এ নামে। 0 তে পৌঁছায় না, কারণ একটা cut-off দিয়ে ওই দুইজন এলোমেলো student কে একসাথে ঠিক করা যায় না। এখানে যে model 0 পেত সে noise মুখস্থ করত।
• Model এর 50/50 point হলো 4.33 ঘণ্টা। এর নিচে probability দ্রুত পড়ে (4.0 ঘণ্টা: 0.30), উপরে দ্রুত ওঠে (5.0 ঘণ্টা: 0.85)।
• Output শুধু "pass" না: 4.5 ঘণ্টা পায় 0.61, দুর্বল একটা হ্যাঁ, আর 7 ঘণ্টা পায় 1.00। এই confidence কাজের জিনিস: 0.4 থেকে 0.6 এর গুলো একজন মানুষকে দিয়ে check করানো যায়।
• Loss এর table দেখায় কেন cross-entropy। p = 0.1 থেকে 0.01 এ গেলে squared error প্রায় বদলায় না (0.81 → 0.98), কিন্তু cross-entropy দ্বিগুণ হয় (2.30 → 4.61)। কতটা confident হয়ে ভুল করছো, squared error সেটা নিয়ে তেমন মাথা ঘামায় না; cross-entropy ঘামায়।

Production এ যা মাথায় রাখবে

• log(0) মানে infinity। Model ঠিক 0 বা 1 output দিয়ে ভুল করলে cross-entropy infinite হয়, training NaN দেয়। Library গুলো p কে [1e-7, 1 − 1e-7] এ clip করে, বা সরাসরি score থেকে loss হিসাব করে (PyTorch এ BCEWithLogitsLoss), এটাই safe default।
• Regression এর output এর range check করো। ভাড়ার model ছোট flat এর জন্য negative ভাড়া বলে দিতে পারে। Output clip করো, বা মান সবসময় positive হলে তার log predict করো।
• Class imbalance। 1% fraud হলে সবসময় "fraud না" বললেই 99% accuracy, আর model কোনো কাজের না। Loss এ rare class কে বেশি weight দাও, আর accuracy না দেখে precision আর recall দিয়ে বিচার করো (lesson 6)।
• Logistic regression একটা শক্ত baseline। কয়েক second এ train হয়, ব্যাখ্যা করা সহজ ("প্রতি বাড়তি ঘণ্টা odds কে e^2.58 গুণ করে"), আর table এর data তে প্রায়ই বড় model এর কয়েক point এর মধ্যে থাকে। আগে এটা বানাও, তারপর জটিল যা কিছু আনবে সেটাকে এটা হারাতে হবে।

এক কথায়

Regression squared error দিয়ে একটা সংখ্যা predict করে; classification একটা score কে sigmoid (বা softmax) এর ভেতর দিয়ে নিয়ে probability দেয়, আর train হয় cross-entropy দিয়ে, যেটা confident ভুলকে সবচেয়ে বেশি শাস্তি দেয়।

নিজে করে দেখো

Train করা model দিয়ে বের করো, pass করার 90% chance পেতে একজন student কে কত ঘণ্টা পড়তে হবে? sigmoid(2.579·h − 11.178) = 0.9 হাতে solve করো। Hint: যে score এ 0.9 আসে সেটা log(0.9 / 0.1)।