Árboles de decisión (Práctica)

Artículo práctico árboles de decisiones

Image for post
Image for post

Dentro de los problemas que se presentan en Machine Learning, se tienen los de clasificación, para variables categóricas que evalúa el modelo con una matriz de confusión y los de regresión que usa variables continuas que evalúa el modelo con error cuadrático medio. Ambos se pueden resolver con árboles de decisión, random forest o máquina de soporte vectorial. Los cuales se ejemplifican sus utilidades en las siguientes líneas de código.

Comandos para árboles de decisión

Cargar la base de datos

Código:

import pandas as pd

#precios de viviendas en boston

data=pd.read_csv(“Boston.csv”)

data.head()

Resultado:

Revisar tamaño de la base

Código:

data.shape

Resultado:

Crear variables predictoras para el árbol

Código:

colnames=data.columns.values.tolist()

predictors=colnames[:13] #columnas de 1 a 13 excluida

target=colnames[13] #columna 13 (“precio”)

x=data[predictors] #crea base con variables extraidas

y=data[target] #crea base de precios

x

y

Resultado:

x:

y:

Cargar librerías y crear árbol

Código:

from sklearn.tree import DecisionTreeRegressor

regtree=DecisionTreeRegressor(min_samples_split=30, min_samples_leaf=10, max_depth=5, random_state=0)

regtree.fit(x,y) #crea el ajuste del arbol a variables x, y, obteniendo parámetros

Resultado:

Predicciones y evaluar el modelo con datos predictores

Código:

preds=regtree.predict(data[predictors])

data[“preds”]=preds #que valor se pronostica con el modelo

data[[“preds”,”medv”]]#valor pronosticado y valor real

Resultado:

Graficar el árbol

Código:

#Se guarda el arbol en formato doc y se vuelve a leer para q sea graficable

from sklearn.tree import export_graphviz

with open(“boston_rtree.dot”,”w”) as dotfile:

export_graphviz(regtree,out_file=dotfile,feature_names=predictors)

dotfile.close()

#importar funcion para graficar

import os

from graphviz import Source

#leer archivo doc. que contiene el modelo

file=open(“boston_rtree.dot”,”r”)#guardar doc

text=file.read()#escribir doc

Source(text)

Resultado:

Cargar librerías y validar si el modelo se acerca al valor real

Código:

from sklearn.model_selection import KFold

from sklearn.model_selection import cross_val_score

import numpy as np

cv= KFold(n_splits=10,shuffle=True, random_state=1)#parametros para validacion cruzada

scores=-cross_val_score(regtree,x,y,scoring=”neg_mean_squared_error”,cv=cv,n_jobs=1) #trae scores

print(scores)

Resultado:

Error cuadrático medio promedio

Código:

score=np.mean(scores)

score

Resultado:

Matriz de importancia de variables

Código:

list(zip(predictors,regtree.feature_importances_))

Resultado:

RANDOM FOREST

Llamados también árboles aleatorios y son una técnica de aprendizaje supervisado. Es un algoritmo predictivo, una combinación de modelos independientes o diferentes (no ligados) para hacer una predicción. Es decir que principalmente crea árboles aleatorios y los promedia.

El resultado final será calculado en base a cada resultado independiente y se decide combinar de algún modo. Si es de clasificación escoge por la mayoría dada y de regresión por menor error promedio de cada árbol. Hay dos formas de algoritmos, ensamblaje de combinación y algoritmos de aprendizaje. Este último es el más utilizado, ya que crea una serie de modelos similares pero independientes obteniendo árboles de diferentes profundidades y varias ramificaciones.

Pero se debe tener en cuenta que no por tener más arboles es mejor el modelo, ya que estas técnicas sufren mucho de overfitting. Esta técnica puede soportar los árboles que se quiera, pero se debe tener en cuenta que la computadora también debe soportar la cantidad de árboles y la profundidad deseada, entonces se busca reducir el sesgo del estimador combinando secuencialmente los árboles y crear un estimador más robusto para crear un modelo más potente, porque se está alimentando de varios modelos más débiles.

