Saltar al contenido

Archivos de categoría Clasificación

Evaluación del modelo de clasificación

Evaluación del modelo de clasificación

Las métricas de evaluación del modelo de clasificación explican el rendimiento de un modelo. Para mostrar algunos modelos de evaluación para la clasificación, vamos a utilizar el supuesto de un conjunto de datos que muestra el ratio de abandono de clientes de una Empresa. Hemos entrenado al modelo,y ahora queremos calcular su precisión utilizando el set de pruebas. Pasamos el set de pruebas a nuestro modelo,y encontramos las etiquetas predichas. ¿Cómo de preciso es este modelo?

Básicamente, se comparan los valores reales del conjunto de pruebas con los valores pronosticados por el modelo, para calcular su precisión. Las métricas de evaluación del modelo de clasificación proporcionan un papel clave en el desarrollo de un modelo, ya que proporcionan pistas de las áreas que pueden mejorarse. Hay diferentes métricas de evaluación de modelos, pero vamos a evaluar las más usadas: índice de Jaccard, F1-score y Log Loss.

Índice de Jaccard

Es una de las medidas de precisión más simples, y también es conocido como el coeficiente de similaridad Jaccard. Para el cálculo de este índice se utiliza la teoría de conjuntos y se puede definir como la intersección de los conjuntos de valores predichos y reales dividido por unión de los dos conjuntos de datos. Si el conjunto completo de etiquetas predichas para una muestra coincide estrictamente con el conjunto verdadero de etiquetas, entonces la precisión del es 1.0, en el extremo contrario, si no coincide ningún valor, el índice es 0.0.

Matríz de confusión (F1-score)

La matriz de confusión muestra las predicciones correctas y exhaustivas, en comparación con las etiquetas reales. Cada fila de la matriz de confusión muestra las etiquetas Reales/Verdaderas del conjunto de pruebas, y las columnas muestran las etiquetas predichas por el clasificador. La matriz de confusión muestra la habilidad del modelo para predecir correctamente. En el caso específico de un clasificador binario podemos interpretar estos números como el recuento de positivos verdaderos (aciertos), positivos falsos (errores), negativos verdaderos (errores), y negativos falsos (aciertos). Basándonos en el conteo de cada sección, podemos calcular la precisión y la exhaustividad de cada una de las etiquetas. La precisión es una medida de la exactitud, a condición de que una etiqueta de clase se haya predicho correctamente.

Se define mediante:
Precision = \frac{Positivo\ verdadero}{(Positivo\ verdadero + Positivo\ Falso)}
Exhaustividad = \frac{Positivo\ verdadero}{(Positivo\ verdadero + Negativo\ Falso)}

Por lo tanto, podemos calcular la precisión y la exhaustividad de cada clase y con ello el F1-scores para cada etiqueta: El F1-score es el promedio armónico de la precisión y la exhaustividad, donde el F1-score alcanza su mejor valor en 1 (que representa la precisión y la exhaustividad perfecta) y su peor valor en 0. Se define utilizando la ecuación F1-score: F1\-score = 2 \cdot \frac{(Precision \cdot Exhaustividad)}{(Precision + Exhaustividad)}
Supongamos el siguiente ejemplo:
F1-score
Para el valor churn=0, Precision = \frac{24}{(24 + 9)} = \frac{24}{33} = 0.727 y Exhaustividad = \frac{24}{(24 + 1)} = \frac{24}{25} = 0.960 => F1\^-score = 2 \cdot \frac{(0.727 \cdot 0.960)}{(0.727 + 0.960)} = 2 \cdot \frac{0.698}{1.687} = 0.827
Para el valor churn=1, Precision = \frac{6}{(6 + 1)} = \frac{6}{7} = 0.857 y Exhaustividad = \frac{6}{(6 + 9)} = \frac{6}{15} = 0.400 => F1\^-score = 2 \cdot \frac{(0.857 \cdot 0.400)}{(0.857 + 0.400)} = 2 \cdot \frac{0.343}{1.257} = 0.546
Y finalmente la media ponderada es \frac{(0.827 \cdot 25) + (0.546 \cdot 15)}{25 + 15} = \frac{28.865}{40} = 0.722

