En esta práctica vamos a usar el clásico dataset de las flores de iris (iris data set), tratando de clasificar distintas variedades de la flor de iris según la longitud y anchura de sus pétalos y sépalos. Trataremos de optimizar distintas métricas y veremos como los diferentes modelos clasifican los puntos y con cuales obtenemos una mayor precisión.
La práctica está estructurada de la siguiente manera (en el que se detalla la puntuación de cada parte).
Importante: Cada ejercicio puede suponer varios minutos de ejecución, por lo que la entrega debe hacerse en formato notebook y html, donde se vea el código y los resultados, junto con los comentarios de cada ejercicio.
# Importamos librerías
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import pandas as pd
import colorsys
import graphviz
from pandas.plotting import scatter_matrix
from matplotlib.colors import ListedColormap
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn import model_selection
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn import datasets, neighbors, tree, svm
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import OneHotEncoder
from sklearn import tree
from sklearn.metrics import classification_report, accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.tree import export_graphviz
%matplotlib inline
#Importamos el dataset para iniciar el análisis
#También se podría hacer a partir de la clase datasets
#iris = datasets.load_iris()
iris = pd.read_csv("Iris.csv")
Exploraremos nuestro conjunto de datos. Para ello, realizaremos las siguientes inspecciones:
Os hemos puesto en forma de comentario los análisis que tendríais que hacer
#Visualizamos los primeros 5 datos del dataset
iris = pd.read_csv("Iris.csv")
display(iris.head())
#Eliminamos la primera columna ID
print()
print('------Eliminamos la columna ID-------------')
iris = iris.drop('Id',axis=1)
display(iris.head())
#Forma, tamaño y número de valores del dataset
print()
print('------Información del dataset------')
print(iris.info())
print("El número de líneas es: " + str(iris.shape[0]) + " y el número de columnas: "+ str(iris.shape[1]))
print("No existe ningún null")
display(iris.isnull().sum())
#Resumen estadístico
print()
print('------Descripción del dataset------')
display(iris.describe())
#Grafico Sépalo - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='green', label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter', x='SepalLengthCm', y='SepalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Sépalo - Longitud')
fig.set_ylabel('Sépalo - Ancho')
fig.set_title('Sépalo - Longitud vs Ancho')
plt.show()
#Grafico Pétalo - Longitud vs Ancho
fig = iris[iris.Species == 'Iris-setosa'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='blue', label='Setosa')
iris[iris.Species == 'Iris-versicolor'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='green', label='Versicolor', ax=fig)
iris[iris.Species == 'Iris-virginica'].plot(kind='scatter', x='PetalLengthCm', y='PetalWidthCm', color='red', label='Virginica', ax=fig)
fig.set_xlabel('Pétalo - Longitud')
fig.set_ylabel('Pétalo - Ancho')
fig.set_title('Pétalo Longitud vs Ancho')
plt.show()
El análisis univariado es la forma más simple de analizar datos. No trata con causas o relaciones (a diferencia de la regresión) y su propósito principal es describir y encontrar patrones en los datos.
Para ello vamos a realizar lo que se conoce como Distribution Plots (o histogramas). Los gráficos de distribución se utilizan para evaluar visualmente cómo se distribuyen los puntos de datos con respecto a su frecuencia. Por lo general, los puntos de datos se agrupan en contenedores y la altura de las barras indica el número de puntos de datos (frecuencua de aparición).
import warnings
warnings.filterwarnings('ignore')
iris_setosa=iris.loc[iris["Species"]=="Iris-setosa"]
iris_virginica=iris.loc[iris["Species"]=="Iris-virginica"]
iris_versicolor=iris.loc[iris["Species"]=="Iris-versicolor"]
sns.FacetGrid(iris,hue="Species",size=3).map(sns.distplot,"PetalLengthCm").add_legend()
sns.FacetGrid(iris,hue="Species",size=3).map(sns.distplot,"PetalWidthCm").add_legend()
sns.FacetGrid(iris,hue="Species",size=3).map(sns.distplot,"SepalLengthCm").add_legend()
sns.FacetGrid(iris,hue="Species",size=3).map(sns.distplot,"SepalWidthCm").add_legend()
plt.show()
La única conclusión es que con PetalLengthCm podemos separa la especie iris-setosa.
Un diagrama de caja (box plot) es una forma estandarizada de mostrar la distribución de datos basada en un resumen de cinco números ("mínimo", primer cuartil (Q1), mediana, tercer cuartil (Q3) y "máximo"). Los box plots nos informan sobre valores atípicos y cuáles son sus valores. También puede decirnos si los datos son simétricos, si están agrupados y si están sesgados. Para realizarlos podemos usar la función boxplot
de seaborn
.
El Violin Plot es un método para visualizar la distribución de datos numéricos de diferentes variables. Es similar al diagrama de caja (box plot) pero con un diagrama rotado en cada lado que brinda más información sobre la estimación de densidad en el eje y. La densidad se refleja y se voltea y la forma resultante se rellena creando una imagen que se parece a un violín. La ventaja de una trama de violín es que puede mostrar matices en la distribución que no son perceptibles en una gráfica de caja. Por otro lado, el diagrama de caja muestra más claramente los valores atípicos en los datos. Los gráficos de violín suelen contener más información que los gráficos de caja aunque son menos populares.
Ahora tracemos los gráficos de violín para nuestro conjunto de datos de iris. Para ello podemos utilizar la función violinplot
de seaborn
. Para su interpretación tengamos en cuenta que el rectángulo que aparece en el violin plot equivale a la información que nos da el box plot y que el círculo blanco nos indica donde está el percentil 50.
Por último realizaremos un pequeño estudio mediante un pair-plot para visualizar posibles relaciones entre nuestras variables (por pares).
En este caso emplearemos la función pairplot
de la librería seaborn
.
import warnings
warnings.filterwarnings('ignore')
sns.boxplot(x="Species",y="PetalLengthCm",data=iris)
plt.show()
sns.boxplot(x="Species",y="PetalWidthCm",data=iris)
plt.show()
sns.boxplot(x="Species",y="SepalLengthCm",data=iris)
plt.show()
sns.boxplot(x="Species",y="SepalWidthCm",data=iris)
plt.show()
display(iris.boxplot())
sns.violinplot(x="Species",y="PetalLengthCm",data=iris)
plt.show()
sns.violinplot(x="Species",y="PetalWidthCm",data=iris)
plt.show()
sns.violinplot(x="Species",y="SepalLengthCm",data=iris)
plt.show()
sns.violinplot(x="Species",y="SepalWidthCm",data=iris)
plt.show()
sns.set_style("whitegrid")
sns.pairplot(iris,hue="Species",size=3);
plt.show()
Si nos fijamos en la gráficas de dispersión que relacionan las carácteristicas del campo sepal veremos como están distribuidos de manera casi uniforme (sobretodo los correspondientes al Iris setosa), mientras que los correspondientes a versicolor y virginica tienen cualidades algo parecidas por lo que se solapan en ocasiones.
En cambio si comparamos el pétalo es una distribución mucho más uniforme en comparación con el sépalo.
Si análizamos el diagramade violín muestra que Iris Virginica tiene un valor medio más alto en longitud de pétalo, ancho de pétalo y longitud de sépalo en comparación con Versicolor y Setosa. En otro sentido, Iris Setosa tiene el mayor valor medio de ancho de sépalo. También podemos ver una diferencia significativa entre la longitud y el ancho del sépalo de Setosa contra la longitud y el ancho de sus pétalos. Esa diferencia es menor en Versicolor y Virginica. El diagrama del violín también indica que el peso del ancho del sépalo de Virginica y el ancho del pétalo están altamente concentrados alrededor de la mediana.
Respecto al diagrama de cajas, los puntos aislados que se pueden ver son los valores atípicos en los datos. Dado que estos son muy pocos en número, no tendría ningún impacto significativo en nuestro análisis.
Antes de aplicar ningún modelo, tenemos que separar los datos entre los conjuntos de train y test. Siempre trabajaremos sobre el conjunto de train y evaluaremos los resultados en el conjunto de test.
Es importante tener en cuenta que nuestra variable target es categórica. El clasificador KNeighborsClassifier
no acepta etiquetas de tipo string
, por lo que debemos tranformar estas etiquetas a números (esto es lo que conocemos como Label encoding).
Para ello dividiremos el dataset en dos arrays: X (características) e Y (etiquetas) y aplicaremos la siguiente correspondencia:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()
iris = pd.read_csv("Iris.csv")
iris = iris.drop('Id',axis=1)
print('----------Aplicación de la correspondecia ----------------------')
print(iris['Species'].unique())
iris['Species']= label_encoder.fit_transform(iris['Species'])
print(iris['Species'].unique())
#X_train, X_test, y_train, y_test = train_test_split(iris[['PetalLengthCm', 'PetalWidthCm','SepalLengthCm','SepalWidthCm']],
print('----------Sepal----------------------')
X_train, X_test, y_train, y_test = train_test_split(iris[['SepalLengthCm', 'SepalWidthCm']],
iris['Species'],
test_size=0.2,
stratify=iris['Species'])
A lo largo de los ejercicios aprenderemos a visualizar gráficamente las fronteras de decisión que nos devuelven los diferentes modelos. Para este fin usaremos la función definida a continuación (que nos servirá para trazar las respectivas fronteras de decisión a lo largo de toda la PEC), la cual sigue los siguientes pasos:
Después de este proceso, ya podemos hacer el gráfico de las fronteras de decisión y añadir los puntos reales. Así veremos las areas en las que el modelo considera que son de una clase y las que considera que son de la otra. Al poner encima los puntos reales veremos si los clasifica correctamente.
# Creamos la meshgrid con los valores mínimo y máximo de 'x' i 'y'.
# La variable X es nuestro dataframe con las variables a estudiar (las del pétalo o las del sépalo)
X=iris[['SepalLengthCm', 'SepalWidthCm']].to_numpy()
# Creamos la meshgrid con los valores mínimo y máximo de 'x' i 'y'.
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
# Definimos la función que nos graficará las fronteras de decisión
def plot_decision_boundaries(model, X, y, x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max, delta: float = .02) -> None:
"""Plot data points and deicision boundaries learned by the model.
Arguments:
----------
model: scikit-learn like model
X: np.array[n_samples, n_features]
Only first 2 features will be considered because it is a 2d plot.
Feature 0 in the x axis, and feature 1 in the y axis.
y: np.array
Labels for each sample.
delta: float
Increment between consecutive points when computing the grid for plotting boundaries.
Lower value for higher resolution.
"""
xx, yy = np.meshgrid(np.arange(x_min, x_max, delta),
np.arange(y_min, y_max, delta))
#Predecimos el clasificador con los valores de la meshgrid
# En este caso model será nuestra variable que contiene el modelo a estudiar, es decir K-nn, SVM,...
# Por ejemplo para K-nn sería model = KNeighborsClassifier()
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
# Creamos mapas de colores con ListedColormap para ver como separa las clases.
# En este caso usaremos:
# Iris-setosa : darkorange
# Iris-versicolor: c
# Iris-virginica: darkblue
cmap_light = ListedColormap(['orange', 'cyan', 'cornflowerblue'])
cmap_bold = ListedColormap(['darkorange', 'c', 'darkblue'])
# Ponemos el resultado en una figura de color
Z = Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx, yy, Z, cmap= cmap_light)
# Dibujamos también los puntos de entrenamiento
plt.scatter(X[:, 0], X[:, 1], c=y, cmap= cmap_bold)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()
def plot_decision_boundaries_bonus(x, y, labels, model,
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
grid_step=0.02):
xx, yy = np.meshgrid(np.arange(x_min, x_max, grid_step),
np.arange(y_min, y_max, grid_step))
# Predecimos el classifier con los valores de la meshgrid.
Z = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:,1]
# Hacemos reshape para tener el formato correcto.
Z = Z.reshape(xx.shape)
# Seleccionamos una paleta de color.
arr = plt.cm.coolwarm(np.arange(plt.cm.coolwarm.N))
arr_hsv = mpl.colors.rgb_to_hsv(arr[:,0:3])
arr_hsv[:,2] = arr_hsv[:,2] * 1.5
arr_hsv[:,1] = arr_hsv[:,1] * .5
arr_hsv = np.clip(arr_hsv, 0, 1)
arr[:,0:3] = mpl.colors.hsv_to_rgb(arr_hsv)
my_cmap = ListedColormap(arr)
# Hacemos el gráfico de las fronteras de decisión.
fig, ax = plt.subplots(figsize=(7,7))
plt.pcolormesh(xx, yy, Z, cmap=my_cmap)
# Añadimos los punts.
ax.scatter(x, y, c=labels, cmap='coolwarm')
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.grid(False)
El primer algoritmo que usaremos para clasificar los puntos es el k-nn. En este ejercicio ajustaremos dos hiperparámetros para tratar de obtener una mayor precisión:
Para decidir los hiperparámetros óptimos usaremos la técnica de grid search, que consiste en entrenar un modelo para cada combinación posible de hiperparámetros y la evaluaremos usando cross validation con 4 particiones estratificadas. Posteriormente, escojeremos la combinación de hiperparametros que haya obtenido mejores resultados.
Para resolver la primer parte podéis usar los módulos GridSearchCV
y KNeighborsClassifier
de sklearn
. Para la visualización del heatmap podéis usar la función pivot que permite la librería Pandas
.
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier()
param_grid = {"n_neighbors": range(1, 11), "weights": ["uniform", "distance"]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=4)
grid_search.fit(X_train, y_train)
means = grid_search.cv_results_["mean_test_score"]
stds = grid_search.cv_results_["std_test_score"]
params = grid_search.cv_results_['params']
for mean, std, pms in zip(means, stds, params):
print("Precisión media: {:.2f} +/- {:.2f} con parametros {}".format(mean*100, std*100, pms))
import seaborn as sns
param1 = [x['n_neighbors'] for x in params]
param2 = [x['weights'] for x in params]
precisions = pd.DataFrame(zip(param1, param2, means), columns=['n_neighbors', 'weights', 'means'])
precisions = precisions.pivot('n_neighbors', 'weights', 'means')
sns.heatmap(precisions)
clf = KNeighborsClassifier(n_neighbors=9, weights='uniform')
clf.fit(X_train, y_train)
plot_decision_boundaries(X=X_test[['SepalLengthCm', 'SepalWidthCm']].to_numpy(), y=y_test, model=clf)
plot_decision_boundaries_bonus(x=X_test['SepalLengthCm'], y=X_test['SepalWidthCm'], labels=y_test, model=clf)
from sklearn.metrics import confusion_matrix
preds = clf.predict(X_test)
accuracy = np.true_divide(np.sum(preds == y_test), preds.shape[0])*100
cnf_matrix = confusion_matrix(y_test, preds)
print(accuracy)
print(cnf_matrix)
Lo resultados no han sido muy buenos. La frontera de desición no parece acurada, hay bastantes zonas que no se han clasificado adecuadamente.
print('----------Petal----------------------')
print('----------División en entrenamiento y test ----------------------')
X_train, X_test, y_train, y_test = train_test_split(iris[['PetalLengthCm', 'PetalWidthCm']],
iris['Species'],
test_size=0.2,
stratify=iris['Species'])
print('----------Creamos la meshgrid con los valores mínimo y máximo de x y y ----------------------')
X=iris[['PetalLengthCm', 'PetalWidthCm']].to_numpy()
# Creamos la meshgrid con los valores mínimo y máximo de 'x' i 'y'.
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
print('----------Pivoteamos ----------------------')
clf = KNeighborsClassifier()
param_grid = {"n_neighbors": range(1, 11), "weights": ["uniform", "distance"]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=4)
grid_search.fit(X_train, y_train)
means = grid_search.cv_results_["mean_test_score"]
stds = grid_search.cv_results_["std_test_score"]
params = grid_search.cv_results_['params']
for mean, std, pms in zip(means, stds, params):
print("Precisión media: {:.2f} +/- {:.2f} con parametros {}".format(mean*100, std*100, pms))
param1 = [x['n_neighbors'] for x in params]
param2 = [x['weights'] for x in params]
precisions = pd.DataFrame(zip(param1, param2, means), columns=['n_neighbors', 'weights', 'means'])
precisions = precisions.pivot('n_neighbors', 'weights', 'means')
sns.heatmap(precisions)
clf = KNeighborsClassifier(n_neighbors=3, weights='uniform')
clf.fit(X_train, y_train)
plot_decision_boundaries(X=X_test[['PetalLengthCm', 'PetalWidthCm']].to_numpy(),x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, y=y_test, model=clf)
plot_decision_boundaries_bonus(x=X_test['PetalLengthCm'], y=X_test['PetalWidthCm'],x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, labels=y_test, model=clf)
preds = clf.predict(X_test)
accuracy = np.true_divide(np.sum(preds == y_test), preds.shape[0])*100
cnf_matrix = confusion_matrix(y_test, preds)
print(accuracy)
print(cnf_matrix)
La frontera de decisión resultante cuando hemos utilizando la información basada en los petalos parece más acurada y exacta que la información proporcionada con sépal. Cuando hemos utilizado sépal aparecen "islas" y no son claras las fronteras entre clases.
Las ventajas que tiene este algoritmo son las siguientes:
No paramétrico. No hace suposiciones explícitas sobre la forma funcional de los datos, evitando los peligros de la distribución subyacente de los datos.
Algoritmo simple. Para explicar, comprender e interpretar.
Alta precisión (relativa). Es bastante alta pero no competitiva en comparación con modelos de aprendizaje mejor supervisados.
Insensible a los valores atípicos. La precisión puede verse afectada por el ruido o las características irrelevantes.
Las desventajas de este algoritmo son:
Basado en instancia. El algoritmo no aprende explícitamente un modelo, en su lugar, elige memorizar las instancias de capacitación que se utilizan posteriormente como conocimiento para la fase de predicción. Concretamente, esto significa que solo cuando se realiza una consulta a nuestra base de datos, es decir cuando le pedimos que prediga una etiqueta dada una entrada, el algoritmo usará las instancias de entrenamiento para escupir una respuesta.
Computacionalmente costoso. Porque el algoritmo almacena todos los datos de entrenamiento.
Requisito de memoria alta. Almacena todos (o casi todos) los datos de entrenamiento.
En este segundo ejercicio clasificaremos los puntos usando el algoritmo SVM con diferentes tipos de kernel. En este caso utilizaremos un kernel radial, un kernel lineal y un kernel polinomial de grado 3. Volveremos a usar una búsqueda en grid (grid search) para la optimización de los hiperparámetros.
En este caso los hiperparámetros a optimitzar son:
Como en el caso anterior, para validar el rendimiento del algoritmo usaremos la validación cruzada (cross-validation) con 4 particiones estratificadas. En este caso solo lo haremos para las características altura-anchura del pétalo.
Material adicional que os puede servir de ayuda:
Introduction to Statistical Learning. Gareth James, Daniela Witten, Trevor Hastie and Robert Tibshirani
Support Vector Machines Succinctly. Alexandre Kowalczyk
A Practical Guide to Support Vector Classification. Chih-Wei Hsu, Chih-Chung Chang, and Chih-Jen Lin
Tutorial sobre Máquinas de Vector Soporte (SVM). Enrique J. Carmona Suárez
A Gentle Introduction to Support Vector Machines in Biomedicine. Alexander Statnikov, Douglas Hardin, Isabelle Guyon, Constantin F. Aliferis
Podéis usar los módulos GridSearchCV
y svm
de sklearn
. Analizar que influencia tienen los hiperparámetros C y gamma una vez calculados los mejores hiperparámetros. Para cada tipo de kernel, hacer predicciones para cada uno de ellos, calcular su matriz de confusión y finalmente dibujar sus fronteras de decisión.
from sklearn import svm
clf = svm.SVC()
param_grid = {"C": [0.01, 0.1, 1, 10, 50, 100, 200], "gamma": [0.001, 0.01, 0.1, 1, 10]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=4)
grid_search.fit(X_train, y_train)
means = grid_search.cv_results_["mean_test_score"]
stds = grid_search.cv_results_["std_test_score"]
params = grid_search.cv_results_['params']
for mean, std, pms in zip(means, stds, params):
print("Precisión media: {:.2f} +/- {:.2f} con parámetros {}".format(mean*100, std*100, pms))
param1 = [x['C'] for x in params]
param2 = [x['gamma'] for x in params]
precisions = pd.DataFrame(zip(param1, param2, means), columns=['C', 'gamma', 'means'])
precisions = precisions.pivot('C', 'gamma', 'means')
sns.heatmap(precisions)
# Entrenem el classificador amb els paràmetres amb els que hem obtingut major precisió.
clf = svm.SVC(C=100, gamma=0.01, probability=True)
clf.fit(X_train, y_train)
plot_decision_boundaries(X=X_test[['PetalLengthCm', 'PetalWidthCm']].to_numpy(),x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, y=y_test, model=clf)
plot_decision_boundaries_bonus(x=X_test['PetalLengthCm'], y=X_test['PetalWidthCm'],x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, labels=y_test, model=clf)
preds = clf.predict(X_test)
accuracy = np.true_divide(np.sum(preds == y_test), preds.shape[0])*100
cnf_matrix = confusion_matrix(y_test, preds)
print(accuracy)
print(cnf_matrix)
Las fronteras de decisión son muy fluidas y definidas. Se observan las tres clases bien diferenciadas con dos únicos errores.
En este tercer ejercicio trazaremos las fronteras de decisión de los dos tipos de atributos (sépalos y pétalos). Veremos que precisión obtenemos con los árboles de decisión. Mapearemos el árbol y lo analizaremos.
Para dibujar el árbol necesitaremos instalar la librería graphviz
. Para ello desde terminal escribiremos el siguiente comando:
sudo apt-get install graphviz
Si alguno utiliza el entorno Conda también puede instalarse desde este entorno.
Los árboles de decisión son un método usado en distintas disciplinas como modelo de predicción. Estos son similares a diagramas de flujo, en los que llegamos a puntos en los que se toman decisiones de acuerdo a una regla.
En el campo del aprendizaje automático hay distintas maneras de obtener árboles de decisión, la que usaremos en esta ocasión es conocida como CART: Classification And Regression Trees. Esta es una técnica de aprendizaje supervisado. Tenemos una variable objetivo (dependiente) y nuestra meta es obtener una función que nos permita predecir, a partir de variables predictoras (independientes), el valor de la variable objetivo para casos desconocidos.
Como el nombre indica, CART es una técnica con la que se pueden obtener árboles de clasificación y de regresión. Usamos clasificación cuando nuestra variable objetivo es discreta, mientras que usamos regresión cuando es continua. Nosotros tendremos una variable discreta, así que haremos clasificación.
De manera general, lo que hace este algoritmo es encontrar la variable independiente que mejor separa nuestros datos en grupos, las cuales corresponden con las categorías de la variable objetivo. Esta mejor separación es expresada con una regla. A cada regla le corresponde un nodo.
Para ello debemos asegurarnos que tenemos instalada en nuestro entorno la librería graphviz.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier()
param_grid = {"max_depth": range(4, 10), "min_samples_split": [2, 10, 20, 50, 100]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=4)
grid_search.fit(X_train, y_train)
means = grid_search.cv_results_["mean_test_score"]
stds = grid_search.cv_results_["std_test_score"]
params = grid_search.cv_results_['params']
for mean, std, pms in zip(means, stds, params):
print("Precisión media {:.2f} +/- {:.2f} con parametros {}".format(mean*100, std*100, pms))
clf = DecisionTreeClassifier(max_depth = 4, min_samples_split = 10)
clf.fit(X_train, y_train)
from sklearn.tree import export_graphviz
from pydotplus import graph_from_dot_data
dot_data = export_graphviz(clf)
from IPython.display import Image as PImage
graph = graph_from_dot_data(dot_data)
graph.write_png('tree.png')
PImage("tree.png")
La interpretación del árbol de este árbol de decisión sería: si la anchura del pétalo es menos de 0.8 centímetros, entonces la flor iris pertenece a la variedad iris-setosa. Si por el contrario, la longitud del pétalo es mayor que 0.8 centímetros y mayor a 1.75 pertenece a Iris.virginica . Si fuera mayor que 0.8 centímetros y menor a 1.75 miraremos la longitud del pétalo. Si es mayor la longitud a 5.45 directamente es Iris.virginica. Si la longitud es menor de 5.45 cm y la anchura es menor de 1.65 entonces es Iris-versicolor y si fuera mayor de 1.65 cm Iris.virginica
Entre otros métodos de minería de datos, los árboles de decisión tienen varias ventajas:
Desventajas
preds = clf.predict(X_test)
accuracy = np.true_divide(np.sum(preds == y_test), preds.shape[0])*100
cnf_matrix = confusion_matrix(y_test, preds)
print(accuracy)
print(cnf_matrix)
plot_decision_boundaries(X=X_test[['PetalLengthCm', 'PetalWidthCm']].to_numpy(),x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, y=y_test, model=clf)
plot_decision_boundaries_bonus(x=X_test['PetalLengthCm'], y=X_test['PetalWidthCm'],x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, labels=y_test, model=clf)
Las fronteras de decisión son fluidas y definidas. Se observan las tres clases bien diferenciadas con dos únicos errores.
En este cuarto apartado clasificaremos los puntos usando un Random forest. Utilizaremos, igual que en los casos anteriores, una búsqueda en grid (grid search) parar ajustar los hiperparámetros.
En este caso, los hiperparámetros que debemos ajustar son:
Igual que en el caso anterior, usaremos validación cruzada (cross-validation) con 4 particiones estratificadas para validar el rendimento del algoritmo con cada combinación de hiperparámetros.
Podéis usar los módulos GridSearchCV
y RandomForestClassifier
de sklearn
.
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier()
param_grid = {"max_depth": range(6, 13), "n_estimators": [10, 50, 100, 200]}
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=4)
grid_search.fit(X_train, y_train)
means = grid_search.cv_results_["mean_test_score"]
stds = grid_search.cv_results_["std_test_score"]
params = grid_search.cv_results_['params']
for mean, std, pms in zip(means, stds, params):
print("Precisión Media {:.2f} +/- {:.2f} con parametros {}".format(mean*100, std*100, pms))
param1 = [x['max_depth'] for x in params]
param2 = [x['n_estimators'] for x in params]
precisions = pd.DataFrame(zip(param1, param2, means), columns=['max_depth', 'n_estimators', 'means'])
precisions = precisions.pivot('max_depth', 'n_estimators', 'means')
sns.heatmap(precisions)
En la práctica anterior estuvimos estudiando la influencia de algunos de los parámetros del Random forest, entre ellos el parámetro max_depth
y cómo una profundidad del árbol demasiado grande podía provocar lo que conocemos como sobreentrenamiento (overfitting).
En este apartado vamos a usar las capacidades interactivas que nos ofrece la librería plotly
para visualizar efectos del overfitting y como cambia la frontera de decisión debido a ello. Para ello, crearemos gráficos de dos clasificadores Random Forest, el primero con una profundidad de árbol razonable (max_depth=4) y el segundo presentando un claro overfitting (por ejemplo, max_depth=300).
Invocar el código de Plotly
es muy similar al de Matplotlib
para generar la frontera de decisión. Necesitaremos una malla de Numpy
para formar la base de nuestras gráficas de superficie, así como el método predict
del modelo de aprendizaje para poblar nuestra frontera con datos.
Recordar que tendréis que instalaros la libería Plotly
. Esto se puede hacer mediante:
pip install plotly
Nota: No hace falta que lo hagáis para las cuatro características (altura-anchura del pétalo y altura-anchura del sépalo), con hacerlo para dos sería suficiente.
clf = RandomForestClassifier(n_estimators = 10, max_depth = 4)
clf.fit(X_train, y_train)
plot_decision_boundaries(X=X_test[['PetalLengthCm', 'PetalWidthCm']].to_numpy(),x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, y=y_test, model=clf)
clf = RandomForestClassifier(n_estimators = 10, max_depth = 300)
clf.fit(X_train, y_train)
plot_decision_boundaries(X=X_test[['PetalLengthCm', 'PetalWidthCm']].to_numpy(),x_min=x_min, x_max=x_max ,y_min=y_min, y_max=y_max, y=y_test, model=clf)
Ventajas de Random Forest
Desventajas de Random Forest
En esta última parte de la PEC vamos a usar la librería Keras
. Para ello compararemos las redes con la capa densa regular (regular Dense Layer) con un número diferente de nodos, empleando como función de activación Softmax y como optimizador Adam.
Para ello tendremos que asegurarnos de tener las librerias Tensorflow
y Keras
instaladas.
Para ello desde terminal escribiremos el siguiente comando:
pip install tensorflow
pip install keras
Si alguno utiliza el entorno Conda también puede instalarse desde este entorno.
Por otro lado, este es el apartado más complicado de toda la práctica y con el que menos estáis familiarizados. Por ello a lo largo del apartado os iremos dando una sería de enlaces a conceptos y ejemplos que os ayudarán a entender mejor lo que estamos haciendo. Es altamente recomendable leer con detenimiento los links (marcados en azul) y referencias indicadas y entender las explicaciones teóricas y los ejemplos de código proporcionados.
# Importamos la librerías necesarias
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Dense
from tensorflow.python.keras.callbacks import TensorBoard
from tensorflow.python.keras.wrappers.scikit_learn import KerasClassifier
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import cross_val_score
# Para ignorar Warnings futuros
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
plt.style.use('ggplot')
%matplotlib inline
Para la preparación de los datos, simplemente usaremos el OneHotEncoder para codificar las características enteras en un vector One-hot y utilizaremos un StandardScaler para eliminar la media y escalar las características a la varianza unitaria. Finalmente, usaremos train_test_split
para comparar nuestros resultados más adelante.
iris = load_iris()
X = iris['data'][:,[2,3]]
y = iris['target']
names = iris['target_names']
feature_names = iris['feature_names']
# One hot encoding
enc = OneHotEncoder()
Y = enc.fit_transform(y[:, np.newaxis]).toarray()
# Scale data to have mean 0 and variance 1
# which is importance for convergence of the neural network
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Split the data set into training and testing
X_train, X_test, Y_train, Y_test = train_test_split(
X_scaled, Y, test_size=0.3, random_state=2)
n_features = X.shape[1]
n_classes = Y.shape[1]
Para ello nos definimos una función que será la encargada de realizar nuestros modelos (en este caso concreto vamos a crear tres modelos que llamaremos Model1, Model2 y Model3). Utilizaremos como función de activación la función ReLu y como función de pérdidas la función categorical_crossentropy
Para mayor profundidad sobre el estudio de las funciones de activación:
Para mayor profundidad en el estudio de las funciones de pérdidas:
def create_custom_model(input_dim, output_dim, nodes, n=1, name='model'):
def create_model():
# Creamos el modelo
model = Sequential(name=name)
for i in range(n):
model.add(Dense(nodes, input_dim=input_dim, activation='relu'))
model.add(Dense(output_dim, activation='softmax'))
# Compilamos el modelo
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
return create_model
models = [create_custom_model(n_features, n_classes, 8, i, 'model_{}'.format(i))
for i in range(1, 4)]
for create_model in models:
create_model().summary()
from keras.callbacks import TensorBoard
history_dict = {}
# TensorBoard Callback
cb = TensorBoard()
for create_model in models:
model = create_model()
print('Model name:', model.name)
history_callback = model.fit(X_train, Y_train,
batch_size=5,
epochs=50,
verbose=0,
validation_data=(X_test, Y_test),
callbacks=[cb])
score = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
history_dict[model.name] = [history_callback, model]
fig, (ax1, ax2) = plt.subplots(2, figsize=(8, 6))
for model_name in history_dict:
val_acc = history_dict[model_name][0].history['val_accuracy']
val_loss = history_dict[model_name][0].history['val_loss']
ax1.plot(val_acc, label=model_name)
ax2.plot(val_loss, label=model_name)
ax1.set_ylabel('validation accuracy')
ax2.set_ylabel('validation loss')
ax2.set_xlabel('epochs')
ax1.legend()
ax2.legend()
plt.show()
from sklearn.metrics import roc_curve, auc
plt.figure(figsize=(10, 10))
plt.plot([0, 1], [0, 1], 'k--')
for model_name in history_dict:
model = history_dict[model_name][1]
Y_pred = model.predict(X_test)
fpr, tpr, threshold = roc_curve(Y_test.ravel(), Y_pred.ravel())
plt.plot(fpr, tpr, label='{}, AUC = {:.3f}'.format(model_name, auc(fpr, tpr)))
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.title('ROC curve')
plt.legend();
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import cross_val_score
create_model = create_custom_model(n_features, n_classes, 8, 3)
estimator = KerasClassifier(build_fn=create_model, epochs=50, batch_size=5, verbose=0)
scores = cross_val_score(estimator, X_scaled, Y, cv=10)
print("Accuracy : {:0.2f} (+/- {:0.2f})".format(scores.mean(), scores.std()))
Sabiendo que la gráfica ROC compara la tasa de falsos positivos con la tasa de verdaderos positimos, he decidido utilizar este valor para ver que módelo ha obtenido mejores resultados. Los resultados obtenidos han sido muy buenos, en todos los modelos hemos obtenidos valores cercanos a 1. Creo que el modelo 3 es el mejor de todos.
Además, calculamos para cada modelo el Área bajo la curva (AUC), donde auc = 1 es una clasificación perfecta y auc = 0.5 es una suposición aleatoria y, en este caso, obtenemos resultados muy cercanos a 1.
model.fit(X_train, Y_train,batch_size=5,
epochs=50,
verbose=0,
validation_data=(X_test, Y_test),
callbacks=[cb])
plot_decision_boundaries_bonus(X_test[:,[0]],X_test[:,[1]], Y_test, model)