Referință rapidă

Ghid Rapid pentru API-ul Scikit-Learn și Fluxul de Lucru în Învățarea Automată

Ghid de referință pentru Scikit-Learn: arhitectură API unificată (Estimator, Transformer, Predictor), pregătirea datelor, ingineria caracteristicilor, modele supervizate și nesupervizate, validare încrucișată, metrici de evaluare și Pipeline-uri sigure.

· Publicat · Actualizat

Scikit-Learn (sklearn) este biblioteca open-source de bază din Python pentru modelare statistică și învățare automată clasică, construită peste NumPy, SciPy și Matplotlib. Principalul său avantaj arhitectural constă într-un model de proiectare strict unificat pe trei interfețe:

  • Estimator: Învață parametrii modelului din date prin fit(X, y).
  • Transformer: Preprocesează și proiectează caracteristicile prin transform(X) și fit_transform(X).
  • Predictor: Generează predicții pentru eșantioane noi prin predict(X), predict_proba(X) și score(X, y).

🔗 Ghiduri rapide corelate: Ghid Rapid NumPy · Ghid Rapid Pandas · Algoritmi de învățare supervizată · Metode de analiză a datelor · Ghid Rapid Python


1. Exemplu practic complet de pornire rapidă

Scriptul complet de mai jos ilustrează încărcarea unui set de date, împărțirea stratificată, scalarea caracteristicilor, antrenarea și evaluarea modelului:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# 1. Încărcarea datelor
iris = load_iris()
X, y = iris.data, iris.target

# 2. Împărțire stratificată între antrenare și test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3. Scalarea caracteristicilor (potrivire DOAR pe setul de antrenare pentru a preveni scurgerile de date)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Antrenarea modelului
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)

# 5. Predicție și evaluare
y_pred = knn.predict(X_test_scaled)
print(f"Acuratețe: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

2. Pregătirea și împărțirea datelor

Scikit-Learn solicită structuri numerice 2D: o matrice de caracteristici $X$ de forma (n_samples, n_features) și un vector țintă $y$ de forma (n_samples,). Sunt acceptate tablouri NumPy ndarray, matrice rare SciPy (scipy.sparse) și DataFrame/Series din Pandas.

2.1 Seturi de date integrate și sintetice

from sklearn import datasets

# Seturi mici de date demonstrative (returnează obiect Bunch)
iris = datasets.load_iris()               # Clasificare multi-clasă
digits = datasets.load_digits()           # Imagini cu cifre scrise de mână 8x8
diabetes = datasets.load_diabetes()       # Set de referință pentru regresie
wine = datasets.load_wine()               # Analiză chimică a vinurilor cu 3 clase

# Seturi reale de date de referință (stocate local în cache)
housing = datasets.fetch_california_housing()

# Generare de date sintetice pentru testarea algoritmilor
X, y = datasets.make_classification(
    n_samples=1000, n_features=20, n_informative=15, n_classes=2, random_state=42
)
X_reg, y_reg = datasets.make_regression(n_samples=500, n_features=10, noise=0.1, random_state=42)
X_blob, y_blob = datasets.make_blobs(n_samples=300, centers=3, n_features=2, random_state=42)

2.2 Împărțirea setului de date (train_test_split)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.25,        # Proporția setului de test (implicit: 0.25)
    random_state=42,       # Seed fix pentru reproductibilitate
    shuffle=True,          # Amestecarea eșantioanelor înainte de împărțire
    stratify=y             # Recomandat în clasificare: păstrează proporția claselor
)

3. Ingineria caracteristicilor și preprocesare (sklearn.preprocessing & sklearn.impute)

