Träna linjär regression med scikit-learn
Ni kommer att använda sklearn.linear_model.LinearRegression för att anpassa en modell till träningsdata, göra förutsägelser och granska de inlärda koefficienterna.
Träna linjär regression med scikit-learn är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
scikit-learns LinearRegression-API
Scikit-learns LinearRegression-klass tillhandahåller ett rent och konsekvent API för att anpassa linjär regression med vanlig minsta kvadratmetoden. Precis som alla estimatorer i scikit-learn följer den samma mönster: instansiera, anpassa, förutsäg.
Under huven använder den normalekvationen (eller en numeriskt stabil SVD-dekomponering för stora featurematriser) för att hitta de exakt optimala vikterna i en enda beräkning – ingen iterativ träningsloop behövs. Därför är den extremt snabb även på stora dataset med många features.
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 parametersFörbereda data
Före träningen måste dina data ha rätt form. scikit-learn förväntar sig:
- X – en 2D-array med formen
(n_samples, n_features) - y – en 1D-array med formen
(n_samples,)
Det vanligaste formfelet är att skicka en 1D-array för X när du har en feature. Lösningen är att ändra formen med .reshape(-1, 1). Dela alltid upp data i tränings- och testmängder före all anpassning – utvärdering på träningsdata ger missvisande perfekta resultat.
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)Anpassa modellen
När du anropar model.fit(X_train, y_train) beräknas de optimala vikterna med normalekvationen och lagras i modellobjektet. Efter anpassningen blir två attribut tillgängliga:
model.coef_– en array med vikter, en per featuremodel.intercept_– bias-termen (skalär)
Det avslutande understrecket i attributnamn är en konvention i scikit-learn som anger att attributet har satts under anpassningen – det finns inte innan fit() har anropats.
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 ~50000Skapa förutsägelser
Efter anpassningen anropar du model.predict(X) för att skapa förutsägelser. Detta beräknar skalärprodukten av featurematrisen och de inlärda vikterna, plus interceptet. Du kan göra förutsägelser på träningsdata, testdata eller helt nya data.
Kom ihåg: utvärdering på träningsdata är inte ett giltigt mått på prestanda. Utvärdera alltid på den undanhållna testmängden för att få en ärlig uppskattning av hur väl modellen kommer att fungera på data den inte har sett.
# 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}')Utvärdera på testmängden
Använd scikit-learns metriksfunktioner för att kvantifiera prestandan på testmängden. Genvägen model.score(X_test, y_test) returnerar R² direkt. För en fullständig bild bör du även beräkna RMSE och MAE.
Genom att jämföra dessa mått mellan olika modeller (t.ex. linjär regression och random forest) kan du objektivt välja det bästa tillvägagångssättet för ditt dataset. Inkludera alltid en naiv baslinje (till exempel att alltid förutsäga medelvärdet för y) för att bekräfta att modellen faktiskt tillför värde.
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!)')Visualisera regressionslinjen
Efter anpassningen ritar du den inlärda regressionslinjen ovanpå spridningsdiagrammet för träningsdata. Denna visuella kontroll besvarar följande frågor: verkar linjen rimlig? Ligger den ungefär på rätt plats? Finns det stora grupper av avvikare som modellen konsekvent missar?
För en modell med en enda feature är detta enkelt. För modeller med flera features behöver du i stället rita förutsägelser mot faktiska värden (ett residualdiagram eller ett spridningsdiagram över ”förutsagt mot faktiskt”), eftersom beslutsgränsen finns i ett högdimensionellt rum.
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()Tolka koefficienterna
De inlärda värdena i coef_ har en direkt affärsmässig tolkning. I en modell för huspriser med flera features visar varje koefficient hur mycket det förutsagda priset förändras när den feature-funktionen ökar med en enhet, medan alla andra features hålls konstanta (en ceteris paribus-tolkning).
Denna tolkning gäller dock bara när features har liknande skalor. Om en feature anges i meter och en annan i kilometer kan deras koefficienter inte jämföras direkt. Skala alltid features innan du tolkar koefficienter i modeller med flera features.
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}')Residualanalys
Att rita residualer mot förutsagda värden är ett viktigt diagnostiskt steg. För en välanpassad modell bör residualerna vara slumpmässigt spridda runt noll utan något tydligt mönster. Systematiska mönster tyder på ett problem:
- En trattform (residualerna sprids mer för större förutsägelser) tyder på heteroskedasticitet – felens varians är inte konstant.
- Ett krökt mönster tyder på att det verkliga sambandet är icke-linjärt och att en linjär modell är underanpassad.
- Residualer som systematiskt är positiva eller negativa för vissa intervall av förutsägelser betyder att modellen är skev i det 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}')Regulariserad linjär regression
Vanlig LinearRegression kan överanpassa när du har många features i förhållande till antalet träningsexempel, eller när features är starkt korrelerade (multikollinearitet). Scikit-learn tillhandahåller två regulariserade varianter:
- Ridge (L2-regularisering) – krymper alla koefficienter proportionellt mot noll, så att alla features behålls men deras storlek minskar.
- Lasso (L1-regularisering) – krymper vissa koefficienter hela vägen till noll och utför därmed i praktiken featureselektion.
Parametern alpha styr regulariseringens styrka: högre alpha = mer krympning = enklare 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}')Korsvalideringspoäng
En enda uppdelning i tränings- och testdata kan ge en missvisande hög eller låg uppskattning av modellens prestanda, beroende på vilka exempel som råkar hamna i testmängden. Korsvalidering ger en tillförlitligare uppskattning genom att beräkna medelvärdet av prestandan över flera foldar.
Använd cross_val_score för en snabb k-fold-utvärdering utan att manuellt dela upp data. De returnerade poängen är en per fold; rapportera medelvärdet och standardavvikelsen för att visa både förväntad prestanda och variation.
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 från början till slut
I professionella ML-arbetsflöden kombineras förbehandlingen och modellen alltid i en Pipeline. Detta förhindrar dataläckage under korsvalidering (skalaren anpassas separat på varje träningsfold) och förenklar driftsättningen (ett objekt att spara och läsa in).
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.')Snabbkontroll
Testa din förståelse av begreppen inom Machine Learning with Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen lärde du dig att fit() beräknar optimala vikter som lagras i coef_ och intercept_, att predict() tillämpar den inlärda linjen på nya data och att residualdiagram visar om det linjära antagandet håller eller om en mer komplex modell behövs. Härnäst utökar vi linjär regression till flera features, lär oss att tolka varje koefficient som ett mått på feature-vikt och utvärderar med R-kvadrat.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Träna linjär regression med scikit-learn” gratis?
Ja – hela texten till ”Träna linjär regression med scikit-learn” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Träna linjär regression med scikit-learn”?
Ni kommer att använda sklearn.linear_model.LinearRegression för att anpassa en modell till träningsdata, göra förutsägelser och granska de inlärda koefficienterna. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Träna linjär regression med scikit-learn”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Linjeekvationen: lutning, intercept och förutsägelser
- Kostnadsfunktioner och minsta kvadratmetoden
- Träna linjär regression med scikit-learn
- Multipel linjär regression och egenskapernas betydelse