• Arborele de decizie este a Tehnica de învățare supravegheată care poate fi folosit atât pentru probleme de clasificare, cât și pentru probleme de regresie, dar în mare parte este preferat pentru rezolvarea problemelor de clasificare. Este un clasificator structurat în arbore, unde nodurile interne reprezintă caracteristicile unui set de date, ramurile reprezintă regulile de decizie și fiecare nod frunză reprezintă rezultatul.
• Într-un arbore de decizie, există două noduri, care sunt Nodul de decizie și Nodul frunzelor. Nodurile de decizie sunt folosite pentru a lua orice decizie și au mai multe ramuri, în timp ce nodurile Leaf sunt rezultatul acelor decizii și nu conțin alte ramuri.
• Deciziile sau testul sunt efectuate pe baza caracteristicilor setului de date dat.
Este o reprezentare grafică pentru obținerea tuturor soluțiilor posibile la o problemă/decizie pe baza unor condiții date.
• Se numește arbore de decizie deoarece, similar unui arbore, începe cu nodul rădăcină, care se extinde pe ramuri suplimentare și construiește o structură asemănătoare arborelui.
• Pentru a construi un copac, folosim algoritmul CART, care reprezintă Algoritmul arborelui de clasificare și regresie.
• Un arbore de decizie pune pur și simplu o întrebare și, pe baza răspunsului (Da/Nu), împarte în continuare arborele în subarbori.
• Diagrama de mai jos explică structura generală a unui arbore de decizie:

Notă: Un arbore de decizie poate conține date categorice (DA/NU), precum și date numerice.

De ce să folosiți Decision Trees?

Există diverși algoritmi în învățarea automată, așa că alegerea celui mai bun algoritm pentru setul de date și problema dată este punctul principal de reținut în timpul creării unui model de învățare automată. Mai jos sunt cele două motive pentru a utiliza arborele de decizie:

• Arborele de decizie imită de obicei capacitatea de gândire umană în timpul luării unei decizii, deci este ușor de înțeles.
• Logica din spatele arborelui de decizie poate fi ușor de înțeles deoarece arată o structură asemănătoare arborelui.

Terminologia arborelui decizional

Cum funcționează algoritmul Decision Tree?

numele orașului din SUA

Într-un arbore de decizie, pentru prezicerea clasei setului de date dat, algoritmul începe de la nodul rădăcină al arborelui. Acest algoritm compară valorile atributului rădăcină cu atributul înregistrare (setul de date real) și, pe baza comparației, urmărește ramura și sare la următorul nod.

Pentru următorul nod, algoritmul compară din nou valoarea atributului cu celelalte sub-noduri și se deplasează mai departe. Continuă procesul până când ajunge la nodul frunzei al copacului. Procesul complet poate fi înțeles mai bine folosind algoritmul de mai jos:

Pasul 1:Începeți arborele cu nodul rădăcină, spune S, care conține setul de date complet.Pasul 2:Găsiți cel mai bun atribut din setul de date folosind Măsura de selecție a atributelor (ASM). Pasul 3:Împărțiți S-ul în subseturi care conține valori posibile pentru cele mai bune atribute.Pasul-4:Generați nodul arborelui de decizie, care conține cel mai bun atribut.Pasul-5:Faceți recursiv noi arbori de decizie folosind subseturile setului de date create la pasul -3. Continuați acest proces până când se ajunge la o etapă în care nu puteți clasifica în continuare nodurile și nu puteți clasifica nodul final ca nod frunză.

Exemplu: Să presupunem că există un candidat care are o ofertă de muncă și dorește să decidă dacă ar trebui să accepte oferta sau Nu. Deci, pentru a rezolva această problemă, arborele de decizie începe cu nodul rădăcină (atributul Salar de la ASM). Nodul rădăcină se împarte în următorul nod de decizie (distanța de la birou) și un nod frunză pe baza etichetelor corespunzătoare. Următorul nod de decizie este împărțit în continuare într-un nod de decizie (facilitate Cab) și un nod frunză. În cele din urmă, nodul de decizie se împarte în două noduri frunză (Oferte acceptate și Oferta refuzată). Luați în considerare diagrama de mai jos:

Măsuri de selecție a atributelor

În timpul implementării unui arbore de decizie, se pune problema principală cum să selectați cel mai bun atribut pentru nodul rădăcină și pentru sub-noduri. Deci, pentru a rezolva astfel de probleme există o tehnică care se numește ca Măsura de selecție a atributelor sau ASM. Prin această măsurare, putem selecta cu ușurință cel mai bun atribut pentru nodurile arborelui. Există două tehnici populare pentru ASM, care sunt:

Câștig de informații Indexul Gini

1. Câștig de informații:

• Câștigul de informații este măsurarea modificărilor entropiei după segmentarea unui set de date pe baza unui atribut.
• Acesta calculează câte informații ne oferă o caracteristică despre o clasă.
• În funcție de valoarea câștigului de informații, împărțim nodul și construim arborele de decizie.
• Un algoritm de arbore de decizie încearcă întotdeauna să maximizeze valoarea câștigului de informații, iar un nod/atribut care are cel mai mare câștig de informații este împărțit mai întâi. Poate fi calculat folosind formula de mai jos:

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

Entropie: Entropia este o măsură pentru a măsura impuritățile dintr-un anumit atribut. Specifică aleatorietatea datelor. Entropia poate fi calculată ca:

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

Unde,

S= Numărul total de probe P(da)= probabilitatea de a da P(nu)= probabilitatea de nr

2. Indicele Gini:

• Indicele Gini este o măsură a impurității sau purității utilizată în timpul creării unui arbore de decizie în algoritmul CART (Arborele de clasificare și regresie).
• Un atribut cu indicele Gini scăzut ar trebui să fie preferat în comparație cu indicele Gini ridicat.
• Acesta creează doar împărțiri binare, iar algoritmul CART folosește indexul Gini pentru a crea împărțiri binare.
• Indicele Gini poate fi calculat folosind formula de mai jos:

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

Tunderea: obținerea unui arbore de decizie optimă

Tunderea este un proces de ștergere a nodurilor inutile dintr-un arbore pentru a obține arborele de decizie optim.

Un arbore prea mare crește riscul de supraadaptare, iar un arbore mic poate să nu capteze toate caracteristicile importante ale setului de date. Prin urmare, o tehnică care scade dimensiunea arborelui de învățare fără a reduce acuratețea este cunoscută sub denumirea de tăiere. Există în principal două tipuri de copaci tăierea tehnologie folosita:

Tăierea complexității costurilor Eroare de tăiere redusă.

Avantajele arborelui decizional

• Este simplu de înțeles, deoarece urmează același proces pe care un om îl urmează în timp ce ia orice decizie în viața reală.
• Poate fi foarte util pentru rezolvarea problemelor legate de decizii.
• Ajută să te gândești la toate rezultatele posibile pentru o problemă.
• Există mai puține cerințe de curățare a datelor în comparație cu alți algoritmi.

Dezavantajele arborelui decizional

• Arborele de decizie conține o mulțime de straturi, ceea ce îl face complex.
• Poate avea o problemă de supraadaptare, care poate fi rezolvată folosind Algoritmul Random Forest.
• Pentru mai multe etichete de clasă, complexitatea de calcul a arborelui de decizie poate crește.

Implementarea Python a arborelui decizional

Acum vom implementa arborele de decizie folosind Python. Pentru aceasta, vom folosi setul de date ' user_data.csv ,' pe care le-am folosit în modelele de clasificare anterioare. Folosind același set de date, putem compara clasificatorul arborelui de decizie cu alte modele de clasificare, cum ar fi KNN SVM, Regresie logistică etc.

Pașii vor rămâne, de asemenea, aceiași, care sunt prezentați mai jos:

Etapa de preprocesare a datelor Potrivirea unui algoritm de arbore de decizie la setul de antrenament Prezicerea rezultatului testului Testați acuratețea rezultatului (Crearea matricei de confuzie) Vizualizarea rezultatului setului de testare.

1. Etapa de preprocesare a datelor:

Mai jos este codul pentru etapa de preprocesare:

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

În codul de mai sus, am preprocesat datele. Unde am încărcat setul de date, care este dat ca:

2. Potrivirea unui algoritm de arbore de decizie la setul de antrenament

Acum vom potrivi modelul la setul de antrenament. Pentru aceasta, vom importa DecisionTreeClassifier clasa de la sklearn.tree bibliotecă. Mai jos este codul pentru acesta:

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

În codul de mai sus, am creat un obiect clasificator, în care am trecut doi parametri principali;

'criteriu='entropie':Criteriul este folosit pentru a măsura calitatea divizării, care este calculată prin câștigul de informații dat de entropie.stare_aleatorie=0':Pentru generarea stărilor aleatorii.

Mai jos este rezultatul pentru aceasta:

 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. Prezicerea rezultatului testului

Acum vom prezice rezultatul setului de test. Vom crea un nou vector de predicție y_pred. Mai jos este codul pentru acesta:

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

Ieșire:

În imaginea de ieșire de mai jos, sunt date rezultatul estimat și rezultatul real al testului. Putem vedea clar că există unele valori în vectorul de predicție, care sunt diferite de valorile vectorului real. Acestea sunt erori de predicție.

cum să împerechezi căștile beats

4. Testați acuratețea rezultatului (matricea de creare a confuziei)

În rezultatul de mai sus, am văzut că au existat unele predicții incorecte, așa că dacă dorim să știm numărul de predicții corecte și incorecte, trebuie să folosim matricea de confuzie. Mai jos este codul pentru acesta:

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

Ieșire:

În imaginea de ieșire de mai sus, putem vedea matricea de confuzie, care are 6+3= 9 predicții incorecte și 62+29=91 predicții corecte. Prin urmare, putem spune că, în comparație cu alte modele de clasificare, clasificatorul Decision Tree a făcut o predicție bună.

5. Vizualizarea rezultatului setului de antrenament:

Aici vom vizualiza rezultatul setului de antrenament. Pentru a vizualiza rezultatul setului de antrenament vom reprezenta un grafic pentru clasificatorul arborelui de decizie. Clasificatorul va prezice da sau Nu pentru utilizatorii care fie au achiziționat, fie nu au achiziționat mașina SUV, așa cum am făcut în regresia logistică. Mai jos este codul pentru acesta:

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

Ieșire:

Ieșirea de mai sus este complet diferită de celelalte modele de clasificare. Are atât linii verticale, cât și orizontale care împart setul de date în funcție de vârsta și variabila salariu estimat.

După cum putem vedea, arborele încearcă să captureze fiecare set de date, ceea ce este cazul supraajustării.

6. Vizualizarea rezultatului setului de testare:

Vizualizarea rezultatului setului de testare va fi similară cu vizualizarea setului de antrenament, cu excepția faptului că setul de antrenament va fi înlocuit cu setul de testare.

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

Ieșire:

După cum putem vedea în imaginea de mai sus, există câteva puncte de date verzi în regiunea violetă și invers. Deci, acestea sunt predicțiile incorecte pe care le-am discutat în matricea de confuzie.