0 dní v řadě · 0 bodů

Strojové učení · 35 min

Logistická regrese

Model, který odpovídá ano, nebo ne a přidá k tomu pravděpodobnost. Sigmoida, log loss, trénink v NumPy a hotové řešení ve scikit-learn.

Hloubka
Úkoly
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}")
Výstup
 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):

text
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
                 0

Pí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))
Výstup
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))
Výstup
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.

Kvíz

Příznak má váhu w = 0. Co to znamená?

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):

text
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 0

Vzorec 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}")
Výstup
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.

Úkol

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
Výstup

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:

text
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")
Výstup
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ň

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.

Najdi chybu

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)
Výstup
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))
Výstup
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.

Kvíz

Přesnost modelu na šachovnicových datech je kolem 50 %. Co je nejpravděpodobnější příčina?

Úkol

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
Výstup

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}")
Výstup
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.94

Vší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))
Výstup
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.]
Úkol

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
Výstup
Spoj dvojice

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)))
Výstup
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é.

Kartičky

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.