Scikit aprende Matriz de confusión

En este tutorial de Python, aprenderemos Cómo funciona la matriz de confusión de aprendizaje de Scikit en Python y también cubriremos diferentes ejemplos relacionados con Scikit aprender matriz de confusión. Y, cubriremos estos temas.

Scikit aprender matriz de confusión

En esta sección aprenderemos sobre cómo funciona la matriz de confusión de aprendizaje de Scikit en pitón

• La matriz de confusión de aprendizaje de Scikit se define como una técnica para calcular el rendimiento de la clasificación.
• La matriz de confusión también se utiliza para predecir o resumir el resultado del problema de clasificación.

Código:

• y_verdadero = [2, 0, 0, 2, 0, 1] se utiliza para obtener el valor real.
• y_pred = [0, 0, 2, 0, 0, 2] se utiliza para obtener el valor predicho.
• matriz_confusión(y_true, y_pred) se utiliza para evaluar la matriz de confusión.

from sklearn.metrics import confusion_matrix
y_true = [2, 0, 0, 2, 0, 1]
y_pred = [0, 0, 2, 0, 0, 2]
confusion_matrix(y_true, y_pred)

Producción:

Después de ejecutar el código anterior, obtenemos el siguiente resultado en el que podemos ver que el valor de la matriz de confusión se imprime en la pantalla.

Scikit aprender ejemplo de matriz de confusión

En esta sección aprenderemos sobre cómo Scikit aprende el ejemplo de matriz de confusión funciona en pitón.

• El ejemplo de matriz de confusión de aprendizaje de Scikit se define como una técnica para resumir el resultado de la clasificación.
• La matriz de confusión también predijo el número de predicciones correctas e incorrectas del modelo de clasificación.

Código:

En el siguiente código, importaremos algunas bibliotecas desde las cuales podemos hacer la matriz de confusión.

• iris = conjuntos de datos.load_iris() se utiliza para cargar los datos del iris.
• class_names = iris.target_names se utiliza para obtener los nombres de destino.
• x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0) se utiliza para dividir el conjunto de datos en datos de entrenamiento y de prueba.
• clasificador = svm.SVC(núcleo=”lineal”, C=0.02).fit(x_tren, y_tren) se utiliza para ajustar el modelo.
• ConfusionMatrixDisplay.from_estimator() se utiliza para trazar la matriz de confusión.
• imprimir (pantalla.confusion_matrix) se utiliza para imprimir la matriz de confusión.

import numpy as num
import matplotlib.pyplot as plot

from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import ConfusionMatrixDisplay


iris = datasets.load_iris()
x = iris.data
y = iris.target
class_names = iris.target_names


x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)


classifier = svm.SVC(kernel="linear", C=0.02).fit(x_train, y_train)

num.set_printoptions(precision=2)

title_options = [
    ("Confusion matrix, without normalization", None),
    ("Normalized confusion matrix", "true"),
]
for title, normalize in title_options:
    display = ConfusionMatrixDisplay.from_estimator(
        classifier,
        x_test,
        y_test,
        display_labels=class_names,
        cmap=plot.cm.Blues,
        normalize=normalize,
    )
    display.ax_.set_title(title)

    print(title)
    print(display.confusion_matrix)

plot.show()

Producción:

En el siguiente resultado, podemos ver que el resultado de la clasificación se resume en la pantalla con la ayuda de una matriz de confusión.

Scikit aprender ejemplo de matriz de confusión

Scikit aprende diagrama de matriz de confusión

En esta sección aprenderemos sobre cómo Scikit aprende diagrama de matriz de confusión en pitón

• El gráfico de matriz de confusión de aprendizaje de Scikit se utiliza para trazar el gráfico en la pantalla para resumir el resultado del modelo.
• Se utiliza para trazar el gráfico para predecir el número de predicciones correctas o incorrectas del modelo.

Código:

En el siguiente código, importaremos algunas bibliotecas desde las cuales podemos trazar la matriz de confusión en la pantalla.

