Sklearn Linear Regression: kompletny przewodnik z przykładami

Regresja liniowa to podstawowa technika w statystyce i uczeniu maszynowym, która pomaga modelować zależność między zmiennymi. Mówiąc prościej, pozwala przewidywać wynik na podstawie jednego lub więcej czynników wpływających. Jest szeroko stosowana w wycenie nieruchomości, prognozowaniu sprzedaży, ocenie ryzyka i wielu innych dziedzinach.

W tym samouczku przyjrzymy się regresji liniowej w scikit-learn: jak działa, dlaczego jest przydatna i jak ją zaimplementować. Na koniec będziesz w stanie zbudować i ocenić model regresji liniowej, by tworzyć prognozy oparte na danych.

Wykres punktowy: cena domu względem liczby pokoi

Regresja liniowa a uczenie maszynowe

Poza oczywistą przydatnością przy wycenie domów, regresja liniowa odgrywa ważną rolę w uczeniu maszynowym.

• To model bazowy pomagający zrozumieć bardziej zaawansowane techniki, takie jak regresja logistyczna, sieci neuronowe i maszyny wektorów nośnych.
• Trenuje się ją szybko, co jest idealne do szybkiego prototypowania.
• Służy jako punkt odniesienia. Jeśli bardziej złożone modele nie przewyższają jej wyraźnie, dodatkowa złożoność może nie mieć uzasadnienia.
• W przeciwieństwie do niektórych technik (np. deep learningu) jest łatwa do interpretacji.
• Może pomóc w selekcji cech, wskazując najistotniejsze predyktory.

Mimo prostoty, regresja liniowa pozostaje niezbędnym narzędziem w uczeniu maszynowym dzięki wydajności, interpretowalności i wszechstronności.

Regresja liniowa a biblioteka scikit-learn

Biblioteka scikit-learn ułatwia implementację regresji liniowej. Ma wiele zalet.

• Spójny interfejs. Kod potrzebny do zaimplementowania różnych algorytmów ML jest podobny.
• Prosty kod, a skomplikowana matematyka i szczegóły implementacyjne są ukryte. Na przykład, aby dopasować model do danych treningowych, wystarczy linia model.fit(X_train, y_train).
• Łatwy dostęp do współczynników modelu.
• Wbudowane metryki do oceny jakości modelu.
• Łatwa integracja regresji liniowej (lub dowolnego innego algorytmu ML) z krokami przetwarzania wstępnego, takimi jak skalowanie i selekcja cech, przy użyciu Pipeline.

Jeśli dopiero zaczynasz ze scikit-learn, sprawdź nasz kurs Machine Learning with scikit-learn, aby praktycznie poznać tę bibliotekę Pythona. 

Zrozumieć regresję liniową

Jak widzieliśmy, w prostej regresji liniowej dane są modelowane przy użyciu „linii najlepszego dopasowania”. Wzór tej linii to: 

gdzie m to nachylenie prostej, a b to wyraz wolny.

„Wieloraka regresja liniowa” uogólnia przypadek jednego predyktora na kilka predyktorów (liczba pokoi, odległość od oceanu, mediany dochodów w okolicy). Wzór uogólnia się do: 

gdzie każde x_i to zmienna niezależna, a odpowiadające jej b_i to współczynnik. W trzech wymiarach prosta uogólnia się do płaszczyzny. W wyższych wymiarach płaszczyzna staje się „hiperpłaszczyzną”.

Jak interpretować współczynniki i wyraz wolny? Wyraz wolny to przewidywana wartość y, gdy wszystkie zmienne niezależne są równe 0, innymi słowy to wartość bazowa zmiennej zależnej, gdy predyktory nie wnoszą wkładu. Każdy współczynnik b_i oznacza zmianę zmiennej zależnej y przy jednostkowej zmianie x_i, przy założeniu niezmienności pozostałych zmiennych niezależnych.

Przygotowanie środowiska

Instalacja scikit-learn jest prosta. Użyj polecenia pip install scikit-learn. Jeśli chcesz zainstalować konkretną wersję, np. 1.2.2, zmodyfikuj polecenie, dodając wersję: pip install scikit-learn==1.2.2. Jeśli używasz Anacondy, scikit-learn powinien być już zainstalowany. Jeśli mimo to musisz go doinstalować w dystrybucji Anaconda, użyj polecenia conda install scikit-learn.

