Dit artikel is gepubliceerd als onderdeel van de Data Science-blogathon.

Deze gids bevat concepten zoals ensembleleren, stemclassificaties, een briefing over inpakken, plakken en out-of-bag-evaluatie en de uitvoering ervan. Een korte uitleg over willekeurig bos, extra bomen en het belang van functies. Ten slotte zullen we de zaken afronden door een snelle blik te werpen op Boosting en enkele basis-QnA's.

Inleiding tot Ensemble Leren

Laten we beginnen met een voorbeeld, je hebt een vraag, en je stelt het rond, en aggregeert vervolgens hun antwoorden. In de meeste gevallen zult u merken dat dit antwoord veel beter is dan het antwoord van één deskundige. Dus dit heet de wisdom of the crowd. Evenzo, als u de voorspellingen van modellen zoals classifiers of regressors samenvoegt, zou u merken dat de groep betere prestaties levert dan het beste individuele model. Dus deze groep voorspellers of modellen heet ensemble en daarom staat deze techniek bekend als: Ensemble leren.

U kunt bijvoorbeeld een groep classifiers van beslissingsbomen trainen op verschillende willekeurige subsets van de trainingsgegevens. Om daarna voorspellingen te doen, voorspellingen te verkrijgen van alle individuele bomen en de meest voorkomende klasse te voorspellen (dwz de meest voorspelde). Dit ensemble van beslissingsbomen heet Willekeurig bos en is een van de krachtigste algoritmen in de wereld van machine learning.

Deze techniek gebruik je vaak aan het einde van een project. Zodra je een paar goede voorspellers in je hand hebt en ze zelfs combineert tot een betere. De meeste winnende oplossingen in competities voor machine learning hebben betrekking op ensemble-methoden. (Bijvoorbeeld de prijscompetitie van Netflix).

Dus, ga een kopje koffie drinken, maak het jezelf gemakkelijk. En laten we beginnen met onze reis van leren over Ensemble Learning.

Stemclassificaties in Ensemble Learning

Stel dat je een aantal classificaties hebt, met elk een nauwkeurigheid van ongeveer 80-85%. Nu kunt u een Support Vector Classifier, een Random Forest Classifier, een Logistics Regression Classifier, een K-Nearest Neighbours-classifier en misschien nog een paar meer hebben. Een eenvoudige manier om een ​​nog betere classifier te maken, is door de voorspellingen van alle classifiers te combineren en de meest voorkomende class uit te voeren. Dit type classificatie (classificatie met meerderheid van stemmen) staat bekend als: Harde stemclassificatie.

Het interessante hier is dat dit type stemclassificatie vaak zelfs de beste classifier in het ensemble overtreft. Zelfs als elk van de classifiers een zwakke leerling is, betekent het zelfs dat het iets beter is dan een model dat willekeurig raadt. Het ensembles-model kan nog steeds een sterke leerling zijn, ervan uitgaande dat er voldoende zwakke leerlingen zijn en onafhankelijk van elkaar zijn. Een ensemble presteert alleen goed in gevallen waarin alle classifiers perfect onafhankelijk van elkaar zijn, dwz ongecorreleerde fouten maken, wat een hele uitdaging is om te bereiken omdat ze allemaal op dezelfde gegevens zijn getraind. Daarom maken ze waarschijnlijk dezelfde soorten fouten. Dus op zijn beurt zal er een meerderheid van de stemmen zijn voor de verkeerde klasse, waardoor de algehele nauwkeurigheid van het ensemble afneemt. Een manier om een ​​diverse reeks classificaties te bereiken, is door zeer verschillende algoritmen te gebruiken. Met verschillende algoritmen kunnen ze verschillende soorten fouten maken, wat op zijn beurt de nauwkeurigheid van het ensemble zal vergroten.

De volgende code initialiseert en traint een classifier die bestaat uit drie verschillende classifiers, namelijk SVM, Random Forest en Logistics Regression. We zullen Moon's Dataset gebruiken voor onze implementatie.

Laten we beginnen met onze implementatie

Benodigde bibliotheken importeren:

van sklearn.model_selection import train_test_split van sklearn.datasets import make_moons van sklearn.linear_model import LogisticRegression van sklearn.svm import SVC van sklearn.ensemble import RandomForestClassifier van sklearn.ensemble import nauwkeurigheid Votingscoren.metric

