Selecția caracteristicilor

Mai multe caracteristici nu înseamnă mai bine. Caracteristicile potrivite înseamnă mai bine.

Tip: Construire Limbaj: Python Cerințe preliminare: Faza 2, lecțiile 01–09, în special lecția 08 — ingineria caracteristicilor Durată: ~75 de minute

Obiective de învățare

• Să implementați de la zero pragul varianței, informația mutuală, RFE, regularizarea L1 și importanța prin arbori; testul chi-pătrat și selecția înainte sunt extensii de studiat, nu implementări ale codului fixat.
• Să explicați de ce informația mutuală surprinde relații neliniare dintre caracteristică și țintă pe care corelația le ratează.
• Să comparați regularizarea L1 — selecție încorporată — cu RFE — selecție wrapper — și să le evaluați compromisurile de calcul.
• Să proiectați un pipeline de selecție a caracteristicilor care poate combina mai multe metode și un protocol de evaluare pe date păstrate separat.

Problema

Aveți 500 de caracteristici. Modelul se antrenează lent, supraînvață constant și nimeni nu poate explica ce a învățat. Adăugați și mai multe caracteristici, sperând să îmbunătățiți performanța. Aceasta devine mai slabă.

Acesta este blestemul dimensionalității în acțiune. Pe măsură ce numărul caracteristicilor crește, volumul spațiului caracteristicilor explodează. Punctele de date devin rare. Distanțele dintre puncte converg. Modelul are nevoie de exponențial mai multe date pentru a găsi tipare reale. Caracteristicile zgomotoase le acoperă pe cele cu semnal. Supraînvățarea devine situația implicită.

Selecția caracteristicilor este antidotul. Eliminați zgomotul. Înlăturați redundanța. Păstrați caracteristicile care conțin informație reală despre țintă. Rezultatul: antrenare mai rapidă, generalizare mai bună și modele pe care le puteți explica efectiv.

Scopul nu este să folosiți toate informațiile disponibile. Scopul este să folosiți informațiile potrivite.

Notă tehnică a traducerii: „Blestemul dimensionalității” nu afectează identic toate modelele, distribuțiile și reprezentările, iar necesarul de date nu crește universal exponențial. Concentrarea distanțelor este relevantă în special metodelor bazate pe distanță și depinde de metrică și distribuție. Selecția poate îmbunătăți generalizarea, dar poate și elimina semnal util; afirmația trebuie verificată pe date de validare separate.

Conceptul

Trei categorii de selecție a caracteristicilor

Fiecare metodă de selecție a caracteristicilor aparține uneia dintre cele trei categorii:

Metodele de filtrare atribuie independent un scor fiecărei caracteristici folosind o măsură statistică. Nu folosesc un model. Sunt rapide, dar ratează interacțiunile dintre caracteristici.

Metodele wrapper antrenează un model pentru a evalua subseturi de caracteristici. Folosesc performanța modelului drept scor. Dau rezultate mai bune, dar sunt costisitoare fiindcă reantrenează modelul de multe ori.

Metodele încorporate selectează caracteristicile ca parte a antrenării modelului. Regularizarea L1 împinge ponderile spre zero. Arborii de decizie separă datele folosind caracteristicile cele mai utile. Selecția are loc în timpul ajustării, nu ca pas separat.

Notă tehnică a traducerii: Categoriile sunt o taxonomie utilă, nu o partiție perfectă, iar metodele wrapper nu oferă automat rezultate mai bune. Ele optimizează performanța estimatorului și protocolului de validare folosite și pot supraînvăța chiar procesul de selecție.

Pragul varianței

Cel mai simplu filtru. Dacă o caracteristică variază foarte puțin între eșantioane, conține aproape nicio informație.

Luați o caracteristică egală cu 0,0 pentru 999 dintre 1.000 de eșantioane. Varianța ei este aproape zero. Niciun model nu o poate folosi pentru a deosebi clasele. Eliminați-o.

variance(x) = mean((x - mean(x))^2)

Stabiliți un prag, de exemplu 0,01. Eliminați fiecare caracteristică a cărei varianță este sub prag. Astfel înlăturați caracteristicile constante sau aproape constante fără a examina deloc variabila țintă.

