Regresie liniară în Sklearn: Ghid complet cu exemple

Regresia liniară este o tehnică fundamentală în statistică și în învățarea automată, folosită pentru a modela relația dintre variabile. Pe scurt, ne permite să prezicem un rezultat pe baza unuia sau mai multor factori care îl influențează. Este folosită pe scară largă în stabilirea prețurilor imobiliare, prognoza vânzărilor, evaluarea riscurilor și multe alte domenii.

În acest tutorial, vom explora regresia liniară în scikit-learn: cum funcționează, de ce este utilă și cum o implementezi folosind scikit-learn. La final, vei putea construi și evalua un model de regresie liniară pentru a face predicții bazate pe date.

Diagrama scatter: Prețul casei versus Numărul de camere

Regresia liniară și învățarea automată

Dincolo de utilitatea imediată în determinarea prețurilor locuințelor, regresia liniară joacă un rol important în învățarea automată.

• Este un model de bază pentru a înțelege tehnici mai avansate precum regresia logistică, rețelele neuronale și mașinile cu vectori de suport.
• Se antrenează rapid, fiind ideală pentru prototipare rapidă.
• Servește și ca linie de bază pentru comparație. Dacă modelele mai avansate nu o depășesc semnificativ, complexitatea lor suplimentară poate să nu fie justificată.
• Spre deosebire de unele tehnici (cum ar fi deep learning), este ușor de interpretat.
• Poate ajuta la selecția de caracteristici, identificând cei mai utili predictori.

În ciuda simplității, regresia liniară rămâne un instrument indispensabil în învățarea automată datorită eficienței, interpretabilității și versatilității ei.

Regresia liniară și biblioteca scikit-learn

Biblioteca scikit-learn face ușoară implementarea regresiei liniare. Această bibliotecă are multe avantaje.

• Are o interfață consecventă. Codul necesar pentru a implementa diferiți algoritmi ML este similar.
• Codul este simplu, matematica complexă și detaliile de implementare fiind ascunse. De exemplu, pentru a potrivi un model pe datele de antrenare, folosești linia model.fit(X_train, y_train).
• Oferă acces facil la coeficienții modelului.
• Oferă metrici încorporate pentru evaluarea performanței modelului.
• Este ușor să integrezi regresia liniară (sau orice alt algoritm ML) cu pași de preprocesare, precum scalare și selecție de caracteristici, folosind Pipeline.

Dacă ești nou în scikit-learn, poți consulta cursul nostru Machine Learning cu scikit-learn pentru o introducere practică în biblioteca Python. 

Înțelegerea regresiei liniare

După cum am văzut, în regresia liniară simplă, datele sunt modelate folosind o „linie de cea mai bună potrivire”. Formula acestei linii este: 

unde m este panta liniei și b este ordonata la origine.

„Regresia liniară multiplă” generalizează cazul cu un predictor la mai mulți predictori (numărul de camere, apropierea de ocean, venitul median al cartierului). Formula este generalizată astfel: 

unde fiecare x_i este o variabilă independentă, iar b_i este coeficientul ei. În trei dimensiuni, linia este generalizată la un plan. În dimensiuni mai mari, planul devine un „hiperplan”.

Cum interpretăm coeficienții și interceptul? Interceptul este valoarea prezisă a lui y când toate variabilele independente sunt 0, sau, altfel spus, valoarea de bază a variabilei dependente când nu există contribuție din partea predictorilor. Fiecare coeficient b_i reprezintă schimbarea variabilei dependente y pentru o schimbare de o unitate în x_i, menținând toate celelalte variabile independente constante.

Configurarea mediului

Instalarea scikit-learn este ușoară. Folosește comanda pip install scikit-learn. Dacă vrei să instalezi o versiune specifică, de exemplu 1.2.2, modifică comanda pentru a include versiunea: pip install scikit-learn==1.2.2. Dacă folosești Anaconda, scikit-learn ar trebui să fie deja instalat. Dacă totuși ai nevoie să îl instalezi în distribuția Anaconda, folosește comanda conda install scikit-learn.

