Матрица путаницы в Scikit Python

В этом разделе мы узнаем о том, как матрица путаницы обучения Scikit работает в Python:

• Определяется как метод расчета эффективности классификации.
• Используется для прогнозирования или обобщения результата задачи классификации.

Код:

• y_true = [2, 0, 0, 2, 0, 1] используется для получения истинного значения.
• y_pred = [0, 0, 2, 0, 0, 2] используется для получения прогнозируемого значения.
• confusion_matrix(y_true, y_pred) используется для оценки матрицы путаницы.

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)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что значение матрицы путаницы печатается на экране.

• Пример
• График матрицы
• Точность матрицы
• Многоклассовая матрица
• Отображение матрицы
• Метки матрицы
• Нормализация матрицы

Пример

Пример матрицы путаницы обучения Scikit определяется как метод суммирования результатов классификации.

Матрица путаницы также предсказала количество правильных и неправильных предсказаний модели классификации.

В следующем коде мы импортируем несколько библиотек, из которых сможем составить матрицу путаницы.

• iris = datasets.load_iris() используется для загрузки данных радужной оболочки.
• 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) используется для подгонки модели.
• ConfusionMatrixDisplay.from_estimator() используется для построения матрицы путаницы.
• print(display.confusion_matrix) используется для печати матрицы путаницы.

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()

В следующем выводе мы видим, что результат классификации суммируется на экране с помощью матрицы путаницы.

График матрицы

В этом разделе мы узнаем о том, как Scikit изучает график матрицы путаницы в Python.

• График матрицы путаницы обучения Scikit используется для построения графика на экране для обобщения результатов модели.
• Он используется для построения графика для прогнозирования количества правильных или неправильных прогнозов модели.

В следующем коде мы импортируем несколько библиотек, из которых сможем построить матрицу путаницы на экране.

• x, y = make_classification(random_state=0) используется для классификации.
• x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0) используется для разделения набора данных на обучающий и тестовый набор.
• classifier.fit(x_train, y_train) используется для подгонки модели.
• plot_confusion_matrix(classifier, x_test, y_test) используется для построения матрицы путаницы на экране.

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()

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что на экране отображается матрица путаницы.

Точность матрицы

Точность матрицы путаницы Scikit используется для расчета точности матрицы, насколько точны результаты нашей модели.

В следующем коде мы импортируем несколько библиотек, из которых сможем рассчитать точность модели.

• y_pred = [1, 3, 2, 0] используется для прогнозирования прогнозируемого значения.
• y_true = [0, 1, 2, 3] используется для прогнозирования истинного значения.
• Precision_score(y_true, y_pred) используется для прогнозирования показателя точности.

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)))

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что показатель точности матрицы путаницы печатается на экране.

Многоклассовая матрица

Многоклассность матрицы путаницы в Scikit определяется как проблема классификации иллюстрации одного из трех или более классов.

В следующем коде мы импортируем несколько библиотек, из которых сможем создать мультикласс матрицы путаницы.

• df = pd.read_csv(“IRIS.csv”) используется для загрузки набора данных.
• df.dtypes используется для выбора типов данных.

#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

• x = df.drop([‘species’], axis=1) используется для разделения независимой переменной и зависимой переменной.
• print(x.shape) используется для печати формы набора данных.

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

print(x.shape)

print(y.shape)

• 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(x_test.shape) используется для печати формы набора тестов.

# 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)

• classifier = SVC(kernel = ‘linear’).fit(x_train,y_train) используется для обучения классификатора из поезда x и поезда y.
• cm = путаница_матрица(y_test, y_pred) используется для создания матрицы путаницы.
• cm_df = pd.DataFrame() используется для создания фрейма данных.
• plot.figure(figsize=(5,4)) используется для построения фигуры.

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 определяется как матрица, в которой i,j равно количеству прогнозируемых наблюдений в группе.

В следующем коде мы научимся импортировать некоторые библиотеки, из которых мы сможем увидеть, как матрица путаницы отображается на экране.

• x, y = make_classification(random_state=0) используется для классификации.
• x_train, x_test, y_train, y_test = train_test_split(x, y,random_state=0) используется для разделения набора данных на обучающие и тестовые данные.
• classifier.fit(x_train, y_train) используется для подгонки данных.
• predictions = classifier.predict(x_test) используются для прогнозирования данных.
• display=ConfusionMatrixDisplay(confusion_matrix=cm,display_labels=classifier.classes_) используется для отображения матрицы путаницы.
• display.plot() используется для построения матрицы.

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()

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что на экране отображается матрица путаницы.

Метки матрицы

Метка матрицы путаницы обучения Scikit определяется как двумерный массив, который противопоставляет предсказанную группу меток истинным меткам.

В следующем коде мы импортируем некоторые библиотеки, чтобы узнать, как работают метки матрицы путаницы scikit Learn.

• 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) используется для получения матрицы путаницы с несколькими метками.

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)

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что метки матрицы путаницы печатаются на экране.

Нормализация матрицы

Нормализация матрицы путаницы в обучении Scikit определяется как процесс, который представляет собой наличие одного образца в каждой группе.

В следующем коде мы импортируем несколько библиотек, из которых сможем нормализовать матрицу.

• iris = datasets.load_iris() используется для загрузки данных.
• 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) используется для подгонки модели.
• cm = путаница_матрица(y_true, y_pred) используется для вычисления матрицы путаницы.
• class = class[unique_labels(y_true, y_pred)] используются для меток, которые появляются в данных.
• рисунок, ось =plot.subplots() используется для построения фигуры на экране.
• plot.setp(axis.get_xticklabels(), Rotation=45, ha=”right”,rotation_mode=”anchor”) используется для установки выравнивания и вращения тиков.
• plot_confusion_matrix(y_test, y_pred,class=class_names,normalize=True, title=’Нормализованная матрица путаницы’) используется для построения нормализованной матрицы путаницы.

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()

В следующем коде мы увидим, как создается нормализованный массив матрицы путаницы, а также на экране отображается график нормализованной матрицы путаницы.