Când să o folosiți: drept pas de preprocesare înaintea altor metode. Detectează caracteristici evident inutile cu un cost aproape nul.

Limitare: o caracteristică poate avea varianță mare și totuși să fie zgomot pur. Pragul varianței este necesar, dar nu suficient.

Notă tehnică a traducerii: O caracteristică rară cu varianță foarte mică poate fi perfect predictivă pentru o clasă rară; exemplul 999/1 nu justifică eliminarea fără context. Pragul depinde și de scară, deci trebuie ales după o reprezentare coerentă și ajustat numai pe datele de antrenare.

Informația mutuală

Informația mutuală măsoară cât de mult reduce cunoașterea valorii caracteristicii X incertitudinea despre ținta Y.

I(X; Y) = sum_x sum_y p(x, y) * log(p(x, y) / (p(x) * p(y)))

Dacă X și Y sunt independente, p(x, y) = p(x) * p(y), deci termenul logaritmic este zero și I(X; Y) = 0. Cu cât X spune mai multe despre Y, cu atât informația mutuală este mai mare.

Avantajul principal față de corelație: informația mutuală surprinde relații neliniare. O caracteristică poate avea corelație zero cu ținta, dar informație mutuală mare, deoarece relația este pătratică sau periodică.

Pentru caracteristici continue, discretizați mai întâi în intervale — estimare bazată pe histogramă. Numărul intervalelor afectează estimarea: prea puține pierd informație, iar prea multe adaugă zgomot. O alegere frecventă: sqrt(n) intervale sau regula lui Sturges — 1 + log2(n).

Notă tehnică a traducerii: Estimatorul discretizat al informației mutuale este sensibil și părtinitor în eșantioane finite; regulile pentru numărul de intervale nu sunt universal optime pentru selecția caracteristicilor. mutual_info_classif din scikit-learn folosește estimatori bazați pe distanțele până la vecinii apropiați pentru variabile continue și cere marcarea corectă a caracteristicilor discrete.

Eliminarea recursivă a caracteristicilor — RFE

RFE este o metodă wrapper. Folosește importanța caracteristicilor oferită de model pentru a le elimina iterativ:

1. Antrenați modelul cu toate caracteristicile.
2. Ordonați caracteristicile după importanță — coeficienți pentru modelele liniare, reducerea impurității pentru arbori.
3. Eliminați caracteristica sau caracteristicile cel mai puțin importante.
4. Repetați până când rămâne numărul dorit de caracteristici.

RFE ia în considerare interacțiunile dintre caracteristici deoarece modelul vede împreună toate caracteristicile rămase. Eliminarea uneia schimbă importanța celorlalte. Aceasta o face mai riguroasă decât metodele de filtrare.

Costul: antrenați modelul de N - țintă ori. Cu 500 de caracteristici și ținta 10, sunt 490 de antrenări. Pentru modele costisitoare, procesul este lent. Îl puteți accelera eliminând mai multe caracteristici la fiecare pas, de exemplu ultimele 10% din clasament.

Notă tehnică a traducerii: RFE surprinde numai interacțiunile pe care estimatorul de bază le poate reprezenta, iar „mai riguroasă” nu înseamnă neapărat mai corectă. Numărul efectiv de ajustări depinde de parametrul step; selecția numărului final de caracteristici trebuie făcută în interiorul validării.

Regularizarea L1 — Lasso

Regularizarea L1 adaugă valoarea absolută a ponderilor la funcția de pierdere:

loss = prediction_error + alpha * sum(|w_i|)

Parametrul alpha controlează cât de agresiv sunt eliminate caracteristicile. Un alpha mai mare înseamnă că mai multe ponderi ajung exact la zero.

De ce exact zero? Penalizarea L1 creează o regiune de constrângere în formă de romb în spațiul ponderilor. Soluția optimă tinde să ajungă într-un colț al acestui romb, unde una sau mai multe ponderi sunt zero. Regularizarea L2 — ridge — creează o constrângere circulară în care ponderile se micșorează, dar rareori ajung la zero.