Câteva biblioteci sunt necesare sau recomandate când folosești scikit-learn. Biblioteca numpy este necesară pentru stocarea caracteristicilor și etichetelor. Biblioteca pandas este recomandată pentru încărcarea, preprocesarea și explorarea seturilor de date. 

Dacă folosești scikit-learn, cel mai probabil folosești deja pandas pentru pregătirea datelor. Pentru a reprezenta grafic rezultatele, probabil vei folosi matplotlib sau seaborn sau ambele. Oricare dintre aceste biblioteci poate fi instalată folosind pip install, similar exemplului de mai sus. Poți chiar instala mai multe biblioteci cu o singură comandă:

pip install scikit-learn numpy pandas matplotlib seaborn.

Implementarea regresiei liniare în sklearn

Înainte să încărcăm setul de date, hai să importăm „suspecții de serviciu”.

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

Încărcarea setului de date

Să folosim binecunoscutul set de date despre locuințele din California.

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


housing = fetch_california_housing()

Pregătirea datelor

Să împărțim datele în seturi de antrenare și testare. Importăm metoda train_test_split() din sklearn.model_selection, apoi o apelăm, specificând procentul setului de test și un random_state. Vom folosi și regresie liniară simplă, utilizând caracteristica corespunzătoare numărului mediu de camere.

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

Acum că am împărțit datele în seturi de test și antrenare, să standardizăm caracteristicile. Acest proces asigură că toate variabilele sunt pe aceeași scară, ceea ce poate îmbunătăți performanța modelului și stabilitatea numerică.

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

În acest cod, StandardScaler este un instrument de preprocesare a datelor folosit pentru a elimina media și a scala caracteristicile la varianță unitară. Acest lucru ajută la prevenirea dominării modelului de către unele caracteristici din cauza diferențelor de scară.

Scalerul este ajustat pe datele de antrenare folosind metoda fit_transform(). Datele de test sunt apoi transformate separat folosind metoda transform() pentru a asigura scalarea cu aceiași factori ca datele de antrenare, prevenind scurgerile de informație.

Antrenarea modelului de regresie liniară

Pentru a crea un model de regresie liniară, importă LinearRegression() din sklearn.linear_model. Apeleaz-o și atribuie-o unei variabile.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Potrivirea modelului cu datele de antrenare este directă.

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

Realizarea de predicții

Acum că ne-am antrenat modelul, facem predicții pe setul de test.

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

Evaluarea performanței modelului

Acum că am făcut predicții pe setul de test, trebuie să știm cât de bine se potrivesc cu realitatea. Există mai multe metrici pentru evaluarea performanței unui algoritm de regresie. Unele dintre cele mai comune sunt coeficientul de determinare (R²), eroarea pătratică medie (MSE) și rădăcina erorii pătratice medii (RMSE).

Coeficientul de determinare, notat R², măsoară cât de bine explică un model de regresie variabilitatea variabilei țintă. Cu alte cuvinte, cuantifică cât din variabilitatea variabilei țintă este explicată de predictori, cunoscut ca „bunătatea potrivirii”.

Pentru a înțelege mai bine, să privim formula:

unde yactual sunt valorile reale ale variabilei țintă, ypredicted sunt valorile prezise de model, iar ȳ este media valorilor reale. Această formulă ne ajută să înțelegem câtă varianță a variabilei țintă este explicată de model. Numitorul reprezintă varianța totală din date, iar numărătorul reprezintă varianța neexplicată după aplicarea modelului de regresie. Raportul indică, așadar, procentul de varianță explicat de model.

Cum interpretăm R²?

• R² = 1: modelul explică perfect toată varianța variabilei țintă. 
• R² = 0: modelul nu explică deloc varianța; predicțiile nu sunt mai bune decât simpla utilizare a mediei. 
• R² < 0: modelul performează mai prost decât folosirea mediei, indicând o potrivire slabă.

Câteva aspecte cheie de reținut.