Transformator Caz de utilizare Transformare matematică / Logică Parametri cheie
StandardScaler Standardizare Z-score a variabilelor numerice $z = \frac{x - \mu}{\sigma}$ (medie zero, varianță unitară) with_mean=True, with_std=True
MinMaxScaler Scalarea caracteristicilor într-un interval închis delimitat $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ feature_range=(0, 1)
RobustScaler Scalare robustă la valori aberante (outliers) Scalare bazată pe intervalul intercuartilic: $x' = \frac{x - Q_2}{Q_3 - Q_1}$ quantile_range=(25.0, 75.0)
Normalizer Normalizare pe rânduri pentru fiecare eșantion Scalează fiecare eșantion la norma unitară ($L_1$, $L_2$ sau Max) norm='l2' ('l1', 'max')
Binarizer Binarizare prin prag a valorilor continue $x > \text{threshold} \Rightarrow 1$, altfel $0$ threshold=0.0
SimpleImputer Imputarea valorilor lipsă Înlocuiește valorile lipsă cu media, mediana, moda sau o constantă missing_values=np.nan, strategy='mean'
OneHotEncoder Codificare One-Hot pentru variabile categorice nominale Transformă categoriile în coloane binare indicatoare drop='first', handle_unknown='ignore'
OrdinalEncoder Codificare ordinală pentru variabile categorice ordonate Transformă categoriile în numere întregi ordonate $0, \dots, K-1$ categories='auto', encoded_missing_value
LabelEncoder Codificarea etichetelor pentru variabila țintă $y$ Convertește etichetele text în numere întregi $0 \dots C-1$ DOAR pentru variabila țintă $y$, NICIODATĂ pentru caracteristicile $X$
PolynomialFeatures Generarea de caracteristici polinomiale și interacțiuni Generează termeni de ordin superior $[1, a, b, a^2, ab, b^2]$ degree=2, include_bias=False

3.1 Exemple de cod de preprocesare

import numpy as np
from sklearn.preprocessing import (
    StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
    Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer

# 1. Standardizare numerică (nu apelați fit pe setul de test!)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)

# 2. Imputarea valorilor lipsă (strategia medianei)
imputer = SimpleImputer(missing_values=np.nan, strategy='median')
X_train_imp = imputer.fit_transform(X_train)
X_test_imp = imputer.transform(X_test)

# 3. Codificare One-Hot (gestionează în siguranță categoriile noi)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_ohe = ohe.fit_transform(X_train_cat)
X_test_ohe = ohe.transform(X_test_cat)

# 4. Codificarea variabilei țintă
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)

# 5. Expansiune polinomială a caracteristicilor
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)

4. Catalogul principal al modelelor uzuale

4.1 Învățare supervizată: Clasificare

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier

# Regresie logistică (linie de bază liniară)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)

# K cei mai apropiați vecini (KNN)
clf_knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)

# Support Vector Machine (nucleu RBF)
clf_svm = SVC(C=1.0, kernel='rbf', gamma='scale', probability=True, random_state=42)

# Naive Bayes gaussian
clf_gnb = GaussianNB()

# Pădure aleatorie (ansamblu Bagging)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)

# Gradient Boosting bazat pe histograme (GBDT rapid similar cu LightGBM)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)

4.2 Învățare supervizată: Regresie

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor

# Regresie liniară simplă prin cele mai mici pătrate (OLS)
reg_lr = LinearRegression()

# Regresie Ridge (regularizare L2 împotriva multicoliniarității)
reg_ridge = Ridge(alpha=1.0)

# Regresie Lasso (regularizare L1 pentru selecția caracteristicilor)
reg_lasso = Lasso(alpha=0.1)

# Regresie cu vectori suport (SVR)
reg_svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)

# Regresor de pădure aleatorie
reg_rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)

4.3 Învățare nesupervizată: Clustering și reducerea dimensionalității

from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA

# Clustering K-Means
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)
cluster_labels = kmeans.labels_        # Atribuiri la clustere
cluster_centers = kmeans.cluster_centers_

# Clustering spațial bazat pe densitate (DBSCAN: rezistent la zgomot)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X)      # -1 indică valori aberante (zgomot)

# Analiza componentelor principale (PCA): păstrează 95% din varianță
pca = PCA(n_components=0.95)
X_pca = pca.fit_transform(X)
print("Componente păstrate:", pca.n_components_)
print("Raport de varianță explicată:", pca.explained_variance_ratio_)

5. Sinteza operațiunilor API unificate

Operațiune Metodă standard Tip obiect țintă Semantică și valoare returnată
Antrenare (Fit) estimator.fit(X, y) Toți Estimatorii Estimează parametrii din datele de antrenare; returnează self
Predicție (Predict) predictor.predict(X) Toți Predictorii Generează etichete discrete sau valori continue
Probabilitate predictor.predict_proba(X) Clasificatori Calculează matricea distribuției de probabilități a posteriori
Distanță de decizie predictor.decision_function(X) Modele liniare / SVM Distanța cu semn a eșantioanelor față de hiperplanul despărțitor
Transformare transformer.transform(X) Toți Transformatorii Proiectează caracteristicile pe baza parametrilor învățați
Potrivire și transformare transformer.fit_transform(X) Toți Transformatorii Calculează parametrii și transformă într-o singură etapă optimizată
Scor implicit estimator.score(X, y) Clasificatori / Regresori Acuratețe pentru clasificare; coeficient de determinare $R^2$ pentru regresie