Aceasta este selecție încorporată a caracteristicilor: modelul învață în timpul antrenării ce caracteristici să ignore. Caracteristicile cu pondere zero sunt eliminate efectiv.

Avantaje: o singură antrenare, gestionează caracteristicile corelate — alege una și le aduce pe celelalte la zero — și este integrată în majoritatea implementărilor de modele liniare.

Limitare: funcționează numai pentru modele liniare. Nu poate surprinde importanța neliniară a caracteristicilor.

Notă tehnică a traducerii: În grupuri de caracteristici puternic corelate, L1 poate alege instabil una dintre ele, iar alegerea se poate schimba între eșantioane; nu garantează păstrarea celei mai potrivite. Penalizarea L1 există și în alte modele diferențiabile, însă interpretarea coeficienților ca selecție directă este cea mai simplă în modelele liniare. Toate caracteristicile trebuie scalate comparabil înainte de a interpreta zerourile.

Importanța caracteristicilor bazată pe arbori

Arborii de decizie și ansamblurile lor — păduri aleatoare, gradient boosting — ordonează în mod natural caracteristicile. Fiecare separare reduce impuritatea — Gini sau entropie pentru clasificare, varianță pentru regresie. Caracteristicile care produc reduceri mai mari ale impurității sunt mai importante.

Pentru o pădure aleatoare cu T arbori:

importanță(caracteristica_j) = (1/T) * suma pentru toți arborii a
    sumei pentru toate nodurile care separă după caracteristica_j a
        (n_eșantioane * scăderea_impurității)

Aceasta oferă un scor de importanță normalizat pentru fiecare caracteristică. Gestionează automat relațiile neliniare și interacțiunile dintre caracteristici.

Atenție: importanța bazată pe arbori este părtinitoare în favoarea caracteristicilor cu multe valori unice — cardinalitate mare. O coloană cu ID-uri aleatoare va părea importantă, deoarece poate separa perfect fiecare eșantion. Folosiți importanța prin permutare drept verificare de plauzibilitate.

Notă tehnică a traducerii: Importanța prin reducerea impurității măsoară utilizarea caracteristicii de către modelul ajustat, nu cauzalitatea și nici utilitatea garantată pe date noi. Un ID cu cardinalitate mare poate primi importanță artificială pe datele de antrenare, dar nu „separă perfect” automat ținta. Calculați și importanța prin permutare pe date păstrate separat.

Importanța prin permutare

O metodă independentă de model:

1. Antrenați modelul și înregistrați performanța de bază pe datele de validare.
2. Pentru fiecare caracteristică, amestecați-i aleatoriu valorile și măsurați scăderea performanței.
3. Cu cât scăderea este mai mare, cu atât caracteristica este mai importantă.

Dacă amestecarea unei caracteristici nu afectează performanța, modelul nu depinde de ea. Dacă performanța se prăbușește, caracteristica este critică.

Importanța prin permutare evită părtinirea față de cardinalitate a importanței bazate pe arbori. Dar este lentă: o evaluare completă pentru fiecare caracteristică, repetată de mai multe ori pentru stabilitate.

Notă tehnică a traducerii: Caracteristicile corelate își pot masca reciproc importanța: amestecarea uneia produce o scădere mică deoarece modelul păstrează informația prin cealaltă. O importanță mică nu dovedește că variabila nu conține semnal, iar o importanță negativă poate apărea din variația eșantionării sau din supraajustare.

Tabel comparativ

Metodă	Tip	Viteză	Neliniară	Interacțiuni între caracteristici
Pragul varianței	Filtru	Foarte rapidă	Nu	Nu
Informație mutuală	Filtru	Rapidă	Da	Nu
Filtru de corelație	Filtru	Rapidă	Nu	Nu
RFE	Wrapper	Lentă	Depinde de model	Da
L1 / Lasso	Încorporată	Rapidă	Nu — liniară	Nu
Importanță prin arbori	Încorporată	Medie	Da	Da
Importanță prin permutare	Independentă de model	Lentă	Da	Da

Diagrama decizională

Notă tehnică a traducerii: Pragurile 50 și 500 sunt euristici didactice. Costul depinde de numărul eșantioanelor, estimator, sparsitate și buget, iar alegerea metodei și a hiperparametrilor trebuie inclusă în evaluarea de validare.

