• Decision Tree är en Övervakad inlärningsteknik som kan användas för både klassificerings- och regressionsproblem, men oftast är det att föredra för att lösa klassificeringsproblem. Det är en trädstrukturerad klassificerare, där interna noder representerar funktionerna i en datauppsättning, grenar representerar beslutsreglerna och varje bladnod representerar resultatet.
• I ett beslutsträd finns det två noder, som är Beslutsnod och Bladnod. Beslutsnoder används för att fatta alla beslut och har flera grenar, medan lövnoder är resultatet av dessa beslut och inte innehåller några ytterligare grenar.
• Besluten eller testet utförs på basis av funktionerna i den givna datamängden.
Det är en grafisk representation för att få alla möjliga lösningar på ett problem/beslut utifrån givna förutsättningar.
• Det kallas ett beslutsträd eftersom det, i likhet med ett träd, börjar med rotnoden, som expanderar på ytterligare grenar och konstruerar en trädliknande struktur.
• För att bygga ett träd använder vi CART-algoritm, som står för Klassificerings- och regressionsträdalgoritm.
• Ett beslutsträd ställer helt enkelt en fråga, och baserat på svaret (Ja/Nej) delar det upp trädet ytterligare i underträd.
• Nedanstående diagram förklarar den allmänna strukturen för ett beslutsträd:

Obs: Ett beslutsträd kan innehålla kategoridata (JA/NEJ) såväl som numerisk data.

Varför använda beslutsträd?

Det finns olika algoritmer inom maskininlärning, så att välja den bästa algoritmen för den givna datamängden och problemet är den viktigaste punkten att komma ihåg när du skapar en maskininlärningsmodell. Nedan följer de två anledningarna till att använda beslutsträdet:

• Beslutsträd efterliknar vanligtvis människans tankeförmåga när man fattar ett beslut, så det är lätt att förstå.
• Logiken bakom beslutsträdet kan lätt förstås eftersom det visar en trädliknande struktur.

Beslutsträdsterminologier

Hur fungerar beslutsträdsalgoritmen?

I ett beslutsträd, för att förutsäga klassen för den givna datamängden, startar algoritmen från trädets rotnod. Denna algoritm jämför värdena för rotattributet med attributet record (real dataset) och, baserat på jämförelsen, följer grenen och hoppar till nästa nod.

när kom windows 7 ut

För nästa nod jämför algoritmen återigen attributvärdet med de andra subnoderna och går vidare. Den fortsätter processen tills den når trädets lövnod. Hela processen kan förstås bättre med hjälp av nedanstående algoritm:

Steg 1:Börja trädet med rotnoden, säger S, som innehåller hela datasetet.Steg 2:Hitta det bästa attributet i datamängden med hjälp av Attribut Selection Measure (ASM). Steg 3:Dela upp S i delmängder som innehåller möjliga värden för de bästa attributen.Steg-4:Generera noden för beslutsträdet, som innehåller det bästa attributet.Steg-5:Gör rekursivt nya beslutsträd med hjälp av delmängderna av datamängden som skapades i steg -3. Fortsätt denna process tills ett stadium nås där du inte kan klassificera noderna ytterligare och kallade den slutliga noden som en lövnod.

Exempel: Anta att det finns en kandidat som har ett jobberbjudande och vill bestämma om han ska acceptera erbjudandet eller inte. Så för att lösa detta problem börjar beslutsträdet med rotnoden (löneattribut av ASM). Rotnoden delas upp ytterligare i nästa beslutsnod (avstånd från kontoret) och en lövnod baserat på motsvarande etiketter. Nästa beslutsnod delas upp i en beslutsnod (hyttanläggning) och en lövnod. Slutligen delas beslutsnoden i två bladnoder (Accepterade erbjudanden och Avvisade erbjudande). Tänk på nedanstående diagram:

Åtgärder för urval av attribut

När du implementerar ett beslutsträd uppstår huvudproblemet hur man väljer det bästa attributet för rotnoden och för subnoder. Så för att lösa sådana problem finns det en teknik som kallas som Attribut urvalsmått eller ASM. Genom denna mätning kan vi enkelt välja det bästa attributet för trädets noder. Det finns två populära tekniker för ASM, som är:

Informationsvinst Gini Index

1. Informationsvinst:

• Informationsvinst är mätningen av förändringar i entropi efter segmentering av en datauppsättning baserat på ett attribut.
• Den beräknar hur mycket information en funktion ger oss om en klass.
• Enligt värdet av informationsvinst delar vi noden och bygger beslutsträdet.
• En beslutsträdsalgoritm försöker alltid maximera värdet av informationsvinsten, och en nod/attribut som har den högsta informationsvinsten delas först. Det kan beräknas med följande formel:

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

Entropi: Entropi är ett mått för att mäta föroreningen i ett givet attribut. Den specificerar slumpmässighet i data. Entropi kan beräknas som:

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

Var,

S= Totalt antal prover P(ja)= sannolikhet för ja P(no)= sannolikhet för nej

2. Gini Index:

• Gini-index är ett mått på orenhet eller renhet som används när man skapar ett beslutsträd i CART-algoritmen (klassificerings- och regressionsträd).
• Ett attribut med det låga Gini-indexet bör föredras jämfört med det höga Gini-indexet.
• Den skapar bara binära uppdelningar, och CART-algoritmen använder Gini-index för att skapa binära uppdelningar.
• Gini-index kan beräknas med följande formel:

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

Beskärning: Få ett optimalt beslutsträd

Beskärning är en process för att ta bort onödiga noder från ett träd för att få det optimala beslutsträdet.

Ett för stort träd ökar risken för övermontering, och ett litet träd kanske inte fångar upp alla viktiga funktioner i datasetet. Därför kallas en teknik som minskar storleken på inlärningsträdet utan att minska noggrannheten beskärning. Det finns huvudsakligen två typer av träd beskärning teknik som används:

Kostnadskomplexitet Beskärning Minskat felbeskärning.

Fördelar med beslutsträdet

• Det är enkelt att förstå eftersom det följer samma process som en människa följer när han fattar valfritt beslut i verkligheten.
• Det kan vara mycket användbart för att lösa beslutsrelaterade problem.
• Det hjälper att tänka på alla möjliga utfall för ett problem.
• Det finns mindre krav på datarensning jämfört med andra algoritmer.

Nackdelar med beslutsträdet

• Beslutsträdet innehåller massor av lager, vilket gör det komplext.
• Det kan ha ett övermonteringsproblem, som kan lösas med hjälp av Random Forest-algoritm.
• För fler klassetiketter kan beslutsträdets beräkningskomplexitet öka.

Python-implementering av beslutsträd

Nu ska vi implementera beslutsträdet med Python. För detta kommer vi att använda datamängden ' user_data.csv ,' som vi har använt i tidigare klassificeringsmodeller. Genom att använda samma dataset kan vi jämföra Beslutsträdsklassificeraren med andra klassificeringsmodeller som t.ex KNN SVM, Logistisk regression, etc.

bash om annat

Stegen kommer också att förbli desamma, som anges nedan:

Steg för förbehandling av data Anpassa en beslutsträdsalgoritm till träningssetet Förutsäga testresultatet Testa resultatets noggrannhet (Skapa förvirringsmatris) Visualisera testsetresultatet.

1. Steg för förbehandling av data:

Nedan är koden för förbehandlingssteget:

 # 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 ovanstående kod har vi förbehandlat datan. Där vi har laddat datamängden, som ges som:

2. Anpassa en beslutsträdsalgoritm till träningssetet

Nu ska vi anpassa modellen till träningssetet. För detta kommer vi att importera DecisionTreeClassifier klass från sklearn.tree bibliotek. Nedan är koden för det:

postorder genomgång av binärt träd

 #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 ovanstående kod har vi skapat ett klassificeringsobjekt, där vi har skickat två huvudparametrar;

'criterion='entropi':Kriterium används för att mäta kvaliteten på split, som beräknas av informationsvinst som ges av entropi.random_state=0':För att generera slumpmässiga tillstånd.

Nedan är utdata för detta:

 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. Förutsäga testresultatet

Nu kommer vi att förutsäga testsetresultatet. Vi kommer att skapa en ny prediktionsvektor y_pred. Nedan är koden för det:

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

Produktion:

I utgångsbilden nedan ges den förväntade utgången och den verkliga testutgången. Vi kan tydligt se att det finns några värden i prediktionsvektorn, som skiljer sig från de verkliga vektorvärdena. Dessa är prediktionsfel.

4. Testa resultatets noggrannhet (Skapa förvirringsmatris)

I ovanstående utdata har vi sett att det fanns några felaktiga förutsägelser, så om vi vill veta antalet korrekta och felaktiga förutsägelser måste vi använda förvirringsmatrisen. Nedan är koden för det:

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

Produktion:

Java förbättrad loop

I ovanstående utdatabild kan vi se förvirringsmatrisen, som har 6+3= 9 felaktiga förutsägelser och 62+29=91 korrekta förutsägelser. Därför kan vi säga att jämfört med andra klassificeringsmodeller gjorde Decision Tree-klassificeraren en bra förutsägelse.

5. Visualisera resultatet av träningsuppsättningen:

Här kommer vi att visualisera träningssetets resultat. För att visualisera träningsuppsättningens resultat kommer vi att rita en graf för beslutsträdsklassificeraren. Klassificeraren kommer att förutsäga ja eller nej för de användare som antingen har köpt eller inte köpt SUV-bilen som vi gjorde i Logistic Regression. Nedan är koden för 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:

Ovanstående utdata skiljer sig helt från övriga klassificeringsmodeller. Den har både vertikala och horisontella linjer som delar upp datasetet enligt ålder och beräknad lönevariabel.

Som vi kan se försöker trädet fånga varje dataset, vilket är fallet med överanpassning.

6. Visualisera testsetresultatet:

Visualisering av testsetresultatet kommer att likna visualiseringen av träningssetet förutom att träningssetet kommer att ersättas med testsetet.

python-väginställning

 #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 i bilden ovan finns det några gröna datapunkter inom den lila regionen och vice versa. Så det här är de felaktiga förutsägelserna som vi har diskuterat i förvirringsmatrisen.