S26L04 – Matriz de Confusión 3D

html
Dominando las Matrices de Confusión: Una Guía Integral para Profesionales de Machine Learning

Tabla de Contenidos

    ¿Qué es una Matriz de Confusión?
    Componentes de una Matriz de Confusión
        
            Verdadero Positivo (TP)
            Verdadero Negativo (TN)
            Falso Positivo (FP)
            Falso Negativo (FN)
        
    
    Entendiendo la Matriz de Confusión con Múltiples Clases
    Construyendo una Matriz de Confusión Usando Scikit-Learn
    Visualizando la Matriz de Confusión
    Interpretando las Métricas de Rendimiento del Modelo
        
            Precisión
            Exactitud
            Recall
            Puntaje F1
            Especificidad
        
    
    Avanzado: Manejo de Matrices de Confusión Multiclase
    Implementación Práctica con el Conjunto de Datos de Predicción del Clima
    Conclusión


¿Qué es una Matriz de Confusión?
Una matriz de confusión es una representación tabular del rendimiento de un modelo de clasificación. Permite visualizar qué tan bien está funcionando tu modelo al comparar los valores reales de los objetivos con los que predice el modelo. Cada fila de la matriz representa las instancias en una clase real, mientras que cada columna representa las instancias en una clase predicha, o viceversa. Esta estructura facilita la identificación no solo de los tipos de errores que comete tu modelo, sino también de su frecuencia.



Figura 1: Estructura básica de una matriz de confusión.

Componentes de una Matriz de Confusión
Entender los componentes individuales de una matriz de confusión es crucial para interpretar los resultados de manera efectiva. La matriz consta de cuatro métricas clave:

Verdadero Positivo (TP)

    Definición: El número de instancias clasificadas correctamente como positivas.
    Ejemplo: Si el modelo predice que lloverá mañana y realmente llueve, es un Verdadero Positivo.


Verdadero Negativo (TN)

    Definición: El número de instancias clasificadas correctamente como negativas.
    Ejemplo: Si el modelo predice que no lloverá mañana y efectivamente no llueve, es un Verdadero Negativo.


Falso Positivo (FP)

    Definición: El número de instancias clasificadas incorrectamente como positivas.
    Ejemplo: Si el modelo predice que lloverá mañana pero no llueve, es un Falso Positivo. Esto también se conoce como un error de Tipo I.


Falso Negativo (FN)

    Definición: El número de instancias clasificadas incorrectamente como negativas.
    Ejemplo: Si el modelo predice que no lloverá mañana pero realmente llueve, es un Falso Negativo. Esto también se conoce como un error de Tipo II.




Figura 2: Desglose de TP, TN, FP y FN dentro de una matriz de confusión.

Entendiendo la Matriz de Confusión con Múltiples Clases
Mientras que la clasificación binaria implica dos clases (positiva y negativa), la clasificación multiclase extiende la matriz de confusión para acomodar más clases. Por ejemplo, en un conjunto de datos con tres clases—setosa, versicolor y virginica—la matriz de confusión se convierte en una cuadrícula de 3x3. Cada fila representa la clase real, y cada columna representa la clase predicha. Los elementos de la diagonal todavía representan predicciones correctas, mientras que los elementos fuera de la diagonal indican varios tipos de clasificaciones erróneas.



Figura 3: Ejemplo de una matriz de confusión multiclase.

Construyendo una Matriz de Confusión Usando Scikit-Learn
La biblioteca scikit-learn de Python ofrece herramientas robustas para generar y analizar matrices de confusión. A continuación, se presenta una guía paso a paso para construir una matriz de confusión usando scikit-learn, complementada con un ejemplo práctico.

Paso 1: Importar las Bibliotecas Necesarias




		
		
			
			
Java
			
			import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
					
				
			
		



Paso 2: Cargar y Preparar el Conjunto de Datos
Para la demostración, usaremos el conjunto de datos Weather Australia.





		
		
			
			
Java
			
			# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS.csv')

# Definir características y variable objetivo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Manejar datos faltantes
from sklearn.impute import SimpleImputer
import numpy as np

# Características numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

# Características categóricas
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])

# Codificación de variables categóricas
X = pd.get_dummies(X, drop_first=True)

# Codificar la variable objetivo
le = LabelEncoder()
y = le.fit_transform(y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS.csv')
 
# Definir características y variable objetivo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Manejar datos faltantes
from sklearn.impute import SimpleImputer
import numpy as np
 
# Características numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
 
# Características categóricas
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])
 
# Codificación de variables categóricas
X = pd.get_dummies(X, drop_first=True)
 
# Codificar la variable objetivo
le = LabelEncoder()
y = le.fit_transform(y)
					
				
			
		



Paso 3: Dividir el Conjunto de Datos




		
		
			
			
Java
			
			# Dividir en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
4
				
						# Dividir en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
					
				
			
		



Paso 4: Escalado de Características




		
		
			
			
Java
			
			# Estandarizar las características
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
				
						# Estandarizar las características
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



Paso 5: Entrenar un Modelo de Clasificación
Usaremos Regresión Logística para este ejemplo.





		
		
			
			