• x, y = hacer_clasificación(estado_aleatorio=0) se utiliza para hacer la clasificación.
• x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0) se utiliza para dividir el conjunto de datos en tren y conjunto de prueba.
• clasificador.fit(x_tren, y_tren) se utiliza para ajustar el modelo.
• plot_confusion_matrix(clasificador, x_test, y_test) se utiliza para trazar la matriz de confusión en la pantalla.

import matplotlib.pyplot as plot
from sklearn.datasets import make_classification
from sklearn.metrics import plot_confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(
         x, y, random_state=0)
classifier = SVC(random_state=0)
classifier.fit(x_train, y_train)
SVC(random_state=0)
plot_confusion_matrix(classifier, x_test, y_test)  
plot.show()

Producción:

Después de ejecutar el código anterior, obtenemos el siguiente resultado en el que podemos ver que la matriz de confusión se traza en la pantalla.

Scikit aprende diagrama de matriz de confusión

Scikit aprende la precisión de la matriz de confusión

En esta sección aprenderemos sobre Scikit aprende la precisión de la matriz de confusión del modelo en python.

Scikit aprende la precisión de la matriz de confusión se usa para calcular la precisión de la matriz, qué tan preciso es el resultado de nuestro modelo.

Código:

En el siguiente código, importaremos algunas bibliotecas desde las cuales podemos calcular la precisión del modelo.

• y_pred = [1, 3, 2, 0] se utiliza para predecir el valor predicho.
• y_verdadero = [0, 1, 2, 3] se utiliza para predecir el valor real.
• precision_score(y_true, y_pred) se utiliza para predecir la puntuación de precisión.

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
y_pred = [1, 3, 2, 0]
y_true = [0, 1, 2, 3]
accuracy_score(y_true, y_pred)
accuracy_score(y_true, y_pred, normalize=False)
import numpy as num
accuracy_score(num.array([[0, 1], [1, 1]]), num.ones((2, 2)))

Producción:

Después de ejecutar el código anterior, obtenemos el siguiente resultado en el que podemos ver que la puntuación de precisión de la matriz de confusión se imprime en la pantalla.

Scikit aprende la precisión de la matriz de confusión

Scikit aprender matriz de confusión multiclase

En esta sección aprenderemos sobre cómo funciona scikit learn confusion matrix multiclass en pitón

Scikit learn confusion matrix multi-class se define como un problema de clasificación de la ilustración de una de las tres o más clases.

Código:

En el siguiente código, importaremos algunas bibliotecas desde las cuales podemos hacer una matriz de confusión multiclase.

• df = pd.read_csv(“IRIS.csv”) se utiliza para cargar el conjunto de datos.
• df.tipos se utiliza para seleccionar los tipos de datos.

#importing packages
import pandas as pds
import numpy as num
import seaborn as sb
import matplotlib.pyplot as plot
 
df = pd.read_csv("IRIS.csv")
df.head()
df.dtypes

Scikit aprende el conjunto de datos multiclase de matriz de confusión

• x = df.drop([‘species’]eje=1) se utiliza para separar la variable independiente y la variable dependiente.
• imprimir (forma x) se utiliza para imprimir la forma del conjunto de datos.

#Separating independant variable and dependent variable("Species")
x = df.drop(['species'], axis=1)
y = df['species']

print(x.shape)

print(y.shape)

scikit aprender matriz de confusión multiclase separando variable dependiente o independiente

• x_train, x_test, y_train, y_test = train_test_split(x, y, test_tamaño =0.3, estado_aleatorio=0) se utiliza para dividir el conjunto de datos en tren y conjunto de prueba.
• imprimir (x_tren.forma) se utiliza para imprimir la forma del juego de trenes.
• imprimir (x_prueba.forma) se utiliza para imprimir la forma del conjunto de prueba.

# Splitting the dataset to Train and test
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)

print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)

Scikit aprende división de datos de prueba de tren multiclase de matriz de confusión

