Træning af lineær regression med scikit-learn
Brug sklearn.linear_model.LinearRegression til at tilpasse en model til træningsdata, lave forudsigelser og undersøge de indlærte koefficienter.
Træning af lineær regression med scikit-learn er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
scikit-learns API til LinearRegression
Scikit-learns LinearRegression-klasse har en enkel og ensartet API til tilpasning af lineær regression med mindste kvadrater. Som alle scikit-learn-estimatorer følger den samme mønster: instantiér, tilpas, forudsig.
Under motorhjelmen bruger den normalformlen (eller en numerisk stabil SVD-dekomponering til store egenskabsmatricer) til at finde de eksakte optimale vægte i én beregning — der er ikke brug for en iterativ træningsløkke. Det gør den ekstremt hurtig, selv på store datasæt med mange egenskaber.
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 parametersKlargøring af dataene
Før træningen skal dine data have den korrekte form. scikit-learn forventer:
- X — et 2D-array med formen
(n_samples, n_features) - y — et 1D-array med formen
(n_samples,)
Den mest almindelige formfejl er at angive et 1D-array for X, når du kun har én egenskab. Løsningen er at ændre formen med .reshape(-1, 1). Opdel altid dataene i trænings- og testsæt, før du tilpasser modellen — evaluering på træningsdata giver 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)Tilpasning af modellen
Kald af model.fit(X_train, y_train) beregner de optimale vægte ved hjælp af normalformlen og gemmer dem i modelobjektet. Efter tilpasningen bliver to attributter tilgængelige:
model.coef_— et array med vægte, én for hver egenskabmodel.intercept_— biasleddet (skalar)
Det afsluttende understregningstegn i attributnavne er en scikit-learn-konvention, der angiver, at attributten blev angivet under tilpasningen — den findes ikke, før fit() er kaldt.
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 ~50000Generering af forudsigelser
Efter tilpasningen skal du kalde model.predict(X) for at generere forudsigelser. Det beregner prikproduktet af egenskabsmatricen og de indlærte vægte plus skæringspunktet. Du kan lave forudsigelser på træningsdata, testdata eller helt nye data.
Husk: Evaluering på træningsdata er ikke et gyldigt mål for ydeevnen. Evaluer altid på det tilbageholdte testsæt for at få et retvisende estimat af, hvor godt modellen vil klare sig på data, den ikke har set før.
# 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}')Evaluering på testsættet
Brug scikit-learns metrikkfunktioner til at kvantificere ydeevnen på testsættet. Genvejen model.score(X_test, y_test) returnerer R² direkte. For at få det fulde billede skal du også beregne RMSE og MAE.
Hvis du sammenligner disse metrikker på tværs af forskellige modeller (f.eks. lineær regression og random forest), kan du objektivt vælge den bedste tilgang til dit datasæt. Inkludér altid en naiv baseline (f.eks. altid at forudsige gennemsnittet af y) for at bekræfte, at din model faktisk tilfører værdi.
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!)')Visualisering af regressionslinjen
Efter tilpasningen skal du tegne den indlærte regressionslinje oven på punktdiagrammet med træningsdataene. Denne visuelle kontrol besvarer spørgsmålene: Giver linjen mening? Ligger den nogenlunde det rigtige sted? Er der store grupper af afvigende værdier, som modellen konsekvent overser?
For en model med én egenskab er dette enkelt. For modeller med flere egenskaber skal du i stedet tegne forudsigelser over for faktiske værdier (et residualdiagram eller et punktdiagram med »forudsagt over for faktisk«), fordi beslutningsgrænsen ligger i et rum med mange dimensioner.
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()Fortolkning af koefficienterne
De indlærte coef_-værdier kan fortolkes direkte i en forretningsmæssig sammenhæng. I en model til huspriser med flere egenskaber fortæller hver koefficient, hvor meget den forudsagte pris ændrer sig, når den pågældende egenskab øges med én enhed, mens alle andre egenskaber holdes konstante (fortolkningen ceteris paribus).
Denne fortolkning er dog kun gyldig, når egenskaberne har nogenlunde samme skala. Hvis én egenskab måles i meter og en anden i kilometer, kan deres koefficienter ikke sammenlignes direkte. Skaler altid egenskaberne, før du fortolker koefficienter i modeller med flere egenskaber.
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
At tegne residualer over for forudsagte værdier er et vigtigt diagnostisk trin. I en model, der er godt tilpasset, bør residualerne være tilfældigt spredt omkring nul uden noget tydeligt mønster. Systematiske mønstre viser, at der er et problem:
- En tragtform (residualerne spredes mere ved større forudsigelser) viser heteroskedasticitet — fejlens varians er ikke konstant.
- Et buet mønster viser, at den sande sammenhæng er ikke-lineær, og at en lineær model er undertilpasset.
- Residualer, der systematisk er positive eller negative for bestemte intervaller af forudsigelser, betyder, at modellen er skæv i dette område.
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}')Regulariseret lineær regression
Almindelig LinearRegression kan overtilpasse, når du har mange egenskaber i forhold til antallet af træningseksempler, eller når egenskaberne er stærkt korrelerede (multikollinearitet). Scikit-learn indeholder to regulariserede varianter:
- Ridge (L2-regularisering) — trækker alle koefficienter proportionalt mod nul, så alle egenskaber bevares, men deres størrelse reduceres.
- Lasso (L1-regularisering) — trækker nogle koefficienter helt ned til nul og udfører dermed i praksis egenskabsudvælgelse.
Parameteren alpha styrer regulariseringens styrke: højere alpha = større reduktion = enklere model.
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}')Score ved krydsvalidering
En enkelt opdeling i trænings- og testdata kan give et misvisende højt eller lavt estimat af modellens ydeevne, afhængigt af hvilke eksempler der tilfældigvis ender i testsættet. Krydsvalidering giver et mere pålideligt estimat ved at beregne gennemsnittet af ydeevnen på tværs af flere fold.
Brug cross_val_score til en hurtig k-fold-evaluering uden at opdele dataene manuelt. De returnerede scorer er én pr. fold; rapportér gennemsnittet og standardafvigelsen for at vise både den forventede ydeevne og variationen.
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})')Pipeline fra start til slut
I professionelle ML-arbejdsgange kombineres forbehandling og modellen altid i en Pipeline. Det forhindrer datalækage under krydsvalidering (skaleren tilpasses separat på hver træningsfold) og forenkler implementeringen (ét objekt, der skal gemmes og indlæses).
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.')Hurtig kontrol
Test din forståelse af begreberne inden for maskinlæring med Python fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du, at fit() beregner optimale vægte, som gemmes i coef_ og intercept_, at predict() anvender den indlærte linje på nye data, og at residualdiagrammer viser, om den lineære antagelse holder, eller om der er brug for en mere kompleks model. Dernæst udvider vi lineær regression til flere egenskaber, lærer at fortolke hver koefficient som et mål for egenskabens betydning og evaluerer med R-kvadreret.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Træning af lineær regression med scikit-learn” gratis?
Ja — hele teksten til “Træning af lineær regression med scikit-learn” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Træning af lineær regression med scikit-learn”?
Brug sklearn.linear_model.LinearRegression til at tilpasse en model til træningsdata, lave forudsigelser og undersøge de indlærte koefficienter. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Træning af lineær regression med scikit-learn”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Linjes ligning: Hældning, skæring og forudsigelser
- Omkostningsfunktioner og mindste kvadraters metode
- Træning af lineær regression med scikit-learn
- Multipel lineær regression og feature-vigtighed