Kilka bibliotek jest niezbędnych lub zalecanych przy pracy ze scikit-learn. Biblioteka numpy służy do przechowywania cech i etykiet. Biblioteka pandas jest zalecana do ładowania, przetwarzania i eksploracji zbiorów danych. 

Jeśli używasz scikit-learn, najpewniej korzystasz już z pandas do przygotowania danych. Do rysowania wykresów użyjesz zapewne matplotlib lub seaborn, albo obu. Każdą z tych bibliotek zainstalujesz przez pip, tak jak w przykładzie powyżej. Możesz też zainstalować kilka bibliotek jednym poleceniem:

pip install scikit-learn numpy pandas matplotlib seaborn.

Implementacja regresji liniowej w sklearn

Zanim załadujemy zbiór danych, zaimportujmy standardowy zestaw bibliotek.

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

Ładowanie zbioru danych

Użyjmy dobrze znanego zbioru danych o nieruchomościach w Kalifornii.

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


housing = fetch_california_housing()

Przygotowanie danych

Podzielmy dane na zbiory treningowy i testowy. Importujemy metodę train_test_split() z sklearn.model_selection, a następnie wywołujemy ją, określając procent danych testowych oraz random_state. Użyjemy też prostej regresji liniowej, wykorzystując cechę odpowiadającą średniej liczbie pokoi.

# 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)

Skoro mamy już podział na zbiory testowy i treningowy, ustandaryzujmy cechy. Ten proces zapewnia, że wszystkie zmienne są w tej samej skali, co może poprawić jakość modelu i stabilność numeryczną.

# 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)

W tym kodzie StandardScaler to narzędzie do przetwarzania danych, które usuwa średnią i skaluje cechy do wariancji jednostkowej. Pomaga to zapobiec dominacji niektórych cech w modelu z powodu różnic skali.

Skaler dopasowujemy do danych treningowych metodą fit_transform(). Dane testowe przekształcamy osobno metodą transform(), aby zapewnić skalowanie tymi samymi współczynnikami co w treningu i uniknąć wycieku danych.

Trenowanie modelu regresji liniowej

Aby utworzyć model regresji liniowej, zaimportuj LinearRegression() z sklearn.linear_model. Utwórz instancję i przypisz do zmiennej.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Dopasowanie modelu do danych treningowych jest proste.

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

Tworzenie prognoz

Skoro wytrenowaliśmy model, wykonajmy predykcje na zbiorze testowym.

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

Ocena jakości modelu

Skoro mamy prognozy na zbiorze testowym, musimy sprawdzić, jak dobrze zgadzają się z rzeczywistością. Istnieje kilka metryk do oceny algorytmów regresji. Do najczęstszych należą współczynnik determinacji (R²), średni błąd kwadratowy (MSE) i pierwiastek z średniego błędu kwadratowego (RMSE).

Współczynnik determinacji, oznaczany R², mierzy, jak dobrze model regresji wyjaśnia zmienność zmiennej docelowej. Innymi słowy, kwantyfikuje, jaka część zmienności zmiennej docelowej jest wyjaśniona przez predyktory, czyli dobroć dopasowania.

Aby lepiej to zrozumieć, spójrzmy na wzór:

gdzie yactual to rzeczywiste wartości zmiennej docelowej, ypredicted to wartości przewidziane przez model, a ȳ to średnia wartości rzeczywistych. Ten wzór pomaga zrozumieć, jaką część wariancji w zmiennej docelowej wyjaśnia model. Mianownik reprezentuje całkowitą wariancję w danych, a licznik — niewyjaśnioną wariancję po zastosowaniu modelu regresji. Iloraz daje więc odsetek wariancji wyjaśnianej przez model.

Jak interpretować R²?

• R² = 1: model idealnie wyjaśnia całą wariancję zmiennej docelowej. 
• R² = 0: model niczego nie wyjaśnia; predykcje nie są lepsze niż użycie średniej. 
• R² < 0: model wypada gorzej niż użycie średniej, co wskazuje na słabe dopasowanie.

Kilka istotnych uwag.

• Wyższe R² nie zawsze jest lepsze. Wysokie R² może oznaczać przeuczenie, zwłaszcza w złożonych modelach. 
• Dodawanie większej liczby cech może sztucznie zwiększać R², więc wyższa wartość nie musi być lepsza.
• W regresji wielorakiej używaj skorygowanego R², które uwzględnia liczbę predyktorów i unika mylących „popraw” od zbędnych zmiennych.

Ocena jakości modelu przy użyciu współczynnika determinacji jest prosta w 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

Inne często używane metryki to średni błąd kwadratowy (MSE) i pierwiastek z średniego błędu kwadratowego (RMSE). Metryki te mierzą, jak bardzo przewidywania modelu odbiegają od wartości rzeczywistych.

MSE oblicza średnią z kwadratów różnic między wartościami rzeczywistymi a przewidywanymi: 

dla całkowitej liczby obserwacji n. Ponieważ błędy są podnoszone do kwadratu przed uśrednieniem, większe błędy są karane mocniej niż mniejsze, co czyni MSE wrażliwym na wartości odstające. Niższy MSE oznacza lepsze dopasowanie.

Aby temu zaradzić, używa się RMSE, czyli pierwiastka z MSE. Ponieważ RMSE ma te same jednostki co zmienna docelowa, daje bardziej interpretowalną miarę przeciętnego odchylenia prognoz.

Obliczenie MSE i RMSE w scikit-learn jest proste.

# 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

Praca z regresją liniową wieloraką w scikit-learn

Uruchommy model ponownie, używając wszystkich dostępnych cech, nie tylko średniej liczby pokoi. Spodziewasz się lepszych czy gorszych wyników?

# 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

Widzimy, że wyniki są znacznie lepsze niż przy użyciu tylko jednej cechy. Pojawia się jednak pytanie, czy potrzebujemy wszystkich cech. Czy niektóre są bardziej istotne niż inne? Wybór najbardziej istotnych cech ze zbioru danych to selekcja cech.

Selekcja cech jest ważna z kilku powodów.

• Redukuje przeuczenie. Mniej cech to mniejsza złożoność i mniejsze ryzyko przeuczenia.
• Poprawia dokładność. Usunięcie nieistotnych lub redundantnych cech pomaga modelowi skupić się na istotnych wzorcach.
• Zwiększa interpretowalność. Ułatwia zrozumienie modelu, podkreślając najważniejsze czynniki.
• Przyspiesza trening. Mniej cech to krótszy czas obliczeń i mniejsze zużycie pamięci.

Gdy wiele cech jest silnie skorelowanych, są redundantne — dostarczają modelowi w zasadzie tych samych informacji. Taka sytuacja to współliniowość (multicollinearity). Choć nie zawsze pogarsza ona dokładność predykcji, utrudnia selekcję i interpretację cech, zwłaszcza w regresji liniowej i modelach pokrewnych.

Współczynnik inflacji wariancji (VIF) to metryka do wykrywania współliniowości między predyktorami. Dla każdego predyktora VIF oblicza się jako: 

gdzie R_i² to wartość R² uzyskana, gdy predyktor X_i jest regresowany względem wszystkich pozostałych predyktorów w modelu. Wyższy VIF oznacza silną korelację predyktora z innymi zmiennymi.

• VIF = 1: brak współliniowości (sytuacja idealna).
• VIF < 5: niska do umiarkowanej współliniowości (zwykle akceptowalna).
• VIF > 5: wysoka współliniowość (rozważ usunięcie lub połączenie skorelowanych zmiennych).
• VIF > 10: silna współliniowość (mocno sugeruje redundancję zmiennych).

# 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

Usuńmy AveBedrms z modelu.

# 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

Wyniki są (nieznacznie) lepsze.

Wydobywanie wniosków z modelu

Zbudowanie modelu regresji to dopiero pierwszy krok; równie ważne jest zrozumienie jego wyników. Analizując współczynniki modelu, możesz sprawdzić, które cechy mają największy wpływ na predykcje.

Zrozumieć współczynniki regresji

Po wytrenowaniu modelu regresji liniowej współczynniki są dostępne przez model.coef_. Wyraz wolny pobierzesz przez model.intercept_.