Gegevensset maken:

X, y = make_moons(n_samples=500, ruis=0.30) X_train, X_test, y_train, y_test = train_test_split(X, y)

De modellen initialiseren:

log = LogisticRegression() rnd = RandomForestClassifier(n_estimators=100) svm = SVC()

stemmen = VotingClassifier( estimators=[('logistics_regression', log), ('random_forest', rnd), ('support_vector_machine', svm)], voting='hard')

Hier zijn we aan het stemmen = 'hard' betekent dat het volgt meerderheidsregel stemmen en n_estimators als 100. De rest van alle parameters is standaard.

Passende trainingsgegevens:

stemmen.fit(X_train, y_train)

Laten we nu eens kijken hoe dit werkt op de testset:

voor clf in (log, rnd, svm, stemmen): clf.fit(X_train, y_train) y_pred = clf.predict(X_test) print(clf.__class__.__name__, nauwkeurigheid_score(y_test, y_pred))

Boom! Daar hebben we het, omdat we kunnen zien dat de stemclassificatie enigszins beter presteert dan andere individuele modellen. Als u werkt met classifiers die de methode predict_proba() hebben, betekent dit dat ze de waarschijnlijkheid van een klasse kunnen schatten. Vervolgens voeren we de klasse uit met de hoogste waarschijnlijkheid die wordt gemiddeld over alle classificaties. Deze techniek staat bekend als: zacht stemmen. Deze techniek presteert meestal beter dan hard stemmen, omdat het meer gericht is op de zeer zelfverzekerde stemmen. Om dit te gebruiken, hoef je alleen maar "hard" te vervangen door "zacht" en onthoud dat dit alleen werkt voor de classifiers die de klassewaarschijnlijkheid kunnen schatten.

Inpakken en plakken in Ensemble Learning

Zoals eerder besproken, kunnen we verschillende algoritmen gebruiken om een ​​diverse set classificaties te krijgen. Er is ook een andere benadering, we kunnen hetzelfde algoritme gebruiken voor elke voorspeller en ze trainen op verschillende willekeurige subsets van trainingsgegevens.

Zakken: Telkens wanneer we een subset van de gegevens selecteren met de vervanging het staat bekend als Bagging.

plakken: Telkens wanneer we een subset van de gegevens selecteren zonder vervanging het staat bekend als Plakken.

Zowel het inpakken als het plakken van treinvoorspellers op een andere willekeurige subset van de trainingsgegevens. Aan het einde, wanneer alle voorspellers zijn getraind, kan het ensemble nieuwe gegevens voorspellen door eenvoudig de voorspelling van alle voorspellers te combineren op dezelfde manier als de harde stemclassificatie (As-modus in statistieken). Meestal heeft ensemble dezelfde bias maar minder variantie dan een individuele voorspeller die is getraind op de originele trainingsgegevens.

Bekijk deze blog voor meer informatie over Bias en Variance hier.

Het grootste voordeel van inpakken en plakken is dat ze kunnen worden getraind op verschillende CPU's of op verschillende servers en dit is een van de vele andere redenen waarom beide erg populaire methoden zijn.

Laten we beginnen met onze implementatie:

We zullen dezelfde dataset gebruiken die we eerder hebben gemaakt.

Benodigde bibliotheken importeren:

van sklearn.ensemble import BaggingClassifier van sklearn.tree import DecisionTreeClassifier van sklearn.metrics import nauwkeurigheid_score

Een zakclassificatie initialiseren:

bagging_clf = BaggingClassifier( DecisionTreeClassifier(), n_estimators=250, max_samples=100, bootstrap=True, random_state=101)

Laten we de code hier een beetje opsplitsen, de bovenstaande code zal een ensemble van 250 beslissingsboomclassificaties (n_estimators) trainen en elk van hen wordt getraind op 100 willekeurige subsets van de trainingsgegevens (max_samples) met vervanging terwijl we eraan werken een bagging-classificatie, maar als je in plaats daarvan aan plakken wilt werken, ga je gang en stel de bootstrap = False in. Ten slotte specificeren de n_jobs-parameters hoeveel CPU-kernen u wilt gebruiken voor training en voorspelling (-1 betekent dat het alle beschikbare kernen kan gebruiken). Voor regressie kunt u BaggingRegressors gebruiken.

Bekijk de officiële documentatie hier voor meer informatie.

De classifier trainen:

bagging_clf.fit(X_train, y_train)

De classificatie testen:

y_pred = bagging_clf.predict(X_test) print(accuracy_score(y_test, y_pred))

Als we een gewone beslisboomclassificator vergelijken met de baggingclassificatie die we zojuist hebben gemaakt, zijn beide getraind op moons-dataset. Door te observeren, kunnen we in de onderstaande afbeelding zien dat:

Het ensemble is veel algemener dan een individuele beslisboom.

Out-of-bag evaluatie

Telkens wanneer u bagging gebruikt, is er een hoeveelheid gegevens die meer dan eens kan worden bemonsterd (subset selecteren) of misschien zelfs meer, en er kunnen gegevens zijn die helemaal niet worden bemonsterd. Bagging Classifier-steekproeven n trainingsinstanties met standaard vervanging, wat betekent dat gemiddeld slechts ongeveer 63% van de gegevens voor elke voorspeller wordt bemonsterd. De rest van de 37% van de gegevens wordt helemaal niet gesampled, nu staan ​​deze gegevens/instanties bekend als out-of-bag (OOB)-instanties. Onthoud dat 37% niet voor alle voorspellers hetzelfde is.

Aangezien ons model deze gegevens nog nooit eerder heeft gezien, kan het nuttig zijn om te evalueren dat er geen afzonderlijke validatiegegevens nodig zijn.

Bagging classifier heeft een parameter oob_score die bij het instellen van true automatisch oobs zal gebruiken voor evaluatie nadat de training is voltooid.

Laten we eens kijken naar de implementatie:

De bibliotheken en datasets die hier worden gebruikt, zijn hetzelfde.

De classificatie initialiseren:

bagging_clf = BaggingClassifier( DecisionTreeClassifier(), n_estimators=250, bootstrap=True, oob_score=True, random_state=101)

bagging_clf.fit(X_train, y_train)

bagging_clf.oob_score_

Als we het afronden, krijgen we 90%, wat dicht genoeg in de buurt komt van wat we eerder hebben bereikt (91.2%). Dus door het model op oobs te testen, kunnen we een ruwe schatting krijgen van de nauwkeurigheid die we zullen bereiken op de testset.

Willekeurige bossen

Zoals we in de inleiding al hebben besproken, is het Random forest slechts een geheel van beslisbomen die zijn getraind door de bagging-methode. Hier worden de max_Samples ingesteld op de grootte van trainingsgegevens. Dus in plaats van een zakclassificatie te maken met behulp van beslissingsbomen, is het beter voor u om meteen de RandomForest Classifier of RandomForest Regressor (voor regressie) te gebruiken, die veel geoptimaliseerd en efficiënter in gebruik is.

Laten we eens kijken naar de implementatie:

Benodigde bibliotheken importeren:

van sklearn.ensemble import RandomForestClassifier

Initialiseren en trainen (dataset van dezelfde maan):

random_forest_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, random_state=42,n_jobs=-1) random_forest_clf.fit(X_train, y_train)

De bovenstaande code traint een Random Forest Classifier met 500 bomen (n_estimators=500) en gebruikt alle beschikbare CPU-cores, zoals we hebben gespecificeerd n_jobs =-1, elk beperkt tot een maximum van 16 knooppunten.

Voor meer gedetailleerde informatie over Beslisboom, bekijk het eens hier.

Voorspellen voor testgegevens:

y_pred_random_forest = willekeurig_forest_clf.predict(X_test)

Random Forest Classifier bestaat uit alle hyperparameters van een Decision Tree Classifier en die van Bagging Classifier om het proces te controleren.

Het Random Forest-algoritme gebruikt extra willekeur bij het kweken van bomen. In plaats van te zoeken naar de beste functie tijdens het splitsen van het knooppunt. Wat het doet, is zoeken naar de beste functie uit een willekeurige subset van functies. Het algoritme ruilt ook een hogere bias in voor een lagere variantie, wat op zijn beurt de algehele nauwkeurigheid verhoogt.

Laten we doorgaan en een vergelijkbare Bagging-classifier maken en de voorspellingen ervan vergelijken met die van de Random Forest Classifier.

Initialiseren en trainen van het model:

bagging_clf = BaggingClassifier( DecisionTreeClassifier(max_leaf_nodes=16), n_estimators=500, random_state=101)

Trainen en voorspellen:

bagging_clf.fit(X_train, y_train) y_pred_bagging = bagging_clf.predict(X_test)

Laten we nu de voorspellingen van de bagging classifier (y_pred_bagging) en Random Forest (y_pred_random_forest) vergelijken en kijken wat we krijgen:

np.sum(y_pred_bagging == y_pred_random_forest) / len(y_pred_bagging)

Zoals we kunnen zien, zijn bijna 95.2% van de voorspellingen van de Bagging-classifier en Random Forest vergelijkbaar.

Extra bomen

Laten we kort doorgaan met dit onderwerp.

Telkens wanneer het Random Forest een boom laat groeien, wordt voor elk knooppunt alleen een willekeurige subset van functies in rekening gebracht voor splitsing. Een manier om tress nog meer willekeurig te maken, is door de willekeurige drempel voor elke functie in te stellen in plaats van te zoeken naar de beste drempel zoals de beslissingsboom doet.

Deze techniek ruilt ook een hoge bias in voor een lage variantie. Het voordeel van het gebruik van Extra bomen in plaats van een willekeurig forest is dat het sneller is, omdat het erg tijdrovend is om de best mogelijke drempel voor elke functie op elk knooppunt te vinden.

Het maken van de Classifier Extra bomen is bijna gelijk aan die van de Random Forest Classifier. Voor classificatie kunt u de Extra Trees-classificatieklasse van Scikit-learn gebruiken en voor regressie de Extra Tree Regressor-klasse van Scikit-learn.

Het is moeilijk om te weten welke het beste of het slechtste zou presteren tussen willekeurige forests en extra bomen, de enige manier om te weten is om beide te creëren en ze te vergelijken met behulp van kruisvalidatie.

Feature Belang

Veruit een van de beste dingen die Random Forest te bieden heeft, het helpt ons om het belang van elke functie te meten. Scikit-learn berekent het door te analyseren hoeveel een boomknooppunt dat die functie gebruikt, gemiddeld onzuiverheden vermindert.

Scikit-learn berekent deze scores automatisch voor elk kenmerk en schaalt het daarna zo dat de som van alle belangrijkheid gelijk is aan 1. Om toegang te krijgen tot het belang van het kenmerk, gebruiken we de variabele feature_importances.

Laten we eens kijken naar het implementatiegedeelte voor beide IRIS en MNIST gegevenssets:

IRIS-GEGEVENSSET

Importeer de benodigde bibliotheken en laad de dataset:

van sklearn.datasets import load_iris iris = load_iris ()

Initialiseer en train een Random Forest Classifier:

rand_forest_clf = RandomForestClassifier(n_estimators=500, random_state=42) rand_forest_clf.fit(iris["data"], iris["target"])

Druk respectievelijk het belang van de functie samen met hun namen af:

voor feature, score in zip(iris["feature_names"], rand_forest_clf.feature_importances_): print(feature, score)

Hier kunnen we zien dat de lengte van de bloembladen (44%) en de breedte van de bloembladen (42%) belangrijker lijken te zijn dan de kelkbladlengte (11%) en de kelkbladbreedte (2%).

MNIST-GEGEVENSSET

Laten we doorgaan en willekeurige Forest Classifier trainen op de MNIST-dataset en het belang van elke pixel plotten met behulp van matplotlib.

Initialiseren en trainen van het model:

rand_forest_clf = RandomForestClassifier(n_estimators=100, random_state=42) rand_forest_clf.fit(mnist["data"], mnist["target"])

In plaats van het belang van het kenmerk af te drukken, is het beter om het meteen te visualiseren:

image = rand_forest_clf.feature_importances_.reshape(28, 28) plt.imshow(image, cmap = mpl.cm.bone,interpolation="nearest") plt.axis ("off")

cbar = plt.colorbar(ticks=[rand_forest_clf.feature_importances_.min(), rand_forest_clf.feature_importances_.max()]) cbar.ax.set_yticklabels(['Minder belang', 'Hoger belang']) plt.show()

Het is vrij eenvoudig te interpreteren dat de grenzen van de afbeeldingen geen betekenis hebben bij de voorspelling van een bepaald getal.