Tenga en cuenta que tanto Jaccard como F1-score se pueden utilizar también para clasificadores multi-clase.

Log Loss

A veces, el resultado de un clasificador es la probabilidad de una etiqueta de clase, en lugar de la etiqueta. Por ejemplo, el resultado puede ser la probabilidad de abandono del cliente, es decir, si el resultado es 1, entonces el cliente abandonaría. Esta probabilidad es un valor entre 0 y 1. Log loss mide el rendimiento de un clasificador donde el resultado pronosticado es un valor de probabilidad entre 0 y 1.
Se puede calcular el Log loss para cada fila utilizando la ecuación de Log loss, que mide como de lejos está cada predicción con respecto a la etiqueta real. Luego calculamos el Log loss promedio en todas las filas del conjunto de pruebas:
LogLoss = -\frac{1}{n} \cdot \sum_{}^{}{(y \cdot \log{(y') + (1 - y) \cdot \log{(1 - y')}})}
Es evidente que los clasificadores más idóneos tienen valores progresivamente más pequeños de Log loss. Por lo tanto, el clasificador con menor Log loss tiene una mejor precisión.

Ir al artículo anterior de la serie: K-vecinos más próximos

Ir al artículo siguiente de la serie: Introducción a los árboles de decisión

0 Seguir leyendo →

K-vecinos más próximos en Python

Importación de los paquetes básicos

import itertools
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter
import pandas as pd
import numpy as np
import matplotlib.ticker as ticker
from sklearn import preprocessing
%matplotlib inline

Importación de los datos

Imagina un proveedor de telecomunicaciones que ha segmentado la base de sus clientes por servicio, categorizando a los clientes en cuatro grupos. Si los datos demográficos se pueden usar para predecir la pertenencia de grupo del envío, la compañía podría personalizar las ofertas para los prospectos. Es un problema de clasificación. Este ejemplo hace foco en datos demográficos, sean region, edad, estado civil, para predecir patrones de uso. El campo objetivo (target), llamado custcat, tiene cuatro valores posibles que corresponden a los cuatro grupos de clientes: 1- Servicio Básico 2- E-Servicio 3- Servicio Plus 4- Servicio Total

Nuestro objetivo es construir un clasificador para predecir la clase de casos desconocidos. Utilizaremos un tipo específico de clasificación llamado K vecino más cercano.

!wget -O teleCust1000t.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/teleCust1000t.csv
df = pd.read_csv('teleCust1000t.csv')
df.head()
region tenure age marital address income ed employ retire gender reside custcat
0 2 13 44 1 9 64.0 4 5 0.0 0 2 1
1 3 11 33 1 7 136.0 5 5 0.0 0 6 4
2 3 68 52 1 24 116.0 1 29 0.0 1 2 3
3 2 33 33 0 12 33.0 2 0 0.0 1 1 1
4 2 23 30 1 9 30.0 1 2 0.0 0 4 3

Veamos cuántos de cada clase están en nuestro set de datos

df['custcat'].value_counts()
3    281
1    266
4    236
2    217
Name: custcat, dtype: int64

Puedes explorar fácilmente tus datos utilizando técnicas de visualización:

df.hist(column='income', bins=50)

Definamos feature sets, X:

df.columns
Index(['region', 'tenure', 'age', 'marital', 'address', 'income', 'ed',
       'employ', 'retire', 'gender', 'reside', 'custcat'],
      dtype='object')

Para utilizar la librería scikit-learn, tenemos que convertir el data frame de Panda en un Numpy array:

X = df[['region', 'tenure','age', 'marital', 'address', 'income', 'ed', 'employ','retire', 'gender', 'reside']] .values  #.astype(float)
X[0:5]
array([[  2.,  13.,  44.,   1.,   9.,  64.,   4.,   5.,   0.,   0.,   2.],
       [  3.,  11.,  33.,   1.,   7., 136.,   5.,   5.,   0.,   0.,   6.],
       [  3.,  68.,  52.,   1.,  24., 116.,   1.,  29.,   0.,   1.,   2.],
       [  2.,  33.,  33.,   0.,  12.,  33.,   2.,   0.,   0.,   1.,   1.],
       [  2.,  23.,  30.,   1.,   9.,  30.,   1.,   2.,   0.,   0.,   4.]])

¿Cuáles son nuestras etiquetas?

y = df['custcat'].values
y[0:5]
array([1, 4, 3, 1, 3])

Normalizar los Datos

La estandarización de datos haciendo que la media sea 0 y la varianza uno es buena práctica, especialmente para algoritmos tales como KNN el cual se basa en distancia de casos:

X = preprocessing.StandardScaler().fit(X).transform(X.astype(float))
X[0:5]
array([[-0.02696767, -1.055125  ,  0.18450456,  1.0100505 , -0.25303431,
        -0.12650641,  1.0877526 , -0.5941226 , -0.22207644, -1.03459817,
        -0.23065004],
       [ 1.19883553, -1.14880563, -0.69181243,  1.0100505 , -0.4514148 ,
         0.54644972,  1.9062271 , -0.5941226 , -0.22207644, -1.03459817,
         2.55666158],
       [ 1.19883553,  1.52109247,  0.82182601,  1.0100505 ,  1.23481934,
         0.35951747, -1.36767088,  1.78752803, -0.22207644,  0.96655883,
        -0.23065004],
       [-0.02696767, -0.11831864, -0.69181243, -0.9900495 ,  0.04453642,
        -0.41625141, -0.54919639, -1.09029981, -0.22207644,  0.96655883,
        -0.92747794],
       [-0.02696767, -0.58672182, -0.93080797,  1.0100505 , -0.25303431,
        -0.44429125, -1.36767088, -0.89182893, -0.22207644, -1.03459817,
         1.16300577]])

Dividimos la muestra en los conjuntos de datos para el entrenamiento y para la prueba de exactitud

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)
print ('Set de Entrenamiento:', X_train.shape,  y_train.shape)
print ('Set de Prueba:', X_test.shape,  y_test.shape)
Set de Entrenamiento: (800, 11) (800,)
Set de Prueba: (200, 11) (200,)

Clasificación

importar librería del Clasificador que implementa k-vecinos más cercanos.

from sklearn.neighbors import KNeighborsClassifier

Para el entrenamiento vamos a comenzar con el algoritmo con k=4 por ahora:

k = 4
#Entrenar el Modelo y Predecir  
neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)
neigh
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=None, n_neighbors=4, p=2,
           weights='uniform')

Usamos el modelo para predecir el set de prueba:

yhat = neigh.predict(X_test)
yhat[0:5]
array([1, 1, 3, 2, 4])

Para evaluar la certeza usamos la función classification accuracy score que computa la certeza del subconjunto. Esta función es igual a la función jaccard_similarity_score. Básicamente, calcula cómo se relacionan las etiquetas actuales con las etiquetas predichas dentro del set de pruebas.

from sklearn import metrics
print("Entrenar el set de Certeza: ", metrics.accuracy_score(y_train, neigh.predict(X_train)))
print("Probar el set de Certeza: ", metrics.accuracy_score(y_test, yhat))
Entrenar el set de Certeza:  0.5475
Probar el set de Certeza:  0.32

Para un K=6 tenemos los siguientes resultados

k = 6
neigh6 = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)
yhat6 = neigh6.predict(X_test)
print("Certeza del Set de Entrenamiento: ", metrics.accuracy_score(y_train, neigh6.predict(X_train)))
print("Certeza del Set de Prueba: ", metrics.accuracy_score(y_test, yhat6))
Certeza del Set de Entrenamiento:  0.51625
Certeza del Set de Prueba:  0.31

Cálculo del mejor k

Elegimos k =1, lo utilizamos como parte del entrenamiento para modelar, y calculamos la certeza de la predicción utilizando todas las muestras del set de pruebas. Repetir este proceso, aumentando el k, y viendo luego, cual es el mejor k para el modelo.

Ks = 10
mean_acc = np.zeros((Ks-1))
std_acc = np.zeros((Ks-1))
ConfustionMx = [];
for n in range(1,Ks):
    #Entrenar el Modelo y Predecir  
    neigh = KNeighborsClassifier(n_neighbors = n).fit(X_train,y_train)
    yhat=neigh.predict(X_test)
    mean_acc[n-1] = metrics.accuracy_score(y_test, yhat)
    std_acc[n-1]=np.std(yhat==y_test)/np.sqrt(yhat.shape[0])
mean_acc
array([0.3  , 0.29 , 0.315, 0.32 , 0.315, 0.31 , 0.335, 0.325, 0.34 ])

Dibujo de la certeza del modelo para diferentes números de vecinos

plt.plot(range(1,Ks),mean_acc,'g')
plt.fill_between(range(1,Ks),mean_acc - 1 * std_acc,mean_acc + 1 * std_acc, alpha=0.10)
plt.legend(('Certeza ', '+/- 3xstd'))
plt.ylabel('Certeza ')
plt.xlabel('Número de Vecinos (K)')
plt.tight_layout()
plt.show()

print( "La mejor aproximación de certeza fue con ", mean_acc.max(), "con k=", mean_acc.argmax()+1) 
La mejor aproximación de certeza fue con  0.34 con k= 9
0 Seguir leyendo →

K-vecinos más próximos

K-vecinos más próximos

Para comprender el algorítmo de clasificación K-vecinos más próximos, imagine que un proveedor de telecomunicaciones ha segmentado su base de clientes según el patrón de uso de servicios, categorizando a los clientes en cuatro grupos. Si los datos demográficos se pueden utilizar para predecir la pertenencia a un grupo, la empresa puede personalizar ofertas para clientes potenciales. Se trata de un problema de clasificación. Es decir, dado el conjunto de datos, con las etiquetas predefinidas, tenemos que construir un modelo que se utilizará para predecir la clase de un caso nuevo o desconocido. El ejemplo se centra en el uso de datos demográficos, como la región, la edad y el estado civil, para predecir patrones de uso. El campo objetivo, tiene cuatro valores posibles que corresponden a los cuatro grupos de clientes: Servicio básico, servicio electrónico, servicio adicional y servicio total. Nuestro objetivo es construir un clasificador usando datos de clientes conocidos para predecir el grupo de un nuevo cliente.

Vamos a utilizar el criterio de clasificación llamado «vecino más próximo». Para simplificar vamos a utilizar sólo dos campos como predictores, la Edad y el Salario, y luego pintar a los clientes en función de estos datos. Si ahora tenemos un nuevo cliente con una edad y salario conocido. ¿Cómo podemos encontrar la clase de este cliente? ¿Podemos encontrar uno de los casos más próximos y asignar la misma etiqueta de clase a nuestro nuevo cliente? ¿Podemos también decir que la clase de nuestro nuevo cliente es probablemente el mismo que el vecino más próximo? Sí, podemos. Pero ¿Hasta qué punto podemos confiar en nuestro juicio, que se basa en el el primer vecino más próximo? Podría ser un mal juicio, especialmente si el primer vecino más próximo es muy específico o un valor atípico, ¿correcto? Por esto, en lugar de elegir al primer vecino más próximo, ¿qué tal si elegimos a los cinco vecinos más próximos, y vemos que tipo es el más frecuente para definir la clase de nuestro nuevo cliente? ¿Esto no tiene más sentido? De hecho, sí.

Este ejemplo pone de relieve la intuición detrás del algoritmo del vecino más próximo.

Definición

El algoritmo del k-vecinos más próximos es un algoritmo de clasificación que toma un montón de puntos marcados y los utiliza para aprender a etiquetar otros puntos. Este algoritmo clasifica los casos basados en su similitud con otros casos. En los vecinos más próximos, los puntos de datos que están cerca entre sí se dicen que son «vecinos». El algoritmo se basa en este paradigma: Casos similares con las mismas etiquetas de clase están cerca el uno al otro.
Por lo tanto, la distancia entre dos casos es una medida de su disimilitud. Existen diferentes maneras de calcular la similitud, la distancia o la disimilitud de dos puntos de datos. El más común es la distancia de Euclidia.

Funcionamiento (VER EJEMPLO EN PYTHON)

En un problema de clasificación, el algoritmo del vecino más próximo funciona de la siguiente forma:

  • Elegir un valor para K.
  • Calcular la distancia desde el nuevo caso (exclusión de cada uno de los casos del conjunto de datos).
  • Buscar las «k» observaciones en los datos de entrenamiento que son «más próximos» al punto de datos desconocido.
  • Predecir la respuesta del punto de datos desconocido utilizando el valor de respuesta más popular de los vecinos más próximos.

Hay dos partes en este algoritmo que pueden ser un poco confusas: Cómo seleccionar la K correcta y cómo calcular la similaridad entre los casos.

Calculo de similitud

Se puede utilizar la distancia Minkowski para calcular la distancia entre datos, que es en efecto, la distancia Euclidia: Dis(x_1, x_2) = \sqrt{\sum_{i=0}^{n}{(x_{1i} - x_{2i})^2}} Si tenemos más de una característica podemos seguir utilizando la misma fórmula, pero ahora lo usamos en un espacio bidimensional. También podemos usar la misma matriz de distancia para los vectores multidimensionales. Por supuesto, tenemos que normalizar nuestro conjunto de características para obtener la medida de disimilitud precisa. También hay otras medidas de disimilitud que pueden ser utilizadas para este propósito, pero, tal como se menciona, es altamente dependiente del tipo de datos y también el dominio que la clasificación está hecho por él.

Cálculo de K en el k-vecinos más próximos

En el algoritmo de K-vecinos más próximos, K es el número de vecinos más próximos a examinar. Se supone que debe ser especificado por el usuario.
¿Qué ocurre si elegimos un valor muy bajo de K, digamos, k= 1? Esto sería una mala predicción, ya que un caso específico puede hacer que el modelo falle. Podemos decir que hemos capturado el ruido en los datos, o elegimos uno de los puntos que era una anomalía en los datos. Un valor bajo de K causa también un modelo muy complejo, lo que podría resultar en un exceso de ajuste del modelo. Esto significa que el proceso de predicción no se generaliza lo suficiente como para ser utilizado para casos fuera de la muestra. Los datos de fuera de la muestra son datos que están fuera del conjunto de datos utilizado para entrenar el modelo. En otras palabras, no se puede confiar en que sea utilizado para la predicción de muestras desconocidas. Es importante recordar que el exceso de ajuste es malo, ya que queremos un modelo general que funcione para cualquier dato, no sólo los datos utilizados para el entrenamiento.
Ahora, en el lado opuesto del espectro, si elegimos un valor muy alto de K, tal como K=20, entonces el modelo se vuelve demasiado generalizado. Así que, ¿cómo podemos encontrar el mejor valor para K? La solución general es reservar una parte de los datos para probar la precisión del modelo. Una vez que se ha hecho, se elige k =1, y luego se usa la parte de entrenamiento para modelaje, y calcula la precisión de la predicción utilizando todos los ejemplos en el conjunto de pruebas. Se repite este proceso, incrementando el k, y se ve cuál de los k es el mejor para su modelo.

