Machine Learning Academy · leksjon

Trene lineær regresjon med scikit-learn

De vil bruke sklearn.linear_model.LinearRegression til å tilpasse en modell til treningsdata, lage prediksjoner og undersøke de innlærte koeffisientene.

Leksjon 3 av 413 trinn

Trene lineær regresjon med scikit-learn er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 3 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.

scikit-learns LinearRegression-API

Scikit-learn-klassen LinearRegression tilbyr et ryddig og konsistent API for å tilpasse lineær regresjon med ordinære minste kvadraters metode. Som alle estimatorer i scikit-learn følger den samme mønster: opprett, tilpass, prediker.

Under panseret bruker den den normale ligningen (eller en numerisk stabil SVD-dekomponering for store funksjonsmatriser) for å finne de eksakte optimale vektene i én enkelt beregning – ingen iterativ treningssløyfe er nødvendig. Dette gjør den svært rask, selv på store datasett med mange funksjoner.

from sklearn.linear_model import LinearRegression
import numpy as np

# Instantiate with optional parameters
model = LinearRegression(
    fit_intercept=True,   # default: add bias term
    copy_X=True,          # don't modify input arrays
    n_jobs=-1             # use all CPU cores
)

print(model)  # shows default parameters

Klargjøre dataene

Før treningen må dataene ha riktig form. scikit-learn forventer:

X – en todimensjonal matrise med formen (n_samples, n_features)
y – en endimensjonal matrise med formen (n_samples,)

Den vanligste formfeilen er å sende inn en endimensjonal matrise for X når du har én funksjon. Løsningen er å endre formen med .reshape(-1, 1). Del alltid dataene inn i trenings- og testsett før en tilpasning – evaluering på treningsdata gir misvisende perfekte resultater.

import numpy as np
from sklearn.model_selection import train_test_split

# Simulate housing data
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 200)
price = 150 * sqft + 50000 + np.random.normal(0, 25000, 200)

# Reshape X to 2D (n_samples, n_features)
X = sqft.reshape(-1, 1)  # shape (200, 1)
y = price                  # shape (200,)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print('Train size:', X_train.shape, '| Test size:', X_test.shape)

Tilpasse modellen

Når du kaller model.fit(X_train, y_train), beregnes de optimale vektene ved hjelp av den normale ligningen, og de lagres i modellobjektet. Etter tilpasningen blir to attributter tilgjengelige:

model.coef_ – en matrise med vekter, én for hver funksjon
model.intercept_ – konstantleddet (en skalar)

Den avsluttende understrekingen i attributtnavn er en konvensjon i scikit-learn som viser at attributtet ble satt under tilpasningen – det finnes ikke før fit() er kalt.

from sklearn.linear_model import LinearRegression
import numpy as np
from sklearn.model_selection import train_test_split

np.random.seed(42)
X = np.random.uniform(500, 3000, 200).reshape(-1, 1)
y = 150 * X.ravel() + 50000 + np.random.normal(0, 25000, 200)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)

print(f'Slope (coef_):     {model.coef_[0]:.2f}')   # should be ~150
print(f'Intercept:         {model.intercept_:.2f}')  # should be ~50000

Lage prediksjoner

Etter tilpasningen kaller du model.predict(X) for å generere prediksjoner. Dette beregner skalarproduktet av funksjonsmatrisen og de innlærte vektene, og legger til konstantleddet. Du kan predikere på treningsdata, testdata eller helt nye data.

Husk: evaluering på treningsdata er ikke et gyldig mål på ytelsen. Evaluer alltid på det tilbakeholdte testsettet for å få et ærlig estimat av hvor godt modellen vil fungere på ukjente data.

# Predict on test set
y_pred = model.predict(X_test)

print('First 5 predictions vs actual:')
for actual, pred in zip(y_test[:5], y_pred[:5]):
    print(f'  Actual: ${actual:,.0f}  |  Predicted: ${pred:,.0f}  |  Error: ${actual-pred:,.0f}')

# Predict a single new house
new_house = np.array([[1750]])  # must be 2D
print(f'\nPrediction for 1750 sqft: ${model.predict(new_house)[0]:,.0f}')

Evaluere på testsettet

Bruk metrikkfunksjonene i scikit-learn til å kvantifisere ytelsen på testsettet. Snarveien model.score(X_test, y_test) returnerer R² direkte. For å få et fullstendig bilde bør du også beregne RMSE og MAE.