Construiți

Pasul 1: generați date sintetice cu o structură cunoscută a caracteristicilor

import numpy as np


def make_feature_selection_data(n_samples=500, seed=42):
    rng = np.random.RandomState(seed)

    x1 = rng.randn(n_samples)
    x2 = rng.randn(n_samples)
    x3 = rng.randn(n_samples)
    x4 = x1 + 0.1 * rng.randn(n_samples)
    x5 = x2 + 0.1 * rng.randn(n_samples)

    informative = np.column_stack([x1, x2, x3, x4, x5])

    correlated = np.column_stack([
        x1 * 0.9 + 0.1 * rng.randn(n_samples),
        x2 * 0.8 + 0.2 * rng.randn(n_samples),
        x3 * 0.7 + 0.3 * rng.randn(n_samples),
        x1 * 0.5 + x2 * 0.5 + 0.1 * rng.randn(n_samples),
        x2 * 0.6 + x3 * 0.4 + 0.1 * rng.randn(n_samples),
    ])

    noise = rng.randn(n_samples, 10) * 0.5

    X = np.hstack([informative, correlated, noise])
    y = (2 * x1 - 1.5 * x2 + x3 + 0.5 * rng.randn(n_samples) > 0).astype(int)

    feature_names = (
        [f"info_{i}" for i in range(5)]
        + [f"corr_{i}" for i in range(5)]
        + [f"noise_{i}" for i in range(10)]
    )

    return X, y, feature_names

Structura sintetică este cunoscută: caracteristicile 0–2 au semnal direct pentru țintă; 3–4 și 5–9 sunt proxy-uri corelate, iar 10–19 sunt zgomot pur. Un selector condițional poate păstra reprezentanți diferiți din grupurile corelate, deci nu trebuie să claseze neapărat toate caracteristicile 0–4 cel mai sus; ar trebui însă să evite în general zgomotul 10–19.

Notă tehnică a traducerii: afirmația sursei despre o ordine obligatorie a tuturor caracteristicilor redundante este prea puternică. În prezența coliniarității, mai multe subseturi pot avea performanță predictivă echivalentă.

Pasul 2: pragul varianței

def variance_threshold(X, threshold=0.01):
    variances = np.var(X, axis=0)
    mask = variances > threshold
    return mask, variances

Pasul 3: informația mutuală — discretă

def discretize(x, n_bins=10):
    min_val, max_val = x.min(), x.max()
    if max_val == min_val:
        return np.zeros_like(x, dtype=int)
    bin_edges = np.linspace(min_val, max_val, n_bins + 1)
    binned = np.digitize(x, bin_edges[1:-1])
    return binned


def mutual_information(X, y, n_bins=10):
    n_samples, n_features = X.shape
    mi_scores = np.zeros(n_features)

    y_vals, y_counts = np.unique(y, return_counts=True)
    p_y = y_counts / n_samples

    for f in range(n_features):
        x_binned = discretize(X[:, f], n_bins)
        x_vals, x_counts = np.unique(x_binned, return_counts=True)
        p_x = dict(zip(x_vals, x_counts / n_samples))

        mi = 0.0
        for xv in x_vals:
            for yi, yv in enumerate(y_vals):
                joint_mask = (x_binned == xv) & (y == yv)
                p_xy = np.sum(joint_mask) / n_samples
                if p_xy > 0:
                    mi += p_xy * np.log(p_xy / (p_x[xv] * p_y[yi]))
        mi_scores[f] = mi

    return mi_scores

Pasul 4: eliminarea recursivă a caracteristicilor

def simple_logistic_importance(X, y, lr=0.1, epochs=100):
    n_samples, n_features = X.shape
    w = np.zeros(n_features)
    b = 0.0

    for _ in range(epochs):
        z = X @ w + b
        pred = 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))
        error = pred - y
        w -= lr * (X.T @ error) / n_samples
        b -= lr * np.mean(error)

    return w, b