Random forest es una colección de árboles de regresión o clasificación, que es fácil de implementar y es eficiente para big data. Tiene un poder de clasificación muy bueno y una estimación muy acertada.

En random forest no se necesita validaciones cruzadas como en los árboles, solo evalúa usando bolseo (bagging).

Tiene dos métodos característicos:

● Métodos de promedio: crea varios modelos similares a independientes y se hace un promedio de las predicciones de cada modelo. Se tendrá la cantidad de árboles que se quiera. Por tener tantos arboles tiene a tener muchos números y cumplir regla de grandes números.

● Método de impulso: reducir el sesgo del estimador combinado construyéndolo de forma secuencial de los estimadores base. Así, se consigue un modelo más robusto a partir de varios más débiles. Toma variables predictoras y muestras y las observaciones fuera de la bolsa se usan para evaluarlas y verificar que tan bien se ha clasificado.

Comandos para análisis con Random Forest

Importar librería para Random Forest y crear modelo

Código:

from sklearn.ensemble import RandomForestRegressor

forest=RandomForestRegressor(n_jobs=2, oob_score=True, n_estimators=10000)

forest.fit(x,y)

Resultado:

Tabla comparativa de variables predictoras y estimadoras

Código:

data[“rforest_pred”]=forest.oob_prediction_

data[[“rforest_pred”,”medv”]]

Resultado:

Obtener error cuadrático

Código:

data[“rforest_error2”]=(data[“rforest_pred”]-data[“medv”])**2

sum(data[“rforest_error2”])/len(data)

Resultado:

Coeficiente de determinación de ajuste

Código:

forest.oob_score_

Resultado:

MÁQUINAS DE SOPORTE VECTORIAL (Support Vector Machine)

Son vectores de algoritmos supervisado de machine learning para clasificación y regresión. Los algoritmos incrementan su dificultad en comparación a los árboles de decisión, usando matemáticas más avanzadas. Al ser supervisado, también estima valores sabiendo al final la etiqueta del valor real. Esta técnica predice datos a futuro y al ser tan compleja hay casos que no se puede realizar una predicción, porque no se puede encontrar un hiperplano que discrimine los grupos existentes.

Para análisis como máquina de soporte vectorial de clasificación, se tiene una serie de puntos de dos grupos diferentes, entonces si se da un punto nuevo, se debe encontrar donde está ubicado en los diferentes grupos. Con una solución lineal que es la más simple, se puede saber a qué grupo pertenece y depende de sus características para su clasificación.

Se puede pensar que un punto es un vector en el espacio p dimensional, donde p es el número de variables predictoras del conjunto, se busca separar por un hiperplano p — 1 dimensional (espacio de dimensión donde están los puntos según sus características en n dimensiones según el número de grupos) entonces se busca un hiperplano que logre separar estos puntos, es decir q los clasifique. El mejor hiperplano es el que más separación da entre los conjuntos, y la mayor distancia entre los puntos. Entonces se tiene una separación óptima de los puntos. El hiperplano maximizador del margen, es un perceptón (hiperplano q maximiza los márgenes de los n grupos).

Análisis matemático de máquina de soporte vectorial

En el caso que exista una separabilidad lineal cualquiera, punto X en un hiperplano separador, satisface la siguiente ecuación:

Considerando que el producto escalar de dos vectores es cero cuando ambos son perpendiculares. Siendo, entonces, w el vector perpendicular la hiperplano y b es una constante que representa como el plano está desplazado.

Y su vector ortonormal es perpendicular al hiperplano buscado, y se encuentra con:

Se tiene la evaluación de distancia del hiperplano al origen, y se debe entonces encontrar estas variables.

Para esto se puede usar un margen ±d con hiperplanos paralelos que definen región de decisión central, para evaluar cuán lejos están los grupos y verificar si se maximizan las distancias. Esta distancia d, se restringe a los puntos más cercanos a las fronteras de este hiperplano paralelo. Es decir que estos planos aseguran que los puntos por encima de la frontera y por debajo de una distancia d, estarán en un hiperplano de regiones separadas.

Por lo tanto, esta región se puede representar:

Esto se puede simplificar como:

Por lo tanto, la formulación de la distancia al origen se tiene que el margen de esta especie de corredor es equivalente a:

Pero sin pérdidas de generalidades, normalmente se iguala a 1, porque a establece la escala del vector b y del módulo w. Entonces al igualar a 1, se maximiza este margen, y en lugar de muchas operaciones se hace 1 dividido para w. Pero al no ser convexa se busca minimizar el módulo de w, para llevar a cabo este proceso de clasificación.

Detección de imágenes con Máquinas de Soporte Vectorial

Importar librería e imágenes de rostros

Código:

from sklearn.datasets import fetch_lfw_people

import matplotlib.pyplot as plt

faces=fetch_lfw_people(min_faces_per_person=60)

Resultado:

Verificar nombres de personas de las imágenes

Código:

print(faces.target_names)

Resultado:

Cantidad de fotografías y tamaño en pixeles

Código:

print(faces.images.shape)

Resultado:

Visualizar fotografías

Código:

fig, ax = plt.subplots(5,5, figsize=(16,9))

for i, ax_i in enumerate(ax.flat): # para mostrar el nombre

ax_i.imshow(faces.images[i], cmap=”bone”) #bone blanco y negro

ax_i.set(xticks=[], yticks=[],xlabel=faces.target_names[faces.target[i]])

Resultado:

Tamaño de pixeles total

Código:

#pixeles de alto * ancho

62*47

Resultado:

Importar librería de máquinas de soporte vectorial y crear modelo no supervisado con PCA (Análisis de componentes principales)

Código:

from sklearn.svm import SVC

from sklearn.pipeline import make_pipeline

from sklearn.decomposition import PCA as RandonmizedPCA

pca=RandonmizedPCA(n_components=150,whiten=True, random_state=42)

svc=SVC(kernel=”rbf”, class_weight=”balanced”)

model=make_pipeline(pca,svc)

from sklearn.model_selection import train_test_split

#dividir data set en training y test para q maquina reconozca imag.

xtrain, xtest, ytrain, ytest = train_test_split(faces.data,faces.target, random_state=42)

#Tecnica de validación: validacion cruzada para evitar overfiting

from sklearn.model_selection import GridSearchCV

param_grid = {

“svc__C”:[0.1,1,5,10,50], #controlar lo preciso

“svc__gamma”:[0.0001, 0.0005, 0.001, 0.005, 0.01] #controlar el radio, funciones radiales

}

grid = GridSearchCV(model, param_grid) #parrilla

%time grid.fit(xtrain, ytrain)#monitorea el tiempo q se demora el modelo en ejecutar

Resultado:

Escoger el mejor modelo grid generado

Código:

print(grid.best_params_)

Resultado:

Predicción del mejor clasificador y validación de imágenes

Código:

classifier=grid.best_estimator_

yfit=classifier.predict(xtest)

fig, ax = plt.subplots(8,6,figsize=(16,9))

for i, ax_i in enumerate(ax.flat):

ax_i.imshow(xtest[i].reshape(62,47), cmap=”bone”)

ax_i.set(xticks=[], yticks=[])

ax_i.set_ylabel(faces.target_names[yfit[i]].split()[-1],

color = “black” if yfit[i]==ytest[i] else “red”)

#pocos errores

fig.suptitle(“Predicciones de las imágnes (incorrectas en rojo)”, size = 15)

Resultado:

Importar librerías métricas y reporte de mayor nivel de precisión por famoso

Código:

from sklearn.metrics import classification_report

print(classification_report(ytest,yfit,target_names=faces.target_names))

Resultado:

Matriz de confusión

Código:

from sklearn.metrics import confusion_matrix

#crear matriz de confusion determinada por ytest y yfit

mat=confusion_matrix(ytest,yfit)

import seaborn as sns; sns.set()

#grafica con mejor formato la matriz

sns.heatmap(mat.T, square=True, annot=True, fmt=’d’, cbar=True,

xticklabels=faces.target_names, yticklabels=faces.target_names )

Resultado:

Autores:

  • Cristina Acosta
  • Jonathan Gavilanes
  • Lucía Loor
  • Xavier Ortiz

Código — Andrea Escobar

Conoce más:

Registrate en el programa de Python for Data Science.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store