0 dní v řadě · 0 bodů

Strojové učení · 28 min

Lineární regrese od nuly

Proložíš data přímkou ručně, odvodíš vzorec, rozšíříš ho na více vlastností v NumPy a výsledek porovnáš se scikit-learn.

Hloubka
Úkoly
Lidsky řečeno

Taxikář si účtuje nástupní sazbu a pak určitou částku za kilometr. Ceník ale neznáš, máš jen hromádku starých účtenek: tolik kilometrů, tolik korun. Lineární regrese z účtenek ten ceník odhadne. Na papíře bys body nakreslil a položil přes ně pravítko tak, aby bylo všem co nejblíž. Přesně to teď naprogramuješ.

Přímka jako model

Vztah z účtenek popisuje rovnice přímky:

text
odhad = w * x + b

x    vstup (kilometry)
w    váha, sklon přímky (cena za kilometr)
b    posun, hodnota při x = 0 (nástupní sazba)

w a b jsou parametry modelu. Trénink znamená najít je tak, aby odhady co nejlépe seděly. Zkus to nejdřív sám. Posouvej w a b a sleduj sloupec s chybou a číslo MSE na konci. Čím je menší, tím lépe přímka sedí.

import numpy as np

km = np.array([1.2, 2.5, 3.1, 4.8, 6.0, 7.4, 9.5, 12.0])
cena = np.array([85, 120, 130, 185, 210, 245, 315, 380])

# w a b nastavují posuvníky
odhad = w * km + b
chyba = odhad - cena

print("  km   cena  odhad  chyba")
for i in range(len(km)):
    pruh = "#" * min(int(abs(chyba[i]) / 10), 20)
    print(f"{km[i]:4.1f}  {cena[i]:5.0f}  {odhad[i]:5.0f}  {chyba[i]:+5.0f}  {pruh}")

print(f"MSE: {np.mean(chyba ** 2):.1f}")
Výstup
  km   cena  odhad  chyba
 1.2     85     54    -31  ###
 2.5    120     80    -40  ####
 3.1    130     92    -38  ###
 4.8    185    126    -59  #####
 6.0    210    150    -60  ######
 7.4    245    178    -67  ######
 9.5    315    220    -95  #########
12.0    380    270   -110  ###########
MSE: 4587.5

Jak změřit, že přímka sedí

Rozdílu mezi skutečností a odhadem se říká reziduum. Potřebujeme z osmi reziduí udělat jedno číslo. Prostý součet nefunguje, protože kladné a záporné chyby by se vyrušily. Používají se hlavně tři míry:

text
MAE  = průměr(|y - odhad|)        průměrná absolutní chyba
MSE  = průměr((y - odhad)²)       průměrná čtvercová chyba
RMSE = odmocnina(MSE)             stejné jednotky jako y

Lineární regrese klasicky minimalizuje MSE, proto se jí také říká metoda nejmenších čtverců. Umocnění má jeden důsledek, který si musíš pamatovat: velké chyby trestá mnohem víc než malé.

import numpy as np

def mae(chyby):
    return np.mean(np.abs(chyby))

def rmse(chyby):
    return np.sqrt(np.mean(chyby ** 2))

rovnomerne = np.array([4.0, 4.0, 4.0, 4.0, 4.0])
jedna_velka = np.array([0.0, 0.0, 0.0, 0.0, 20.0])

print(f"rovnoměrné chyby:  MAE {mae(rovnomerne):.1f}  RMSE {rmse(rovnomerne):.1f}")
print(f"jedna velká chyba: MAE {mae(jedna_velka):.1f}  RMSE {rmse(jedna_velka):.1f}")
Výstup
rovnoměrné chyby:  MAE 4.0  RMSE 4.0
jedna velká chyba: MAE 4.0  RMSE 8.9

MAE obě situace nerozliší, RMSE ano. Jediná ujetá hodnota proto umí přímku pořádně vychýlit. Než začneš trénovat, podívej se, jestli v datech nejsou překlepy.

