Multipel linjär regression och egenskapernas betydelse
Ni kommer att utöka modellen med flera indataegenskaper, tolka varje koefficient som egenskapens betydelse och utvärdera modellen med R-kvadrat.
Multipel linjär regression och egenskapernas betydelse är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 4 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.
Bortom en enda feature
Verkliga prediktionsproblem har nästan alltid flera relevanta indata. Huspriset beror på boyta, antal sovrum, läge, ålder och dussintals andra faktorer. Multipel linjär regression utökar linjen med en enda feature så att alla tillgängliga features används samtidigt:
ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b
Varje feature får sin egen vikt, och modellen lär sig alla vikter samtidigt genom att minimera MSE. Att lägga till fler relevanta features förbättrar nästan alltid prediktionens träffsäkerhet – så länge dessa features faktiskt innehåller information om målet.
import pandas as pd
import numpy as np
# Multi-feature housing dataset
np.random.seed(42)
n = 300
df = pd.DataFrame({
'sqft': np.random.randint(600, 4000, n),
'bedrooms': np.random.randint(1, 7, n),
'bathrooms': np.random.randint(1, 5, n),
'age': np.random.randint(1, 60, n),
'distance_to_center': np.random.uniform(1, 30, n)
})
df['price'] = (150 * df['sqft'] + 8000 * df['bedrooms']
- 300 * df['age'] - 5000 * df['distance_to_center']
+ 40000 + np.random.normal(0, 20000, n))
print(df.head())Träna med flera features
API:t i scikit-learn är identiskt för en feature eller hundra features – du skickar helt enkelt in hela featurematrisen. Modellen anpassar automatiskt en koefficient per kolumn i X.
Med flera features ökar R² vanligtvis jämfört med modellen med en enda feature, eftersom varje ytterligare informativ feature ger modellen mer signal att arbeta med. Att lägga till irrelevanta eller brusiga features kan däremot faktiskt försämra prestandan genom att orsaka överanpassning, särskilt på små dataset.
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
import pandas as pd
import numpy as np
# (df defined in previous scene)
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
X = df[features]
y = df['price']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f'Multi-feature R2: {r2_score(y_test, y_pred):.3f}')Inspektera koefficienterna
Efter att en modell med flera features har anpassats är model.coef_ en array med ett värde per feature. Varje värde är den förutsagda förändringen i y vid en ökning med en enhet i den feature-funktionen, under antagandet att alla andra features hålls konstanta.
En koefficient på 150 för sqft betyder till exempel följande: när antal sovrum, ålder och alla andra features hålls konstanta förutsägs ytterligare en kvadratfot öka priset med 150 dollar. Denna tolkning av partiell effekt är det som gör linjär regression så användbar för att förklara vilka faktorer som driver en förutsägelse.
import pandas as pd
from sklearn.linear_model import LinearRegression
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
# Create a readable coefficient table
coef_df = pd.DataFrame({
'Feature': features,
'Coefficient': model.coef_
}).sort_values('Coefficient', ascending=False)
print(coef_df.to_string(index=False))
print(f'\nIntercept: {model.intercept_:,.0f}')Varför råa koefficienter kan vara missvisande
Råa koefficienter är inte direkt jämförbara när features har olika enheter och skalor. I bostadsmodellen varierar sqft från 600 till 4000, medan bathrooms varierar från 1 till 5. En koefficient på 150 för sqft och 8000 för bedrooms betyder inte att bedrooms är 53 gånger viktigare – det betyder att en förändring med en enhet i bedrooms (en stor förändring) har 53 gånger så stor effekt som en förändring med en enhet i sqft (en liten förändring).
För att jämföra feature-vikt på ett rättvist sätt måste du först standardisera alla features till samma skala (medelvärde noll, varians ett). Då visar koefficienterna effekten av en förändring på en standardavvikelse i varje feature, vilket kan jämföras mellan features.
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
# Scale features to zero mean, unit variance
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train[features])
model_scaled = LinearRegression()
model_scaled.fit(X_train_scaled, y_train)
# Now coefficients ARE comparable
coef_df = pd.DataFrame({
'Feature': features,
'Standardised Coefficient': model_scaled.coef_
}).sort_values('Standardised Coefficient', key=abs, ascending=False)
print(coef_df.to_string(index=False))Stapeldiagram över feature-vikt
Genom att visualisera standardiserade koefficienter som ett stapeldiagram får intressenter en intuitiv bild av vilka features som driver modellens förutsägelser. Positiva staplar höjer förutsägelsen och negativa staplar sänker den. Ju längre stapeln är, desto större är effekten av en förändring på en standardavvikelse i den featuren.
Detta diagram är ett av de mest övertygande verktygen för att kommunicera modellens beteende till icke-tekniska målgrupper. Det besvarar frågan ”vad spelar roll?” i ett enda lättläst diagram.
import matplotlib.pyplot as plt
import numpy as np
feature_names = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
coeffs = model_scaled.coef_
colors = ['steelblue' if c > 0 else 'salmon' for c in coeffs]
plt.figure(figsize=(8, 5))
plt.barh(feature_names, coeffs, color=colors)
plt.axvline(x=0, color='black', linewidth=0.8)
plt.xlabel('Standardised Coefficient (impact per 1 std dev)')
plt.title('Feature Importance from Linear Regression')
plt.tight_layout()
plt.show()R-kvadrat och justerad R-kvadrat
Vanligt R² ökar alltid (eller förblir detsamma) när du lägger till fler features, även om dessa features bara består av slumpmässigt brus. Därför är det ett missvisande mått vid modellval med olika antal features.
Justerad R² korrigerar detta genom att införa en straffavgift för varje ytterligare feature: Adj R² = 1 - (1-R²)(n-1)/(n-p-1), där n är antalet sampel och p är antalet features. Om en tillagd feature inte förbättrar modellen tillräckligt för att motivera dess komplexitet minskar justerad R². Använd justerad R² när du jämför modeller med olika antal features.
from sklearn.metrics import r2_score
import numpy as np
def adjusted_r2(y_true, y_pred, n_features):
r2 = r2_score(y_true, y_pred)
n = len(y_true)
adj = 1 - (1 - r2) * (n - 1) / (n - n_features - 1)
return adj
y_pred_test = model.predict(X_test[features])
r2 = r2_score(y_test, y_pred_test)
adj_r2 = adjusted_r2(y_test, y_pred_test, n_features=len(features))
print(f'R2: {r2:.4f}')
print(f'Adjusted R2: {adj_r2:.4f}') # slightly lower, penalises complexityMultikollinearitet: korrelerade features
Multikollinearitet uppstår när två eller fler features är starkt korrelerade med varandra. Till exempel förändras sqft och number_of_rooms ofta tillsammans – större hus har fler rum. När features är starkt korrelerade kan modellen inte på ett tillförlitligt sätt uppskatta individuella koefficienter, eftersom den inte kan avgöra vilken feature som faktiskt ligger bakom effekten på y.
Symptom är bland annat koefficienter som förändras kraftigt när du lägger till eller tar bort en enda feature, mycket stora koefficientvärden med motsatta tecken eller högt R² samtidigt som alla koefficienter har stora standardfel. Variance Inflation Factor (VIF) är det etablerade diagnostiska måttet för multikollinearitet.
import pandas as pd
import numpy as np
# Detect multicollinearity via correlation matrix
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
corr = df[features].corr()
print('Feature correlation matrix:')
print(corr.round(2))
# High correlation (>0.7) between two features indicates multicollinearity
high_corr = (corr.abs() > 0.7) & (corr != 1.0)
print('\nHighly correlated pairs:')
print(high_corr)Featureselektion: lägga till och ta bort features
Alla features förbättrar inte modellens prestanda. Att lägga till irrelevanta features ökar komplexiteten och kan försämra generaliseringen. Ett disciplinerat tillvägagångssätt för featureselektion innebär att jämföra modeller med olika delmängder av features med hjälp av korsvaliderad justerad R².
Iterativ framåtriktad selektion lägger till en feature i taget och behåller den bara om den förbättrar valideringspoängen. Rekursiv featureeliminering (RFE) tar iterativt bort den minst viktiga featuren. Scikit-learn tillhandahåller båda metoderna.
from sklearn.feature_selection import RFE
from sklearn.linear_model import LinearRegression
import pandas as pd
import numpy as np
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
X_all = df[features].values
y_all = df['price'].values
# Keep the top 3 most informative features
rfe = RFE(estimator=LinearRegression(), n_features_to_select=3)
rfe.fit(X_all, y_all)
selected = [f for f, s in zip(features, rfe.support_) if s]
print('Selected features:', selected)Förutsäga priser på nya hus
När du har tränat en modell med flera egenskaper är det enkelt att göra förutsägelser på nya data: skapa en DataFrame eller array med samma egenskapskolumner i samma ordning och anropa model.predict(). Modellen returnerar ett förutsagt pris per rad.
Om du använde en Pipeline med en scaler ska du skicka in rådata (utan skalning) – pipelinen tillämpar automatiskt samma skalningstransformering som anpassades till träningsdata. Detta är ytterligare en anledning till att Pipelines är det professionella sättet att arbeta.
import pandas as pd
import numpy as np
# New houses to value
new_houses = pd.DataFrame({
'sqft': [1200, 2500, 800],
'bedrooms': [3, 4, 2],
'bathrooms': [2, 3, 1],
'age': [10, 5, 30],
'distance_to_center': [5.0, 12.0, 2.5]
})
features = ['sqft', 'bedrooms', 'bathrooms', 'age', 'distance_to_center']
predictions = model.predict(new_houses[features])
for i, (_, row) in enumerate(new_houses.iterrows()):
print(f'House {i+1}: {row["sqft"]} sqft, {row["bedrooms"]}bd -> ${predictions[i]:,.0f}')Polynomegenskaper för icke-linjära samband
Linjär regression är begränsad till linjära samband, men du kan modellera icke-linjära mönster genom att skapa polynomegenskaper. PolynomialFeatures i scikit-learn skapar automatiskt kvadrerade termer, kubiska termer och interaktionstermer från dina ursprungliga egenskaper.
Ett polynom av grad 2 med två egenskaper x₁ och x₂ ger: x₁, x₂, x₁², x₂², x₁x₂. Modellen är fortfarande linjär i sina parametrar (vilket är anledningen till att den fortfarande kallas ”linjär regression”), men den kan anpassa sig till böjda samband i det ursprungliga egenskapsrummet. Använd korsvalidering för att välja optimal grad.
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import r2_score
import numpy as np
np.random.seed(0)
X = np.random.uniform(0, 5, 100).reshape(-1, 1)
y = X.ravel()**2 + np.random.randn(100) * 2 # quadratic true relationship
# Compare linear vs degree-2 polynomial
for degree in [1, 2, 3]:
pipe = Pipeline([('poly', PolynomialFeatures(degree=degree)),
('model', LinearRegression())])
pipe.fit(X, y)
r2 = r2_score(y, pipe.predict(X))
print(f'Degree {degree} R2 (train): {r2:.3f}')Sammanfattning: koefficienter som mått på egenskapernas betydelse
Viktiga slutsatser om att använda koefficienter för att mäta egenskapernas betydelse:
- Råkoefficienter beror på egenskapernas skala – en koefficient på 150 för sqft kan inte direkt jämföras med 8000 för bedrooms om inte båda har standardiserats.
- Standardiserade koefficienter (från en modell som tränats på skalade egenskaper) mäter effekten av en förändring på en standardavvikelse i varje egenskap, vilket gör dem direkt jämförbara.
- Stora absolutbelopp anger inflytelserika egenskaper; små värden (nära noll) anger svaga eller redundanta egenskaper.
- Bekräfta alltid att egenskaper med hög betydelse har ett kausalt eller meningsfullt samband med målet, inte bara en statistisk korrelation i träningsdata.
Snabbtest
Testa dina kunskaper om begreppen inom Machine Learning med Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen lärde du dig att multipel linjär regression tilldelar en vikt per egenskap i ekvationen ŷ = w₁x₁ + ... + wₙxₙ + b, att råkoefficienter måste standardiseras innan betydelsen jämförs mellan egenskaper med olika skalor och att justerat R² bestraffar tillagda egenskaper för att förhindra överanpassning vid modellval. Nästa steg är att gå från att förutsäga tal till att förutsäga kategorier med logistisk regression och klassificering baserad på tröskelvärden.
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 ”Multipel linjär regression och egenskapernas betydelse” gratis?
Ja – hela texten till ”Multipel linjär regression och egenskapernas betydelse” 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 ”Multipel linjär regression och egenskapernas betydelse”?
Ni kommer att utöka modellen med flera indataegenskaper, tolka varje koefficient som egenskapens betydelse och utvärdera modellen med R-kvadrat. 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 4 av 4.
Hur lång tid tar lektionen ”Multipel linjär regression och egenskapernas betydelse”?
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