def rfe(X, y, n_features_to_select=5, lr=0.1, epochs=100):
    n_total = X.shape[1]
    remaining = list(range(n_total))
    rankings = np.ones(n_total, dtype=int)
    rank = n_total

    while len(remaining) > n_features_to_select:
        X_subset = X[:, remaining]
        w, _ = simple_logistic_importance(X_subset, y, lr, epochs)
        importances = np.abs(w)

        least_idx = np.argmin(importances)
        original_idx = remaining[least_idx]
        rankings[original_idx] = rank
        rank -= 1
        remaining.pop(least_idx)

    for idx in remaining:
        rankings[idx] = 1

    selected_mask = rankings == 1
    return selected_mask, rankings

Pasul 5: selecția caracteristicilor cu L1

def soft_threshold(w, alpha):
    return np.sign(w) * np.maximum(np.abs(w) - alpha, 0)


def l1_feature_selection(X, y, alpha=0.1, lr=0.01, epochs=500):
    n_samples, n_features = X.shape
    w = np.zeros(n_features)
    b = 0.0

    for _ in range(epochs):
        z = X @ w + b
        pred = 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))
        error = pred - y

        gradient_w = (X.T @ error) / n_samples
        gradient_b = np.mean(error)

        w -= lr * gradient_w
        w = soft_threshold(w, lr * alpha)
        b -= lr * gradient_b

    selected_mask = np.abs(w) > 1e-6
    return selected_mask, w

Pasul 6: importanța bazată pe arbori — arbore de decizie simplu

def gini_impurity(y):
    if len(y) == 0:
        return 0.0
    classes, counts = np.unique(y, return_counts=True)
    probs = counts / len(y)
    return 1.0 - np.sum(probs ** 2)


def best_split(X, y, feature_idx):
    values = np.unique(X[:, feature_idx])
    if len(values) <= 1:
        return None, -1.0

    best_threshold = None
    best_gain = -1.0
    parent_gini = gini_impurity(y)
    n = len(y)

    for i in range(len(values) - 1):
        threshold = (values[i] + values[i + 1]) / 2.0
        left_mask = X[:, feature_idx] <= threshold
        right_mask = ~left_mask

        n_left = np.sum(left_mask)
        n_right = np.sum(right_mask)

        if n_left == 0 or n_right == 0:
            continue

        gain = parent_gini - (n_left / n) * gini_impurity(y[left_mask]) - (n_right / n) * gini_impurity(y[right_mask])

        if gain > best_gain:
            best_gain = gain
            best_threshold = threshold

    return best_threshold, best_gain


def tree_importance(X, y, n_trees=50, max_depth=5, seed=42):
    rng = np.random.RandomState(seed)
    n_samples, n_features = X.shape
    importances = np.zeros(n_features)

    for _ in range(n_trees):
        sample_idx = rng.choice(n_samples, size=n_samples, replace=True)
        feature_subset = rng.choice(n_features, size=max(1, int(np.sqrt(n_features))), replace=False)

        X_boot = X[sample_idx]
        y_boot = y[sample_idx]

        tree_imp = _build_tree_importance(X_boot, y_boot, feature_subset, max_depth)
        importances += tree_imp

    total = importances.sum()
    if total > 0:
        importances /= total

    return importances


def _build_tree_importance(X, y, feature_subset, max_depth, depth=0):
    n_features = X.shape[1]
    importances = np.zeros(n_features)

    if depth >= max_depth or len(np.unique(y)) <= 1 or len(y) < 4:
        return importances

    best_feature = None
    best_threshold = None
    best_gain = -1.0

    for f in feature_subset:
        threshold, gain = best_split(X, y, f)
        if gain > best_gain:
            best_gain = gain
            best_feature = f
            best_threshold = threshold

    if best_feature is None or best_gain <= 0:
        return importances

    importances[best_feature] += best_gain * len(y)

    left_mask = X[:, best_feature] <= best_threshold
    right_mask = ~left_mask

    importances += _build_tree_importance(X[left_mask], y[left_mask], feature_subset, max_depth, depth + 1)
    importances += _build_tree_importance(X[right_mask], y[right_mask], feature_subset, max_depth, depth + 1)

    return importances