Als je dol bent op visualisatie, bekijk dan mijn blog hier.

Dus als u functieselectie moet uitvoeren, is Random forest er om u te helpen een snelle analyse te krijgen van welke functies er veel toe doen.

Het stimuleren van

Wanneer meerdere zwakke leerlingen worden gecombineerd om een ​​sterke leerling te vormen, noemen we dit boosting (boosting-hypothese). Wat het eigenlijk doet, is de voorspellers in sequentiële volgorde trainen, elk van hen corrigeert de fout van zijn voorganger. Er zijn veel boosting-algoritmen die Scikit-learn te bieden heeft, maar verreweg de beste en meest populaire zijn AdaBoost (Adaptive Boosting) en Gradient Boosting.

Laten we eerst Adaboost opsplitsen:

AdaBoost

Over het algemeen is de techniek die door AdaBoost wordt gebruikt, dat het aandacht besteedt aan de trainingsgegevens die zijn voorgangers hebben aangepast. Dit resulteert in nieuwe voorspellers die zich meer concentreren op deze harde gevallen.

Laten we dit met een voorbeeld begrijpen. Bij het trainen van een Adaboost-classifier traint het algoritme eerst een base classifier (veronderstel Decision Trees) en na het trainen gebruikt het deze base classifier om voorspellingen te doen op de trainingsgegevens. Hierna verhoogt het algoritme zijn relatieve gewicht voor de trainingsinstanties die onze basisclassificator fout had (misclassificatie). Vervolgens traint het een andere classifier met deze nieuwe (bijgewerkte) gewichten en doet opnieuw voorspellingen over trainingsgegevens en werkt de gewichten dienovereenkomstig bij, en dit proces gaat maar door.

Zodra alle voorspellers zijn getraind en klaar zijn om te gaan, maakt het ensemble voorspellingen die vergelijkbaar zijn met inpakken of plakken, het enige verschil is dat de voorspellers verschillende gewichten hebben op basis van de nauwkeurigheid (classificaties die ze goed hebben) op de trainingsgegevens.

Een van de grote nadelen van deze sequentiële benadering is dat ze niet kunnen worden geparalleliseerd, wat betekent dat ze niet tegelijkertijd op verschillende systemen kunnen worden getraind, aangezien elk van de voorspellers de training en evaluatie van zijn eerdere voorspellers vereist. Daarom schalen ze niet zoals in zakken doen en plakken.

We zullen het hier niet hebben over de wiskunde hierachter, maar ik verzoek je om enkele andere blogs of artikelen te bekijken om een ​​wiskundige intuïtie en een gedetailleerde algemene werking te krijgen.

Laten we eens kijken naar de implementatie:

De dataset is dezelfde die we eerder hebben gemaakt, voor het geval je het bent vergeten; aangezien je een heel eind verder bent

van sklearn.ensemble import AdaBoostClassifier

adaboost_clf = AdaBoostClassifier( DecisionTreeClassifier(max_depth=1), n_estimators=200, algorithm="SAMME.R", learning_rate=0.5, random_state=42) adaboost_clf.fit(X_train, y_train)

De bovenstaande code traint een AdaBoost-classificatie op basis van 200 Decision Stumps (een met max_diepte ingesteld op 1, bestaat uit een enkel beslissingsknooppunt en twee bladknooppunten). Hier is de leersnelheid het gewicht dat wordt toegepast op elke classificatie tijdens de boosting-iteraties. Hoe hoger het leertempo, hoe hoger de bijdrage van elke classifier. Houd er rekening mee dat er een wisselwerking is tussen n_estimators en leersnelheid.

Nu moet je je afvragen wat SAMME hier is, dus het is een versie met meerdere klassen van AdaBoost die staat voor Stagewise Addictive Modeling met behulp van een Multiclass Exponential Loss-functie. Je hebt daar misschien ook een (.R) opgemerkt, het staat voor echt, als de voorspellers waarmee je werkt de methode predict_proba() hebben, wat betekent dat ze klassenwaarschijnlijkheden kunnen schatten, kun je a gebruiken. R omdat klassekansen over het algemeen beter presteren. Dit is de standaard basisschatter voor AdaBoost Classifier.

Voorspelling en nauwkeurigheid:

y_pred = adaboost_clf.predict(X_test) nauwkeurigheid_score(y_test, y_pred)

We hebben ongeveer 90% nauwkeurigheid, wat ook niet slecht is!

Laten we nu beginnen met Gradient Boosting.

Verloopversterking

Het tweede extreem populaire boost-algoritme dat we binnenkort gaan zien, is: gradiëntversterking. Gradient boost werkt ook ongeveer op dezelfde manier als AdaBoost werkt, dwz het opeenvolgend toevoegen van voorspellers aan een ensemble, waarbij elk van hen zijn voorganger corrigeert. Het enige verschil is dat in plaats van het aanpassen van de gewichten bij elke iteratie zoals AdaBoost, deze methode zich meer richt op en nieuwe voorspellers probeert aan te passen aan de restfout gemaakt door de vorige.

Resterende fout in eenvoudige bewoordingen betekent het verschil tussen een groep waargenomen waarden en hun rekenkundig gemiddelde.

Laten we gaan met een eenvoudig voorbeeld voor een beter begrip:

We gebruiken een beslisboom als basisvoorspeller. Laten we doorgaan en een beslisboomregressor aanpassen aan de trainingsgegevens. We zullen de dataset nu wijzigen, hier zullen we een eenvoudige kwadratische dataset met ruis maken.

np.random.seed(42) X = np.random.rand(100, 1) - 0.5 y = 3*X[:, 0]**2 + 0.05 * np.random.randn(100)

Nu het maken van onze dataset voltooid is, gaan we verder en passen het in ons model.

van sklearn.tree import DecisionTreeRegressor

tree_reg_first = DecisionTreeRegressor(max_depth=2, random_state=42) tree_reg_first.fit(X, y)

Zoals eerder besproken, dat deze methode zich richt op restfouten. Nu gaan we de tweede beslisboom-regressor trainen op de resterende fouten van de eerste.

y2 = y - tree_reg_first.predict(X) tree_reg_second = DecisionTreeRegressor(max_depth=2, random_state=42) tree_reg_second.fit(X, y2)

We moeten de derde regressor trainen met behulp van de residuen die door de vorige (tweede) zijn gemaakt.

y3 = y2 - tree_reg_second.predict(X) tree_reg_third = DecisionTreeRegressor(max_depth=2, random_state=42) tree_reg_third.fit(X, y3)

Laten we nu een ensemble maken dat bestaat uit alle bomen die we zojuist hebben getraind.

X_new = np.array([[0.8]]) //value waarop we het zullen testen.

y_pred = sum(tree.predict(X_new) voor tree in (tree_reg_first, tree_reg_second, tree_reg_third))

Nu zal het voorspellingen doen voor nieuwe gegevens door gewoon een voorspelling van alle bomen bij elkaar op te tellen. Laten we doorgaan en zien wat het voorspelt.

Dus het voorspelde y = 0.75 voor x = 0.8.

De volgende code werkt ongeveer hetzelfde:

van sklearn.ensemble import GradientBoostingRegressor

gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=3, learning_rate=1.0, random_state=42) gbrt.fit(X, y)

En het zal dezelfde ensembles creëren als degene die er eerder uitzagen.

gbrt.predict(X_new)

Bekijk de officiële documentatie voor meer info.

Ensemble Learning Q&A-sessie

In dit gedeelte zullen we enkele basisvragen doornemen, zodat u de onderwerpen die we zojuist hebben besproken beter kunt begrijpen.

1. Wat is het verschil tussen harde en zachte stemclassificaties?

Antwoord: Een harde stemclassificator telt alleen de stemmen van elke classifier in het ensemble en geeft de klasse weer die in meerderheid was. Aan de andere kant berekent een zachte stemclassificatie de klassewaarschijnlijkheid voor elke classifier in het ensemble en geeft de klasse met de hoogste waarschijnlijkheid weer. Maar zacht stemmen werkt alleen voor de classifier die de methode predict_proba() heeft.

2. Denk je dat je de trainingstijd van het inpakken kunt versnellen door het over meerdere servers te verdelen? Zo ja, waarom dan? Hoe zit het met Plakken, boosten en Random Forest?