Ved å sammenligne disse metrikkene på tvers av ulike modeller (for eksempel lineær regresjon og tilfeldig skog) kan du velge den beste tilnærmingen for datasettet ditt på en objektiv måte. Ta alltid med en naiv referansemodell (for eksempel en modell som alltid predikerer gjennomsnittet av y) for å bekrefte at modellen faktisk gir merverdi.

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

y_pred = model.predict(X_test)

rmse = np.sqrt(mean_squared_error(y_test, y_pred))
mae  = mean_absolute_error(y_test, y_pred)
r2   = r2_score(y_test, y_pred)

print(f'Test RMSE: ${rmse:,.0f}')
print(f'Test MAE:  ${mae:,.0f}')
print(f'Test R2:   {r2:.3f}')

# Baseline: always predict the mean
baseline_rmse = np.sqrt(((y_test - y_train.mean()) ** 2).mean())
print(f'Baseline RMSE: ${baseline_rmse:,.0f}  (must beat this!)')

Visualisere regresjonslinjen

Etter tilpasningen tegner du den innlærte regresjonslinjen oppå punktdiagrammet for treningsdataene. Denne visuelle kontrollen svarer på følgende: Gir linjen mening? Ligger den omtrent på riktig sted? Finnes det store grupper av avvikere som modellen konsekvent ikke treffer?

For en modell med én funksjon er dette enkelt. For modeller med flere funksjoner må du i stedet plotte prediksjoner mot faktiske verdier (et residualplott eller et punktdiagram over «predikert mot faktisk»), siden beslutningsgrensen befinner seg i et flerdimensjonalt rom.

import matplotlib.pyplot as plt
import numpy as np

# Plot training data and the fitted line
plt.figure(figsize=(8, 5))
plt.scatter(X_train, y_train, alpha=0.4, label='Training data')
plt.scatter(X_test, y_test, alpha=0.4, color='orange', label='Test data')

# Draw the regression line across the full range
x_range = np.linspace(500, 3000, 100).reshape(-1, 1)
y_range = model.predict(x_range)
plt.plot(x_range, y_range, 'r-', linewidth=2, label='Regression line')

plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.legend()
plt.title('Linear Regression Fit')
plt.show()

Tolke koeffisientene

De innlærte coef_-verdiene kan tolkes direkte i en forretningsmessig sammenheng. I en modell for boligpriser med flere funksjoner viser hver koeffisient hvor mye den predikerte prisen endres når funksjonen øker med én enhet, mens alle andre funksjoner holdes konstante (tolkningen ceteris paribus).

Denne tolkningen er imidlertid bare gyldig når funksjonene har omtrent samme skala. Hvis én funksjon måles i meter og en annen i kilometer, kan koeffisientene ikke sammenlignes direkte. Skaler alltid funksjonene før du tolker koeffisienter i modeller med flere funksjoner.

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import numpy as np
import pandas as pd

# Multi-feature housing data
features = ['sqft', 'bedrooms', 'bathrooms', 'age']
np.random.seed(0)
X_data = pd.DataFrame({
    'sqft': np.random.randint(600, 3000, 100),
    'bedrooms': np.random.randint(1, 6, 100),
    'bathrooms': np.random.randint(1, 4, 100),
    'age': np.random.randint(1, 50, 100)
})
y_data = 150*X_data['sqft'] + 8000*X_data['bedrooms'] - 500*X_data['age'] + 30000

model = LinearRegression().fit(X_data, y_data)
for feat, coef in zip(features, model.coef_):
    print(f'{feat}: {coef:.1f}')

Residualanalyse

Å plotte residualer mot predikerte verdier er et viktig diagnostisk trinn. For en godt tilpasset modell bør residualene være tilfeldig spredt rundt null uten noe tydelig mønster. Systematiske mønstre tyder på et problem:

En traktform (residualene sprer seg mer for større prediksjoner) tyder på heteroskedastisitet – variansen til feilene er ikke konstant.
Et buet mønster tyder på at den virkelige sammenhengen er ikke-lineær, og at en lineær modell ikke tilpasser seg godt nok.
Residualer som systematisk er positive eller negative for bestemte prediksjonsintervaller, betyr at modellen er skjev i dette området.

import matplotlib.pyplot as plt
import numpy as np

y_pred = model.predict(X_test)
residuals = y_test - y_pred

plt.figure(figsize=(8, 5))
plt.scatter(y_pred, residuals, alpha=0.5)
plt.axhline(y=0, color='red', linestyle='--', linewidth=1.5)
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.title('Residual Plot (should be random scatter around 0)')
plt.show()

print(f'Mean residual: {residuals.mean():.2f}  (should be ~0)')
print(f'Std of residuals: {residuals.std():.2f}')

Regularisert lineær regresjon

Vanlig LinearRegression kan overtilpasse når du har mange funksjoner i forhold til antallet treningseksempler, eller når funksjonene er sterkt korrelerte (multikollinearitet). Scikit-learn tilbyr to regulariserte varianter:

Ridge (L2-regularisering) – krymper alle koeffisientene proporsjonalt mot null, slik at alle funksjoner beholdes samtidig som størrelsen reduseres.
Lasso (L1-regularisering) – krymper noen koeffisienter helt ned til null, og utfører dermed i praksis funksjonsutvelgelse.

Parameteren alpha styrer styrken på regulariseringen: høyere alpha = mer krymping = enklere modell.

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
import numpy as np

np.random.seed(42)
X = np.random.randn(100, 20)  # 20 features, many irrelevant
y = 3*X[:, 0] + 2*X[:, 1] + np.random.randn(100)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

for name, model in [('OLS', LinearRegression()),
                    ('Ridge', Ridge(alpha=1.0)),
                    ('Lasso', Lasso(alpha=0.1))]:
    model.fit(X_train, y_train)
    print(f'{name} R2: {r2_score(y_test, model.predict(X_test)):.3f}')

Kryssvalideringspoeng

Én enkelt oppdeling i trenings- og testsett kan gi et misvisende høyt eller lavt estimat av modellens ytelse, avhengig av hvilke eksempler som havner i testsettet. Kryssvalidering gir et mer pålitelig estimat ved å beregne gjennomsnittet av ytelsen på tvers av flere deler.

Bruk cross_val_score for en rask k-fold-evaluering uten å dele opp dataene manuelt. De returnerte poengene er ett per del; rapporter gjennomsnittet og standardavviket for å vise både forventet ytelse og variasjon.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
import numpy as np

np.random.seed(42)
X = np.random.randn(200, 3)
y = 2*X[:, 0] - X[:, 1] + np.random.randn(200)*0.5

model = LinearRegression()
scores = cross_val_score(
    model, X, y,
    cv=5,          # 5-fold cross-validation
    scoring='r2'   # use R2 as the metric
)

print('CV R2 scores per fold:', scores.round(3))
print(f'Mean R2: {scores.mean():.3f} (+/- {scores.std():.3f})')

Helhetlig prosesseringsløp

I profesjonelle arbeidsflyter for ML kombineres forbehandlingen og modellen alltid i en Pipeline. Dette hindrer datalekkasjer under kryssvalidering (skaleringen tilpasses separat på hver treningsdel) og forenkler utrulling (ett objekt som kan lagres og lastes inn).

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
import numpy as np

np.random.seed(42)
X = np.random.randn(200, 3)
y = 2*X[:, 0] - X[:, 1] + np.random.randn(200)*0.5

# Scale + Fit in one object
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LinearRegression())
])

scores = cross_val_score(pipeline, X, y, cv=5, scoring='r2')
print(f'Pipeline CV R2: {scores.mean():.3f} (+/- {scores.std():.3f})')

# Fit once for deployment
pipeline.fit(X, y)
print('Pipeline fitted and ready for deployment.')

Hurtigsjekk

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

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte du at: fit() beregner optimale vekter som lagres i coef_ og intercept_, predict() bruker den innlærte linjen på nye data, og residualplott viser om den lineære antakelsen holder, eller om en mer kompleks modell er nødvendig. Deretter utvider vi lineær regresjon til flere funksjoner, lærer hvordan hver koeffisient kan tolkes som et mål på funksjonens betydning, og evaluerer med R-kvadrat.

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 «Trene lineær regresjon med scikit-learn» gratis?

Ja – hele teksten i «Trene lineær regresjon med scikit-learn» 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 «Trene lineær regresjon med scikit-learn»?

De vil bruke sklearn.linear_model.LinearRegression til å tilpasse en modell til treningsdata, lage prediksjoner og undersøke de innlærte koeffisientene. 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 3 av 4.

Hvor lang tid tar leksjonen «Trene lineær regresjon med scikit-learn»?

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

Linjeligningen: Stigningstall, konstantledd og prediksjoner
Kostnadsfunksjoner og minste kvadrater
Trene lineær regresjon med scikit-learn
Multippel lineær regresjon og egenskapsviktighet

← Tilbake til Machine Learning Academy