Nejlepší přímka vzorcem

Pro jednu vlastnost existuje přesné řešení. Není potřeba nic zkoušet.

text
w = součet((x - průměr_x) * (y - průměr_y)) / součet((x - průměr_x)²)
b = průměr_y - w * průměr_x

Čitatel se ptá, jestli x a y rostou společně. Když je x nad svým průměrem a y taky, přičte se kladné číslo. Jmenovatel říká, jak moc se samotné x mění, a převádí výsledek na „korun za kilometr“. Druhý řádek zaručí, že přímka prochází těžištěm dat, tedy bodem (průměr_x, průměr_y).

import numpy as np

km = np.array([1.2, 2.5, 3.1, 4.8, 6.0, 7.4, 9.5, 12.0])
cena = np.array([85, 120, 130, 185, 210, 245, 315, 380], dtype=float)

dx = km - km.mean()
dy = cena - cena.mean()

w = (dx * dy).sum() / (dx ** 2).sum()
b = cena.mean() - w * km.mean()

print(f"za kilometr: {w:.2f} Kč")
print(f"nástupní sazba: {b:.2f} Kč")
print(f"MSE: {np.mean((w * km + b - cena) ** 2):.1f}")
print(f"jízda 5 km: {w * 5 + b:.0f} Kč")

kontrola = np.polyfit(km, cena, deg=1)
print("polyfit:", np.round(kontrola, 2))
Výstup
za kilometr: 27.47 Kč
nástupní sazba: 49.08 Kč
MSE: 18.0
jízda 5 km: 186 Kč
polyfit: [27.47 49.08]

Porovnej tohle MSE s tím nejlepším, co se ti povedlo posuvníky. Můžeš se k němu přiblížit, ale pod něj se nedostaneš. np.polyfit s deg=1 je hotová funkce pro totéž a vrací nejdřív sklon, potom posun.

Graf ukáže víc než tabulka. Pokud grafy z modulu o datech ještě neznáš, stačí se dívat na výsledek.

import matplotlib.pyplot as plt
import numpy as np

km = np.array([1.2, 2.5, 3.1, 4.8, 6.0, 7.4, 9.5, 12.0])
cena = np.array([85, 120, 130, 185, 210, 245, 315, 380], dtype=float)
w, b = np.polyfit(km, cena, deg=1)

osa = np.array([0, 13])
plt.scatter(km, cena, label="účtenky")
plt.plot(osa, w * osa + b, label="model")
plt.vlines(km, cena, w * km + b, linestyles="dotted", label="rezidua")
plt.xlabel("kilometry")
plt.ylabel("cena v Kč")
plt.legend()
plt.show()
Výstup
Úkol

Napiš fit_line

Napiš fit_line(x, y), která pro dvě pole NumPy vrátí dvojici (w, b) podle vzorce výše. Hotové polyfit ani lstsq nepoužívej, jde o to napsat si výpočet.

import numpy as np

def fit_line(x, y):
    # doplň
    return 0.0, 0.0

print(fit_line(np.array([0.0, 1.0, 2.0]), np.array([1.0, 3.0, 5.0])))
Výstup
Kvíz

Čím se změní výsledný sklon w, když ceny na všech účtenkách zvýšíš o 20 Kč?

Více vlastností najednou

Cena jízdy nezávisí jen na vzdálenosti, ale i na čase v zácpě. Přímka se změní na rovnici s více vahami:

text
odhad = w1 * km + w2 * minuty + b

S maticí se to píše pořád stejně, ať je vlastností kolik chce. Do X přidáme sloupec samých jedniček. Jeho váha je právě b, takže posun už není zvláštní případ. Pak platí odhad = X @ theta, kde theta je pole všech parametrů a @ je maticové násobení.

Řešení má tvar takzvané normální rovnice:

text
theta = (Xᵀ X)⁻¹ Xᵀ y

Tak se to píše v knihách, v kódu ale inverzi nepočítej. np.linalg.lstsq řeší stejnou úlohu stabilnějším postupem. Data si tentokrát vyrobíme, takže známe správnou odpověď: základ 40 Kč, 18 Kč za kilometr a 4 Kč za minutu.

import numpy as np

rng = np.random.default_rng(1)
n = 60
km = rng.uniform(1, 15, n)
minuty = 2.5 * km + rng.uniform(0, 15, n)
cena = 40 + 18 * km + 4 * minuty + rng.normal(0, 10, n)

X = np.column_stack([np.ones(n), km, minuty])
print("tvar X:", X.shape)

theta, *_ = np.linalg.lstsq(X, cena, rcond=None)
print("základ, za km, za minutu:", np.round(theta, 1))

nova_jizda = np.array([1, 5, 20])   # jednička patří k základu
print(f"jízda 5 km a 20 minut: {nova_jizda @ theta:.0f} Kč")
Výstup
tvar X: (60, 3)
základ, za km, za minutu: [42.3 19.2  3.5]
jízda 5 km a 20 minut: 209 Kč

Model z dat zhruba vytáhl skutečný ceník, přestože každá cena byla zatížená náhodným šumem. Váha se čte snadno: při stejném počtu minut přidá další kilometr w1 korun.

Úkol

Vlastní LinearRegression

Dokonči třídu LinearniRegrese. Metoda fit(X, y) přidá k X sloupec jedniček, najde parametry a uloží je do atributů intercept_ (posun, jedno číslo) a coef_ (pole vah bez posunu). Vrátí self. Metoda predict(X) vrátí odhady. X nemá sloupec jedniček ani při jednom volání.

import numpy as np

class LinearniRegrese:
    def fit(self, X, y):
        # doplň
        return self

    def predict(self, X):
        # doplň
        return np.zeros(len(X))

X = np.array([[1.0, 2.0], [2.0, 0.0], [3.0, 1.0], [4.0, 5.0]])
y = 3 * X[:, 0] - 2 * X[:, 1] + 7
print(LinearniRegrese().fit(X, y).predict(X))
Výstup

Kolik toho model vysvětlil: R²

MSE je číslo v „korunách na druhou“ a samo o sobě neříká, jestli je dobré. R² výsledek porovná s baseline z první lekce, tedy s odhadováním průměru.

text
R² = 1 - součet((y - odhad)²) / součet((y - průměr_y)²)

Hodnota 1 je dokonalá shoda, 0 znamená „stejně dobré jako průměr“. Záporné číslo znamená, že model je horší než průměr, a to se na testovacích datech opravdu stává.

import numpy as np

def r2(y, odhad):
    return 1 - ((y - odhad) ** 2).sum() / ((y - y.mean()) ** 2).sum()

km = np.array([1.2, 2.5, 3.1, 4.8, 6.0, 7.4, 9.5, 12.0])
cena = np.array([85, 120, 130, 185, 210, 245, 315, 380], dtype=float)
w, b = np.polyfit(km, cena, 1)

print(f"nejlepší přímka: {r2(cena, w * km + b):.3f}")
print(f"vždy průměr:     {r2(cena, np.full(8, cena.mean())):.3f}")
print(f"špatná přímka:   {r2(cena, -5 * km + 300):.3f}")
Výstup
nejlepší přímka: 0.998
vždy průměr:     0.000
špatná přímka:   -0.827
Úkol

Skóre R² jako funkce

Napiš r2_score(y, odhad) podle vzorce. Funkce dostane dvě pole NumPy a vrátí číslo.

import numpy as np

def r2_score(y, odhad):
    # doplň
    return None

print(r2_score(np.array([1.0, 2.0, 3.0]), np.array([1.0, 2.0, 4.0])))
Výstup

Lineární neznamená přímka

Slovo „lineární“ se týká parametrů, ne vstupů. Do X můžeš přidat sloupec s druhou mocninou a model je pořád lineární regrese, jen se v původním grafu ohne. Brzdná dráha roste přibližně se čtvercem rychlosti, takže ji přímka vystihne jen zhruba.

import numpy as np

