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)șifit_transform(X). - Predictor: Generează predicții pentru eșantioane noi prin
predict(X),predict_proba(X)șiscore(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))