Wieloraka regresja liniowa i ważność cech
Rozszerz model o wiele cech wejściowych, interpretuj każdy współczynnik jako miarę ważności cechy i oceniaj model za pomocą R-squared.
Wieloraka regresja liniowa i ważność cech to bezpłatna lekcja Machine Learning Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Machine Learning Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Poza pojedynczą cechę
Rzeczywiste problemy predykcyjne niemal zawsze obejmują wiele istotnych danych wejściowych. Cena domu zależy od jego powierzchni, liczby sypialni, lokalizacji, wieku i dziesiątek innych czynników. Regresja liniowa z wieloma zmiennymi rozszerza prostą z jedną cechą, aby jednocześnie wykorzystywać wszystkie dostępne cechy:
ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b
Każda cecha otrzymuje własną wagę, a model uczy się wszystkich wag jednocześnie, minimalizując MSE. Dodanie większej liczby istotnych cech niemal zawsze poprawia dokładność predykcji — o ile cechy te rzeczywiście zawierają informacje o zmiennej docelowej.
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())Trenowanie z wieloma cechami
Interfejs API scikit-learn jest identyczny dla jednej cechy i dla stu cech — wystarczy przekazać pełną macierz cech. Model automatycznie dopasowuje po jednym współczynniku do każdej kolumny X.
W przypadku wielu cech wartość R² zazwyczaj rośnie w porównaniu z modelem wykorzystującym jedną cechę, ponieważ każda dodatkowa informacyjna cecha dostarcza modelowi więcej użytecznych sygnałów. Jednak dodawanie nieistotnych lub zaszumionych cech może faktycznie pogorszyć wydajność przez wprowadzenie nadmiernego dopasowania, szczególnie w przypadku małych zbiorów danych.
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}')Sprawdzanie współczynników
Po dopasowaniu modelu z wieloma cechami model.coef_ jest tablicą zawierającą po jednej wartości dla każdej cechy. Każda wartość oznacza przewidywaną zmianę y przy wzroście danej cechy o jedną jednostkę, przy założeniu stałości wszystkich pozostałych cech.
Na przykład współczynnik 150 dla sqft oznacza, że przy stałej liczbie sypialni, wieku i wszystkich pozostałych cech, przewiduje się wzrost ceny o 150 USD za każdy dodatkowy stóp kwadratowy. Taka interpretacja efektu cząstkowego sprawia, że regresja liniowa jest tak przydatna do wyjaśniania, które czynniki wpływają na predykcję.
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}')Dlaczego surowe współczynniki mogą wprowadzać w błąd
Surowych współczynników nie można bezpośrednio porównywać, gdy cechy mają różne jednostki i skale. W modelu cen domów sqft przyjmuje wartości od 600 do 4000, a bathrooms od 1 do 5. Współczynnik 150 dla sqft i 8000 dla bedrooms nie oznacza, że bedrooms jest 53 razy ważniejsze — oznacza, że zmiana bedrooms o jedną jednostkę (czyli duża zmiana) ma 53 razy większy wpływ niż zmiana sqft o jedną jednostkę (czyli mała zmiana).
Aby uczciwie porównać znaczenie cech, należy najpierw standaryzować wszystkie cechy do tej samej skali (średnia równa zero, wariancja równa jeden). Wtedy współczynniki odzwierciedlają wpływ zmiany każdej cechy o jedno odchylenie standardowe, dzięki czemu można je porównywać między cechami.
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))Wykres słupkowy znaczenia cech
Wizualizacja standaryzowanych współczynników w postaci wykresu słupkowego daje interesariuszom intuicyjny obraz tego, które cechy wpływają na predykcje modelu. Dodatnie słupki zwiększają predykcję, a ujemne ją zmniejszają. Im dłuższy słupek, tym większy wpływ zmiany danej cechy o jedno odchylenie standardowe.
Ten wykres jest jednym z najbardziej przekonujących narzędzi do komunikowania działania modelu odbiorcom nietechnicznym. Odpowiada na pytanie „co ma znaczenie?” za pomocą jednego, łatwego do odczytania wykresu.
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-kwadrat i skorygowany R-kwadrat
Zwykłe R² zawsze rośnie (lub pozostaje bez zmian) po dodaniu kolejnych cech, nawet jeśli są one losowym szumem. Sprawia to, że jest mylącą metryką przy wyborze modeli różniących się liczbą cech.
Skorygowane R² koryguje ten problem, nakładając karę za każdą dodatkową cechę: Adj R² = 1 - (1-R²)(n-1)/(n-p-1), gdzie n oznacza liczbę próbek, a p liczbę cech. Jeśli dodana cecha nie poprawia modelu na tyle, aby uzasadnić jego większą złożoność, skorygowane R² maleje. Skorygowanego R² należy używać przy porównywaniu modeli o różnej liczbie cech.
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 complexityWspółliniowość: skorelowane cechy
Współliniowość występuje, gdy co najmniej dwie cechy są ze sobą silnie skorelowane. Na przykład sqft i number_of_rooms często zmieniają się razem — większe domy mają więcej pomieszczeń. Gdy cechy są silnie skorelowane, model nie może wiarygodnie oszacować poszczególnych współczynników, ponieważ nie potrafi rozróżnić, która cecha rzeczywiście odpowiada za wpływ na y.
Objawy obejmują: współczynniki, które zmieniają się znacząco po dodaniu lub usunięciu jednej cechy, bardzo duże wartości współczynników o przeciwnych znakach albo wysokie R² przy dużych błędach standardowych wszystkich współczynników. Współczynnik inflacji wariancji (VIF) jest standardową metodą diagnostyczną współliniowości.
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)Selekcja cech: dodawanie i usuwanie cech
Nie wszystkie cechy poprawiają wydajność modelu. Dodawanie nieistotnych cech zwiększa złożoność i może pogorszyć zdolność do generalizacji. Metodyczne podejście do selekcji cech polega na porównywaniu modeli z różnymi podzbiorami cech za pomocą skorygowanego R² obliczanego w walidacji krzyżowej.
Iteracyjna selekcja w przód dodaje po jednej cesze, zachowując ją tylko wtedy, gdy poprawia wynik walidacji. Rekurencyjna eliminacja cech (RFE) iteracyjnie usuwa najmniej istotną cechę. Scikit-learn udostępnia oba podejścia.
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)Predykcja dla nowych domów
Gdy mają już Państwo wytrenowany model wykorzystujący wiele cech, wykonywanie predykcji dla nowych danych jest proste: należy utworzyć DataFrame lub tablicę z tymi samymi kolumnami cech, w tej samej kolejności, a następnie wywołać model.predict(). Model zwraca jedną przewidywaną cenę dla każdego wiersza.
Jeśli użyli Państwo Pipeline ze skalowaniem, należy przekazać dane surowe (nieskalowane) — potok automatycznie zastosuje tę samą transformację skalowania, która została dopasowana na danych treningowych. To kolejny powód, dla którego Pipeline to profesjonalny sposób pracy.
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}')Cechy wielomianowe dla zależności nieliniowych
Regresja liniowa jest ograniczona do zależności liniowych, ale wzorce nieliniowe można modelować, konstruując cechy wielomianowe. PolynomialFeatures w scikit-learn automatycznie tworzy składniki kwadratowe, sześcienne i interakcyjne na podstawie cech wejściowych.
Wielomian stopnia 2 dla dwóch cech x₁ i x₂ daje: x₁, x₂, x₁², x₂², x₁x₂. Model nadal jest liniowy względem swoich parametrów (dlatego wciąż jest to „regresja liniowa”), ale może dopasowywać krzywoliniowe zależności w oryginalnej przestrzeni cech. Aby wybrać optymalny stopień, należy użyć walidacji krzyżowej.
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}')Podsumowanie: współczynniki jako miara ważności cech
Najważniejsze wnioski dotyczące używania współczynników do pomiaru ważności cech:
- Surowe współczynniki zależą od skali cechy — współczynnika 150 dla sqft nie można bezpośrednio porównywać ze współczynnikiem 8000 dla bedrooms, chyba że obie cechy zostały wystandaryzowane.
- Współczynniki standaryzowane (z modelu wytrenowanego na przeskalowanych cechach) mierzą efekt zmiany każdej cechy o jedno odchylenie standardowe, dzięki czemu można je bezpośrednio porównywać.
- Duże wartości bezwzględne wskazują na cechy mające istotny wpływ, a małe wartości (bliskie zeru) — na cechy słabe lub redundantne.
- Zawsze należy potwierdzić, że cechy o dużej ważności mają przyczynową lub znaczącą zależność ze zmienną docelową, a nie tylko korelację statystyczną w danych treningowych.
Szybki test
Sprawdź swoją wiedzę na temat zagadnień uczenia maszynowego w Pythonie przedstawionych w tej lekcji.
Podsumowanie lekcji
W tej lekcji nauczyli się Państwo, że: regresja liniowa wieloraka przypisuje każdej cesze jedną wagę w równaniu ŷ = w₁x₁ + ... + wₙxₙ + b, przed porównaniem ważności cech o różnych skalach należy wystandaryzować surowe współczynniki, a skorygowany R² uwzględnia karę za dodawanie cech, aby zapobiegać przeuczeniu podczas wyboru modelu. W następnej części przejdziemy od przewidywania liczb do przewidywania kategorii za pomocą regresji logistycznej i klasyfikacji opartej na progach.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 30
- Lekcje
- 120
Często zadawane pytania
Czy lekcja „Wieloraka regresja liniowa i ważność cech” jest bezpłatna?
Tak — pełny tekst „Wieloraka regresja liniowa i ważność cech” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Machine Learning Academy, przejdź na CoddyKit PRO. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Wieloraka regresja liniowa i ważność cech”?
Rozszerz model o wiele cech wejściowych, interpretuj każdy współczynnik jako miarę ważności cechy i oceniaj model za pomocą R-squared. Ćwiczysz Machine Learning Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Machine Learning Academy?
Nie wymagamy żadnego doświadczenia. Machine Learning Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Wieloraka regresja liniowa i ważność cech”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Machine Learning Academy?
Tak. Każda lekcja Machine Learning Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Równanie prostej: nachylenie, wyraz wolny i predykcje
- Funkcje kosztu i metoda najmniejszych kwadratów
- Trenowanie regresji liniowej za pomocą scikit-learn
- Wieloraka regresja liniowa i ważność cech