El análisis del vecinos más próximo también se puede utilizar para calcular valores para un objetivo continuo. En esta situación, se utiliza el valor de objetivo promedio o promedio de los vecinos más próximos para obtener el valor predicho para el nuevo caso. Por ejemplo, suponga que está prediciendo el precio de un inicio basado en su conjunto de características, tales como el número de habitaciones, las imágenes cuadradas, el año en que fue construido, etc. Puede encontrar fácilmente las tres casas vecinas más cercanas, por supuesto, no sólo en base a la distancia, si no también basado en todos los atributos, y luego predice el precio de la casa, como el promedio de los vecinos.

Ir al artículo anterior de la serie: Introducción a la clasificación

Ir al artículo siguiente de la serie: Evaluación del modelo de clasificación

0 Seguir leyendo →

Introducción a la clasificación

Introducción a la clasificación

Para realizar esta introducción a la clasificación tenemos que conocer que en Machine Learning, la clasificación es un enfoque de aprendizaje supervisado, que puede ser pensado como un medio de categorización o «clasificación» de algunos elementos desconocidos en un conjunto discreto de «clases».
La clasificación intenta aprender la relación entre un conjunto de variables características y una variable objetivo. El atributo objetivo en clasificación es una variable categórica con valores discretos.

¿Cómo funcionan las clasificaciones y los clasificadores?

Dado un conjunto de datos de entrenamiento, junto con las etiquetas objetivo, la clasificación determina la etiqueta de clase para un caso de prueba no etiquetado. Veamos un ejemplo: Veamos como clasificar la predicción de incumplimiento de pago de un préstamo. Supongamos que un banco está preocupado por el incumplimiento de pago de sus préstamos. Si se puede usar datos previos de préstamos no pagados para predecir qué clientes podrían tener problemas pagando sus préstamos, estos clientes de «riesgo» pueden no obtener un prestamos o se les puede ofrecer productos alternativos. El objetivo es utilizar los datos de incumplimiento de préstamo existentes de los clientes (edad, ingresos, educación, etc.) para construir un clasificador, pasar a un nuevo cliente por el modelo y luego etiquetarlo como «no pagador» o «pagador».

Así es como un clasificador predice un caso de prueba sin etiquetas. Hay que tener en cuenta que en este ejemplo específico era de un clasificador binario con dos valores. También podemos crear modelos de clasificadores multi-clases. Por ejemplo, si hemos recopilado datos acerca de un conjunto de pacientes, los cuales sufrieron todos de la misma enfermedad. Durante su tratamiento, cada paciente respondió a uno de tres medicamentos. Puede utilizar este conjuunto de datos etiquetado, con un algoritmo de clasificación, para contruir un modelo de clasificación. De esta manera puedes usarlo para averiguar qué medicamento podría ser apropiado para un futuro paciente con la misma enfermedad. Como puede ver, se trata de una muestra de clasificación multi-clases.

La clasificación tiene también diferentes casos de uso empresarial, por ejemplo:

  • Para predecir la categoría a la que pertenece un cliente
  • Para la detección del ratio de abandono,donde predecimos si un cliente cambia a otro proveedor o marca; o para predecir si un cliente responde o no a una campaña publicitaria en particular.
  • Para el filtrado de correos electrónico, reconocimiento de voz, reconocimiento de escritura a mano, identificación bio-métrica, clasificación de documentos, y mucho más.

Aquí tenemos algunos tipos de algoritmos de clasificación en machine learning.

  • Árboles de decisión
  • Naïve Bayes
  • Análisis Linear Discriminante
  • K-nearest neighbor
  • Regresión logística
  • Neural Networks
  • Support Vector Machines.

Ir al artículo anterior de la serie: Regresión no lineal

Ir al artículo siguiente de la serie: K-vecinos más próximos

0 Seguir leyendo →