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:
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}")
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:
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 yLineá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}")
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.
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))
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()
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])))
Čím se změní výsledný sklon w, když ceny na všech účtenkách zvýšíš o 20 Kč?
Přímka se posune nahoru jako celek. Odchylky y od průměru zůstanou stejné, takže sklon se nehne.
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:
odhad = w1 * km + w2 * minuty + bS 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:
theta = (Xᵀ X)⁻¹ Xᵀ yTak 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č")
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.
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))
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.
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}")
nejlepší přímka: 0.998 vždy průměr: 0.000 špatná přímka: -0.827
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])))
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}")
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}")
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čí.
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ň
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))
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č")
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.