rng = np.random.default_rng(0)
v = np.arange(20.0, 131.0, 10.0)                      # km/h
draha = v / 5 + v ** 2 / 150 + rng.normal(0, 2, len(v))   # metry

def r2(y, odhad):
    return 1 - ((y - odhad) ** 2).sum() / ((y - y.mean()) ** 2).sum()

def fit_predict(X, y):
    theta, *_ = np.linalg.lstsq(X, y, rcond=None)
    return X @ theta

jedna = np.ones(len(v))
print(f"jen v:      R² = {r2(draha, fit_predict(np.column_stack([jedna, v]), draha)):.4f}")
print(f"v a v²:     R² = {r2(draha, fit_predict(np.column_stack([jedna, v, v ** 2]), draha)):.4f}")
Výstup
jen v:      R² = 0.9734
v a v²:     R² = 0.9990

I přímka má vysoké R², a přesto se mýlí systematicky: na krajích dráhu podhodnocuje a uprostřed nadhodnocuje. Vysoké R² tedy nezaručuje správný tvar modelu, to ukáže až pohled na rezidua. Po přidání v² zbude skoro jen šum.

Přidáváním mocnin ale můžeš trefit skoro cokoli, včetně šumu. Kde je rozumná hranice, řeší lekce Přeučení, bias a variance.

Totéž ve scikit-learn

V praxi sáhneš po LinearRegression. Sloupec jedniček přidá sama, naučené hodnoty najdeš v coef_ a intercept_. Ukázka nejdřív potvrdí, že dává stejný výsledek jako ruční řešení, a pak ji použije na skutečných datech o průběhu cukrovky s poctivým vyhodnocením na testu.

import numpy as np
from sklearn.datasets import load_diabetes, make_regression
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score, root_mean_squared_error
from sklearn.model_selection import train_test_split

X, y = make_regression(n_samples=200, n_features=3, noise=10, random_state=0)
model = LinearRegression().fit(X, y)
A = np.column_stack([np.ones(len(X)), X])
theta, *_ = np.linalg.lstsq(A, y, rcond=None)
print("shoda s ručním řešením:", np.allclose(theta[1:], model.coef_))

X, y = load_diabetes(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=0
)
model = LinearRegression().fit(X_train, y_train)
odhad = model.predict(X_test)

print(f"R² trénink: {model.score(X_train, y_train):.3f}")
print(f"R² test:    {r2_score(y_test, odhad):.3f}")
print(f"MAE test:   {mean_absolute_error(y_test, odhad):.1f}")
print(f"RMSE test:  {root_mean_squared_error(y_test, odhad):.1f}")
print(f"baseline MAE: {np.abs(y_test - y_train.mean()).mean():.1f}")
Výstup
shoda s ručním řešením: True
R² trénink: 0.555
R² test:    0.359
MAE test:   45.1
RMSE test:  56.4
baseline MAE: 58.3

Co ve výstupu hledat: první řádek má být True. R² na tréninku a testu by nemělo být dramaticky odlišné, jinak by šlo o přeučení. MAE modelu má být zřetelně menší než MAE baseline. Čekat R² blízko jedničky nemá smysl, průběh nemoci deset měření zdaleka neurčí.

Úkol

Regrese ve scikit-learn

Rozděl data s test_size=0.25 a random_state=0. Natrénuj LinearRegression jen na trénovací části, ulož ji do model a do skore ulož R² na testovací části.

from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

X, y = make_regression(n_samples=120, n_features=4, noise=20, random_state=1)
# doplň
Výstup
Pod kapotou · geometrie a numerika

Odhad X @ theta je vždy kombinací sloupců X. Nejmenší čtverce hledají bod tohoto podprostoru nejbližší k y, tedy ortogonální projekci. Proto je vektor reziduí kolmý na každý sloupec, Xᵀ(y - X theta) = 0, a právě to jsou normální rovnice. Se sloupcem jedniček z toho plyne, že součet reziduí je nula.