• Un R² mai mare nu este întotdeauna mai bun. Un R² ridicat poate indica supraînvățare, mai ales la modele complexe. 
• Adăugarea mai multor caracteristici poate crește artificial R², deci o valoare mai mare nu este neapărat mai bună.
• Pentru regresie multiplă, folosește R² ajustat, care ține cont de numărul de predictori și evită îmbunătățiri înșelătoare din variabile inutile.

Evaluarea performanței modelului folosind coeficientul de determinare este ușoară cu 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

Alte metrici utilizate frecvent sunt eroarea pătratică medie (MSE) și rădăcina erorii pătratice medii (RMSE). Aceste metrici măsoară cât de mult se abat predicțiile modelului de la valorile reale.

MSE calculează diferența pătratică medie dintre valorile reale și cele prezise: 

pentru numărul total de observații n. Deoarece erorile sunt pătrate înainte de mediere, erorile mai mari sunt penalizate mai puternic decât cele mici, ceea ce face ca MSE să fie sensibil la valori aberante. Un MSE mai mic indică o potrivire mai bună a modelului.

Pentru a aborda aceste probleme, se folosește RMSE, care este pur și simplu rădăcina pătrată a MSE. Deoarece RMSE este în aceleași unități ca variabila țintă, oferă o măsură mai ușor de interpretat a cât de mult, în medie, se abat predicțiile.

Calcularea MSE și RMSE este ușoară cu 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

Lucrul cu regresia liniară multiplă în scikit-learn

Să rerulăm modelul folosind toate caracteristicile disponibile, nu doar numărul mediu de camere. Te aștepți la rezultate mai bune sau mai slabe?

# 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

Vedem că rezultatele sunt considerabil mai bune decât atunci când am folosit o singură caracteristică. Totuși, apare întrebarea dacă avem nevoie de toate caracteristicile. Sunt unele mai relevante decât altele? Alegerea celor mai relevante caracteristici din setul de date este cunoscută drept selecție de caracteristici.

Selecția de caracteristici este importantă din mai multe motive.

• Reduce supraînvățarea. Mai puține caracteristici înseamnă mai puțină complexitate, reducând riscul de supraînvățare.
• Îmbunătățește acuratețea. Eliminarea caracteristicilor irelevante sau redundante ajută modelul să se concentreze pe tiparele semnificative.
• Crește interpretabilitatea. Face modelele mai ușor de înțeles, evidențiind cei mai importanți factori.
• Accelerează antrenarea. Reducerea numărului de caracteristici scade timpul de calcul și utilizarea memoriei.

Când mai multe caracteristici sunt puternic corelate, ele sunt redundante, adică oferă practic aceeași informație modelului. Această situație este denumită multicoliniaritate. Deși multicoliniaritatea nu afectează întotdeauna acuratețea modelelor predictive, complică selecția caracteristicilor și interpretarea, în special în regresia liniară și modelele înrudite.

Variance Inflation Factor (VIF) este o metrică folosită pentru a detecta multicoliniaritatea dintre predictori. Pentru fiecare predictor, VIF se calculează astfel: 

unde R_i² este valoarea R² obținută când predictorul X_i este regresat pe toți ceilalți predictori din model. Un VIF mai mare înseamnă că predictorul este puternic corelat cu alte variabile.

• VIF = 1: fără multicoliniaritate (scenariul ideal).
• VIF < 5: multicoliniaritate scăzută spre moderată (în general acceptabilă).
• VIF > 5: multicoliniaritate ridicată (ia în considerare eliminarea sau combinarea variabilelor corelate).
• VIF > 10: multicoliniaritate severă (sugerează puternic redundanța variabilelor).

# 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

Să eliminăm AveBedrms din model.

# 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

Rezultatele sunt (ușor) îmbunătățite.

Extrage insighturi din model

Construirea unui model de regresie este doar primul pas; la fel de important este să-i înțelegi rezultatele. Analizând coeficienții modelului, poți determina care caracteristici au cel mai mare impact asupra predicțiilor.

Înțelegerea coeficienților de regresie

După ce un model de regresie liniară este antrenat, coeficienții pot fi accesați cu model.coef_. Interceptul poate fi accesat cu model.intercept_.

După ce un model de regresie liniară este antrenat folosind LinearRegression(), coeficienții pot fi accesați cu model.coef_, iar interceptul poate fi accesat cu 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

Rezumatul rezultatelor modelului

Deoarece Scikit-Learn nu oferă o metodă summary() încorporată ca Statsmodels, putem extrage manual și vizualiza importanța fiecărei caracteristici folosind coeficienții de regresie. Caracteristicile cu coeficienți absoluți mai mari au un impact mai puternic asupra variabilei țintă. Ia în considerare codul următor.

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

Grafic al importanței caracteristicilor pe baza valorilor coeficienților

Acum, să vizualizăm reziduurile și potrivirea regresiei.

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

Grafice pentru a vizualiza reziduurile și potrivirea regresiei

Distribuția reziduurilor (graficul din stânga) ar trebui să fie centrată în jurul valorii zero, indicând că erorile sunt distribuite aleator. Dacă reziduurile urmează o distribuție normală, modelul se potrivește bine, dar dacă apare asimetrie sau un trend, poate sugera erori sistematice. Potrivirea regresiei (graficul din dreapta) compară valorile reale cu cele prezise, iar linia întreruptă roșie reprezintă o potrivire perfectă. Dacă punctele urmează îndeaproape linia, predicțiile sunt precise, dar dacă apare un tipar (de exemplu, o curbă), relația ar putea să nu fie cu adevărat liniară. 

Aceste vizualizări ajută la diagnosticarea supraînvățării sau sub-învățării, dezvăluie tipare în reziduuri care sugerează relații lipsă și oferă o evaluare clară a eficacității modelului.

Aplicații din lumea reală

Regresia liniară este folosită pe scară largă în industrii pentru predicție și luarea deciziilor. În imobiliare, estimează prețurile locuințelor pe baza unor factori precum mărimea și locația. 

Vânzările și marketingul o folosesc pentru prognoza cererii și optimizarea bugetelor, în timp ce sănătatea o aplică în evaluarea riscului de boală. În finanțe, ajută la predicția prețului acțiunilor și la scorarea creditelor, iar în producție, ajută la controlul calității și predicția defecțiunilor. 

Când să folosești regresia liniară

• Caracteristicile și variabila țintă au o relație liniară.
• Interpretabilitatea și simplitatea contează mai mult decât un modelaj complex.
• Datele necesită un minim de inginerie a caracteristicilor.

Când să nu folosești regresia liniară

• Relația dintre țintă și caracteristici este complexă și neliniară.
• Datele sunt puternic corelate.
• Datele conțin valori aberante care nu pot fi eliminate. În acest caz, poate fi nevoie să aplici transformări ale datelor sau să folosești strategii pentru a le atenua impactul.

Concluzie

Regresia liniară rămâne una dintre cele mai fundamentale și mai utilizate tehnici în învățarea automată și modelarea statistică. În ciuda simplității, este un instrument puternic pentru a înțelege relațiile dintre variabile și pentru a face predicții în numeroase aplicații reale.

Iată ideile principale din tutorial:

• Aplicații versatile. Regresia liniară oferă insighturi valoroase în multiple industrii și tipuri de probleme.
• Interpretabilă. Spre deosebire de modelele „cutie neagră” complexe, regresia liniară oferă interpretări clare bazate pe coeficienți, fiind ușor de explicat.
• Selecția caracteristicilor. Alegerea corectă a caracteristicilor și abordarea multicoliniarității asigură că modelele rămân precise, stabile și de încredere. 

Pentru informații suplimentare despre interpolarea șirurilor în Python, consultă resursele DataCamp.

• Regresie liniară simplă: Tot ce trebuie să știi - Tutorial
• Cum să faci regresie liniară în R - Tutorial
• Regresie liniară în Excel: Ghid cuprinzător pentru începători - Tutorial
• Introducere în regresie în R - Curs
• Învățare supervizată cu scikit-learn - Curs
• Scikit-Learn Cheat Sheet: Machine Learning în Python - Foaie de parcurs
• Înțelegerea regresiei logistice în Python - Tutorial