Stemmebaserte ensemblemodeller: Hard og myk avstemning
De vil kombinere KNN, logistisk regresjon og et beslutningstre i en VotingClassifier, og sammenligne flertallsavstemning med hard stemme med gjennomsnittsberegning av sannsynligheter med myk stemme.
Stemmebaserte ensemblemodeller: Hard og myk avstemning er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva er et voting-ensemble?
Et Voting Ensemble kombinerer prediksjonene fra flere ulike modelltyper – for eksempel logistisk regresjon, en k-nærmeste-naboer-klassifikator og et beslutningstre – for å lage én endelig prediksjon. I motsetning til bagging, som bruker mange kopier av samme modelltype, utnytter et voting-ensemble mangfold i modellarkitekturen. Siden ulike modeller gjør ulike typer feil, kan kombinasjonen prestere bedre enn hvert enkelt medlem, særlig på datasett der ingen enkeltalgoritme dominerer.
Hard voting: Flertallet bestemmer
Ved hard voting stemmer hver modell på en klasseetikett, og klassen som får flest stemmer, vinner. Hvis tre modeller predikerer [cat, cat, dog], predikerer ensemblet cat. Hard voting er enkelt og lett å tolke, men behandler alle modeller som like pålitelige og ignorerer konfidensnivåene. En modell som bare er 51 % sikker, stemmer på samme måte som en som er 99 % sikker. Dette kan føre til suboptimale avgjørelser når modellenes konfidensnivåer varierer mye.
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))Soft voting: Gjennomsnitt av sannsynligheter
Ved soft voting returnerer hver modell klassesannsynligheter i stedet for faste etiketter. Ensemblet beregner gjennomsnittet av sannsynlighetene på tvers av modellene og velger klassen med høyest gjennomsnittlig sannsynlighet. Hvis tre modeller tilordner sannsynlighetene [0.9, 0.1], [0.7, 0.3] og [0.6, 0.4] til to klasser, blir gjennomsnittet [0.73, 0.27], og klasse 0 vinner. Soft voting gir vanligvis bedre resultater enn hard voting fordi metoden bruker mer informasjon om hvor sikre modellene er.
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))Krav: Alle modeller må støtte predict_proba
Soft voting krever at alle modellene i ensemblet kan levere sannsynlighetsestimater via predict_proba(). De fleste scikit-learn-klassifikatorer støtter dette innebygd (logistisk regresjon, random forest, KNN, naiv Bayes). SVC returnerer imidlertid ikke sannsynligheter som standard – De må angi probability=True i konstruktøren. Dette legger til Platt-skalering (et kalibreringstrinn) og øker treningstiden. Hvis en modell ikke kan produsere sannsynligheter, må De bruke hard voting i stedet.
Vekte individuelle modeller
Både hard og soft voting støtter parameteren weights, som lar Dem gi mer innflytelse til mer nøyaktige modeller. Hvis logistisk regresjon for eksempel har 92 % nøyaktighet og KNN har 85 %, kan De vekte dem som [2, 1]. Ved hard voting gjentas hver stemme i henhold til vekten. Ved soft voting multipliseres hver modells sannsynlighetsvektor med vekten før gjennomsnittsberegningen. Å velge vekter basert på nøyaktighet fra kryssvalidering er en enkel og effektiv fremgangsmåte.
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))Sammenligne hard voting, soft voting og individuelle modeller
En direkte sammenligning av individuelle modeller, hard voting og soft voting på det samme datasettet viser ensembleeffekten tydelig. I de fleste tilfeller overgår soft voting hard voting, og begge overgår den svakeste individuelle modellen. Ensemblet slår imidlertid ikke alltid den sterkeste enkeltmodellen – det avhenger av hvor korrelerte modellenes feil er. Hvis alle modellene mislykkes på de samme eksemplene, gir kombinasjonen ingen fordel.
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}')Velge modeller for mangfold
Nøkkelen til et kraftig voting-ensemble er mangfold mellom modellene. Å kombinere tre logistiske regresjonsmodeller med ulike startverdier gir nesten ingen verdi – de vil alle gjøre de samme feilene. De mest effektive ensemblene kombinerer modeller med ulike induktive skjevheter: en lineær modell (logistisk regresjon), en instansbasert modell (KNN), en trebasert modell (random forest) og eventuelt en kjernebasert modell (SVM). Hver modell ser dataene fra en annen vinkel og gjør andre feil, som opphever hverandre ved gjennomsnittsberegning.
VotingRegressor for kontinuerlige målverdier
VotingRegressor bruker samme idé på regresjon: beregn gjennomsnittet av de numeriske prediksjonene fra flere regressorer. Det finnes ikke noe skille mellom hard og soft voting i regresjon – resultatet er alltid et vektet eller uvektet gjennomsnitt av de individuelle prediksjonene. En kombinasjon av Ridge-regresjon (lineær), Random Forest (treensemble) og SVR (kjernebasert metode) slår ofte hver enkelt modell på varierte tabellformede datasett.
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))Voting-ensembler i produksjon
Voting-ensembler er enkle å sette i drift fordi alle modellene kan serialiseres sammen med omslaget VotingClassifier ved hjelp av joblib.dump(). Ved prediksjon må alle modellene kjøres, så prediksjonsforsinkelsen øker lineært med antallet medlemmer. For applikasjoner som er følsomme for forsinkelse bør De begrense ensemblet til 2–3 sterke og raske modeller i stedet for mange langsomme. Mål alltid prediksjonstiden som en del av evalueringen før produksjonssetting.
Når voting-ensembler ikke gir bedre resultater
Voting-ensembler skuffer når: (1) alle modellene har de samme blindsonene og gjør korrelerte feil, (2) én modell er langt bedre enn de andre, slik at de svakere modellene trekker ensemblet ned, (3) oppgaven har svært lite støy, slik at én godt innstilt modell allerede oppnår nesten perfekte resultater, eller (4) datasettet er for lite, slik at den ekstra modellkapasiteten bare fører til overtilpasning. Diagnostiser dette ved å sammenligne individuelle feil mønstre på et valideringssett. Hvis feilene er sterkt korrelerte, kan De prøve å erstatte noen modeller med mer ulike arkitekturer.
Stacking kontra voting
Voting bruker en fast aggregering som er valgt på forhånd (flertallsavstemning eller gjennomsnitt). Stacking (eller stablet generalisering) går ett skritt videre: En metamodel trenes for å kombinere resultatene fra basismodellene optimalt. Basismodellenes out-of-fold-prediksjoner blir inndatafunksjonene for metamodellen. Dette gir større fleksibilitet – metamodellen kan lære at modell A er pålitelig for enkle eksempler, mens modell B er bedre for vanskelige eksempler. Stacking gir vanligvis bedre resultater enn voting, men krever mer omhyggelig implementering for å unngå datalekkasje.
Kort kontroll
Test forståelsen Deres av begrepene rundt Voting Ensemble fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at: Voting Ensembles kombinerer ulike modelltyper for å redusere korrelerte feil, hard voting bruker flertallets klasseetikett, mens soft voting beregner gjennomsnittet av sannsynlighetsestimatene, og mangfold mellom modellene er den viktigste ingrediensen i et effektivt voting-ensemble. Deretter skal vi se på Support Vector Machines og klassifikatoren med maksimal margin.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Stemmebaserte ensemblemodeller: Hard og myk avstemning» gratis?
Ja – hele teksten i «Stemmebaserte ensemblemodeller: Hard og myk avstemning» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Stemmebaserte ensemblemodeller: Hard og myk avstemning»?
De vil kombinere KNN, logistisk regresjon og et beslutningstre i en VotingClassifier, og sammenligne flertallsavstemning med hard stemme med gjennomsnittsberegning av sannsynligheter med myk stemme. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Machine Learning Academy?
Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Stemmebaserte ensemblemodeller: Hard og myk avstemning»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?
Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Bootstrap-aggregering (bagging) forklart
- Tilfeldig valg av egenskaper: Trikset i Random Forest
- Out-of-bag-feil: Gratis validering i skogen
- Stemmebaserte ensemblemodeller: Hard og myk avstemning