Sklearn linear regression: en komplett guide med exempel

Linjär regression är en grundläggande teknik inom statistik och maskininlärning som hjälper till att modellera sambandet mellan variabler. Enkelt uttryckt låter den oss förutsäga ett utfall baserat på en eller flera påverkande faktorer. Den används ofta för bostadsprissättning, försäljningsprognoser, riskbedömning och många andra områden.

I den här guiden går vi igenom linjär regression i scikit-learn: hur den fungerar, varför den är användbar och hur du implementerar den med scikit-learn. När du är klar kommer du att kunna bygga och utvärdera en linjär regressionsmodell för att göra datadrivna prediktioner.

Spridningsdiagram över huspris kontra antal rum

Linjär regression och maskininlärning

Utöver sin direkta nytta för att bestämma huspriser spelar linjär regression en viktig roll i maskininlärning.

• Den är en grundmodell för att förstå mer avancerade tekniker som logistisk regression, neurala nätverk och supportvektormaskiner.
• Den är snabb att träna, vilket gör den idealisk för snabb prototyping.
• Den fungerar också som en baslinje för jämförelse. Om mer avancerade modeller inte presterar avsevärt bättre kan deras ökade komplexitet vara svår att motivera.
• Till skillnad från vissa tekniker (som djupinlärning) är den lätt att tolka.
• Den kan hjälpa vid feature selection och identifiera de mest användbara prediktorerna.

Trots sin enkelhet är linjär regression ett oumbärligt verktyg i maskininlärning tack vare sin effektivitet, tolkningsbarhet och mångsidighet.

Linjär regression och biblioteket scikit-learn

Biblioteket scikit-learn gör det enkelt att implementera linjär regression. Det här biblioteket har många fördelar.

• Det har ett enhetligt gränssnitt. Koden som behövs för att implementera olika ML-algoritmer är likartad.
• Koden är enkel, med komplex matematik och implementeringsdetaljer abstraherade. Till exempel, för att anpassa en modell på träningsdata, använd bara raden model.fit(X_train, y_train).
• Det ger enkel åtkomst till modellkoefficienter.
• Det innehåller inbyggda mått för att utvärdera modellens prestanda.
• Det är lätt att integrera linjär regression (eller någon annan ML-algoritm) med förbehandling som skalning och feature selection via Pipeline.

Om du är ny på scikit-learn kan du kolla in vår kurs Machine Learning with scikit-learn för en praktisk introduktion till Python-biblioteket. 

Förstå linjär regression

Som vi har sett modelleras data i enkel linjär regression med en ”bästa anpassningslinje”. Formeln för denna linje är: 

där m är linjens lutning och b är skärningen.

”Multipel linjär regression” generaliserar fallet med en prediktor till flera prediktorer (antal rum, närhet till havet, områdets medianinkomst). Formeln generaliseras till: 

där varje x_i är en oberoende variabel och motsvarande b_i är dess koefficient. I tre dimensioner generaliseras linjen till ett plan. I högre dimensioner blir planet ett ”hyperplan”.

Hur tolkar vi koefficienterna och skärningen? Skärningen är det förutsagda värdet på y när alla oberoende variabler är 0, eller med andra ord baslinjevärdet för den beroende variabeln när det inte finns något bidrag från prediktorerna. Varje koefficient b_i representerar förändringen i den beroende variabeln y för en enhets förändring i x_i, givet att alla andra oberoende variabler hålls konstanta.

Förbereda miljön

Att installera scikit-learn är enkelt. Använd bara kommandot pip install scikit-learn. Om du vill installera en specifik version, säg 1.2.2, lägger du till versionen i kommandot: pip install scikit-learn==1.2.2. Om du använder Anaconda bör scikit-learn redan vara installerat. Om du ändå behöver installera det i Anaconda-distributionen använder du kommandot conda install scikit-learn.

Flera bibliotek är antingen nödvändiga eller rekommenderade när du använder scikit-learn. Biblioteket numpy behövs för att lagra features och etiketter. Biblioteket pandas rekommenderas för att läsa in, förbehandla och utforska dataset. 

Om du använder scikit-learn använder du sannolikt redan pandas för databereden. För att plotta dina resultat använder du troligen matplotlib eller seaborn eller båda. Vilket som helst av dessa bibliotek kan installeras med pip install, på samma sätt som i exemplet ovan. Du kan till och med installera flera bibliotek med ett kommando:

pip install scikit-learn numpy pandas matplotlib seaborn.

Implementera linjär regression i sklearn

Innan vi laddar datasetet importerar vi de vanliga misstänkta.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Ladda datasetet

Vi använder det välkända California housing-datasetet.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

Förbereda data

Vi delar upp data i tränings- och testmängder. Vi importerar metoden train_test_split() från sklearn.model_selection, anropar den och anger andelen testdata samt en random_state. Vi använder också enkel linjär regression, med den feature som motsvarar genomsnittligt antal rum.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Nu när vi delat upp data i test- och träningsmängder standardiserar vi features. Denna process säkerställer att alla variabler ligger på samma skala, vilket kan förbättra modellens prestanda och numeriska stabilitet.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

I den här koden är StandardScaler ett förbehandlingsverktyg som tar bort medelvärdet och skalar features till enhetsvarians. Detta hjälper till att förhindra att vissa features dominerar modellen på grund av skillnader i skala.

Skalaren anpassas på träningsdatan med metoden fit_transform(). Testdatan transformeras sedan separat med metoden transform() för att säkerställa att den skalas med samma faktorer som träningsdatan, vilket förhindrar dataläckage.

Träna den linjära regressionsmodellen

För att skapa en linjär regressionsmodell importerar du LinearRegression() från sklearn.linear_model. Anropa den och tilldela den till en variabel.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Att anpassa modellen med träningsdata är rakt på sak.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Göra prediktioner

Nu när vi har tränat vår modell gör vi prediktioner på testmängden.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Utvärdera modellens prestanda

Nu när vi har gjort prediktioner på testmängden behöver vi veta hur väl de stämmer överens med verkligheten. Det finns flera mått för att utvärdera en regressionsalgoritms prestanda. Några av de vanligaste är determinationskoefficienten (R²), medelkvadratfelet (MSE) och roten ur medelkvadratfelet (RMSE).

Determinationskoefficienten, betecknad R², mäter hur väl en regressionsmodell förklarar variationen i målvariabeln. Med andra ord kvantifierar den hur stor del av variationen i målvariabeln som förklaras av prediktorerna, det vill säga modellens förklaringsgrad.

För att förstå detta bättre tittar vi på formeln:

där yactual är de faktiska värdena för målvariabeln, ypredicted är de värden som modellen förutsagt och ȳ är medelvärdet av de faktiska värdena. Den här formeln hjälper oss att förstå hur mycket av variansen i målvariabeln som förklaras av modellen. Nämnaren representerar den totala variansen i datan, medan täljaren representerar den oförklarade variansen efter att regressionsmodellen tillämpats. Kvoten ger alltså andelen förklarad varians.

Hur tolkar vi R²?

• R² = 1: modellen förklarar all varians i målvariabeln perfekt. 
• R² = 0: modellen förklarar ingen varians; prediktionerna är inte bättre än att bara använda medelvärdet. 
• R² < 0: modellen presterar sämre än att enbart använda medelvärdet, vilket indikerar en dålig anpassning.

Några viktiga saker att ha i åtanke.

• Högre R² är inte alltid bättre. Ett högt R² kan tyda på överanpassning, särskilt med komplexa modeller. 
• Att lägga till fler features kan artificiellt höja R², så ett högre värde är inte nödvändigtvis bättre.
• För multipel regression, använd justerat R², som tar hänsyn till antalet prediktorer och undviker missvisande förbättringar från onödiga variabler.

Att utvärdera modellens prestanda med determinationskoefficienten är enkelt med scikit-learn.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

Andra vanliga mått är medelkvadratfelet (MSE) och roten ur medelkvadratfelet (RMSE). Dessa mått mäter hur långt en modells prediktioner avviker från de faktiska värdena.

MSE beräknar den genomsnittliga kvadrerade skillnaden mellan faktiska och förutsagda värden: 

för det totala antalet observationer n. Eftersom felen kvadreras innan medelvärdet tas straffas större fel hårdare än mindre, vilket gör MSE känslig för avvikare. Ett lägre MSE indikerar en bättre modellpassning.

För att hantera detta används RMSE, som helt enkelt är kvadratroten av MSE. Eftersom RMSE har samma enheter som målvariabeln ger den ett mer tolkbart mått på hur mycket prediktionerna i genomsnitt missar.

Att beräkna MSE och RMSE är enkelt med scikit-learn.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Arbeta med multipel linjär regression i scikit-learn

Låt oss köra modellen igen med alla tillgängliga features, inte bara genomsnittligt antal rum. Förväntar du dig bättre eller sämre resultat?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

Vi ser att resultaten är betydligt bättre än när vi bara använde en feature. Detta väcker dock frågan om vi behöver alla features. Är vissa mer relevanta än andra? Att välja de mest relevanta features från datasetet kallas feature selection.

Feature selection är viktigt av flera skäl.

• Minskar överanpassning. Färre features innebär mindre komplexitet och minskar risken för överanpassning.
• Förbättrar noggrannhet. Att ta bort irrelevanta eller redundanta features hjälper modellen att fokusera på meningsfulla mönster.
• Ökar tolkningsbarheten. Gör modeller lättare att förstå genom att lyfta fram de viktigaste faktorerna.
• Snabbar upp träningen. Färre features minskar beräkningstid och minnesanvändning.

När flera features är starkt korrelerade är de redundanta, vilket innebär att de i praktiken ger modellen samma information. Denna situation kallas multikollinearitet. Även om multikollinearitet inte alltid påverkar prediktionsnoggrannheten komplicerar den feature selection och tolkning, särskilt i linjär regression och närliggande modeller.

Variance Inflation Factor (VIF) är ett mått som används för att upptäcka multikollinearitet bland prediktorer. För varje prediktor beräknas VIF som: 

där R_i² är R²-värdet som erhålls när prediktorn X_i regresseras mot alla andra prediktorer i modellen. Ett högre VIF betyder att prediktorn är starkt korrelerad med andra variabler.

• VIF = 1: ingen multikollinearitet (idealt scenario).
• VIF < 5: låg till måttlig multikollinearitet (oftast acceptabelt).
• VIF > 5: hög multikollinearitet (överväg att ta bort eller kombinera korrelerade variabler).
• VIF > 10: allvarlig multikollinearitet (tyder starkt på variabelredundans).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Låt oss ta bort AveBedrms från modellen.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

Resultaten är (marginellt) förbättrade.

Hämta insikter ur modellen

Att bygga en regressionsmodell är bara första steget; att förstå dess utdata är lika viktigt. Genom att analysera modellens koefficienter kan vi avgöra vilka features som har störst påverkan på prediktionerna.

Förstå regressionskoefficienter

När en linjär regressionsmodell har tränats kan koefficienterna nås via model.coef_. Skärningen nås via model.intercept_.

När en linjär regressionsmodell har tränats med LinearRegression() kan koefficienterna nås via model.coef_ och skärningen nås via model.intercept_.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Sammanfatta modellresultat

Eftersom Scikit-Learn inte erbjuder en inbyggd metod som summary() i Statsmodels kan vi manuellt extrahera och visualisera varje features betydelse med regressionskoefficienter. Features med större absoluta koefficienter har starkare påverkan på målvariabeln. Se följande kod.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Diagram över featurebetydelse baserat på koefficientvärden

Nu visualiserar vi residualer och regressionspassningen.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Diagram för att visualisera residualer och regressionspassning

Fördelningen av residualer (vänstra diagrammet) bör vara centrerad kring noll, vilket indikerar att felen är slumpmässigt fördelade. Om residualerna följer en normalfördelning passar modellen väl, men om det finns skevhet eller en trend kan det tyda på systematiska fel. Regressionspassningen (högra diagrammet) jämför faktiska kontra förutsagda värden, där den röda streckade linjen representerar en perfekt passning. Om punkterna ligger nära linjen är prediktionerna träffsäkra, men om ett mönster (t.ex. en kurva) syns kan sambandet vara icke-linjärt. 

Dessa visualiseringar hjälper till att diagnostisera över- eller underanpassning, avslöjar mönster i residualerna som tyder på saknade samband och ger en tydlig bedömning av modellens effektivitet.

Tillämpningar i verkligheten

Linjär regression används brett i många branscher för prediktion och beslutsfattande. Inom fastigheter uppskattar den huspriser baserat på faktorer som storlek och läge. 

Försäljning och marknadsföring använder den för efterfrågeprognoser och budgetoptimering, medan vården använder den för riskbedömning av sjukdomar. Inom finans hjälper den till med aktieprisprognoser och kreditbedömning, och inom tillverkning bidrar den till kvalitetskontroll och felprediktion. 

När du bör använda linjär regression

• Features och målvariabeln har ett linjärt samband.
• Tolkningsbarhet och enkelhet väger tyngre än komplex modellering.
• Datan kräver minimal feature engineering.

När du inte bör använda linjär regression

• Sambandet mellan mål och features är komplext och icke-linjärt.
• Datan är starkt korrelerad.
• Datan innehåller avvikare som inte kan tas bort. I sådana fall kan du behöva tillämpa datatransformationer eller använda strategier för att mildra deras påverkan.

Slutsats

Linjär regression är fortfarande en av de mest grundläggande och mest använda teknikerna inom maskininlärning och statistisk modellering. Trots sin enkelhet är den ett kraftfullt verktyg för att förstå samband mellan variabler och göra prediktioner i olika verkliga tillämpningar.

Här är de viktigaste lärdomarna från handledningen:

• Mångsidiga tillämpningar. Linjär regression ger värdefulla insikter i många branscher och problemområden.
• Tolkningsbar. Till skillnad från komplexa black box-modeller erbjuder linjär regression tydliga tolkningar baserade på koefficienter, vilket gör den lätt att förklara.
• Feature selection. Att välja features på rätt sätt och hantera multikollinearitet säkerställer att modeller förblir träffsäkra, stabila och pålitliga. 

För mer information om stränginterpolering i Python, kolla in DataCamps resurser.

• Simple Linear Regression: Everything You Need to Know - Tutorial
• How to Do Linear Regression in R - Tutorial
• Linear Regression in Excel: A Comprehensive Guide For Beginners - Tutorial
• Introduction to Regression in R - Course
• Supervised Learning with scikit-learn - Course
• Scikit-Learn Cheat Sheet: Python Machine Learning - Cheat Sheet
• Understanding Logistic Regression in Python - Tutorial