Python | Implementación del árbol de decisión

Prerrequisitos: Árbol de decisiones , DecisionTreeClassifier , sklearn , numpy , pandas

Decision Tree es uno de los algoritmos más poderosos y populares. El algoritmo del árbol de decisiones cae dentro de la categoría de algoritmos de aprendizaje supervisado. Funciona tanto para variables de salida continuas como categóricas.

En este artículo, vamos a implementar un algoritmo de árbol de decisiones en la base de datos de peso y distancia de Balance Scale presentada en la UCI.

Descripción del conjunto de datos:

Title                : Balance Scale Weight & Distance Database
Number of Instances  : 625 (49 balanced, 288 left, 288 right)
Number of Attributes : 4 (numeric) + class name = 5
Attribute Information:
Class Name (Target variable): 3

L [punta de la balanza a la izquierda]
B [la balanza se equilibre]
R [punta de la balanza a la derecha]

Peso izquierdo : 5 (1, 2, 3, 4, 5)

Distancia izquierda : 5 (1, 2, 3, 4, 5)

Peso correcto : 5 (1, 2, 3, 4, 5)

Distancia derecha : 5 (1, 2, 3, 4, 5)

Valores de atributos faltantes
: Ninguna

Distribución de clases:

46.08 por ciento son L
07.84 por ciento son B
46.08 por ciento son R

Puede encontrar más detalles del conjunto de datos
aquí
.

Paquetes de Python usados:

aprender :
- En python, sklearn es un paquete de aprendizaje automático que incluye muchos algoritmos de ML.
- Aquí, estamos usando algunos de sus módulos como train_test_split, DecisionTreeClassifier y precision_score.
NúmPy:
- Es un módulo de Python numérico que proporciona funciones matemáticas rápidas para los cálculos.
- Se utiliza para leer datos en arrays numpy y con fines de manipulación.
pandas:
- Se utiliza para leer y escribir diferentes archivos.
- La manipulación de datos se puede hacer fácilmente con marcos de datos.

Instalación de los paquetes:

En Python, sklearn es el paquete que contiene todos los paquetes necesarios para implementar el algoritmo de aprendizaje automático. Puede instalar el paquete sklearn siguiendo los comandos que se indican a continuación.
usando pip:

pip install -U scikit-learn

Antes de usar el comando anterior, asegúrese de tener instalados los paquetes scipy y numpy .

Si no tienes pipa. Puedes instalarlo usando

python get-pip.py

usando conda:

conda install scikit-learn

Suposiciones que hacemos al usar el árbol de decisión:

Al principio, consideramos todo el conjunto de entrenamiento como la raíz.
Se supone que los atributos son categóricos para la obtención de información y para el índice de Gini, se supone que los atributos son continuos.
Sobre la base de los valores de los atributos, los registros se distribuyen recursivamente.
Usamos métodos estadísticos para ordenar atributos como raíz o Node interno.

Pseudocódigo:

Encuentre el mejor atributo y colóquelo en el Node raíz del árbol.
Ahora, divida el conjunto de entrenamiento del conjunto de datos en subconjuntos. Al crear el subconjunto, asegúrese de que cada subconjunto del conjunto de datos de entrenamiento tenga el mismo valor para un atributo.
Encuentre Nodes hoja en todas las ramas repitiendo 1 y 2 en cada subconjunto.

Mientras implementamos el árbol de decisiones, pasaremos por las siguientes dos fases:

Fase de construcción
- Preprocesar el conjunto de datos.
- Divida el conjunto de datos del tren y pruebe usando el paquete sklearn de Python.
- Entrenar al clasificador.
Fase Operativa
- Hacer predicciones.
- Calcular la precisión.

Importación de datos:

Para importar y manipular los datos estamos usando el paquete pandas provisto en python.

Aquí, estamos usando una URL que obtiene directamente el conjunto de datos del sitio de UCI, sin necesidad de descargar el conjunto de datos. Cuando intente ejecutar este código en su sistema, asegúrese de que el sistema tenga una conexión a Internet activa.

Como el conjunto de datos está separado por «,» tenemos que pasar el valor del parámetro sep como «,».

