• Beslutningstræ er en Superviseret læringsteknik der kan bruges til både klassifikations- og regressionsproblemer, men for det meste foretrækkes det til at løse klassifikationsproblemer. Det er en træstruktureret klassificering, hvor interne noder repræsenterer funktionerne i et datasæt, grene repræsenterer beslutningsreglerne og hver bladknude repræsenterer resultatet.
• I et beslutningstræ er der to noder, som er Beslutningsknudepunkt og Bladknude. Beslutningsknudepunkter bruges til at træffe enhver beslutning og har flere grene, hvorimod bladknudepunkter er outputtet af disse beslutninger og ikke indeholder yderligere grene.
• Beslutningerne eller testen udføres på baggrund af funktionerne i det givne datasæt.
Det er en grafisk fremstilling til at få alle mulige løsninger på et problem/beslutning ud fra givne forhold.
• Det kaldes et beslutningstræ, fordi det i lighed med et træ starter med rodknuden, som udvider sig på yderligere grene og konstruerer en trælignende struktur.
• For at bygge et træ bruger vi CART algoritme, som står for Klassifikations- og regressionstræ-algoritme.
• Et beslutningstræ stiller blot et spørgsmål, og baseret på svaret (Ja/Nej) opdeler det træet yderligere i undertræer.
• Nedenstående diagram forklarer den generelle struktur af et beslutningstræ:

Bemærk: Et beslutningstræ kan indeholde kategoriske data (JA/NEJ) såvel som numeriske data.

Hvorfor bruge beslutningstræer?

Der er forskellige algoritmer i Machine learning, så at vælge den bedste algoritme til det givne datasæt og det givne problem er det vigtigste punkt at huske, mens du opretter en maskinlæringsmodel. Nedenfor er de to grunde til at bruge beslutningstræet:

• Beslutningstræer efterligner normalt menneskets tænkeevne, mens de træffer en beslutning, så det er let at forstå.
• Logikken bag beslutningstræet kan let forstås, fordi det viser en trælignende struktur.

Beslutningstræ-terminologier

Hvordan virker beslutningstræ-algoritmen?

I et beslutningstræ, for at forudsige klassen af ​​det givne datasæt, starter algoritmen fra træets rodknude. Denne algoritme sammenligner værdierne for rodattributten med attributten record (reelt datasæt) og, baseret på sammenligningen, følger grenen og hopper til den næste knude.

For den næste knude sammenligner algoritmen igen attributværdien med de andre underknuder og går videre. Den fortsætter processen, indtil den når træets bladknude. Den komplette proces kan bedre forstås ved hjælp af nedenstående algoritme:

Trin 1:Begynd træet med rodnoden, siger S, som indeholder det komplette datasæt.Trin-2:Find den bedste egenskab i datasættet ved hjælp af Attribut Selection Measure (ASM). Trin-3:Opdel S i delmængder, der indeholder mulige værdier for de bedste attributter.Trin-4:Generer beslutningstræ-knuden, som indeholder den bedste attribut.Trin-5:Lav rekursivt nye beslutningstræer ved hjælp af undersættene af datasættet, der blev oprettet i trin -3. Fortsæt denne proces, indtil et trin er nået, hvor du ikke kan klassificere knudepunkterne yderligere og kaldet den endelige knude som en bladknude.

Eksempel: Antag, at der er en kandidat, der har et jobtilbud og ønsker at beslutte, om han skal acceptere tilbuddet eller ej. Så for at løse dette problem starter beslutningstræet med rodknuden (Løn attribut af ASM). Rodnoden opdeles yderligere i den næste beslutningsknude (afstand fra kontoret) og en bladknude baseret på de tilsvarende etiketter. Den næste beslutningsknude bliver yderligere opdelt i en beslutningsknude (førerhusfacilitet) og en bladknude. Endelig opdeles beslutningsknuden i to bladknuder (Accepterede tilbud og Afvist tilbud). Overvej nedenstående diagram:

Tiltag til attributudvælgelse

Mens du implementerer et beslutningstræ, opstår hovedproblemet, hvordan man vælger den bedste attribut for rodknuden og for undernoder. Så for at løse sådanne problemer er der en teknik, der kaldes som Attributvalgsmål eller ASM. Ved denne måling kan vi nemt vælge den bedste egenskab for træets noder. Der er to populære teknikker til ASM, som er:

Informationsgevinst Gini indeks

1. Informationsgevinst:

• Informationsgevinst er måling af ændringer i entropi efter segmentering af et datasæt baseret på en attribut.
• Den beregner, hvor meget information en funktion giver os om en klasse.
• I henhold til værdien af ​​informationsgevinst opdeler vi noden og bygger beslutningstræet.
• En beslutningstræalgoritme forsøger altid at maksimere værdien af ​​informationsgevinst, og en node/attribut med den højeste informationsgevinst opdeles først. Det kan beregnes ved hjælp af nedenstående formel:

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

Entropi: Entropi er en metrik til at måle urenheden i en given egenskab. Det specificerer tilfældighed i data. Entropi kan beregnes som:

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

Hvor,

S= Samlet antal prøver P(ja)= sandsynlighed for ja P(nej)= sandsynlighed for nej

2. Gini-indeks:

• Gini-indekset er et mål for urenhed eller renhed, der bruges under oprettelse af et beslutningstræ i CART(Classification and Regression Tree) algoritmen.
• En egenskab med det lave Gini-indeks bør foretrækkes sammenlignet med det høje Gini-indeks.
• Den opretter kun binære opdelinger, og CART-algoritmen bruger Gini-indekset til at skabe binære opdelinger.
• Gini-indekset kan beregnes ved hjælp af nedenstående formel:

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

Beskæring: Få et optimalt beslutningstræ

Beskæring er en proces med at slette de unødvendige noder fra et træ for at få det optimale beslutningstræ.

Et for stort træ øger risikoen for overfitting, og et lille træ fanger muligvis ikke alle de vigtige funktioner i datasættet. Derfor er en teknik, der formindsker størrelsen af ​​læringstræet uden at reducere nøjagtigheden, kendt som beskæring. Der er hovedsageligt to typer træer beskæring anvendt teknologi:

Omkostningskompleksitet Beskæring Reduceret fejlbeskæring.

Fordele ved beslutningstræet

• Det er nemt at forstå, da det følger den samme proces, som et menneske følger, mens det træffer enhver beslutning i det virkelige liv.
• Det kan være meget nyttigt til at løse beslutningsrelaterede problemer.
• Det hjælper at tænke på alle de mulige udfald for et problem.
• Der er mindre krav om datarensning sammenlignet med andre algoritmer.

Ulemper ved beslutningstræet

• Beslutningstræet indeholder masser af lag, hvilket gør det komplekst.
• Det kan have et overmonteringsproblem, som kan løses ved hjælp af Random Forest algoritme.
• For flere klasseetiketter kan den beregningsmæssige kompleksitet af beslutningstræet øges.

Python-implementering af beslutningstræ

Nu vil vi implementere beslutningstræet ved hjælp af Python. Til dette vil vi bruge datasættet ' bruger_data.csv ,' som vi har brugt i tidligere klassifikationsmodeller. Ved at bruge det samme datasæt kan vi sammenligne Decision tree-klassifikatoren med andre klassifikationsmodeller som f.eks KNN SVM, Logistisk regression mv.

Trinene forbliver også de samme, som er angivet nedenfor:

Dataforbehandlingstrin Tilpasning af en beslutningstræ-algoritme til træningssættet Forudsigelse af testresultatet Test nøjagtigheden af ​​resultatet (Oprettelse af forvirringsmatrix) Visualisering af testsættets resultat.

1. Trin til dataforbehandling:

Nedenfor er koden til forbehandlingstrinnet:

 # 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) 

I ovenstående kode har vi forbehandlet dataene. Hvor vi har indlæst datasættet, som er givet som:

2. Tilpasning af en beslutningstræ-algoritme til træningssættet

Nu vil vi tilpasse modellen til træningssættet. Til dette vil vi importere DecisionTreeClassifier klasse fra sklearn.tree bibliotek. Nedenfor er koden til det:

 #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) 

I ovenstående kode har vi lavet et klassifikationsobjekt, hvori vi har videregivet to hovedparametre;

'criterion='entropi':Kriterium bruges til at måle kvaliteten af ​​split, som beregnes af informationsgevinst givet af entropi.random_state=0':Til generering af tilfældige tilstande.

Nedenfor er output for dette:

 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. Forudsigelse af testresultatet

Nu vil vi forudsige resultatet af testsættet. Vi vil skabe en ny forudsigelsesvektor y_pred. Nedenfor er koden til det:

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

Produktion:

I nedenstående outputbillede er det forudsagte output og reelle testoutput givet. Vi kan tydeligt se, at der er nogle værdier i forudsigelsesvektoren, som er forskellige fra de reelle vektorværdier. Disse er forudsigelsesfejl.

4. Test nøjagtigheden af ​​resultatet (oprettelse af forvirringsmatrix)

I ovenstående output har vi set, at der var nogle forkerte forudsigelser, så hvis vi vil kende antallet af korrekte og forkerte forudsigelser, skal vi bruge forvirringsmatricen. Nedenfor er koden til det:

windows.åbn javascript

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

Produktion:

I ovenstående outputbillede kan vi se forvirringsmatricen, som har 6+3= 9 forkerte forudsigelser og 62+29=91 korrekte forudsigelser. Derfor kan vi sige, at sammenlignet med andre klassifikationsmodeller lavede Decision Tree-klassifikatoren en god forudsigelse.

5. Visualisering af træningssættets resultat:

Her vil vi visualisere træningssættets resultat. For at visualisere træningssættets resultat vil vi plotte en graf for beslutningstræklassifikatoren. Klassificeringen vil forudsige ja eller nej for de brugere, der enten har købt eller ikke købt SUV-bilen, som vi gjorde i Logistic Regression. Nedenfor er koden til det:

 #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() 

Produktion:

Ovenstående output er helt anderledes end de øvrige klassifikationsmodeller. Den har både lodrette og vandrette linjer, der opdeler datasættet efter alder og estimeret lønvariabel.

Som vi kan se, forsøger træet at fange hvert datasæt, hvilket er tilfældet med overfitting.

6. Visualisering af testsættets resultat:

Visualisering af testsættets resultat vil ligne visualiseringen af ​​træningssættet bortset fra at træningssættet vil blive erstattet med testsættet.

 #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() 

Produktion:

Som vi kan se på ovenstående billede, er der nogle grønne datapunkter inden for den lilla region og omvendt. Så det er de forkerte forudsigelser, som vi har diskuteret i forvirringsmatricen.