• L'albero decisionale è un Tecnica di apprendimento supervisionato che può essere utilizzato sia per problemi di classificazione che di regressione, ma soprattutto è preferito per risolvere problemi di classificazione. È un classificatore strutturato ad albero, dove i nodi interni rappresentano le caratteristiche di un dataset, i rami rappresentano le regole decisionali E ogni nodo foglia rappresenta il risultato.
• In un albero decisionale ci sono due nodi, che sono: Nodo decisionale E Nodo fogliare. I nodi decisionali vengono utilizzati per prendere qualsiasi decisione e hanno più rami, mentre i nodi foglia sono l'output di tali decisioni e non contengono ulteriori rami.
• Le decisioni o il test vengono eseguiti sulla base delle caratteristiche del set di dati fornito.
Si tratta di una rappresentazione grafica per ottenere tutte le possibili soluzioni ad un problema/decisione in base a determinate condizioni.
• Si chiama albero decisionale perché, analogamente a un albero, inizia con il nodo radice, che si espande su ulteriori rami e costruisce una struttura ad albero.
• Per costruire un albero usiamo il file Algoritmo CART, che sta per Algoritmo di classificazione e albero di regressione.
• Un albero decisionale pone semplicemente una domanda e, in base alla risposta (Sì/No), suddivide ulteriormente l'albero in sottoalberi.
• Il diagramma seguente spiega la struttura generale di un albero decisionale:

Nota: un albero decisionale può contenere dati categorici (SÌ/NO) nonché dati numerici.

Perché utilizzare gli alberi decisionali?

Esistono vari algoritmi nell'apprendimento automatico, quindi scegliere l'algoritmo migliore per il set di dati e il problema forniti è il punto principale da ricordare durante la creazione di un modello di apprendimento automatico. Di seguito sono riportati i due motivi per utilizzare l'albero decisionale:

• Gli alberi decisionali di solito imitano la capacità di pensiero umano mentre prendono una decisione, quindi è facile da capire.
• La logica dietro l'albero decisionale può essere facilmente compresa perché mostra una struttura ad albero.

Terminologie dell'albero decisionale

Come funziona l'algoritmo dell'albero decisionale?

In un albero decisionale, per prevedere la classe di un dato set di dati, l'algoritmo inizia dal nodo radice dell'albero. Questo algoritmo confronta i valori dell'attributo root con l'attributo record (set di dati reali) e, in base al confronto, segue il ramo e salta al nodo successivo.

Per il nodo successivo, l'algoritmo confronta nuovamente il valore dell'attributo con gli altri sottonodi e va oltre. Continua il processo fino a raggiungere il nodo foglia dell'albero. Il processo completo può essere compreso meglio utilizzando l'algoritmo seguente:

Passo 1:Iniziare l'albero con il nodo radice, dice S, che contiene il set di dati completo.Passo 2:Trova l'attributo migliore nel set di dati utilizzando Misura di selezione degli attributi (ASM). Passaggio 3:Dividi la S in sottoinsiemi che contengono possibili valori per i migliori attributi.Passaggio 4:Genera il nodo dell'albero decisionale, che contiene l'attributo migliore.Passaggio 5:Crea ricorsivamente nuovi alberi decisionali utilizzando i sottoinsiemi del set di dati creato nel passaggio -3. Continuare questo processo fino a raggiungere una fase in cui non è possibile classificare ulteriormente i nodi e chiamare il nodo finale come nodo foglia.

Esempio: Supponiamo che ci sia un candidato che ha un'offerta di lavoro e vuole decidere se accettare o meno l'offerta. Quindi, per risolvere questo problema, l'albero decisionale inizia con il nodo radice (attributo Salary di ASM). Il nodo radice si divide ulteriormente nel nodo decisionale successivo (distanza dall'ufficio) e in un nodo foglia in base alle etichette corrispondenti. Il nodo decisionale successivo viene ulteriormente suddiviso in un nodo decisionale (struttura Cab) e un nodo foglia. Infine, il nodo decisionale si divide in due nodi foglia (Offerte accettate e Offerta rifiutata). Considera il diagramma seguente:

java tostring

Misure di selezione degli attributi

Durante l'implementazione di un albero decisionale, il problema principale sorge su come selezionare l'attributo migliore per il nodo radice e per i sottonodi. Quindi, per risolvere tali problemi esiste una tecnica chiamata as Misura di selezione degli attributi o ASM. Con questa misurazione possiamo facilmente selezionare l'attributo migliore per i nodi dell'albero. Esistono due tecniche popolari per l'ASM, che sono:

Guadagno di informazioni Indice Gini

1. Guadagno di informazioni:

• Il guadagno di informazioni è la misurazione delle variazioni di entropia dopo la segmentazione di un set di dati in base a un attributo.
• Calcola quante informazioni ci fornisce una funzionalità su una classe.
• In base al valore del guadagno informativo, dividiamo il nodo e costruiamo l'albero decisionale.
• Un algoritmo dell'albero decisionale cerca sempre di massimizzare il valore del guadagno di informazioni e un nodo/attributo con il guadagno di informazioni più elevato viene diviso per primo. Può essere calcolato utilizzando la formula seguente:

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

Entropia: L'entropia è una metrica per misurare l'impurità in un dato attributo. Specifica la casualità nei dati. L’entropia può essere calcolata come:

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

Dove,

S= Numero totale di campioni P(si)= probabilità di sì P(no)= probabilità di no

2. Indice Gini:

• L'indice di Gini è una misura di impurità o purezza utilizzata durante la creazione di un albero decisionale nell'algoritmo CART (Classification and Regression Tree).
• Un attributo con un indice di Gini basso dovrebbe essere preferito rispetto a un attributo con un indice di Gini alto.
• Crea solo suddivisioni binarie e l'algoritmo CART utilizza l'indice Gini per creare suddivisioni binarie.
• L’indice di Gini può essere calcolato utilizzando la formula seguente:

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

Potatura: ottenere un albero decisionale ottimale

La potatura è un processo di eliminazione dei nodi non necessari da un albero al fine di ottenere l'albero decisionale ottimale.

Un albero troppo grande aumenta il rischio di overfitting, mentre un albero piccolo potrebbe non catturare tutte le caratteristiche importanti del set di dati. Pertanto, una tecnica che riduce la dimensione dell'albero di apprendimento senza ridurre la precisione è nota come Pruning. Esistono principalmente due tipi di alberi potatura tecnologia utilizzata:

Eliminazione della complessità dei costi Eliminazione degli errori ridotta.

Vantaggi dell'albero decisionale

• È semplice da capire poiché segue lo stesso processo che un essere umano segue mentre prende qualsiasi decisione nella vita reale.
• Può essere molto utile per risolvere problemi legati alle decisioni.
• Aiuta a pensare a tutti i possibili risultati di un problema.
• I requisiti di pulizia dei dati sono inferiori rispetto ad altri algoritmi.

Svantaggi dell'albero decisionale

• L'albero decisionale contiene molti livelli, il che lo rende complesso.
• Potrebbe esserci un problema di overfitting, che può essere risolto utilizzando il file Algoritmo della foresta casuale.
• Per più etichette di classe, la complessità computazionale dell'albero decisionale potrebbe aumentare.

Implementazione Python dell'albero decisionale

Ora implementeremo l'albero decisionale utilizzando Python. Per questo utilizzeremo il set di dati ' dati_utente.csv ,' che abbiamo utilizzato nei precedenti modelli di classificazione. Utilizzando lo stesso set di dati, possiamo confrontare il classificatore dell'albero decisionale con altri modelli di classificazione come KNN SVM, Regressione logistica, ecc.

come accoppiare le cuffie beats

Anche i passaggi rimarranno gli stessi, riportati di seguito:

Fase di pre-elaborazione dei dati Adattare un algoritmo Decision-Tree al Training set Predire il risultato del test Verifica l'accuratezza del risultato (creazione della matrice di confusione) Visualizzazione del risultato del set di test.

1. Fase di pre-elaborazione dei dati:

Di seguito è riportato il codice per la fase di pre-elaborazione:

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

Nel codice sopra, abbiamo pre-elaborato i dati. Dove abbiamo caricato il set di dati, che è dato come:

2. Adattare un algoritmo Decision-Tree al Training set

Ora adatteremo il modello al set di addestramento. Per questo importeremo il file DecisionTreeClassifier classe da sklearn.tree biblioteca. Di seguito è riportato il codice:

array di byte in stringa

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

Nel codice sopra abbiamo creato un oggetto classificatore, in cui abbiamo passato due parametri principali;

'criterio='entropia':Il criterio viene utilizzato per misurare la qualità della divisione, che viene calcolata in base al guadagno di informazioni fornito dall'entropia.stato_casuale=0':Per generare gli stati casuali.

Di seguito è riportato l'output per questo:

 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. Predire il risultato del test

Ora prevederemo il risultato del set di test. Creeremo un nuovo vettore di previsione y_pred. Di seguito è riportato il codice:

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

Produzione:

Nell'immagine di output seguente vengono forniti l'output previsto e l'output reale del test. Possiamo vedere chiaramente che ci sono alcuni valori nel vettore di previsione, che sono diversi dai valori del vettore reale. Questi sono errori di previsione.

converte la stringa in intero

4. Testare l'accuratezza del risultato (creazione della matrice di confusione)

Nell'output sopra abbiamo visto che c'erano alcune previsioni errate, quindi se vogliamo conoscere il numero di previsioni corrette e errate, dobbiamo utilizzare la matrice di confusione. Di seguito è riportato il codice:

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

Produzione:

Nell'immagine di output sopra, possiamo vedere la matrice di confusione, che ha 6+3= 9 pronostici errati E 62+29=91 pronostici corretti. Pertanto, possiamo dire che rispetto ad altri modelli di classificazione, il classificatore Decision Tree ha fatto una buona previsione.

5. Visualizzazione del risultato del set di training:

Qui visualizzeremo il risultato del set di allenamento. Per visualizzare il risultato del training set tracciamo un grafico per il classificatore dell'albero decisionale. Il classificatore prevederà sì o no per gli utenti che hanno acquistato o non acquistato l'auto SUV come abbiamo fatto nella regressione logistica. Di seguito è riportato il codice:

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

Produzione:

L'output di cui sopra è completamente diverso dagli altri modelli di classificazione. Presenta linee sia verticali che orizzontali che dividono il set di dati in base all'età e alla variabile salariale stimata.

Come possiamo vedere, l'albero cerca di catturare ogni set di dati, che è il caso di overfitting.

6. Visualizzazione del risultato del set di test:

La visualizzazione del risultato del set di test sarà simile alla visualizzazione del set di training, tranne per il fatto che il set di training verrà sostituito con il set di test.

algoritmo per rsa

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

Produzione:

Come possiamo vedere nell'immagine sopra, ci sono alcuni punti dati verdi all'interno della regione viola e viceversa. Quindi, queste sono le previsioni errate di cui abbiamo discusso nella matrice di confusione.