6. Metrici de evaluare (sklearn.metrics)

6.1 Metrici de clasificare

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix, classification_report,
    ConfusionMatrixDisplay
)

# 1. Metrici pentru etichete discrete (specificați average la multi-clasă)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred, average='macro')
rec = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')

# 2. Metrici de clasare continuă (ROC-AUC necesită probabilități estimate)
y_prob = clf.predict_proba(X_test)[:, 1]   # Probabilități pentru clasa pozitivă
auc = roc_auc_score(y_test, y_prob)

# 3. Matricea de confuzie și raport complet de clasificare
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))

# 4. Afișarea grafică a matricei de confuzie
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()

6.2 Metrici de regresie

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)  # Rădăcina erorii pătratice medii (RMSE)
r2 = r2_score(y_test, y_pred)                            # Coeficient de determinare R²

6.3 Metrici de clustering

from sklearn.metrics import (
    adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)

# Validare externă (când etichetele reale sunt cunoscute)
ari = adjusted_rand_score(y_true, cluster_labels)       # Interval: [-1, 1], mai mare indică o grupare mai bună
homo = homogeneity_score(y_true, cluster_labels)        # Interval: [0, 1]
vm = v_measure_score(y_true, cluster_labels)           # Media armonică a omogenității și completitudinii

# Validare internă (geometrică, fără etichete reale)
sil = silhouette_score(X, cluster_labels)              # Interval: [-1, 1], valori apropiate de 1 indică clustere bine separate

7. Validare încrucișată și reglarea hiperparametrilor (sklearn.model_selection)

7.1 Validare încrucișată (Cross-Validation)

from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold

# Validare încrucișată K-Fold standard
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"Acuratețe 5-Fold CV: {scores.mean():.4f} (±{scores.std():.4f})")

# Generator K-Fold stratificat
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_skf = cross_val_score(clf, X, y, cv=skf, scoring='f1_macro')

# Evaluare simultană pe mai multe metrici
multi_scores = cross_validate(
    clf, X, y, cv=5,
    scoring=['accuracy', 'roc_auc'],
    return_train_score=False
)
print("AUC mediu de validare:", multi_scores['test_roc_auc'].mean())

7.2 Căutare pe grilă și căutare aleatorie

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint

# 1. Căutare exhaustivă pe grilă (GridSearchCV)
param_grid = {
    'n_neighbors': [3, 5, 7, 11],
    'weights': ['uniform', 'distance'],
    'metric': ['euclidean', 'manhattan']
}
grid = GridSearchCV(
    estimator=KNeighborsClassifier(),
    param_grid=param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)
grid.fit(X_train, y_train)
print("Cei mai buni parametri:", grid.best_params_)
best_model = grid.best_estimator_

# 2. Căutare aleatorie a hiperparametrilor (pentru spații mari de căutare)
param_dist = {
    'n_estimators': randint(50, 300),
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': randint(2, 11)
}
rand_search = RandomizedSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=20,             # Număr de combinații aleatorii
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("Cei mai buni parametri Random Search:", rand_search.best_params_)

8. Cele mai bune practici în producție: Pipeline și ColumnTransformer

8.1 De ce utilizarea Pipeline-urilor este obligatorie

Aplicarea globală a scalării sau a imputării datelor înainte de împărțire duce la fenomenul de Scurgere de Date (Data Leakage): informațiile din seturile de test contaminează statisticile de antrenare, creând scoruri nerealist de optimiste offline care eșuează în producție.

Pipeline leagă etapele de transformare și estimatorii într-o entitate indivizibilă fără scurgeri. În validarea încrucișată, transformatorii sunt antrenați exclusiv pe seturile de antrenare ale fiecărei partiții.

8.2 Șablon de producție cu ColumnTransformer

Datele tabelare din lumea reală combină coloane numerice continue și variabile categorice:

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier

# 1. Partiționarea explicită a numelor de coloane
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']

# 2. Sub-pipeline numeric: imputare mediană -> standardizare
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# 3. Sub-pipeline categoric: imputare cu valoare constantă -> codificare One-Hot
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# 4. Unificarea coloanelor într-un ColumnTransformer
preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# 5. Asamblarea pipeline-ului complet al modelului
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# 6. Antrenare și inferență atomice (fără scurgeri, implementare sigură)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("Acuratețea testului cu Pipeline:", full_pipeline.score(X_test_df, y_test))

Subiecte conexe