Otra cosa es notar que el conjunto de datos no contiene el encabezado, por lo que pasaremos el valor del parámetro del encabezado como ninguno. Si no pasamos el parámetro del encabezado, considerará la primera línea del conjunto de datos como el encabezado.

Rebanado de datos:

Antes de entrenar el modelo, tenemos que dividir el conjunto de datos en el conjunto de datos de entrenamiento y prueba.

Para dividir el conjunto de datos para entrenamiento y prueba, estamos usando el módulo sklearn train_test_split

En primer lugar, debemos separar la variable de destino de los atributos en el conjunto de datos.

X = balance_data.values[:, 1:5]
Y = balance_data.values[:,0]

Arriba están las líneas del código que separan el conjunto de datos. La variable X contiene los atributos mientras que la variable Y contiene la variable de destino del conjunto de datos.

El siguiente paso es dividir el conjunto de datos con fines de entrenamiento y prueba.

X_train, X_test, y_train, y_test = train_test_split( 
          X, Y, test_size = 0.3, random_state = 100)

La línea superior divide el conjunto de datos para entrenamiento y prueba. Como estamos dividiendo el conjunto de datos en una proporción de 70:30 entre entrenamiento y prueba, pasamos el valor del parámetro test_size como 0.3.

La variable random_state es un estado generador de números pseudoaleatorios que se utiliza para el muestreo aleatorio.

Términos utilizados en el código:

El índice de Gini y la ganancia de información, ambos métodos se utilizan para seleccionar de los n atributos del conjunto de datos qué atributo se colocaría en el Node raíz o en el Node interno.

Índice Gini:

$\text { Gini Index }=1-\sum_{j}{ }_{\mathrm{j}}^{2}$

El índice Gini es una métrica para medir la frecuencia con la que un elemento elegido al azar se identificaría incorrectamente.

Significa que se debe preferir un atributo con un índice Gini más bajo.

Sklearn admite los criterios «gini» para el índice Gini y, de forma predeterminada, toma el valor «gini».

Entropía:

$if a random variable $\mathrm{x}$ can take $\mathrm{N}$ different value , the i'value $\mathrm{x}_{\mathrm{i}}$ with probability $\mathrm{p}\left(\mathrm{x}_{\mathrm{ii}}\right)$ ,we can associate the following entropy with $\mathrm{x}$ : $$ H(x)=-\sum_{i=1}^{N} p\left(x_{i}\right) \log _{2} p\left(x_{i}\right) $$$

La entropía es la medida de incertidumbre de una variable aleatoria, caracteriza la impureza de una colección arbitraria de ejemplos. Cuanto mayor sea la entropía, mayor será el contenido de información.

Ganancia de información

$Definition: Suppose $S$ is a set of instances, $A$ is an attribute, $\mathrm{S}_{\mathrm{v}}$ is the subset of $\mathrm{s}$ with $\mathrm{A}=\mathrm{v}$ and Values(A) is the set of all possible of A,then$

La entropía normalmente cambia cuando usamos un Node en un árbol de decisión para dividir las instancias de entrenamiento en subconjuntos más pequeños. La ganancia de información es una medida de este cambio en la entropía.

Sklearn admite criterios de «entropía» para la obtención de información y, si queremos utilizar el método de obtención de información en sklearn, debemos mencionarlo explícitamente.

Puntuación de precisión

La puntuación de precisión se utiliza para calcular la precisión del clasificador entrenado.

Array de confusión

Confusion Matrix se utiliza para comprender el comportamiento del clasificador entrenado sobre el conjunto de datos de prueba o validar el conjunto de datos.

A continuación se muestra el código Python para el árbol de decisión.

# Run this program on your local python
# interpreter, provided you have installed
# the required libraries.
  
# Importing the required packages
import numpy as np
import pandas as pd
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
  
# Function importing Dataset
def importdata():
    balance_data = pd.read_csv(
'https://archive.ics.uci.edu/ml/machine-learning-'+
'databases/balance-scale/balance-scale.data',
    sep= ',', header = None)
      
    # Printing the dataswet shape
    print ("Dataset Length: ", len(balance_data))
    print ("Dataset Shape: ", balance_data.shape)
      
    # Printing the dataset obseravtions
    print ("Dataset: ",balance_data.head())
    return balance_data
  