Numericky je důležité, že cond(XᵀX) = cond(X)². Sestavením XᵀX zahodíš zhruba polovinu platných číslic. lstsq proto pracuje přímo s X přes SVD (LAPACK gelsd), QR rozklad je rychlejší alternativa pro dobře podmíněné úlohy. Cena je řádově O(n * d²). SVD navíc zvládne hodnostně deficitní X a vrátí řešení s nejmenší normou. Stejný gelsd používá přes SciPy i LinearRegression.

import numpy as np

km = np.array([1.2, 2.5, 3.1, 4.8, 6.0, 7.4, 9.5, 12.0])
cena = np.array([85, 120, 130, 185, 210, 245, 315, 380], dtype=float)
A = np.column_stack([np.ones(8), km])
rezidua = cena - A @ np.linalg.lstsq(A, cena, rcond=None)[0]
print("rezidua kolmá na sloupce:", np.allclose(A.T @ rezidua, 0, atol=1e-8))

rng = np.random.default_rng(1)
a = rng.normal(size=200)
X = np.column_stack([a, a + 1e-6 * rng.normal(size=200)])
spravne = np.array([1.0, 2.0])
y = X @ spravne

print(f"řád cond(X):   1e{np.log10(np.linalg.cond(X)):.0f}")
print(f"řád cond(XᵀX): 1e{np.log10(np.linalg.cond(X.T @ X)):.0f}")

pres_lstsq = np.linalg.lstsq(X, y, rcond=None)[0]
pres_normalni = np.linalg.solve(X.T @ X, X.T @ y)
print("lstsq přesné na 7 míst:", bool(np.abs(pres_lstsq - spravne).max() < 1e-7))
print("normální rovnice také:", bool(np.abs(pres_normalni - spravne).max() < 1e-7))
Výstup
rezidua kolmá na sloupce: True
řád cond(X):   1e6
řád cond(XᵀX): 1e13
lstsq přesné na 7 míst: True
normální rovnice také: False

Minimalizace MSE odpovídá odhadu maximální věrohodnosti při normálně rozděleném šumu. Minimalizace MAE odpovídá Laplaceovu šumu a konstantní model pak vychází jako medián místo průměru. Volba ztráty je tedy předpoklad o datech. Pro p-hodnoty a intervaly spolehlivosti koeficientů sáhni po statsmodels, LinearRegression je nepočítá.

Pod kapotou · kolinearita v praxi

Když jsou dvě vlastnosti skoro totožné, predikce zůstane dobrá, ale jednotlivé váhy ztratí význam. Model může jednu zvýšit a druhou snížit téměř bez dopadu na chybu. Tady se tatáž vzdálenost objevuje v kilometrech i v mílích a obě poloviny dat dávají úplně jiné koeficienty a téměř stejnou predikci. Interpretace vah bez kontroly korelací je častá chyba reportů o „důležitosti vlastností“. Pomáhá odstranění sloupce nebo regularizace.

import numpy as np

rng = np.random.default_rng(3)
n = 80
km = rng.uniform(1, 15, n)
mile = km * 0.621 + rng.normal(0, 0.01, n)
cena = 40 + 25 * km + rng.normal(0, 10, n)
X = np.column_stack([np.ones(n), km, mile])
dotaz = np.array([1, 10, 6.21])

for nazev, cast in [("první půlka", range(0, 40)), ("druhá půlka", range(40, 80))]:
    cast = list(cast)
    theta, *_ = np.linalg.lstsq(X[cast], cena[cast], rcond=None)
    print(f"{nazev}: km {theta[1]:7.1f}  míle {theta[2]:7.1f}  odhad {dotaz @ theta:.0f} Kč")
Výstup
první půlka: km   -74.8  míle   161.1  odhad 293 Kč
druhá půlka: km    99.1  míle  -118.7  odhad 289 Kč

Vyzkoušej si: Přímka mezi body

Přetahuj body, ručně nastav sklon a posun a sleduj chyby a střední kvadratickou chybu. Tlačítko najde nejlepší přímku.