Notă tehnică a traducerii: Implementarea didactică alege un singur feature_subset pentru întregul arbore și îl reutilizează la fiecare nod; o pădure aleatoare obișnuită reeșantionează subsetul de caracteristici la fiecare separare. Scorurile rezultate nu sunt identice cu feature_importances_ din scikit-learn.

Pasul 7: rulați toate metodele și comparați-le

Fișierul de cod compară informația mutuală, RFE, L1 și importanța prin arbori pe același set sintetic și afișează măștile de selecție. Pragul varianței este implementat separat; testul chi-pătrat și selecția înainte nu sunt implementate în fișierul fixat.

Notă tehnică a traducerii: formularea sursei supraevaluează acoperirea scriptului; păstrați metodele neimplementate ca exerciții sau extinderi și validați fiecare selector în interiorul protocolului de evaluare.

Folosiți

În scikit-learn, selecția caracteristicilor este integrată în pipeline:

from sklearn.feature_selection import (
    VarianceThreshold,
    mutual_info_classif,
    RFE,
    SelectFromModel,
)
from sklearn.linear_model import Lasso, LogisticRegression
from sklearn.ensemble import RandomForestClassifier

vt = VarianceThreshold(threshold=0.01)
X_filtered = vt.fit_transform(X)

mi_scores = mutual_info_classif(X, y)
top_k = np.argsort(mi_scores)[-10:]

rfe_selector = RFE(LogisticRegression(), n_features_to_select=10)
rfe_selector.fit(X, y)
X_rfe = rfe_selector.transform(X)

lasso_selector = SelectFromModel(Lasso(alpha=0.01))
lasso_selector.fit(X, y)
X_lasso = lasso_selector.transform(X)

rf = RandomForestClassifier(n_estimators=100)
rf.fit(X, y)
importances = rf.feature_importances_

Implementările de la zero arată exact ce se întâmplă în fiecare metodă. Pragul varianței înseamnă doar calcularea lui var(X, axis=0) și aplicarea unei măști. Informația mutuală înseamnă numărarea frecvențelor comune și marginale într-un tabel de contingență. RFE este o buclă care antrenează, ordonează și elimină. L1 este coborâre pe gradient cu un pas de prag moale. Importanța prin arbori acumulează reducerile impurității din separări. Nu există magie — numai statistică și bucle.

Versiunile scikit-learn adaugă robustețe — de exemplu, mutual_info_classif folosește estimarea densității prin k-NN în locul discretizării —, viteză prin implementări C și integrare în pipeline.

Notă tehnică a traducerii: Exemplul ajustează selectorii pe întregul X, y; dacă apoi raportați performanța pe o împărțire derivată din aceleași date, apare scurgerea informației. Includeți selecția într-un Pipeline și validați întregul proces. Pentru clasificare binară, Lasso tratează etichetele ca țintă de regresie; un estimator liniar de clasificare cu penalizare L1, precum LogisticRegression(penalty="l1", solver="liblinear"), aliniază selecția cu obiectivul de clasificare. Fragmentul nu demonstrează singur îmbunătățirea generalizării menționată în obiective.

Livrați

Această lecție produce:

• outputs/skill-feature-selector.md — un arbore decizional de referință rapidă pentru alegerea metodei potrivite de selecție a caracteristicilor.

Exerciții

1. Selecție înainte: implementați opusul RFE. Începeți fără caracteristici. La fiecare pas, adăugați caracteristica ce îmbunătățește cel mai mult performanța modelului. Opriți-vă când adăugarea caracteristicilor nu mai ajută. Comparați caracteristicile selectate cu rezultatele RFE. Care metodă este mai rapidă? Care oferă rezultate mai bune?

2. Selecție stabilă: rulați selecția L1 de 50 de ori, de fiecare dată pe un subeșantion aleatoriu de 80% din date și cu valori alpha ușor diferite. Numărați cât de des este selectată fiecare caracteristică. Caracteristicile selectate în peste 80% dintre rulări sunt „stabile”. Comparați-le cu selecția L1 dintr-o singură rulare. Care este mai fiabilă?

