Ensemble a votazione: hard vote e soft vote
Combinerà KNN, regressione logistica e albero decisionale in un VotingClassifier e confronterà la maggioranza hard vote con la media delle probabilità soft vote.
Ensemble a votazione: hard vote e soft vote è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Che cos'è un ensemble a voto?
Un ensemble a voto combina le predizioni di diversi tipi di modello distinti, ad esempio una regressione logistica, un classificatore k-nearest neighbours e un albero decisionale, per produrre un'unica predizione finale. A differenza del bagging, che usa molte copie dello stesso tipo di modello, un ensemble a voto sfrutta la diversità dell'architettura dei modelli. Poiché modelli diversi commettono tipi diversi di errori, la loro combinazione può superare qualsiasi singolo componente, soprattutto nei dataset in cui nessun algoritmo prevale nettamente.
Voto rigido: decide la maggioranza
Nel voto rigido, ogni modello vota per un'etichetta di classe e vince la classe che riceve più voti. Se tre modelli predicono [cat, cat, dog], l'ensemble predice cat. Il voto rigido è semplice e interpretabile, ma considera tutti i modelli ugualmente affidabili e ignora i livelli di confidenza. Un modello sicuro appena al 51% esprime lo stesso voto di uno sicuro al 99%, il che può portare a decisioni non ottimali quando le confidenze dei modelli differiscono molto.
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
X, y = load_iris(return_X_y=True)
voter = VotingClassifier(
estimators=[
('lr', LogisticRegression(max_iter=1000)),
('knn', KNeighborsClassifier()),
('dt', DecisionTreeClassifier())
],
voting='hard'
)
scores = cross_val_score(voter, X, y, cv=5)
print('Hard Voting CV:', scores.mean().round(4))Voto morbido: media delle probabilità
Nel voto morbido, ogni modello restituisce le probabilità delle classi invece di etichette rigide. L'ensemble calcola la media delle probabilità dei modelli e sceglie la classe con la probabilità media più alta. Ad esempio, se tre modelli assegnano alle due classi le probabilità [0.9, 0.1], [0.7, 0.3] e [0.6, 0.4], la media è [0.73, 0.27] e vince la classe 0. Il voto morbido generalmente supera il voto rigido perché utilizza informazioni più ricche sulla confidenza di ciascun modello.
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
X, y = load_iris(return_X_y=True)
voter = VotingClassifier(
estimators=[
('lr', LogisticRegression(max_iter=1000)),
('knn', KNeighborsClassifier()),
('svc', SVC(probability=True)) # probability=True required for soft vote
],
voting='soft'
)
scores = cross_val_score(voter, X, y, cv=5)
print('Soft Voting CV:', scores.mean().round(4))Requisito: tutti i modelli devono supportare predict_proba
Il voto morbido richiede che ogni modello dell'ensemble fornisca stime di probabilità tramite predict_proba(). La maggior parte dei classificatori scikit-learn lo supporta nativamente (regressione logistica, random forest, KNN, naive Bayes). Tuttavia, SVC non restituisce probabilità per impostazione predefinita: è necessario impostare probability=True nel costruttore, aggiungendo il Platt scaling (un passaggio di calibrazione) e aumentando il tempo di addestramento. Se un modello non è in grado di produrre probabilità, è necessario ricorrere al voto rigido.
Assegnare pesi ai singoli modelli
Sia il voto rigido sia quello morbido supportano il parametro weights, che consente di dare maggiore influenza ai modelli più accurati. Ad esempio, se la regressione logistica ha un'accuratezza del 92% e KNN dell'85%, si possono assegnare i pesi [2, 1]. Nel voto rigido, ogni voto viene replicato in base al relativo peso. Nel voto morbido, il vettore delle probabilità di ciascun modello viene moltiplicato per il suo peso prima di calcolare la media. Scegliere i pesi in base all'accuratezza ottenuta con la convalida incrociata è un approccio semplice ed efficace.
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
voter = VotingClassifier(
estimators=[
('lr', LogisticRegression(max_iter=1000)),
('knn', KNeighborsClassifier(n_neighbors=5)),
('dt', DecisionTreeClassifier(max_depth=5))
],
voting='soft',
weights=[2, 1, 1] # Trust LR twice as much
)
print('Weighted soft vote CV:', cross_val_score(voter, X, y, cv=5).mean().round(4))Confrontare voto rigido, voto morbido e singoli modelli
Un confronto diretto tra i singoli modelli, il voto rigido e il voto morbido sullo stesso dataset rende evidente l'effetto dell'ensemble. Nella maggior parte dei casi, il voto morbido supera quello rigido ed entrambi superano il modello singolo più debole. Tuttavia, l'ensemble non supera sempre il modello singolo più forte: dipende da quanto sono correlati gli errori dei modelli. Se tutti i modelli falliscono sugli stessi esempi, combinarli non offre alcun vantaggio.
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
estimators = [('lr', LogisticRegression(max_iter=1000)), ('knn', KNeighborsClassifier()), ('dt', DecisionTreeClassifier())]
for name, est in estimators:
print(f'{name}: {cross_val_score(est, X, y, cv=5).mean():.4f}')
for v in ['hard', 'soft']:
vc = VotingClassifier(estimators=estimators, voting=v)
print(f'Voting ({v}): {cross_val_score(vc, X, y, cv=5).mean():.4f}')Scegliere modelli diversificati
La chiave per un ensemble a voto efficace è la diversità dei modelli. Combinare tre regressioni logistiche con seed diversi aggiunge un valore quasi nullo: commetteranno tutti gli stessi errori. Gli ensemble più efficaci abbinano modelli con bias induttivi diversi: un modello lineare (regressione logistica), un modello basato sulle istanze (KNN), un modello basato sugli alberi (random forest) e, facoltativamente, un modello basato sui kernel (SVM). Ciascun modello osserva i dati da una prospettiva diversa e commette errori distinti, che si compensano durante la media.
VotingRegressor per target continui
VotingRegressor applica la stessa idea alla regressione: calcola la media delle predizioni numeriche di più regressori. Nella regressione non esiste il concetto di voto rigido o morbido: l'output è sempre una media, ponderata o non ponderata, delle singole predizioni. La combinazione di una regressione Ridge (lineare), di una Random Forest (ensemble di alberi) e di un SVR (metodo basato sui kernel) spesso supera qualsiasi singolo modello su dataset tabellari eterogenei.
from sklearn.ensemble import VotingRegressor, RandomForestRegressor
from sklearn.linear_model import Ridge
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
vr = VotingRegressor(estimators=[
('ridge', make_pipeline(StandardScaler(), Ridge())),
('rf', RandomForestRegressor(n_estimators=50, random_state=42)),
('svr', make_pipeline(StandardScaler(), SVR()))
])
rmse = np.sqrt(-cross_val_score(vr, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print('VotingRegressor RMSE:', round(rmse, 4))Gli ensemble a voto in produzione
Gli ensemble a voto sono facili da distribuire perché tutti i modelli componenti possono essere serializzati insieme al wrapper VotingClassifier usando joblib.dump(). L'inferenza richiede l'esecuzione di ogni modello componente, quindi la latenza delle predizioni cresce linearmente con il numero di componenti. Per le applicazioni sensibili alla latenza, limiti l'ensemble a 2-3 modelli solidi e veloci invece di usarne molti e lenti. Valuti sempre il tempo di inferenza come parte della valutazione della distribuzione.
Quando gli ensemble a voto non sono utili
Gli ensemble a voto danno risultati deludenti quando: (1) tutti i modelli componenti condividono gli stessi punti deboli e commettono errori correlati; (2) un modello è nettamente superiore agli altri e i modelli più deboli peggiorano l'ensemble; (3) il compito presenta pochissimo rumore, quindi un singolo modello ben regolato raggiunge già prestazioni quasi perfette; oppure (4) il dataset è troppo piccolo e la capacità aggiuntiva dei modelli porta soltanto a un overfitting. Esegua la diagnosi confrontando i pattern degli errori dei singoli modelli su un set di validazione: se gli errori sono altamente correlati, provi a sostituire alcuni modelli con architetture più diversificate.
Stacking e voto a confronto
Il voto usa un'aggregazione fissa, scelta manualmente (voto di maggioranza o media). Lo stacking (o generalizzazione a più livelli) va oltre: addestra un meta-learner per combinare in modo ottimale gli output dei modelli di base. Le predizioni out-of-fold dei modelli di base diventano le caratteristiche di input del meta-learner. Questo aggiunge flessibilità: il meta-learner può imparare che il modello A è affidabile sugli esempi facili, mentre il modello B è migliore su quelli difficili. Lo stacking generalmente supera il voto, ma richiede un'implementazione più attenta per evitare la fuoriuscita di dati.
Verifica rapida
Verifichi la Sua comprensione dei concetti relativi agli ensemble a voto trattati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: gli ensemble a voto combinano diversi tipi di modello per ridurre gli errori correlati, il voto rigido usa le etichette di maggioranza, mentre quello morbido calcola la media delle stime di probabilità e la diversità dei modelli è l'ingrediente fondamentale per un ensemble a voto efficace. Nella prossima lezione esamineremo le Support Vector Machines e il classificatore a margine massimo.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Ensemble a votazione: hard vote e soft vote» è gratuita?
Sì — il testo completo di «Ensemble a votazione: hard vote e soft vote» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Ensemble a votazione: hard vote e soft vote»?
Combinerà KNN, regressione logistica e albero decisionale in un VotingClassifier e confronterà la maggioranza hard vote con la media delle probabilità soft vote. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Ensemble a votazione: hard vote e soft vote»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Bootstrap aggregation (bagging) spiegato
- Selezione casuale delle feature: il trucco del random forest
- Errore out-of-bag: validazione gratuita nella foresta
- Ensemble a votazione: hard vote e soft vote