• El árbol de decisión es un Técnica de aprendizaje supervisado. que se puede utilizar tanto para problemas de clasificación como de regresión, pero sobre todo se prefiere para resolver problemas de clasificación. Es un clasificador estructurado en árbol, donde Los nodos internos representan las características de un conjunto de datos, las ramas representan las reglas de decisión. y cada nodo de hoja representa el resultado.
• En un árbol de decisión, hay dos nodos, que son los Nodo de decisión y Nodo hoja. Los nodos de decisión se utilizan para tomar cualquier decisión y tienen múltiples ramas, mientras que los nodos Hoja son el resultado de esas decisiones y no contienen más ramas.
• Las decisiones o la prueba se realizan en función de las características del conjunto de datos dado.
Es una representación gráfica para obtener todas las soluciones posibles a un problema/decisión en función de condiciones dadas.
• Se llama árbol de decisión porque, al igual que un árbol, comienza con el nodo raíz, que se expande en más ramas y construye una estructura similar a un árbol.
• Para construir un árbol utilizamos el algoritmo de carrito, Lo que significa Algoritmo de clasificación y árbol de regresión.
• Un árbol de decisión simplemente hace una pregunta y, según la respuesta (Sí/No), divide el árbol en subárboles.
• El siguiente diagrama explica la estructura general de un árbol de decisión:

Nota: Un árbol de decisión puede contener datos categóricos (SÍ/NO), así como datos numéricos.

¿Por qué utilizar árboles de decisión?

Existen varios algoritmos en el aprendizaje automático, por lo que elegir el mejor algoritmo para el conjunto de datos y el problema determinado es el punto principal a recordar al crear un modelo de aprendizaje automático. A continuación se detallan las dos razones para utilizar el árbol de decisión:

• Los árboles de decisión suelen imitar la capacidad de pensamiento humano al tomar una decisión, por lo que son fáciles de entender.
• La lógica detrás del árbol de decisión se puede entender fácilmente porque muestra una estructura similar a un árbol.

Terminologías del árbol de decisión

¿Cómo funciona el algoritmo del árbol de decisión?

no

En un árbol de decisión, para predecir la clase del conjunto de datos dado, el algoritmo comienza desde el nodo raíz del árbol. Este algoritmo compara los valores del atributo raíz con el atributo del registro (conjunto de datos real) y, basándose en la comparación, sigue la rama y salta al siguiente nodo.

Para el siguiente nodo, el algoritmo vuelve a comparar el valor del atributo con los otros subnodos y avanza. Continúa el proceso hasta llegar al nodo de la hoja del árbol. El proceso completo se puede entender mejor utilizando el siguiente algoritmo:

Paso 1:Comience el árbol con el nodo raíz, dice S, que contiene el conjunto de datos completo.Paso 2:Encuentre el mejor atributo en el conjunto de datos usando Medida de selección de atributos (ASM). Paso 3:Divida la S en subconjuntos que contengan valores posibles para los mejores atributos.Etapa 4:Genere el nodo del árbol de decisión, que contiene el mejor atributo.Paso 5:Cree recursivamente nuevos árboles de decisión utilizando los subconjuntos del conjunto de datos creado en el paso -3. Continúe este proceso hasta llegar a una etapa en la que no pueda clasificar más los nodos y llame al nodo final como nodo hoja.

Ejemplo: Supongamos que hay un candidato que tiene una oferta de trabajo y quiere decidir si debe aceptar la oferta o no. Entonces, para resolver este problema, el árbol de decisión comienza con el nodo raíz (atributo Salario de ASM). El nodo raíz se divide aún más en el siguiente nodo de decisión (distancia de la oficina) y un nodo hoja según las etiquetas correspondientes. El siguiente nodo de decisión se divide en un nodo de decisión (instalación Cab) y un nodo hoja. Finalmente, el nodo de decisión se divide en dos nodos hoja (Ofertas aceptadas y Oferta rechazada). Considere el siguiente diagrama:

Medidas de selección de atributos

Al implementar un árbol de decisión, surge el problema principal: cómo seleccionar el mejor atributo para el nodo raíz y para los subnodos. Entonces, para resolver este tipo de problemas existe una técnica que se llama Medida de selección de atributos o ASM. Mediante esta medida, podemos seleccionar fácilmente el mejor atributo para los nodos del árbol. Existen dos técnicas populares para la MAPE, que son:

Ganancia de información Índice de Gini

1. Obtención de información:

• La ganancia de información es la medición de los cambios en la entropía después de la segmentación de un conjunto de datos en función de un atributo.
• Calcula cuánta información nos proporciona una característica sobre una clase.
• Según el valor de la ganancia de información, dividimos el nodo y construimos el árbol de decisión.
• Un algoritmo de árbol de decisión siempre intenta maximizar el valor de la ganancia de información, y un nodo/atributo que tenga la mayor ganancia de información se divide primero. Se puede calcular utilizando la siguiente fórmula:

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

Entropía: La entropía es una métrica para medir la impureza en un atributo determinado. Especifica la aleatoriedad en los datos. La entropía se puede calcular como:

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

Dónde,

Python escribe json en un archivo

S= Número total de muestras P(sí)= probabilidad de sí P(no)= probabilidad de no

2. Índice de Gini:

• El índice de Gini es una medida de impureza o pureza que se utiliza al crear un árbol de decisión en el algoritmo CART (árbol de clasificación y regresión).
• Se debe preferir un atributo con un índice de Gini bajo en comparación con un índice de Gini alto.
• Solo crea divisiones binarias y el algoritmo CART utiliza el índice de Gini para crear divisiones binarias.
• El índice de Gini se puede calcular utilizando la siguiente fórmula:

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

Poda: obtención de un árbol de decisión óptimo

La poda es un proceso de eliminación de nodos innecesarios de un árbol para obtener el árbol de decisión óptimo.

Un árbol demasiado grande aumenta el riesgo de sobreajuste y es posible que un árbol pequeño no capture todas las características importantes del conjunto de datos. Por tanto, una técnica que disminuye el tamaño del árbol de aprendizaje sin reducir la precisión se conoce como poda. Existen principalmente dos tipos de árboles. poda tecnología utilizada:

Poda de complejidad de costos Poda de errores reducida.

Ventajas del árbol de decisión

• Es sencillo de entender ya que sigue el mismo proceso que sigue un ser humano al tomar cualquier decisión en la vida real.
• Puede resultar muy útil para resolver problemas relacionados con decisiones.
• Es útil pensar en todos los resultados posibles de un problema.
• Hay menos requisitos de limpieza de datos en comparación con otros algoritmos.

Desventajas del árbol de decisión

• El árbol de decisión contiene muchas capas, lo que lo hace complejo.
• Puede tener un problema de sobreajuste, que se puede resolver utilizando el Algoritmo de bosque aleatorio.
• Para más etiquetas de clase, la complejidad computacional del árbol de decisión puede aumentar.

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

Ahora implementaremos el árbol de decisión usando Python. Para esto usaremos el conjunto de datos ' datos_usuario.csv ,' que hemos utilizado en modelos de clasificación anteriores. Al utilizar el mismo conjunto de datos, podemos comparar el clasificador de árbol de decisión con otros modelos de clasificación como knn SVM, Regresión logística, etc.

Los pasos también seguirán siendo los mismos, que se detallan a continuación:

Paso de preprocesamiento de datos Cómo ajustar un algoritmo de árbol de decisión al conjunto de entrenamiento Predecir el resultado de la prueba Pruebe la precisión del resultado (Creación de matriz de confusión) Visualizando el resultado del conjunto de pruebas.

1. Paso de preprocesamiento de datos:

A continuación se muestra el código para el paso de preprocesamiento:

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

En el código anterior, hemos preprocesado los datos. Donde hemos cargado el conjunto de datos, que se expresa como:

2. Adaptar un algoritmo de árbol de decisión al conjunto de entrenamiento

Ahora ajustaremos el modelo al conjunto de entrenamiento. Para ello importaremos el Clasificador de árbol de decisión clase de sklearn.árbol biblioteca. A continuación se muestra el código para ello:

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

En el código anterior, hemos creado un objeto clasificador, al que le hemos pasado dos parámetros principales;

'criterio='entropía':El criterio se utiliza para medir la calidad de la división, que se calcula mediante la ganancia de información dada por la entropía.estado_aleatorio=0':Para generar los estados aleatorios.

A continuación se muestra el resultado de esto:

bharti jha

 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. Predecir el resultado de la prueba

Ahora predeciremos el resultado del conjunto de pruebas. Crearemos un nuevo vector de predicción. y_pred. A continuación se muestra el código para ello:

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

Producción:

En la siguiente imagen de salida, se proporcionan la salida prevista y la salida de prueba real. Podemos ver claramente que hay algunos valores en el vector de predicción que son diferentes de los valores del vector real. Estos son errores de predicción.

4. Pruebe la precisión del resultado (Creación de matriz de confusión)

En el resultado anterior, hemos visto que hubo algunas predicciones incorrectas, por lo que si queremos saber la cantidad de predicciones correctas e incorrectas, debemos usar la matriz de confusión. A continuación se muestra el código para ello:

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

Producción:

logotipo de java

En la imagen de salida de arriba, podemos ver la matriz de confusión, que tiene 6+3= 9 predicciones incorrectas y 62+29=91 predicciones correctas. Por tanto, podemos decir que, en comparación con otros modelos de clasificación, el clasificador de árbol de decisión hizo una buena predicción.

5. Visualizando el resultado del conjunto de entrenamiento:

Aquí visualizaremos el resultado del conjunto de entrenamiento. Para visualizar el resultado del conjunto de entrenamiento, trazaremos un gráfico para el clasificador del árbol de decisión. El clasificador predecirá sí o no para los usuarios que compraron o no el automóvil SUV como lo hicimos en Regresión logística. A continuación se muestra el código para ello:

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

Producción:

El resultado anterior es completamente diferente del resto de modelos de clasificación. Tiene líneas verticales y horizontales que dividen el conjunto de datos según la variable edad y salario estimado.

Como podemos ver, el árbol intenta capturar cada conjunto de datos, lo cual es el caso del sobreajuste.

6. Visualización del resultado del conjunto de prueba:

La visualización del resultado del conjunto de prueba será similar a la visualización del conjunto de entrenamiento excepto que el conjunto de entrenamiento será reemplazado por el conjunto de prueba.

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

Producción:

Como podemos ver en la imagen de arriba, hay algunos puntos de datos verdes dentro de la región violeta y viceversa. Entonces, estas son las predicciones incorrectas que hemos discutido en la matriz de confusión.