Machine Learning Academy · leksjon

Logistisk regresjon og sigmoidfunksjonen

De vil bruke sigmoidfunksjonen til å produsere sannsynligheter, tolke resultatet som modellens sikkerhet for klassen og trene en logistisk modell med scikit-learn.

Leksjon 2 av 413 trinn

Logistisk regresjon og sigmoidfunksjonen er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Logistisk regresjon: En probabilistisk klassifikator

Logistisk regresjon er den foretrukne algoritmen for binær klassifisering. Til tross for navnet er den en klassifikator, ikke en regresjonsmodell. Den utvider den lineære modellen ved å føre resultatet gjennom en spesiell funksjon kalt sigmoid, slik at prediksjonene alltid er gyldige sannsynligheter mellom 0 og 1.

Logistisk regresjon er en av de mest brukte ML-modellene i produksjon. Den er rask å trene, tolkbar og gir kalibrerte sannsynlighetsestimater. Den er ofte den første klassifikatoren De bør prøve på et nytt binært klassifiseringsproblem før De tar i bruk mer komplekse metoder.

Sigmoidfunksjonen

Sigmoidfunksjonen (også kalt den logistiske funksjonen) avbilder ethvert reelt tall til intervallet (0, 1):

σ(z) = 1 / (1 + e^(-z))

Viktige egenskaper: σ(0) = 0,5, σ(+∞) → 1, σ(-∞) → 0. Den S-formede kurven går jevnt fra 0 til 1. Når z er et stort positivt tall (et sterkt signal for klasse 1), nærmer resultatet seg 1. Når z er et stort negativt tall (et sterkt signal for klasse 0), nærmer resultatet seg 0.

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z = np.linspace(-10, 10, 200)
y = sigmoid(z)

plt.plot(z, y, 'b-', linewidth=2)
plt.axhline(y=0.5, color='red', linestyle='--', alpha=0.5, label='threshold=0.5')
plt.axvline(x=0, color='gray', linestyle='--', alpha=0.5)
plt.xlabel('z (linear score)')
plt.ylabel('sigmoid(z) = probability')
plt.title('The Sigmoid Function')
plt.legend()
plt.show()

print('sigmoid(0):', sigmoid(0))   # 0.5
print('sigmoid(5):', sigmoid(5))   # ~0.993
print('sigmoid(-5):', sigmoid(-5)) # ~0.007

Slik beregner logistisk regresjon sannsynlighet

Logistisk regresjon beregner først den samme lineære kombinasjonen som lineær regresjon (z = w₁x₁ + w₂x₂ + ... + b), og sender den deretter gjennom sigmoidfunksjonen for å få en sannsynlighet:

P(y=1|x) = σ(wᵀx + b) = 1 / (1 + e^(-(wᵀx+b)))

Modellen gir en sannsynlighet for at inndataene tilhører klasse 1. Hvis denne sannsynligheten er større enn 0,5, predikerer modellen klasse 1; ellers klasse 0. Vektene w læres under treningen for å maksimere sannsynligheten for de observerte etikettene — en prosess som kalles maksimum likelihood-estimering.

import numpy as np

def logistic_predict_proba(X, weights, bias):
    z = X @ weights + bias  # linear score
    probability = 1 / (1 + np.exp(-z))  # sigmoid
    return probability

# Example: spam classification
# Features: word_count, exclamation_marks, capital_ratio
weights = np.array([0.05, 0.3, 2.0])
bias = -3.0

new_email = np.array([50, 5, 0.6])  # 50 words, 5 '!', 60% capitals
prob_spam = logistic_predict_proba(new_email, weights, bias)
print(f'P(spam): {prob_spam:.3f}')
print('Predicted label:', 1 if prob_spam >= 0.5 else 0)

Logaritmisk tap: Den riktige kostnadsfunksjonen

Logistisk regresjon bruker ikke MSE som kostnadsfunksjon. I stedet bruker den binært krysstap (log-tap):

Loss = -(y × log(ŷ) + (1-y) × log(1-ŷ))

Dette straffer svært hardt når modellen kommer med sikre, men feilaktige prediksjoner. Hvis den sanne etiketten er 1 og modellen predikerer sannsynligheten 0.001, er log-tapet -log(0.001) ≈ 6.9 — enormt. Hvis modellen predikerer 0.99, er tapet -log(0.99) ≈ 0.01 — ubetydelig. Denne asymmetriske straffingen er akkurat det som trengs for god sannsynlighetskalibrering.

import numpy as np

def log_loss_single(y_true, y_pred_proba, epsilon=1e-9):
    # Clip to avoid log(0)
    p = np.clip(y_pred_proba, epsilon, 1 - epsilon)
    return -(y_true * np.log(p) + (1 - y_true) * np.log(1 - p))

# True label = 1 (spam)
print('P(spam)=0.95, loss:', log_loss_single(1, 0.95).round(3))  # small
print('P(spam)=0.5,  loss:', log_loss_single(1, 0.50).round(3))  # moderate
print('P(spam)=0.05, loss:', log_loss_single(1, 0.05).round(3))  # large!
print('P(spam)=0.001,loss:', log_loss_single(1, 0.001).round(3)) # very large!

Trening av logistisk regresjon med scikit-learn

scikit-learns LogisticRegression bruker en gradientbasert optimeringsalgoritme (LBFGS som standard) for å minimere log-tapet og finne de optimale vektene. API-et er identisk med LinearRegression: opprett en instans, tilpass modellen og prediker.

Viktige parametere omfatter C (den inverse styrken på regulariseringen — en mindre C-verdi betyr sterkere regularisering) og max_iter (maksimalt antall optimeringstrinn). Hvis De ser en advarsel om manglende konvergens, kan De øke max_iter eller skalere egenskapene først.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features (important for logistic regression)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = LogisticRegression(C=1.0, max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))

Sannsynlighetsverdier og konfidens

Logistisk regresjon er en av de få klassifikatorene som produserer godt kalibrerte sannsynlighetsestimater. En sannsynlighet på 0.85 for klasse 1 betyr at omtrent 85 % av prediksjonene med dette konfidensnivået faktisk bør tilhøre klasse 1. Denne kalibreringen er verdifull i applikasjoner for risikostyring (kredittvurdering og medisinsk diagnostikk), der selve sannsynligheten er viktig, ikke bare den binære etiketten.

Bruk predict_proba() for å hente hele sannsynlighetsvektoren. De to kolonnene representerer P(klasse 0) og P(klasse 1). Summen er alltid 1.0.

import numpy as np

# Get class probabilities
probas = model.predict_proba(X_test_s[:8])
labels = model.predict(X_test_s[:8])

print('Sample | P(benign) | P(malignant) | Predicted')
for i, (proba, label) in enumerate(zip(probas, labels)):
    print(f'  {i+1}    |   {proba[0]:.3f}   |    {proba[1]:.3f}     | {label}')

print('\nClass names:', model.classes_)  # [0, 1] or ['benign', 'malignant']

Tolkning av koeffisienter i logistisk regresjon

Koeffisientene i logistisk regresjon er ikke like direkte tolkbare som koeffisientene i lineær regresjon, men de inneholder fortsatt meningsfull informasjon. Koeffisienten w for en egenskap representerer endringen i log-odds for den positive klassen ved en økning på én enhet i egenskapen:

log(P(y=1)/P(y=0)) = wᵀx + b

Oddsforholdet for en egenskap er exp(w). Hvis exp(w) = 2, dobler egenskapen oddsene for den positive klassen. Store positive koeffisienter indikerer egenskaper som i sterk grad predikerer klasse 1, mens store negative koeffisienter i sterk grad predikerer klasse 0.

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer

data = load_breast_cancer()
feature_names = data.feature_names

# Coefficient table with odds ratios
coef_df = pd.DataFrame({
    'Feature': feature_names,
    'Coefficient': model.coef_[0],
    'Odds_Ratio': np.exp(model.coef_[0])
}).sort_values('Coefficient', key=abs, ascending=False)

print(coef_df.head(5).to_string(index=False))
# Features with largest |coef| drive predictions most strongly

Regularisering i logistisk regresjon

Logistisk regresjon i scikit-learn bruker L2-regularisering som standard, styrt av parameteren C. I motsetning til de fleste regulariseringsparametere er C den inverse styrken på regulariseringen: en mindre C-verdi betyr sterkere regularisering (større krymping av vektene), mens en større C-verdi betyr svakere regularisering.