Antwoord: Ja, het is mogelijk om de trainingstijd van het inpakken te versnellen door ze op meerdere servers te distribueren, omdat ze allemaal onafhankelijk van elkaar zijn. Plakken en Random Forest werken ook op dezelfde manier. Dus ook bij hen geen probleem. Over het versterken van algoritmen gesproken, ze vertrouwen op hun voorgangers. Het is dus niet mogelijk om ze over meerdere servers te trainen.

3. Wat zijn de voordelen van Out-of-Bag Evaluation?

Antwoord: Zoals we allemaal weten, wordt in de out-of-bag-evaluatie elke voorspeller beoordeeld op de gevallen waarop deze niet is getraind (37% die over was, als u zich dat herinnert). Dit geeft het voordeel van een onbevooroordeelde evaluatie van het ensemble zonder dat een validatieset nodig is.

4. Waarin verschillen extra bomen van een gewoon willekeurig bos? Tussen extra bomen en willekeurig bos, wat is sneller? Hoe kan Randomness helpen bij extra bomen?

Antwoord: Zowel Extra Trees als Random Forest beschouwen een willekeurige subset van functies voor splitsing op elk knooppunt. Het enige verschil is dat in plaats van te zoeken naar de best mogelijke drempel voor een kenmerk, extra bomen een willekeurige drempel gebruiken. Deze willekeurigheid van functies werkt als regularisatie, als Random Forest ooit de trainingsgegevens overvult, is de kans groot dat Extra bomen beter presteren. In termen van voorspellingssnelheid zijn ze allebei hetzelfde, omdat we weten dat Extra Trees niet op zoek is naar de beste drempel voor een functie, het bespaart veel tijd. Daarom is het sneller dan Random Forest.

5. Terwijl je aan het werk bent, merk je dat de AdaBoost-classifier de trainingsgegevens te weinig aanpast, wat zijn de hyperparameters die je gaat aanpassen en hoe?

Antwoord: Als we vaststellen dat AdaBoost de trainingsgegevens ondermaats maakt, kunnen we proberen het aantal schatters te vergroten of we kunnen ook proberen de regularisatiehyperparameters van de basisschatter te verminderen. Het verhogen van de leersnelheid kan ook een beetje helpen.

6. Terwijl u aan het werk bent, merkt u dat uw Gradient Boosting de trainingsgegevens overbelast. Wat vindt u van de leersnelheid?

Antwoord: Als we constateren dat Gradient Boosting de trainingsgegevens overbelast, kunnen we doorgaan en de leersnelheid verlagen, en ook kunnen we vroeg stoppen gebruiken (een ander hot topic zal een andere dag bespreken) om het juiste aantal voorspellers te vinden.

Dus als je de helft van of alle bovenstaande vragen goed hebt, gefeliciteerd! U hebt waarschijnlijk alle paragrafen van deze handleiding doorgenomen. Ik ben dankbaar dat ik een lezer zoals jij heb...

eindnoten

Eindelijk, onze reis om dit onderwerp te leren is tot een einde gekomen!. Het was best een lange. Maar ik ben blij dat je de hele tijd bij me bent. Om de zaken af ​​te ronden... laten we de onderwerpen herzien die we in deze gids hebben gezien. Eerst begonnen we met een algemene introductie, daarna een basisdiscussie over stemclassificaties, we zagen wat bagging, plakken en out-of-bag evaluatie is, samen met hun implementatie, daarna zagen we een korte werking van Random Forest, Extra-Trees en Beschikt over zowel theoretisch als praktisch belang, tot slot hebben we een blik geworpen op het stimuleren van algoritmen. We kregen ook de kans om enkele vragen door te nemen, waarmee u zelf kunt beoordelen hoeveel u in deze gids heeft kunnen consumeren.

Blijf kijken!!

Kijk ook eens bij mijn andere blogs hier.

Ik hoop dat je dit artikel met plezier hebt gelezen. Als je het nuttig vond, deel het dan ook met je vrienden op sociale media. Voor vragen en suggesties kun je me hier in de comments pingen of je kunt me rechtstreeks bereiken via e-mail.

Verbind mij met op LinkedIn

E-mail: [e-mail beveiligd]

Bedankt!

Verwant

PlatoAi. Web3 opnieuw uitgevonden. Gegevensintelligentie versterkt.
Klik hier om toegang te krijgen.

Bron: https://www.analyticsvidhya.com/blog/2021/12/a-detailed-guide-to-ensemble-learning/