Árboles de decisión (Práctica)
Artículo práctico árboles de decisiones
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