Bruk penalty='l1' og løseren 'liblinear' for L1-regularisering. Denne utfører automatisk egenskapsseleksjon ved å sette vektene til irrelevante egenskaper lik null. L1-logistisk regresjon er spesielt nyttig når De har mange egenskaper og antar at de fleste er irrelevante.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# Compare regularisation strengths
for C in [0.01, 0.1, 1.0, 10.0, 100.0]:
    model_c = LogisticRegression(C=C, max_iter=1000)
    scores = cross_val_score(model_c, X_train_s, y_train, cv=5)
    print(f'C={C:6}: CV Accuracy = {scores.mean():.3f} (+/- {scores.std():.3f})')

Klassifikasjonsrapport

Et enkelt nøyaktighetstall skjuler viktig informasjon. scikit-learns classification_report() skriver ut presisjon, gjenkalling og F1-skår for hver klasse, i tillegg til makro- og vektede gjennomsnitt. Dette er standardmåten å rapportere klassifikasjonsytelse på innen forskning og næringsliv.

Slik leser De rapporten: Kolonnen «support» viser hvor mange eksempler av hver klasse som finnes i testsettet. Hvis antallet eksempler er svært ulikt (klasseubalanse), bør De se på gjenkalling per klasse i stedet for samlet nøyaktighet for å forstå hvor modellen gjør feil.

from sklearn.metrics import classification_report

y_pred = model.predict(X_test_s)
print(classification_report(y_test, y_pred, target_names=['benign', 'malignant']))
# Shows for each class:
#   precision: of all predicted positive, how many were actually positive
#   recall: of all actual positive, how many did we catch
#   f1-score: harmonic mean of precision and recall
#   support: number of true instances of each class in test set

Logistisk regresjon sammenlignet med lineær regresjon

Her er en tydelig sammenligning av når hver av dem bør brukes:

Måltype: Lineær regresjon → kontinuerlig tall; logistisk regresjon → sannsynlighet / binær etikett.
Utdataområde: Lineær → (-∞, +∞); logistisk → (0, 1).
Tapfunksjon: Lineær → MSE; logistisk → binært krysstap (log-tap).
Evaluering: Lineær → RMSE, R²; logistisk → nøyaktighet, F1, AUC-ROC.
Felles egenskap: Begge er lineære modeller — beslutningsgrensen er et hyperplan, og begge har fordel av skalering av egenskaper og regularisering.

Logistisk regresjon med flere klasser

For problemer med mer enn to klasser generaliseres logistisk regresjon til Softmax-regresjon (også kalt multinomisk logistisk regresjon). I stedet for én sigmoid beregner den én lineær skår per klasse og sender alle gjennom softmax-funksjonen, som produserer en sannsynlighetsfordeling over alle klassene.

I scikit-learn angir De multi_class='multinomial' og bruker løseren 'lbfgs' eller 'saga'. Modellen produserer en sannsynlighet for hver klasse, og den predikerte klassen er den med høyest sannsynlighet.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train_s = StandardScaler().fit_transform(X_train)
X_test_s = StandardScaler().fit_transform(X_test)

# Multinomial for 3 classes
model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))
print('Proba shape:', model.predict_proba(X_test_s[:1]).shape)  # (1, 3)

Kunnskapssjekk

Test forståelsen Deres av konsepter innen maskinlæring med Python fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at: sigmoidfunksjonen komprimerer enhver lineær skår til en gyldig sannsynlighet mellom 0 og 1, logistisk regresjon bruker binært krysstap som straffer sikre, men feilaktige prediksjoner hardt, og koeffisienter representerer endringer i log-odds, mens oddsforholdet exp(w) gir en mer intuitiv, skala-uavhengig tolkning. Deretter skal vi bygge en forvekslingsmatrise fra prediksjoner og fasit, slik at vi får en detaljert oversikt over hvor klassifikatoren lykkes og mislykkes.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Logistisk regresjon og sigmoidfunksjonen» gratis?

Ja – hele teksten i «Logistisk regresjon og sigmoidfunksjonen» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Logistisk regresjon og sigmoidfunksjonen»?

De vil bruke sigmoidfunksjonen til å produsere sannsynligheter, tolke resultatet som modellens sikkerhet for klassen og trene en logistisk modell med scikit-learn. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Logistisk regresjon og sigmoidfunksjonen»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Fra regresjon til klassifisering: Beslutninger med terskelverdi
Logistisk regresjon og sigmoidfunksjonen
Forklaring av forvekslingsmatrisen
Presisjon, tilbakekalling og F1-skår i praksis

← Tilbake til Machine Learning Academy