Andragradsfunktioner

$f(x) = ax^2 + bx + c$ ritar en parabel — en skål.

Om	Då
$a > 0$	skålen öppnar uppåt, har ett minimum
$a < 0$	skålen öppnar nedåt, har ett maximum
stort $	a
litet $	a

Vertex (skålens botten eller topp) ligger vid

$x = -\frac{b}{2a}$

Den formeln är värd att memorera. Den kommer direkt ur symmetrin: parabeln är spegelsymmetrisk kring en lodrät linje genom vertex, så vertex ligger mitt emellan nollställena.

Varför AI bryr sig: medelkvadratfelet för en linjär modell är en parabel i varje enskild parameter. När du hör att «modellen söker minimum av förlustfunktionen» — det är den här skålen den letar botten i.

Nollställen — där $f(x) = 0$:

$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$

Diskriminanten $D = b^2 - 4ac$ avgör hur många det finns:

$D$	Antal nollställen	Grafen
$> 0$	två	skär x-axeln på två ställen
$= 0$	ett (dubbelrot)	tangerar x-axeln
$< 0$	noll (reella)	ligger helt över eller helt under

Kvadratkomplettering skriver om funktionen så att vertex syns direkt:

$ax^2 + bx + c = a\left(x + \frac{b}{2a}\right)^2 + c - \frac{b^2}{4a}$

Det är den formen som gör det uppenbart att minimum är $c - \frac{b^2}{4a}$ och nås vid $x = -\frac{b}{2a}$: kvadraten är alltid ≥ 0, och är noll precis där.

Kopplingen till maskininlärning, konkret. Anpassa $\hat{y} = wx$ till data med medelkvadratfel:

$L(w) = \frac{1}{n}\sum_i (y_i - w x_i)^2 = \underbrace{\left(\tfrac{1}{n}\sum x_i^2\right)}_{a} w^2 - \underbrace{\left(\tfrac{2}{n}\sum x_i y_i\right)}_{-b} w + \underbrace{\tfrac{1}{n}\sum y_i^2}_{c}$

Det är en parabel i $w$, med $a > 0$. Minimum ligger vid $w^* = -\frac{b}{2a} = \frac{\sum x_i y_i}{\sum x_i^2}$ — och det är exakt den lösning minsta kvadratmetoden ger.

Därför är «konvex förlust» något man vill ha: en skål har en botten, och gradientnedstigning kan inte fastna någon annanstans.

import numpy as np

def vertex(a, b, c):
    x = -b / (2 * a)
    return x, a * x ** 2 + b * x + c

def nollstallen(a, b, c):
    D = b ** 2 - 4 * a * c
    if D < 0:
        return []
    if D == 0:
        return [-b / (2 * a)]
    r = D ** 0.5
    return [(-b - r) / (2 * a), (-b + r) / (2 * a)]

print(vertex(1, -4, 3))         # (2.0, -1.0)
print(nollstallen(1, -4, 3))    # [1.0, 3.0]  — vertex ligger mitt emellan
print(nollstallen(1, 2, 5))     # []          — D = 4 - 20 < 0

# Förlustfunktionen för y = w·x ÄR en parabel i w
x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([2.1, 3.9, 6.2, 7.8])

def L(w):
    return float(np.mean((y - w * x) ** 2))

a = float(np.mean(x ** 2))
b = float(-2 * np.mean(x * y))
c = float(np.mean(y ** 2))
w_stjarna = -b / (2 * a)
print(round(w_stjarna, 4), round(L(w_stjarna), 5))     # 1.99 0.02425

# Samma svar som minsta kvadratmetoden ger direkt
print(round(float(np.sum(x * y) / np.sum(x ** 2)), 4))  # 1.99

# Och parabeln är verkligen en skål: alla andra w är sämre
for w in (1.5, 1.9, w_stjarna, 2.1, 2.5):
    print(f"  w={w:.4f}  L={L(w):.5f}")
#   w=1.5000  L=1.82500
#   w=1.9000  L=0.08500
#   w=1.9900  L=0.02425   ← botten
#   w=2.1000  L=0.11500
#   w=2.5000  L=1.97500

De sista raderna är hela poängen: att träna en linjär modell är att hitta botten på en parabel, och för just den här modellen kan man räkna ut svaret direkt i stället för att leta.