• Beslisboom is een Begeleide leertechniek dat kan worden gebruikt voor zowel classificatie- als regressieproblemen, maar heeft meestal de voorkeur voor het oplossen van classificatieproblemen. Het is een boomgestructureerde classificator, waarbij interne knooppunten vertegenwoordigen de kenmerken van een dataset, takken vertegenwoordigen de beslissingsregels En elk bladknooppunt vertegenwoordigt de uitkomst.
• In een beslissingsboom zijn er twee knooppunten, namelijk de Beslissingsknooppunt En Bladknooppunt. Beslissingsknooppunten worden gebruikt om elke beslissing te nemen en hebben meerdere vertakkingen, terwijl Leaf-knooppunten de uitvoer zijn van die beslissingen en geen verdere vertakkingen bevatten.
• De beslissingen of de test worden uitgevoerd op basis van kenmerken van de gegeven dataset.
Het is een grafische weergave om alle mogelijke oplossingen voor een probleem/beslissing te verkrijgen op basis van gegeven omstandigheden.
• Het wordt een beslissingsboom genoemd omdat het, net als een boom, begint met het wortelknooppunt, dat zich uitbreidt naar verdere takken en een boomachtige structuur construeert.
• Om een ​​boom te bouwen, gebruiken we de CART-algoritme, wat staat voor Classificatie- en regressieboomalgoritme.
• Een beslissingsboom stelt eenvoudigweg een vraag en op basis van het antwoord (Ja/Nee) wordt de boom verder opgesplitst in subbomen.
• Het onderstaande diagram legt de algemene structuur van een beslisboom uit:

Opmerking: Een beslissingsboom kan zowel categorische gegevens (JA/NEE) als numerieke gegevens bevatten.

Waarom beslisbomen gebruiken?

Er zijn verschillende algoritmen in Machine Learning, dus het kiezen van het beste algoritme voor de gegeven dataset en het gegeven probleem is het belangrijkste punt om te onthouden bij het maken van een machine learning-model. Hieronder staan ​​de twee redenen om de beslisboom te gebruiken:

• Beslissingsbomen bootsen meestal het menselijk denkvermogen na tijdens het nemen van een beslissing, dus het is gemakkelijk te begrijpen.
• De logica achter de beslissingsboom kan gemakkelijk worden begrepen omdat deze een boomachtige structuur vertoont.

Beslisboomterminologieën

Hoe werkt het Decision Tree-algoritme?

In een beslissingsboom begint het algoritme voor het voorspellen van de klasse van de gegeven dataset vanaf het hoofdknooppunt van de boom. Dit algoritme vergelijkt de waarden van het root-attribuut met het record-attribuut (echte dataset) en volgt op basis van de vergelijking de vertakking en springt naar het volgende knooppunt.

Voor het volgende knooppunt vergelijkt het algoritme opnieuw de attribuutwaarde met de andere subknooppunten en gaat verder. Het zet het proces voort totdat het de bladknoop van de boom bereikt. Het volledige proces kan beter worden begrepen met behulp van het onderstaande algoritme:

Stap 1:Begin de boom met het hoofdknooppunt, zegt S, dat de volledige dataset bevat.Stap 2:Vind het beste attribuut in de dataset met behulp van Attribuutselectiemaatstaf (ASM). Stap 3:Verdeel de S in subsets die mogelijke waarden voor de beste eigenschappen bevatten.Stap 4:Genereer het beslissingsboomknooppunt, dat het beste attribuut bevat.Stap 5:Maak recursief nieuwe beslissingsbomen met behulp van de subsets van de gegevensset die in stap -3 zijn gemaakt. Ga door met dit proces totdat een stadium is bereikt waarin u de knooppunten niet verder kunt classificeren en het laatste knooppunt een bladknooppunt kunt noemen.

Voorbeeld: Stel dat er een kandidaat is die een baanaanbod heeft en wil beslissen of hij het aanbod moet accepteren of niet. Om dit probleem op te lossen, begint de beslissingsboom dus met het hoofdknooppunt (Salarisattribuut door ASM). Het hoofdknooppunt splitst zich verder op in het volgende beslissingsknooppunt (afstand vanaf het kantoor) en één bladknooppunt op basis van de bijbehorende labels. Het volgende beslissingsknooppunt wordt verder opgesplitst in één beslissingsknooppunt (Cab-faciliteit) en één bladknooppunt. Ten slotte splitst het beslissingsknooppunt zich in twee bladknooppunten (Geaccepteerde aanbiedingen en Afgewezen aanbod). Beschouw het onderstaande diagram:

string-tokenizer java

Attribuutselectiemetingen

Bij het implementeren van een beslissingsboom rijst de belangrijkste vraag hoe het beste attribuut voor het hoofdknooppunt en voor subknooppunten moet worden geselecteerd. Om dergelijke problemen op te lossen is er dus een techniek die as wordt genoemd Attribuutselectiemaatstaf of ASM. Door deze meting kunnen we eenvoudig het beste kenmerk voor de knooppunten van de boom selecteren. Er zijn twee populaire technieken voor ASM, namelijk:

Informatiewinst Gini-index

1. Informatiewinst:

• Informatiewinst is het meten van veranderingen in entropie na de segmentatie van een dataset op basis van een attribuut.
• Het berekent hoeveel informatie een functie ons over een klasse biedt.
• Afhankelijk van de waarde van de informatiewinst splitsen we het knooppunt en bouwen we de beslissingsboom.
• Een beslissingsboomalgoritme probeert altijd de waarde van de informatiewinst te maximaliseren, en een knooppunt/attribuut met de hoogste informatiewinst wordt eerst gesplitst. Het kan worden berekend met behulp van de onderstaande formule:

 Information Gain= Entropy(S)- [(Weighted Avg) *Entropy(each feature) 

Entropie: Entropie is een metriek om de onzuiverheid in een bepaald attribuut te meten. Het specificeert willekeur in gegevens. Entropie kan worden berekend als:

Entropy(s)= -P(yes)log2 P(yes)- P(no) log2 P(no)

Waar,

S= Totaal aantal monsters P(ja)= waarschijnlijkheid van ja P(nee)= waarschijnlijkheid van nee

2. Gini-index:

• Gini-index is een maatstaf voor onzuiverheid of zuiverheid die wordt gebruikt bij het maken van een beslissingsboom in het CART-algoritme (Classification and Regression Tree).
• Een attribuut met de lage Gini-index verdient de voorkeur boven de hoge Gini-index.
• Het creëert alleen binaire splitsingen, en het CART-algoritme gebruikt de Gini-index om binaire splitsingen te creëren.
• De Gini-index kan worden berekend met behulp van de onderstaande formule:

 Gini Index= 1- &#x2211;<sub>j</sub>P<sub>j</sub><sup>2</sup> 

Snoeien: een optimale beslisboom krijgen

Snoeien is een proces waarbij onnodige knooppunten uit een boom worden verwijderd om de optimale beslissingsboom te krijgen.

Een te grote boom vergroot het risico op overfitting, en een kleine boom kan mogelijk niet alle belangrijke kenmerken van de dataset vastleggen. Daarom staat een techniek die de omvang van de leerboom verkleint zonder de nauwkeurigheid te verminderen bekend als Snoeien. Er zijn hoofdzakelijk twee soorten bomen snoeien gebruikte technologie:

Kostencomplexiteit Snoeien Minder fouten bij het snoeien.

Voordelen van de beslisboom

• Het is eenvoudig te begrijpen omdat het hetzelfde proces volgt dat een mens volgt bij het nemen van een beslissing in het echte leven.
• Het kan zeer nuttig zijn bij het oplossen van beslissingsgerelateerde problemen.
• Het helpt om na te denken over alle mogelijke uitkomsten van een probleem.
• Er is minder vereiste voor het opschonen van gegevens in vergelijking met andere algoritmen.

Nadelen van de beslisboom

• De beslisboom bevat veel lagen, wat het complex maakt.
• Mogelijk is er sprake van een overfittingprobleem, dat kan worden opgelost met behulp van de Willekeurig Forest-algoritme.
• Voor meer klassenlabels kan de computationele complexiteit van de beslissingsboom toenemen.

Python-implementatie van beslissingsboom

Nu zullen we de beslissingsboom implementeren met behulp van Python. Hiervoor gebruiken we de dataset ' gebruiker_data.csv ,' die we in eerdere classificatiemodellen hebben gebruikt. Door dezelfde dataset te gebruiken, kunnen we de beslissingsboomclassificator vergelijken met andere classificatiemodellen zoals KNN SVM, LogistiekeRegressie, etc.

Linux-wijzigingsbestand

De stappen blijven ook hetzelfde, die hieronder worden weergegeven:

Gegevensvoorverwerkingsstap Een beslissingsboomalgoritme aan de trainingsset aanpassen Het voorspellen van het testresultaat Testnauwkeurigheid van het resultaat (Creation of Confusion-matrix) Het visualiseren van het resultaat van de testset.

1. Stap voorverwerking van gegevens:

Hieronder vindt u de code voor de voorverwerkingsstap:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. 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, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

In de bovenstaande code hebben we de gegevens voorbewerkt. Waar we de dataset hebben geladen, die wordt gegeven als:

2. Een beslissingsboomalgoritme aan de trainingsset aanpassen

Nu gaan we het model aanpassen aan de trainingsset. Hiervoor importeren we de DecisionTreeClassifier klasse uit sklearn.boom bibliotheek. Hieronder staat de code ervoor:

laatste trefwoord in Java

 #Fitting Decision Tree classifier to the training set From sklearn.tree import DecisionTreeClassifier classifier= DecisionTreeClassifier(criterion='entropy', random_state=0) classifier.fit(x_train, y_train) 

In de bovenstaande code hebben we een classifier-object gemaakt, waarin we twee hoofdparameters hebben doorgegeven;

'criterium='entropie':Criterium wordt gebruikt om de kwaliteit van de splitsing te meten, die wordt berekend op basis van informatiewinst gegeven door entropie.willekeurige_status=0':Voor het genereren van de willekeurige toestanden.

Hieronder vindt u de uitvoer hiervoor:

 Out[8]: DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None, max_features=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, presort=False, random_state=0, splitter='best') 

3. Het voorspellen van het testresultaat

Nu gaan we het resultaat van de testset voorspellen. We zullen een nieuwe voorspellingsvector creëren y_pred. Hieronder staat de code ervoor:

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Uitgang:

In de onderstaande outputafbeelding worden de voorspelde output en de echte testoutput gegeven. We kunnen duidelijk zien dat er enkele waarden in de voorspellingsvector zitten die verschillen van de echte vectorwaarden. Dit zijn voorspellingsfouten.

4. Testnauwkeurigheid van het resultaat (Creation of Confusion-matrix)

In de bovenstaande uitvoer hebben we gezien dat er enkele onjuiste voorspellingen waren, dus als we het aantal juiste en onjuiste voorspellingen willen weten, moeten we de verwarringsmatrix gebruiken. Hieronder staat de code ervoor:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

Uitgang:

Java-voorbeeldprogramma's

In de bovenstaande uitvoerafbeelding kunnen we de verwarringsmatrix zien, die heeft 6+3= 9 onjuiste voorspellingen En 62+29=91 correcte voorspellingen. Daarom kunnen we zeggen dat de Decision Tree-classificator, vergeleken met andere classificatiemodellen, een goede voorspelling heeft gedaan.

5. Het resultaat van de trainingsset visualiseren:

Hier visualiseren we het resultaat van de trainingsset. Om het resultaat van de trainingsset te visualiseren, zullen we een grafiek uitzetten voor de beslissingsboomclassificator. De classificator voorspelt ja of nee voor de gebruikers die de SUV-auto wel of niet hebben gekocht, zoals we deden in Logistieke Regressie. Hieronder staat de code ervoor:

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Uitgang:

De bovenstaande output is compleet anders dan de restclassificatiemodellen. Het heeft zowel verticale als horizontale lijnen die de dataset opsplitsen op basis van de leeftijd en de geschatte salarisvariabele.

Zoals we kunnen zien, probeert de boom elke dataset vast te leggen, wat het geval is van overfitting.

6. Visualisatie van het resultaat van de testset:

De visualisatie van het testsetresultaat zal vergelijkbaar zijn met de visualisatie van de trainingsset, behalve dat de trainingsset wordt vervangen door de testset.

bin naar bcd

 #Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Uitgang:

Zoals we in de bovenstaande afbeelding kunnen zien, zijn er enkele groene gegevenspunten in het paarse gebied en omgekeerd. Dit zijn dus de onjuiste voorspellingen die we in de verwarringsmatrix hebben besproken.