# Function to split the dataset
def splitdataset(balance_data):
  
    # Separating the target variable
    X = balance_data.values[:, 1:5]
    Y = balance_data.values[:, 0]
  
    # Splitting the dataset into train and test
    X_train, X_test, y_train, y_test = train_test_split( 
    X, Y, test_size = 0.3, random_state = 100)
      
    return X, Y, X_train, X_test, y_train, y_test
      
# Function to perform training with giniIndex.
def train_using_gini(X_train, X_test, y_train):
  
    # Creating the classifier object
    clf_gini = DecisionTreeClassifier(criterion = "gini",
            random_state = 100,max_depth=3, min_samples_leaf=5)
  
    # Performing training
    clf_gini.fit(X_train, y_train)
    return clf_gini
      
# Function to perform training with entropy.
def tarin_using_entropy(X_train, X_test, y_train):
  
    # Decision tree with entropy
    clf_entropy = DecisionTreeClassifier(
            criterion = "entropy", random_state = 100,
            max_depth = 3, min_samples_leaf = 5)
  
    # Performing training
    clf_entropy.fit(X_train, y_train)
    return clf_entropy
  
  
# Function to make predictions
def prediction(X_test, clf_object):
  
    # Predicton on test with giniIndex
    y_pred = clf_object.predict(X_test)
    print("Predicted values:")
    print(y_pred)
    return y_pred
      
# Function to calculate accuracy
def cal_accuracy(y_test, y_pred):
      
    print("Confusion Matrix: ",
        confusion_matrix(y_test, y_pred))
      
    print ("Accuracy : ",
    accuracy_score(y_test,y_pred)*100)
      
    print("Report : ",
    classification_report(y_test, y_pred))
  
# Driver code
def main():
      
    # Building Phase
    data = importdata()
    X, Y, X_train, X_test, y_train, y_test = splitdataset(data)
    clf_gini = train_using_gini(X_train, X_test, y_train)
    clf_entropy = tarin_using_entropy(X_train, X_test, y_train)
      
    # Operational Phase
    print("Results Using Gini Index:")
      
    # Prediction using gini
    y_pred_gini = prediction(X_test, clf_gini)
    cal_accuracy(y_test, y_pred_gini)
      
    print("Results Using Entropy:")
    # Prediction using entropy
    y_pred_entropy = prediction(X_test, clf_entropy)
    cal_accuracy(y_test, y_pred_entropy)
      
      
# Calling main function
if __name__=="__main__":
    main()

Data Infomation:

Dataset Length: 625 Dataset Shape: (625, 5) Dataset: 0 1 2 3 4 0 B 1 1 1 1 1 R 1 1 1 2 2 R 1 1 1 3 3 R 1 1 1 4 4 R 1 1 1 5

Results Using Gini Index:

Predicted values: ['R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'R' 'L' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L' 'R' 'L' 'L' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'L' 'L' 'R' 'R' 'L' 'L' 'L' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'R' 'R'] Confusion Matrix: [[ 0 6 7] [ 0 67 18] [ 0 19 71]] Accuracy : 73.4042553191 Report : precision recall f1-score support B 0.00 0.00 0.00 13 L 0.73 0.79 0.76 85 R 0.74 0.79 0.76 90 avg/total 0.68 0.73 0.71 188

Results Using Entropy:

Predicted values: ['R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L' 'R' 'L' 'L' 'R' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'L' 'L' 'R' 'R' 'L' 'L' 'L' 'R' 'L' 'L' 'R' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'L' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'R' 'R' 'R' 'R' 'R' 'L' 'R' 'L' 'R' 'R' 'L' 'R' 'L' 'R' 'L' 'R' 'L' 'L' 'L' 'L' 'L' 'R' 'R' 'R' 'L' 'L' 'L' 'R' 'R' 'R'] Confusion Matrix: [[ 0 6 7] [ 0 63 22] [ 0 20 70]] Accuracy : 70.7446808511 Report : precision recall f1-score support B 0.00 0.00 0.00 13 L 0.71 0.74 0.72 85 R 0.71 0.78 0.74 90 avg / total 0.66 0.71 0.68 188

Publicación traducida automáticamente

Artículo escrito por Abhishek Sharma 44 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA