Lidsky řečeno
Provozní restaurace kouká na páteční rezervace a odhaduje, kdo nepřijde. Každá indicie přidá nebo ubere body: rezervace před měsícem přidá, potvrzení přes SMS ubere. Na konci body převede na číslo od 0 do 100 %. Logistická regrese dělá totéž, jen si velikost bodů za každou indicii vypočítá z minulých rezervací.
Proč přímka nestačí
Doteď model předpovídal číslo, třeba cenu bytu. Teď chceme odpověď ano, nebo ne: přijde host, nebo ne? Takové úloze se říká klasifikace a odpovědi třída. Třídy zapíšeme jako 1 (host nepřišel) a 0 (přišel).
První nápad: vzít lineární regresi a proložit nulami a jedničkami přímku. Tady je deset rezervací a to, kolik dní předem vznikly.
import numpy as np
dny = np.array([1, 2, 3, 5, 7, 10, 14, 20, 30, 45])
neprisel = np.array([0, 0, 0, 0, 1, 0, 1, 1, 1, 1])
sklon, posun = np.polyfit(dny, neprisel, 1)
for d in [1, 15, 45, 90]:
print(f"{d:>2} dní předem: {sklon * d + posun:+.2f}")
1 dní předem: +0.17 15 dní předem: +0.53 45 dní předem: +1.31 90 dní předem: +2.48
Pro rezervaci 90 dní předem vyjde číslo větší než 1. Jako pravděpodobnost to nedává smysl, nic nemůže nastat s jistotou větší než stoprocentní. Přímka navíc reaguje na vzdálené body: jedna rezervace s odstupem jednoho roku by ji sklopila a posunula odhady všem ostatním.
Potřebujeme funkci, která vezme libovolné číslo a stlačí ho mezi 0 a 1.
Sigmoida a šance
Ta funkce se jmenuje sigmoida (podle tvaru písmene S):
z = w1·x1 + w2·x2 + ... + b skóre: součet bodů za indicie
p = 1 / (1 + e^(-z)) sigmoida: převod skóre na pravděpodobnost
p
1.0 | ______
| .-'
0.5 | .'
| .'
0.0 |______.-'
+------------+------------ z
0Písmena x jsou příznaky (vlastnosti rezervace), w jsou váhy (kolik bodů za jednotku příznaku) a b je posun (výchozí stav, když všechny příznaky jsou nula). První řádek je stejný jako u lineární regrese. Nový je jen ten druhý.
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-z))
print(round(float(sigmoid(0)), 2))
print(round(float(sigmoid(100)), 2))
print(round(float(sigmoid(-100)), 2))
0.5 1.0 0.0
Co ale znamená váha? Tady pomůže pojem ze sázkových kanceláří: šance (anglicky odds) je poměr p / (1 - p). Pravděpodobnost 0,8 znamená šanci 4 ku 1. A skóre z je přesně logaritmus šance. Proto se mu říká logit a celá metoda má „logistická“ v názvu.
Zvednutí příznaku o 1 přičte ke skóre w, a tím vynásobí šanci číslem e^w. Posouvej w a b a sleduj sloupce.
import math
for x in range(6):
z = w * x + b
p = 1 / (1 + math.exp(-z))
sance = p / (1 - p)
print(f"x={x} z={z:+.1f} p={p:.3f} šance={sance:7.3f}")
print("každé x navíc násobí šanci číslem", round(math.exp(w), 3))
x=0 z=-2.0 p=0.119 šance= 0.135 x=1 z=-1.3 p=0.214 šance= 0.273 x=2 z=-0.6 p=0.354 šance= 0.549 x=3 z=+0.1 p=0.525 šance= 1.105 x=4 z=+0.8 p=0.690 šance= 2.226 x=5 z=+1.5 p=0.818 šance= 4.482 každé x navíc násobí šanci číslem 2.014
S výchozí váhou 0,7 se šance s každým krokem zhruba zdvojnásobí, zatímco p roste nerovnoměrně: uprostřed rychle, u krajů pomalu.
Příznak má váhu w = 0. Co to znamená?
Příznak přispívá do skóre součinem w·x, takže s nulovou váhou přispívá nulou. Násobek šance je e^0 = 1.
Jak měřit chybu: log loss
Model se učí tak, že zmenšuje číslo vyjadřující, jak moc se plete. Pro pravděpodobnosti se používá log loss (také křížová entropie):
chyba jednoho příkladu = -( y·ln(p) + (1 - y)·ln(1 - p) )
když y = 1: chyba = -ln(p) chceme p blízko 1
když y = 0: chyba = -ln(1 - p) chceme p blízko 0Vzorec vypadá hůř, než je. Vždy se uplatní jen jedna polovina, ta druhá se vynásobí nulou. Podstatné je, jak chyba roste, když se model plete a je si přitom jistý.
import math
print("host opravdu nepřišel (y = 1)")
for p in [0.99, 0.9, 0.5, 0.1, 0.01, 0.0001]:
print(f"model říkal p = {p:<7} chyba = {-math.log(p):.3f}")
host opravdu nepřišel (y = 1) model říkal p = 0.99 chyba = 0.010 model říkal p = 0.9 chyba = 0.105 model říkal p = 0.5 chyba = 0.693 model říkal p = 0.1 chyba = 2.303 model říkal p = 0.01 chyba = 4.605 model říkal p = 0.0001 chyba = 9.210
Opatrné „nevím“ (p = 0,5) stojí málo. Sebejisté tvrzení, které se nevyplní, stojí mnohonásobně víc a s dalšími nulami za desetinnou čárkou chyba roste bez omezení. Model se tak učí nepřehánět.
Spočítej log loss
Doplň funkci log_loss(y, p), která vrátí průměrnou log loss přes všechny příklady. Hodnoty p nejdřív ořízni do rozsahu od 1e-15 do 1 - 1e-15 pomocí np.clip, aby ln(0) nezpůsobil nekonečno.
import numpy as np
def log_loss(y, p):
y = np.asarray(y, dtype=float)
p = np.asarray(p, dtype=float)
# doplň
return 0.0
Trénink od nuly
Log loss chceme co nejmenší, takže použijeme gradientní sestup: spočítat, kterým směrem chyba roste, a udělat malý krok opačně. Po zderivování vyjde překvapivě čistý výsledek:
chyba_i = p_i - y_i
změna w: průměr( chyba_i · x_i )
změna b: průměr( chyba_i )Selský rozum sedí: když model tipoval moc vysoko (p > y) a příznak byl kladný, váhu sníží.
Data si vyrobíme sami, takže známe pravidla, která v nich jsou: každý den předem přidá ke skóre 0,12 a potvrzení přes SMS ubere 1,8. Model je musí objevit. Příznaky převádíme na stejnou stupnici (standardizace: odečíst průměr, vydělit směrodatnou odchylkou), jinak by dny s velkými čísly přehlušily SMS a sestup by se rozkmital.
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-z))
def log_loss(y, p):
p = np.clip(p, 1e-15, 1 - 1e-15)
return np.mean(-(y * np.log(p) + (1 - y) * np.log(1 - p)))
# Synthetic reservations with known rules.
np.random.seed(0)
n = 400
dny = np.random.uniform(0, 40, n)
sms = np.random.randint(0, 2, n)
y = (np.random.random(n) < sigmoid(0.12 * dny - 1.8 * sms - 1.0)).astype(float)
X = np.column_stack([dny, sms]).astype(float)
prumer, odchylka = X.mean(axis=0), X.std(axis=0)
X_std = (X - prumer) / odchylka
w = np.zeros(2)
b = 0.0
for krok in range(int(kroku)):
p = sigmoid(X_std @ w + b)
if krok % 100 == 0:
print(f"krok {krok:>3}: log loss {log_loss(y, p):.4f}")
chyba = p - y
w -= lr * (X_std.T @ chyba) / n
b -= lr * chyba.mean()
p = sigmoid(X_std @ w + b)
print(f"konec: log loss {log_loss(y, p):.4f}")
print(f"přesnost: {np.mean((p >= 0.5) == y):.3f}")
w_puvodni = w / odchylka
print(f"váha dne: {w_puvodni[0]:+.3f} (skutečně +0.120)")
print(f"váha SMS: {w_puvodni[1]:+.3f} (skutečně -1.800)")
print(f"den navíc násobí šanci {np.exp(w_puvodni[0]):.3f}krát")
krok 0: log loss 0.6931 krok 100: log loss 0.4970 krok 200: log loss 0.4970 konec: log loss 0.4970 přesnost: 0.745 váha dne: +0.108 (skutečně +0.120) váha SMS: -1.761 (skutečně -1.800) den navíc násobí šanci 1.114krát
Chyba klesá a váhy se blíží skutečným pravidlům. Přesně se s nimi nepotkají, protože 400 rezervací obsahuje náhodu. Zkus posuvníkem lr nastavit velmi malý krok a pak kroku na nulu: bez tréninku je log loss přesně ln 2, tedy kolik stojí tipovat pořád 50 %. Celý cyklus si můžeš projít tlačítkem krokovat.
Doplň tréninkový krok
Doplň výpočet pravděpodobnosti a gradientu, aby se model naučil oddělit záporná čísla od kladných.
Model se učí pozpátku
Trénink má vést ke kladné váze, protože větší X znamená třídu 1. Místo toho model utíká opačným směrem. Najdi řádek s chybou.
Hranice a její limity
Aby model řekl ano, nebo ne, porovná p s prahem, obvykle 0,5. Sigmoida dává 0,5 přesně pro z = 0, takže hranice mezi třídami je množina bodů, kde w1·x1 + w2·x2 + b = 0. To je rovnice přímky. Ve třech rozměrech rovina, ve více rozměrech její obdoba. Na mapě je to dobře vidět: # je oblast třídy 1, tečka třídy 0.
import numpy as np
np.random.seed(1)
n = 100
A = np.random.normal([-1.2, -1.0], 0.9, size=(n, 2))
B = np.random.normal([1.2, 1.0], 0.9, size=(n, 2))
X = np.vstack([A, B])
y = np.r_[np.zeros(n), np.ones(n)]
w, b = np.zeros(2), 0.0
for _ in range(500):
p = 1 / (1 + np.exp(-(X @ w + b)))
w -= 0.3 * X.T @ (p - y) / len(y)
b -= 0.3 * np.mean(p - y)
print(f"hranice: {w[0]:.2f}·x1 + {w[1]:.2f}·x2 + {b:.2f} = 0")
for x2 in np.linspace(3, -3, 13):
radek = ""
for x1 in np.linspace(-4, 4, 41):
radek += "#" if w[0] * x1 + w[1] * x2 + b > 0 else "."
print(radek)
hranice: 2.53·x1 + 2.10·x2 + -0.10 = 0 ........################################# ..........############################### ............############################# ..............########################### .................######################## ...................###################### .....................#################### .......................################## .........................################ ...........................############## .............................############ ...............................########## .................................########
Přímá hranice je síla i slabina. Když jsou třídy rozložené šachovnicově (kladné tam, kde mají x1 a x2 stejné znaménko), žádná přímka je neoddělí. Pomůže přidat příznak, který vztah popíše: součin x1·x2.
import numpy as np
def presnost_po_treninku(X, y, kroku=2000, lr=0.5):
w, b = np.zeros(X.shape[1]), 0.0
for _ in range(kroku):
p = 1 / (1 + np.exp(-(X @ w + b)))
w -= lr * X.T @ (p - y) / len(y)
b -= lr * np.mean(p - y)
return np.mean(((X @ w + b) > 0) == (y == 1))
np.random.seed(2)
X = np.random.uniform(-1, 1, size=(300, 2))
y = (X[:, 0] * X[:, 1] > 0).astype(float)
soucin = (X[:, 0] * X[:, 1]).reshape(-1, 1)
X_rozsirene = np.hstack([X, soucin])
print("jen x1, x2: ", round(float(presnost_po_treninku(X, y)), 3))
print("navíc součin x1·x2:", round(float(presnost_po_treninku(X_rozsirene, y)), 3))
jen x1, x2: 0.52 navíc součin x1·x2: 0.97
Model zůstal lineární ve vahách, jen dostal lepší vstup. Vymýšlení takových příznaků je ruční práce. Stromy z lekce o rozhodovacích stromech a neuronové sítě si podobné vztahy najdou samy.
Přesnost modelu na šachovnicových datech je kolem 50 %. Co je nejpravděpodobnější příčina?
Delší trénink nepomůže, nejlepší přímka zůstává špatná. Práh jen posouvá hranici rovnoběžně s ní.
Natrénuj model
Doplň funkci trenuj(X, y, lr=0.5, kroku=500). X má tvar (n, d), y obsahuje 0 a 1. Začni s nulovými vahami a posunem a proveď kroku kroků gradientního sestupu. Vrať dvojici (w, b).
import numpy as np
def trenuj(X, y, lr=0.5, kroku=500):
w = np.zeros(X.shape[1])
b = 0.0
# doplň cyklus
return w, b
scikit-learn
V praxi vlastní smyčku nepíšeš. Knihovna scikit-learn má lepší optimalizátor a regularizaci. Tady na vestavěných datech o nádorech prsu: 30 měření a dvě třídy, zhoubný a nezhoubný nález. Pozor na kódování této sady, 0 je zhoubný a 1 nezhoubný. make_pipeline spojí standardizaci s modelem, takže se standardizace naučí jen na trénovacích datech (víc v lekci o pipelines).
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
data = load_breast_cancer()
X_tr, X_te, y_tr, y_te = train_test_split(
data.data, data.target, test_size=0.25, stratify=data.target, random_state=42
)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000, random_state=42))
model.fit(X_tr, y_tr)
print("přesnost na testu:", round(model.score(X_te, y_te), 3))
print("pořadí sloupců:", list(data.target_names))
print(model.predict_proba(X_te[:3]).round(3))
vahy = model[-1].coef_[0]
for i in np.argsort(np.abs(vahy))[::-1][:5]:
print(f"{data.feature_names[i]:<22} {vahy[i]:+.2f}")
přesnost na testu: 0.986
pořadí sloupců: [np.str_('malignant'), np.str_('benign')]
[[0.031 0.969]
[1. 0. ]
[0.441 0.559]]
worst texture -1.25
radius error -1.07
worst symmetry -0.96
worst concave points -0.94
area error -0.94Všímej si tří věcí. predict_proba vrací jeden sloupec na třídu a jejich pořadí určuje classes_. Váhy jsou po standardizaci, takže jdou mezi sebou porovnat. A záporná váha zde táhne ke třídě 0, tedy ke zhoubnému nálezu.
Při více třídách dostane každá třída vlastní skóre a místo sigmoidy se použije softmax: skóre se převedou tak, aby součet pravděpodobností dal 1.
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, stratify=y, random_state=0)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000, random_state=0))
model.fit(X_tr, y_tr)
proba = model.predict_proba(X_te[:4])
print("přesnost:", round(model.score(X_te, y_te), 3))
print("tvar coef_ (třídy, příznaky):", model[-1].coef_.shape)
print(proba.round(3))
print("součty řádků:", proba.sum(axis=1).round(6))
přesnost: 0.974 tvar coef_ (třídy, příznaky): (3, 4) [[0.971 0.029 0. ] [0.95 0.05 0. ] [0.985 0.015 0. ] [0.935 0.065 0. ]] součty řádků: [1. 1. 1. 1.]
Silná a slabá regularizace
Parametr C funguje obráceně, než by člověk čekal: menší C znamená silnější tlak na malé váhy. Natrénuj na připravených datech dva modely LogisticRegression s max_iter=1000: silna s C=0.01 a slaba s C=100.
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
X, y = make_classification(n_samples=300, n_features=8, n_informative=4, random_state=0)
silna = None
slaba = None
Spoj pojmy
Přiřaď ke každému pojmu jeho význam.
Pod kapotou · vlastnosti řešení, numerika a past jménem MSE
Proč ne MSE. S kvadratickou chybou je gradient podle skóre 2(p - y)·p(1 - p). Činitel p(1 - p) se u sebejistého omylu blíží nule, takže model, který se plete nejvíc, se učí nejpomaleji. Ztráta navíc přestane být v w konvexní. Log loss je konvexní, její hessián je Xᵀ S X se S = diag(p(1 - p)), a na něm stojí Newtonova metoda známá jako IRLS. Optimalizátor lbfgs v scikit-learn hessián jen aproximuje z historie gradientů.
Bilance. Podmínka optima s posunem říká Σ(p - y) = 0: průměrná předpověď se na trénovacích datech rovná podílu třídy 1. Stejně Σ(p - y)·x = 0 pro každý příznak. Regularizace tuhle rovnost pro příznaky poruší.
Numerika. 1 / (1 + e^-z) a následný logaritmus přetečou už kolem |z| ≈ 710. Ztrátu počítej přímo ze skóre: -ln p = ln(1 + e^-z), tedy np.logaddexp(0, -z). Stejný důvod má BCEWithLogitsLoss v PyTorchi.
import numpy as np
np.random.seed(3)
X = np.random.normal(size=(300, 2))
y = (np.random.random(300) < 1 / (1 + np.exp(-(1.5 * X[:, 0] - X[:, 1] - 0.8)))).astype(float)
w, b = np.zeros(2), 0.0
for _ in range(3000):
p = 1 / (1 + np.exp(-(X @ w + b)))
w -= 0.5 * X.T @ (p - y) / len(y)
b -= 0.5 * np.mean(p - y)
p = 1 / (1 + np.exp(-(X @ w + b)))
print(f"průměr y {y.mean():.4f}, průměr p {p.mean():.4f}")
print("Σ(p-y)·x ≈ 0:", bool(np.allclose(X.T @ (p - y), 0, atol=1e-6)))
z_spatne, y_spravne = -6.0, 1.0
p_s = 1 / (1 + np.exp(-z_spatne))
print(f"gradient log loss {p_s - y_spravne:+.4f}")
print(f"gradient MSE {2 * (p_s - y_spravne) * p_s * (1 - p_s):+.4f}")
z = -800.0
with np.errstate(all="ignore"):
naivne = -np.log(1 / (1 + np.exp(-z)))
print("naivně:", float(naivne), " stabilně:", float(np.logaddexp(0.0, -z)))
průměr y 0.3233, průměr p 0.3233 Σ(p-y)·x ≈ 0: True gradient log loss -0.9975 gradient MSE -0.0049 naivně: inf stabilně: 800.0
Co dělá C. Minimalizuje se C·Σ ztráta + ½‖w‖². Ztráta je součet, ne průměr, takže s více daty regularizace relativně slábne. Solver lbfgs posun netrestá, liblinear ho historicky trestá jako další příznak (mírní to intercept_scaling).
Dokonale oddělitelná data. Bez regularizace optimum neexistuje, váhy rostou do nekonečna a model se tváří stále jistěji. Z toho plynou absurdní pravděpodobnosti 1,0 v produkci.
Podvzorkování. Když si pro trénink ponecháš jen každý k-tý negativní příklad, šance vyjdou k-krát vyšší. Váhy zůstanou v očekávání správně, ale od posunu je potřeba odečíst ln k, jinak budou pravděpodobnosti nadhodnocené.
Opakování
Vyzkoušej si: Hranice mezi dvěma třídami
Klikáním přidávej body dvou tříd. Model se v prohlížeči přetrénuje a ukáže pravděpodobnosti a hranici.