Java
			
			# Inicializar y entrenar el modelo
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)

# Hacer predicciones
y_pred = model.predict(X_test)
			
				
					
				
					1
2
3
4
5
6
				
						# Inicializar y entrenar el modelo
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)
 
# Hacer predicciones
y_pred = model.predict(X_test)
					
				
			
		



Paso 6: Generar la Matriz de Confusión




		
		
			
			
Java
			
			# Calcular la precisión
accuracy = accuracy_score(y_pred, y_test)
print(f'Accuracy: {accuracy:.4f}')

# Generar matriz de confusión
cm = confusion_matrix(y_test, y_pred)
print('Confusion Matrix:')
print(cm)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Calcular la precisión
accuracy = accuracy_score(y_pred, y_test)
print(f'Accuracy: {accuracy:.4f}')
 
# Generar matriz de confusión
cm = confusion_matrix(y_test, y_pred)
print('Confusion Matrix:')
print(cm)
					
				
			
		



Salida:




		
		
			
			
Java
			
			Accuracy: 0.8297
Confusion Matrix:
[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
3
4
				
						Accuracy: 0.8297
Confusion Matrix:
[[21087  1058]
 [ 3786  2508]]
					
				
			
		



Visualizando la Matriz de Confusión
La visualización ayuda a una comprensión intuitiva del rendimiento del modelo. Scikit-learn proporciona funciones integradas para trazar matrices de confusión sin esfuerzo.





		
		
			
			
Java
			
			# Trazar matriz de confusión
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusión')
plt.show()
			
				
					
				
					1
2
3
4
				
						# Trazar matriz de confusión
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusión')
plt.show()
					
				
			
		





Figura 4: Visualización de la matriz de confusión usando scikit-learn.

Interpretando las Métricas de Rendimiento del Modelo
Más allá de la precisión, la matriz de confusión permite el cálculo de varias otras métricas de rendimiento:

Precisión

    Definición: La proporción de instancias correctamente clasificadas sobre el total de instancias.
    Fórmula: 
      \[
      \text{Precisión} = \frac{TP + TN}{TP + TN + FP + FN}
      \]
    
    Interpretación: Aunque es útil, la precisión puede ser engañosa, especialmente en conjuntos de datos desequilibrados.


Exactitud

    Definición: La proporción de observaciones positivas predichas correctamente sobre el total de predicciones positivas.
    Fórmula: 
      \[
      \text{Exactitud} = \frac{TP}{TP + FP}
      \]
    
    Interpretación: Alta exactitud indica que un algoritmo devolvió sustancialmente más resultados relevantes que irrelevantes.


Recall (Sensibilidad)

    Definición: La proporción de observaciones positivas predichas correctamente sobre todas las observaciones en la clase real.
    Fórmula: 
      \[
      \text{Recall} = \frac{TP}{TP + FN}
      \]
    
    Interpretación: Un alto recall indica que un algoritmo devolvió la mayoría de los resultados relevantes.


Puntaje F1

    Definición: El promedio ponderado de Precisión y Recall.
    Fórmula: 
      \[
      F1 = 2 \times \frac{\text{Precisión} \times \text{Recall}}{\text{Precisión} + \text{Recall}}
      \]
    
    Interpretación: El puntaje F1 transmite el equilibrio entre Precisión y Recall.


Especificidad

    Definición: La proporción de observaciones negativas predichas correctamente sobre el total de negativas reales.
    Fórmula: 
      \[
      \text{Especificidad} = \frac{TN}{TN + FP}
      \]
    
    Interpretación: Alta especificidad indica que el modelo identifica efectivamente los casos negativos.


Avanzado: Manejo de Matrices de Confusión Multiclase
En escenarios con más de dos clases, la matriz de confusión se expande a una cuadrícula multidimensional. Cada elemento de la diagonal representa las instancias correctamente clasificadas para cada clase, mientras que los elementos fuera de la diagonal indican diversas clasificaciones erróneas.

Ejemplo:
Considera un problema de clasificación de tres clases con las clases A, B y C.





		
		
			
			
Java
			
			               Predicho
               A    B    C
Actual A      50     2     3
       B       5    45     5
       C       2     3    48
			
				
					
				
					1
2
3
4
5
				
						               Predicho
               A    B    C
Actual A      50     2     3
       B       5    45     5
       C       2     3    48
					
				
			
		




    Verdaderos Positivos para la Clase A: 50
    Falsos Positivos para la Clase A: 5 (de B) + 2 (de C) = 7
    Falsos Negativos para la Clase A: 2 (a B) + 3 (a C) = 5
    Verdaderos Negativos para la Clase A: Total - (TP + FP + FN) = 100 - (50 + 7 + 5) = 38


La función confusion_matrix de scikit-learn maneja sin problemas escenarios multiclase, proporcionando una matriz clara que facilita un análisis detallado del rendimiento.

Implementación Práctica con el Conjunto de Datos de Predicción del Clima
Para solidificar los conceptos, recorramos un ejemplo práctico utilizando el conjunto de datos Weather Australia. Este conjunto de datos implica predecir si lloverá al día siguiente basado en varios atributos del clima.

Implementación Paso a Paso

    Preprocesamiento de Datos:
        
            Manejar valores faltantes usando SimpleImputer.
            Codificar variables categóricas usando codificación one-hot.
            Codificar la variable objetivo usando LabelEncoder.
        
    
    Escalado de Características:
        
            Estandarizar las características para asegurar que cada una contribuya por igual al rendimiento del modelo.
        
    
    Entrenamiento del Modelo:
        
            Entrenar múltiples modelos de clasificación como K-Nearest Neighbors, Regresión Logística, Gaussian Naive Bayes, Support Vector Machines, Árboles de Decisión, Random Forests, AdaBoost y XGBoost.
        
    
    Evaluación:
        
            Calcular las puntuaciones de precisión para cada modelo.
            Generar y visualizar matrices de confusión para entender la distribución de las predicciones.
        
    


Fragmentos de Código de Muestra

Entrenamiento de un Modelo de Regresión Logística:




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Inicializar el modelo
LRM = LogisticRegression(random_state=0, max_iter=200)

# Entrenar el modelo
LRM.fit(X_train, y_train)

# Predecir en datos de prueba
y_pred = LRM.predict(X_test)

# Evaluar precisión
print(accuracy_score(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.linear_model import LogisticRegression
 
# Inicializar el modelo
LRM = LogisticRegression(random_state=0, max_iter=200)
 
# Entrenar el modelo
LRM.fit(X_train, y_train)
 
# Predecir en datos de prueba
y_pred = LRM.predict(X_test)
 
# Evaluar precisión
print(accuracy_score(y_pred, y_test))
					
				
			
		



Salida:




		
		
			
			
Java
			
			0.8296705228735187
			
				
					
				
					1
				
						0.8296705228735187
					
				
			
		



Generando la Matriz de Confusión:




		
		
			
			
Java
			
			from sklearn.metrics import confusion_matrix, plot_confusion_matrix

# Calcular matriz de confusión
cm = confusion_matrix(y_test, y_pred)
print(cm)

# Trazar matriz de confusión
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusión de Regresión Logística')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.metrics import confusion_matrix, plot_confusion_matrix
 
# Calcular matriz de confusión
cm = confusion_matrix(y_test, y_pred)
print(cm)
 
# Trazar matriz de confusión
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusión de Regresión Logística')
plt.show()
					
				
			
		



Salida:




		
		
			
			
Java
			
			[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
				
						[[21087  1058]
 [ 3786  2508]]
					
				
			
		





Figura 5: Matriz de confusión para el modelo de Regresión Logística.

Comparación de Precisión de Múltiples Modelos:




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# Inicializar modelos
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Regresión Logística': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Árbol de Decisión': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}

# Entrenar y evaluar modelos
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'{name} Accuracy: {accuracy:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb
 
# Inicializar modelos
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Regresión Logística': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Árbol de Decisión': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}
 
# Entrenar y evaluar modelos
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'{name} Accuracy: {accuracy:.4f}')
					
				
			
		



Salida de Ejemplo:




		
		
			
			
Java
			
			KNN Accuracy: 0.8003
Regresión Logística Accuracy: 0.8297
GaussianNB Accuracy: 0.7960
SVC Accuracy: 0.8282
Árbol de Decisión Accuracy: 0.8302
Random Forest Accuracy: 0.8302
AdaBoost Accuracy: 0.8299
XGBoost Accuracy: 0.8302
			
				
					
				
					1
2
3
4
5
6
7
8
				
						KNN Accuracy: 0.8003
Regresión Logística Accuracy: 0.8297
GaussianNB Accuracy: 0.7960
SVC Accuracy: 0.8282
Árbol de Decisión Accuracy: 0.8302
Random Forest Accuracy: 0.8302
AdaBoost Accuracy: 0.8299
XGBoost Accuracy: 0.8302
					
				
			
		



A partir de la salida, es evidente que los modelos de Árbol de Decisión, Random Forest y XGBoost exhiben la mayor precisión, seguidos de cerca por Regresión Logística y AdaBoost.

Conclusión
Las matrices de confusión son indispensables para evaluar el rendimiento de los modelos de clasificación. Proporcionan una vista granular de cómo los modelos funcionan a través de diferentes clases, destacando tanto las fortalezas como las áreas que necesitan mejora. Al dominar la construcción e interpretación de las matrices de confusión, junto con métricas complementarias como precisión, recall y puntaje F1, los profesionales de machine learning pueden desarrollar modelos más robustos y confiables. Aprovechar herramientas como scikit-learn simplifica este proceso, permitiendo una evaluación eficiente del modelo y una mejora iterativa. A medida que continúas explorando e implementando modelos de machine learning, integrar matrices de confusión en tu pipeline de evaluación sin duda mejorará tus capacidades analíticas y la eficacia de tus modelos.



Para ejemplos más detallados y técnicas avanzadas, consulta la documentación de scikit-learn sobre Matrices de Confusión.