Compartir en LinkedIn Compartir en Twitter Compartir en Facebook

Matriz de confusión en Python

Una matriz de confusión es una herramienta utilizada en el machine learning y la estadística para evaluar el rendimiento de un modelo de clasificación. En Python, podemos crear una matriz de confusión utilizando varias bibliotecas populares como scikit-learn y numpy .

• Es una tabla que se utiliza en problemas de clasificación para evaluar dónde se cometieron errores en el modelo.
• Las filas representan las clases reales que deberían haber sido los resultados. Mientras que las columnas representan las predicciones que hemos hecho. Usando esta tabla, es fácil ver qué predicciones están equivocadas.

Ejemplo de cómo crear una matriz de confusión utilizando scikit-learn

Aquí tienes un ejemplo:

    print(matriz_confusion)
  

Resultado :

    Matriz de Confusión:
[[3 2]
[3 2]]

En este ejemplo, hemos utilizado datos de ejemplo y_real y y_pred , que representan las etiquetas reales y las etiquetas predichas por un modelo de clasificación, respectivamente. Luego, utilizamos la función confusion_matrix() de scikit-learn para crear la matriz de confusión. La matriz de confusión resultante tiene la siguiente interpretación:

• Verdaderos positivos (TP): 3 (clase 1 correctamente clasificada como clase 1).
• Falsos positivos (FP): 2 (clase 0 incorrectamente clasificada como clase 1).
• Verdaderos negativos (TN): 2 (clase 0 correctamente clasificada como clase 0).
• Falsos negativos (FN): 3 (clase 1 incorrectamente clasificada como clase 0).

La matriz de confusión muestra la cantidad de muestras clasificadas correctamente e incorrectamente para cada clase. Es una herramienta útil para evaluar la precisión, la sensibilidad, la especificidad y otras métricas de rendimiento de un modelo de clasificación.

Crear una matriz de confusión paso a paso

Las matrices de confusión se pueden crear mediante predicciones hechas a partir de una regresión logística.

1. Por ahora, generaremos valores reales y predichos utilizando NumPy:

    import numpy
  

2. A continuación, necesitaremos generar los números para los valores "reales" y "predichos".

    import numpy

actual = numpy.random.binomial(1, 0.9, size = 1000)
predicted = numpy.random.binomial(1, 0.9, size = 1000)
print(predicted)
  

3. Para crear la matriz de confusión, necesitamos importar métricas del módulo sklearn.

    from sklearn import metrics
  

4. Una vez que se importan las métricas, podemos usar la función de matriz de confusión en nuestros valores reales y previstos.

    confusion_matrix = metrics.confusion_matrix(actual, predicted)
print(confusion_matrix)
  

5. Para crear una pantalla visual más interpretable, necesitamos convertir la tabla en una pantalla de matriz de confusión.

    confusion_matrix = metrics.confusion_matrix(actual, predicted)
print(confusion_matrix)
cm_display = metrics.ConfusionMatrixDi
cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])
print(cm_display)
  

6. Visualizar la pantalla requiere que importemos pyplot desde matplotlib.

    import matplotlib.pyplot as plt
  

7. Finalmente, para mostrar el diagrama, podemos usar las funciones plot() y show() de pyplot.

    cm_display.plot()
plt.show()
cm_display.plot()
plt.show()
  

A continuación el ejemplo completo en acción:

Ejemplo para generar una matriz de confusión y visualizarla con la función plot() de ConfusionMatrixDisplay.

El código que proporcionaste utiliza la biblioteca matplotlib, numpy y sklearn para generar una matriz de confusión y visualizarla con la función plot() de ConfusionMatrixDisplay .

Es importante destacar que en este ejemplo, tanto las etiquetas reales ( actual ) como las etiquetas predichas ( predicted ) están generadas aleatoriamente utilizando la función numpy.random.binomial() con una probabilidad de éxito del 0.9 (90% de probabilidad de ser 1).

    # Crear la matriz de confusión utilizando sklearn
confusion_matrix = metrics.confusion_matrix(actual, predicted)
# Crear la visualización de la matriz de confusión
cm_display # Crear la visualización de la matriz de confusión
cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])
# Graficar la matriz de confusión
cm_display.plot()
plt.show()
# Graficar la matriz de confusión
cm_display.plot()
plt.show()
plt.show()
  

El resultado es un gráfico que muestra la matriz de confusión, con las etiquetas "False" (0) y "True" (1) en los ejes x e y, respectivamente. El contenido de la matriz variará en cada ejecución del código debido a que las etiquetas se generan aleatoriamente.

Recuerda que en un caso real, las etiquetas reales ( actual ) y las etiquetas predichas ( predicted ) se obtendrían de los resultados de un modelo de clasificación aplicado a un conjunto de datos real. La matriz de confusión y su visualización proporcionan información valiosa para evaluar el rendimiento del modelo de clasificación y la precisión de sus predicciones.