Po wytrenowaniu modelu regresji liniowej przy użyciu LinearRegression() współczynniki uzyskasz przez model.coef_, a wyraz wolny przez 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

Podsumowanie wyników modelu

Ponieważ Scikit-Learn nie oferuje wbudowanej metody summary() jak Statsmodels, możemy ręcznie wyciągnąć i zwizualizować ważność cech, korzystając ze współczynników regresji. Cechy o większych bezwzględnych wartościach współczynników mają silniejszy wpływ na zmienną docelową. Rozważ poniższy 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()

Wykres ważności cech na podstawie wartości współczynników

Teraz zwizualizujmy reszty i dopasowanie regresji.

# 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()

Wykresy do wizualizacji reszt i dopasowania regresji

Rozkład reszt (wykres po lewej) powinien być wyśrodkowany wokół zera, co wskazuje na losowy rozkład błędów. Jeśli reszty mają rozkład normalny, model dobrze się dopasowuje, ale jeśli widać skośność lub trend, może to sugerować błędy systematyczne. Dopasowanie regresji (wykres po prawej) porównuje wartości rzeczywiste i przewidywane, a czerwona przerywana linia reprezentuje idealne dopasowanie. Jeśli punkty ściśle podążają za linią, predykcje są trafne; jeśli pojawia się wzorzec (np. krzywa), relacja może nie być liniowa. 

Te wizualizacje pomagają diagnozować przeuczenie lub niedouczenie, ujawniają wzorce w resztach sugerujące brakujące zależności i dają jasną ocenę skuteczności modelu.

Zastosowania w praktyce

Regresja liniowa jest szeroko używana w różnych branżach do predykcji i podejmowania decyzji. W nieruchomościach szacuje ceny domów na podstawie takich czynników jak metraż i lokalizacja. 

Sprzedaż i marketing wykorzystują ją do prognozowania popytu i optymalizacji budżetów, a opieka zdrowotna — do oceny ryzyka chorób. W finansach pomaga w przewidywaniu cen akcji i ocenie kredytowej, a w produkcji — w kontroli jakości i przewidywaniu awarii. 

Kiedy używać regresji liniowej

• Między cechami a zmienną docelową zachodzi zależność liniowa.
• Interpretowalność i prostota są ważniejsze niż złożone modelowanie.
• Dane wymagają minimalnego inżynierowania cech.

Kiedy nie używać regresji liniowej

• Relacja między zmienną docelową a cechami jest złożona i nieliniowa.
• Dane są silnie skorelowane.
• Dane zawierają wartości odstające, których nie można usunąć. W takim przypadku możesz zastosować transformacje danych lub użyć strategii łagodzących ich wpływ.

Podsumowanie

Regresja liniowa pozostaje jedną z najbardziej fundamentalnych i najczęściej stosowanych technik w uczeniu maszynowym i modelowaniu statystycznym. Mimo prostoty jest potężnym narzędziem do zrozumienia zależności między zmiennymi i tworzenia prognoz w wielu praktycznych zastosowaniach.

Najważniejsze wnioski z tego samouczka:

• Wszechstronne zastosowania. Regresja liniowa dostarcza cennych wniosków w wielu branżach i typach problemów.
• Interpretowalność.  W przeciwieństwie do złożonych „czarnych skrzynek” regresja liniowa oferuje przejrzystą interpretację opartą na współczynnikach, co ułatwia wyjaśnianie.
• Selekcja cech. Właściwy dobór cech i adresowanie współliniowości zapewniają, że modele pozostają dokładne, stabilne i wiarygodne. 

Więcej informacji o interpolacji łańcuchów w Pythonie znajdziesz w zasobach DataCamp.

• Prosta regresja liniowa: wszystko, co musisz wiedzieć - Tutorial
• Jak przeprowadzić regresję liniową w R - Tutorial
• Regresja liniowa w Excelu: kompleksowy przewodnik dla początkujących - Tutorial
• Wprowadzenie do regresji w R - Kurs
• Uczenie nadzorowane ze scikit-learn - Kurs
• Scikit-Learn Cheat Sheet: Python Machine Learning - Cheat Sheet
• Zrozumieć regresję logistyczną w Pythonie - Tutorial