• clasificador = SVC(núcleo = ‘lineal’).fit(x_tren,y_tren) se utiliza para entrenar el clasificador de tren x y tren y.
• cm = matriz_confusión(y_test, y_pred) se utiliza para crear la matriz de confusión.
• cm_df = pd.DataFrame() se utiliza para crear el marco de datos.
• plot.figure(figsize=(5,4)) se utiliza para trazar la figura.

from sklearn.svm import SVC
from sklearn.metrics import confusion_matrix

classifier = SVC(kernel="linear").fit(x_train,y_train)
classifier.predict(x_train)

y_pred = classifier.predict(X_test)

cm = confusion_matrix(y_test, y_pred)

cm_df = pd.DataFrame(cm,
                     index = ['SETOSA','VERSICOLR','VIRGINICA'], 
                     columns = ['SETOSA','VERSICOLR','VIRGINICA'])

plot.figure(figsize=(5,4))
sb.heatmap(cm_df, annot=True)
plot.title('Confusion Matrix')
plot.ylabel('Actal Values')
plot.xlabel('Predicted Values')
plot.show()

Scikit aprender matriz de confusión multiclase

Scikit aprender pantalla de matriz de confusión

En esta sección, aprenderemos cómo Scikit aprender obras de visualización de matriz de confusión en pitón

La visualización de matriz de confusión de aprendizaje de Scikit se define como una matriz en la que i, j es igual al número de observaciones que se pronostica que habrá en un grupo.

Código:

En el siguiente código, aprenderemos a importar algunas bibliotecas desde las cuales podemos ver cómo se muestra la matriz de confusión en la pantalla.

• x, y = hacer_clasificación(estado_aleatorio=0) se utiliza para hacer la clasificación.
• x_train, x_test, y_train, y_test = train_test_split(x, y,random_state=0) se utiliza para dividir el conjunto de datos en datos de entrenamiento y de prueba.
• clasificador.fit(x_tren, y_tren) se utiliza para ajustar los datos.
• Predictions = classifier.predict(x_test) se usa para predecir los datos.
• display=ConfusionMatrixDisplay(confusion_matrix=cm,display_labels=classifier.classes_) se utiliza para mostrar la matriz de confusión.
• mostrar.plot() se utiliza para trazar la matriz.

import matplotlib.pyplot as plot
from sklearn.datasets import make_classification
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
x, y = make_classification(random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y,
                                                    random_state=0)
classifier = SVC(random_state=0)
classifier.fit(x_train, y_train)
SVC(random_state=0)
predictions = classifier.predict(x_test)
cm = confusion_matrix(y_test, predictions, labels=classifier.classes_)
display = ConfusionMatrixDisplay(confusion_matrix=cm,
                               display_labels=classifier.classes_)
display.plot()

plot.show()

Producción:

Después de ejecutar el código anterior, obtenemos el siguiente resultado en el que podemos ver que se muestra una matriz de confusión en la pantalla.

Scikit aprender pantalla de matriz de confusión

Scikit aprende etiquetas de matriz de confusión

En esta sección aprenderemos cómo Scikit aprende las etiquetas de matriz de confusión funciona en pitón.

La etiqueta de matriz de confusión de aprendizaje de Scikit se define como una matriz de dos dimensiones que contrasta un grupo predicho de etiquetas con etiquetas verdaderas.

Código:

En el siguiente código, importaremos algunas bibliotecas para saber cómo funcionan las etiquetas de matriz de confusión de aprendizaje de scikit.

• y_true = num.matriz([[1, 0, 0],[0, 1, 1]]) se utiliza para recopilar las etiquetas verdaderas en la matriz.
• y_pred = num.matriz([[1, 0, 1],[0, 1, 0]]) se utiliza para recopilar las etiquetas predichas en la matriz.
• multilabel_confusion_matrix(y_true, y_pred) se utiliza para obtener la matriz de confusión multietiqueta.

import numpy as num
from sklearn.metrics import multilabel_confusion_matrix
y_true = num.array([[1, 0, 0],
                    [0, 1, 1]])
y_pred = num.array([[1, 0, 1],
                   [0, 1, 0]])
multilabel_confusion_matrix(y_true, y_pred)

Producción:

Después de ejecutar el código anterior, obtenemos el siguiente resultado en el que podemos ver que las etiquetas de la matriz de confusión se imprimen en la pantalla.

Scikit aprende etiquetas de matriz de confusión

Scikit aprender matriz de confusión normalizar

En esta sección aprenderemos sobre cómo funciona scikit learn confusion matrix normalize en pitón

Scikit aprende a normalizar la matriz de confusión se define como un proceso que representa una muestra presente en cada grupo.

Código:

En el siguiente código, importaremos algunas bibliotecas desde las cuales podemos normalizar la matriz.

• iris = conjuntos de datos.load_iris() se utiliza para cargar los datos.
• x_train, x_test, y_train, y_test = train_test_split(X, y, random_state=0) se utiliza para dividir el conjunto de datos en datos de entrenamiento y prueba.
• clasificador = svm.SVC(núcleo=’lineal’, C=0.01) se utiliza como clasificador.
• y_pred = clasificador.ajustar(x_tren, y_tren).predecir(x_prueba) se utiliza para ajustar el modelo.
• cm = matriz_confusión(y_true, y_pred) se utiliza para calcular la matriz de confusión.
• clases = clases[unique_labels(y_true, y_pred)] se utiliza de etiqueta que aparece en los datos.
• figura, eje = plot.subplots() se utiliza para trazar la figura en la pantalla.
• plot.setp(axis.get_xticklabels(), rotación=45, ha=”derecha”,modo_rotación=”ancla”) se utiliza para establecer la alineación y rotar las marcas.
• plot_confusion_matrix(y_test, y_pred, classes=class_names, normalize=True, title=’Matriz de confusión normalizada’) se utiliza para trazar la matriz de confusión normalizada.

import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm, datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.utils.multiclass import unique_labels


iris = datasets.load_iris()
x_digits = iris.data
y = iris.target
class_names = iris.target_names

x_train, x_test, y_train, y_test = train_test_split(X, y, random_state=0)


classifier = svm.SVC(kernel="linear", C=0.01)
y_pred = classifier.fit(x_train, y_train).predict(x_test)


def plot_confusion_matrix(y_true, y_pred, classes,
                          normalize=False,
                          title=None,
                          cmap=plot.cm.Blues):
   
    if not title:
        if normalize:
            title="Normalized confusion matrix"
        
    cm = confusion_matrix(y_true, y_pred)

    classes = classes[unique_labels(y_true, y_pred)]
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, num.newaxis]
        print("Normalized confusion matrix")
   

    print(cm)

    figure, axis = plot.subplots()
    im = axis.imshow(cm, interpolation='nearest', cmap=cmap)
    axis.figure.colorbar(im, ax=axis)

    axis.set(xticks=num.arange(cm.shape[1]),
           yticks=num.arange(cm.shape[0]),

           xticklabels=classes, yticklabels=classes,
           title=title,
           ylabel="True label",
           xlabel="Predicted label")


    plot.setp(axis.get_xticklabels(), rotation=45, ha="right",
             rotation_mode="anchor")

    fmt=".2f" if normalize else 'd'
    thresh = cm.max() / 2.
    for i in range(cm.shape[0]):
        for j in range(cm.shape[1]):
            axis.text(j, i, format(cm[i, j], fmt),
                    ha="center", va="center",
                    color="cyan" if cm[i, j] > thresh else "red")
    figure.tight_layout()
    return axis

plot_confusion_matrix(y_test, y_pred, classes=class_names, normalize=True,
                      title="Normalized confusion matrix")

plot.show()

Producción:

En el siguiente código, veremos que se crea una matriz de confusión normalizada y también se traza en la pantalla un gráfico de matriz de confusión normalizada.

Scikit aprender matriz de confusión normalizada