Resultado :

Resultado Explicado

La Matriz de Confusión creada tiene cuatro cuadrantes diferentes:

• Negativo verdadero (cuadrante superior izquierdo)
• Falso positivo (cuadrante superior derecho)
• Falso negativo (cuadrante inferior izquierdo)
• Verdadero positivo (cuadrante inferior derecho)
• Verdadero significa que los valores se predijeron con precisión, Falso significa que hubo un error o una predicción incorrecta.

Ahora que hemos creado una matriz de confusión, podemos calcular diferentes medidas para cuantificar la calidad del modelo. Primero, echemos un vistazo a la precisión.

Métricas creadas para evaluar la matriz de confusión

La matriz nos proporciona muchas métricas útiles que nos ayudan a evaluar nuestro modelo de clasificación:

• Exactitud
• Precisión
• Sensibilidad
• Especificidad
• F-Score

Las diferentes medidas incluyen: Exactitud, Precisión, Sensibilidad (Recordatorio), Especificidad y la puntuación F, que se explican a continuación.

Exactitud

La precisión mide con qué frecuencia el modelo es correcto.

Como calcular la exactitud

(Verdadero positivo + Verdadero negativo) / Predicciones totales

Ejemplo para calcular la exactitud

    Accuracy = metrics.accuracy_score(actual, predicted)
print(Accuracy)
  

Precisión

De los positivos pronosticados, ¿qué porcentaje es realmente positivo?

Cómo calcular la precisión

Verdadero Positivo / (Verdadero Positivo + Falso Positivo)

La precisión no evalúa los casos negativos predichos correctamente:

    Precision = metrics.precision_score(actual, predicted)
print(Precision)
  

Sensibilidad

• De todos los casos positivos, ¿qué porcentaje se pronostican positivos?
• La sensibilidad (a veces denominada recuperación) mide qué tan bueno es el modelo para predecir aspectos positivos.

Esto significa que analiza los verdaderos positivos y los falsos negativos (que son positivos que se han predicho incorrectamente como negativos).

Cómo calcular la sensibilidad

Verdadero Positivo / (Verdadero Positivo + Falso Negativo)

La sensibilidad es buena para comprender qué tan bien el modelo predice que algo es positivo:

    from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 1, 0]
y_pred = [0, 1, 0, 0, 1, 1]
print(confusion_matrix(y_true, y_pred))
  

Especificidad

• ¿Como de bien el modelo predice resultados negativos?
• La especificidad es similar a la sensibilidad, pero la mira desde la perspectiva de los resultados negativos.

Cómo calcular la especificidad

    from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 1, 0]
y_pred = [0, 1, 0, 0, 1, 1]
print(confusion_matrix(y_true, y_pred))
  

F-Score

F-score es la "media armónica" de precisión y sensibilidad.

Considera casos falsos positivos y falsos negativos y es bueno para conjuntos de datos desequilibrados.

Cómo calcular el F-Score

2 * ((Precisión * Sensibilidad) / (Precisión + Sensibilidad))

Esta puntuación no tiene en cuenta los valores True Negative:

Ejemplo de cálculo del F-Score

    from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 1, 0]
y_pred = [0, 1, 0, 0, 1, 1]
print(confusion_matrix(y_true, y_pred))
  

Evaluar todos los cálculos a la vez

    print(matriz_confusion)
  

Practica Matriz de confusión en Python en el editor

Pon en práctica lo aprendido con nuestro editor Python interactivo. Cada ejercicio incluye el código de partida y un botón para abrirlo en una nueva pestaña, donde puedes modificarlo y ejecutarlo.

    import numpy as np
from sklearn import metrics

actual = np.array([1, 0, 1, 1, 0])
predicted = np.array([1, 0, 0, 1, 0])
matriz = metrics.confusion_matrix(actual, predicted)
print(matriz)
  

    import numpy as np
from sklearn import metrics

np.random.seed(0)
actual = np.random.binomial(1, 0.9, size=50)
predicted = np.random.binomial(1, 0.9, size=50)
print(metrics.confusion_matrix(actual, predicted))
  

    from sklearn import metrics

actual = [1, 0, 1, 1, 0, 1]
predicted = [1, 0, 0, 1, 0, 1]
print(metrics.confusion_matrix(actual, predicted))
  

    from sklearn import metrics

actual = [True, False, True, True, False]
predicted = [True, False, False, True, False]
matriz = metrics.confusion_matrix(actual, predicted)
cm = metrics.ConfusionMatrixDisplay(confusion_matrix=matriz, display_labels=[False, True])
print(matriz)
print(cm)
  

    from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 1, 0]
y_pred = [0, 1, 1, 1, 0, 0]
print(confusion_matrix(y_true, y_pred))
  

    import numpy as np

actual = np.array([1, 0, 1, 0, 1])
predicted = np.array([1, 0, 0, 0, 1])
print(actual)
print(predicted)