3. Detectarea multicoliniarității: calculați matricea de corelație pentru toate caracteristicile. Implementați o funcție care, pentru un prag de corelație dat — de exemplu 0,9 —, elimină câte o caracteristică din fiecare pereche puternic corelată, păstrând-o pe cea cu informație mutuală mai mare față de țintă. Testați pe setul sintetic și verificați dacă elimină caracteristicile corelate redundante.

4. Pipeline de selecție a caracteristicilor: înlănțuiți pragul varianței, filtrul de informație mutuală și RFE într-un singur pipeline. Eliminați mai întâi caracteristicile cu varianță aproape zero, apoi păstrați jumătatea superioară după informația mutuală și rulați RFE pe cele rămase. Comparați pipeline-ul cu RFE rulat singur pe toate caracteristicile. Este pipeline-ul mai rapid? Are aceeași acuratețe?

5. Importanță prin permutare de la zero: implementați importanța prin permutare. Pentru fiecare caracteristică, amestecați valorile de 10 ori și măsurați scăderea medie a scorului F1. Comparați clasamentul cu importanța bazată pe arbori. Găsiți cazuri în care nu coincid și explicați de ce — indiciu: caracteristici corelate.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
Metodă de filtrare	„Atribuiți scoruri independente caracteristicilor”	Abordare care ordonează caracteristicile printr-o măsură statistică fără a antrena un model și evaluează fiecare caracteristică izolat
Metodă wrapper	„Folosiți modelul pentru a alege caracteristicile”	Abordare care evaluează subseturile antrenând un model și folosind performanța acestuia drept criteriu de selecție
Metodă încorporată	„Modelul selectează caracteristicile în timpul antrenării”	Selecție care are loc ca parte a ajustării modelului, precum regularizarea L1 ce împinge ponderile spre zero
Informație mutuală	„Cât de mult spune o variabilă despre alta”	Măsură a reducerii incertitudinii despre Y când cunoaștem X, care surprinde dependențe liniare și neliniare
Eliminarea recursivă a caracteristicilor	„Antrenați, ordonați, eliminați, repetați”	Metodă wrapper iterativă care antrenează un model, elimină caracteristicile cel mai puțin importante și repetă până la numărul țintă
Regularizare L1 / Lasso	„Penalizarea care ucide caracteristici”	Adăugarea sumei valorilor absolute ale ponderilor la pierdere, ceea ce împinge spre zero ponderile caracteristicilor neimportante
Pragul varianței	„Eliminați caracteristicile constante”	Eliminarea caracteristicilor a căror varianță între eșantioane este sub un prag, filtrând caracteristicile care nu conțin informație
Importanța caracteristicilor	„Care caracteristici contează cel mai mult”	Scor care indică contribuția fiecărei caracteristici la predicțiile modelului, calculat din câștigurile separărilor — arbori — sau mărimea coeficienților — modele liniare
Importanță prin permutare	„Amestecați și măsurați dauna”	Evaluarea importanței prin amestecarea aleatoare a valorilor fiecărei caracteristici și măsurarea scăderii performanței modelului
Blestemul dimensionalității	„Prea multe caracteristici, prea puține date”	Fenomenul prin care adăugarea caracteristicilor mărește exponențial volumul spațiului, rarefiază datele și face distanțele lipsite de semnificație

Lecturi suplimentare

• „An Introduction to Variable and Feature Selection”, Guyon și Elisseeff (2003) — sinteza fundamentală despre metodele de selecție a caracteristicilor, încă citată pe scară largă.
• Ghidul scikit-learn pentru selecția caracteristicilor — referință practică pentru metode de filtrare, wrapper și încorporate, cu exemple de cod.
• „Stability Selection”, Meinshausen și Bühlmann (2010) — combină subeșantionarea cu selecția caracteristicilor pentru rezultate robuste și reproductibile.
• „Bias in Random Forest Variable Importance Measures”, Strobl și colaboratorii (2007) — demonstrează părtinirea importanței bazate pe arbori față de cardinalitate și propune importanța condiționată ca alternativă.

Sursă: Originalul în limba engleză

Navigare: ← Lecția 02.17 — Gestionarea datelor dezechilibrate · Faza 2 — Bazele învățării automate · Catalog complet