Làm cách nào để triển khai ma trận nhầm lẫn trong python?

Sau khi tạo mô hình học máy, độ chính xác là thước đo được sử dụng để đánh giá mô hình học máy. Mặt khác, bạn không thể sử dụng độ chính xác trong mọi trường hợp vì nó sẽ gây hiểu nhầm. Bởi vì độ chính xác 99% có thể trông đẹp như một tỷ lệ phần trăm, nhưng hãy xem xét mô hình học máy được sử dụng để Phát hiện gian lận hoặc phát hiện tiêu thụ ma túy

Trong những tình huống quan trọng như vậy, tỷ lệ thất bại 1% có thể tạo ra tác động đáng kể

Ví dụ: nếu một mô hình dự đoán một giao dịch gian lận trị giá 10000 đô la là Không gian lận, thì đó không phải là một mô hình tốt và không thể được sử dụng trong sản xuất

Trong mô hình tiêu thụ ma túy, hãy xem xét liệu mô hình có dự đoán rằng người đó đã sử dụng ma túy nhưng thực tế không. Nhưng do Dự đoán sai của mô hình, người đó có thể bị bỏ tù vì tội không thực sự phạm phải

Trong những tình huống như vậy, bạn cần một số liệu tốt hơn độ chính xác để xác thực mô hình máy học
Đây là nơi ma trận nhầm lẫn xuất hiện trong bức tranh

Trong hướng dẫn này, bạn sẽ tìm hiểu ma trận nhầm lẫn là gì, cách vẽ ma trận nhầm lẫn cho mô hình phân loại nhị phân và mô hình phân loại đa biến

Mục lục

Ma trận nhầm lẫn là gì?

Ma trận nhầm lẫn là ma trận cho phép bạn hình dung hiệu suất của các mô hình học máy phân loại. Với hình ảnh trực quan này, bạn có thể hiểu rõ hơn về cách thức hoạt động của mô hình máy học của mình

Tạo mô hình phân loại lớp nhị phân

Trong phần này, bạn sẽ tạo một mô hình phân loại để dự đoán liệu bệnh nhân có bị ung thư vú hay không, được biểu thị bằng các lớp đầu ra

    Model is Created

9 hoặc

y_pred = knn.predict(X_test)

y_pred

0

Bộ dữ liệu ung thư vú có sẵn trong thư viện bộ dữ liệu sklearn

Nó chứa tổng số 569 hàng dữ liệu. Mỗi hàng bao gồm 30 tính năng số và một lớp đầu ra. Nếu bạn muốn thao tác hoặc trực quan hóa tập dữ liệu sklearn, bạn có thể chuyển đổi nó thành khung dữ liệu gấu trúc và chơi xung quanh với các chức năng của khung dữ liệu gấu trúc

Để tạo mô hình, bạn sẽ tải tập dữ liệu sklearn, chia nó thành tập huấn luyện và tập thử nghiệm và điều chỉnh dữ liệu huấn luyện vào mô hình

y_pred = knn.predict(X_test)

y_pred

1

Sau khi tạo mô hình, bạn có thể sử dụng dữ liệu thử nghiệm để dự đoán các giá trị và kiểm tra xem mô hình đang hoạt động như thế nào

Bạn có thể sử dụng các lớp đầu ra thực tế từ dữ liệu thử nghiệm của mình và đầu ra dự đoán được trả về bởi phương pháp

y_pred = knn.predict(X_test)

y_pred

2 để vẽ ma trận nhầm lẫn và đánh giá độ chính xác của mô hình

Sử dụng đoạn mã dưới đây để tạo mô hình

Đoạn trích

import numpy as np

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier as KNN

breastCancer = load_breast_cancer()

X = breastCancer.data
y = breastCancer.target

# Split the dataset into train and test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state = 42)

knn = KNN(n_neighbors = 3)

# train the model
knn.fit(X_train, y_train)

print('Model is Created')

Mô hình KNeighborsClassifier được tạo cho dữ liệu đào tạo về bệnh ung thư vú

đầu ra

    Model is Created

Để kiểm tra mô hình đã tạo, bạn có thể sử dụng dữ liệu kiểm tra thu được từ phân tách thử nghiệm đào tạo và dự đoán đầu ra. Sau đó, bạn sẽ có các giá trị dự đoán

Đoạn trích

y_pred = knn.predict(X_test)

y_pred

đầu ra

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

Bây giờ, hãy sử dụng các lớp được dự đoán và các lớp đầu ra thực tế từ dữ liệu thử nghiệm để trực quan hóa ma trận nhầm lẫn

Bạn sẽ học cách vẽ ma trận nhầm lẫn cho mô hình phân loại nhị phân trong phần tiếp theo

Vẽ ma trận nhầm lẫn cho các lớp nhị phân

Bạn có thể tạo ma trận nhầm lẫn bằng cách sử dụng phương thức mess_matrix() từ gói

y_pred = knn.predict(X_test)

y_pred

3. Phương thức

y_pred = knn.predict(X_test)

y_pred

4 sẽ cung cấp cho bạn một mảng mô tả các Giá trị tích cực đúng, Giá trị tích cực sai, Giá trị phủ định sai và Giá trị phủ định thực

** Đoạn trích **

from sklearn.metrics import confusion_matrix

#Generate the confusion matrix
cf_matrix = confusion_matrix(y_test, y_pred)

print(cf_matrix)

đầu ra

    [[ 73   7]
     [  7 141]]

Khi bạn đã tạo ma trận nhầm lẫn, bạn có thể sử dụng phương pháp

y_pred = knn.predict(X_test)

y_pred

5 có sẵn trong thư viện seaborn để vẽ ma trận nhầm lẫn

Phương thức seaborn heatmap() chấp nhận một tham số bắt buộc và một vài tham số tùy chọn khác

• y_pred = knn.predict(X_test)
  
  y_pred

  6 – Một tập dữ liệu hình chữ nhật có thể được ép thành một mảng 2d. Tại đây, bạn có thể chuyển ma trận nhầm lẫn mà bạn đã có

• y_pred = knn.predict(X_test)
  
  y_pred

  7 – Để ghi giá trị dữ liệu vào ô của ma trận được in. Theo mặc định, đây là

  y_pred = knn.predict(X_test)
  
  y_pred

  8

• y_pred = knn.predict(X_test)
  
  y_pred

  9 – Đây là để biểu thị tên bản đồ màu matplotlib. Ở đây, chúng tôi đã tạo cốt truyện bằng cách sử dụng các sắc thái màu xanh lam

Phương thức

y_pred = knn.predict(X_test)

y_pred

5 trả về các trục matplotlib có thể được lưu trữ trong một biến. Tại đây, bạn sẽ lưu trữ trong biến

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

1. Giờ đây, bạn có thể đặt tiêu đề, nhãn trục x và trục y cũng như nhãn đánh dấu cho trục x và trục y

• Tiêu đề – Được sử dụng để gắn nhãn cho hình ảnh hoàn chỉnh. Sử dụng phương thức set_title() để đặt tiêu đề
• Nhãn trục – Được sử dụng để đặt tên cho trục

      array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
             0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
             1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
             0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
             1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
             0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
             0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
             1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
             0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
             0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
             0, 1, 0, 0, 1, 1, 0, 1])

  2 hoặc trục

      array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
             0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
             1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
             0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
             1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
             0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
             0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
             1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
             0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
             0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
             0, 1, 0, 0, 1, 1, 0, 1])

  3. Sử dụng set_xlabel() để đặt nhãn trục x và set_ylabel() để đặt nhãn trục y
• Đánh dấu nhãn – Được sử dụng để biểu thị các điểm dữ liệu trên các trục. Bạn có thể chuyển các nhãn đánh dấu trong một mảng và nó phải theo thứ tự tăng dần. Bởi vì ma trận nhầm lẫn chứa các giá trị ở định dạng thứ tự tăng dần. Sử dụng trục x. set_ticklabels() để đặt nhãn đánh dấu cho trục x và trục y. set_ticklabels() để đặt nhãn đánh dấu cho trục y

Cuối cùng, sử dụng cốt truyện. show() để vẽ ma trận nhầm lẫn

Sử dụng đoạn mã dưới đây để tạo ma trận nhầm lẫn, đặt tiêu đề và nhãn cho trục, đặt nhãn đánh dấu và vẽ biểu đồ

Đoạn trích

import seaborn as sns

ax = sns.heatmap(cf_matrix, annot=True, cmap='Blues')

ax.set_title('Seaborn Confusion Matrix with labels\n\n');
ax.set_xlabel('\nPredicted Values')
ax.set_ylabel('Actual Values ');

## Ticket labels - List must be in alphabetical order
ax.xaxis.set_ticklabels(['False','True'])
ax.yaxis.set_ticklabels(['False','True'])

## Display the visualization of the Confusion Matrix.
plt.show()

đầu ra

Ma trận nhầm lẫn Seaborn với nhãn

Ngoài ra, bạn cũng có thể vẽ ma trận nhầm lẫn bằng phương pháp có sẵn trong chính thư viện sklearn nếu bạn muốn tránh sử dụng seaborn

Tiếp theo, bạn sẽ học cách vẽ ma trận nhầm lẫn với tỷ lệ phần trăm

Vẽ ma trận nhầm lẫn cho các lớp nhị phân với tỷ lệ phần trăm

Mục tiêu của việc tạo và vẽ ma trận nhầm lẫn là để kiểm tra tính chính xác của mô hình học máy. Sẽ tốt hơn nếu trực quan hóa độ chính xác bằng tỷ lệ phần trăm thay vì chỉ sử dụng số. Trong phần này, bạn sẽ học cách vẽ ma trận nhầm lẫn cho các lớp nhị phân với tỷ lệ phần trăm.

Để vẽ ma trận nhầm lẫn với tỷ lệ phần trăm, trước tiên, bạn cần tính tỷ lệ phần trăm của Kết quả xác thực đúng, Kết quả tích cực sai, Phủ định sai và Phủ định đúng. Bạn có thể tính tỷ lệ phần trăm của các giá trị này bằng cách chia giá trị cho tổng của tất cả các giá trị

Sử dụng phương pháp

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

4, bạn có thể tính tổng tất cả các giá trị trong ma trận nhầm lẫn

Sau đó, chuyển tỷ lệ phần trăm của mỗi giá trị dưới dạng dữ liệu sang phương thức

y_pred = knn.predict(X_test)

y_pred

5 bằng cách sử dụng câu lệnh

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

6

Sử dụng đoạn mã dưới đây để vẽ ma trận nhầm lẫn với tỷ lệ phần trăm

Đoạn trích

ax = sns.heatmap(cf_matrix/np.sum(cf_matrix), annot=True, 
            fmt='.2%', cmap='Blues')

ax.set_title('Seaborn Confusion Matrix with labels\n\n');
ax.set_xlabel('\nPredicted Values')
ax.set_ylabel('Actual Values ');

## Ticket labels - List must be in alphabetical order
ax.xaxis.set_ticklabels(['False','True'])
ax.yaxis.set_ticklabels(['False','True'])

## Display the visualization of the Confusion Matrix.
plt.show()

đầu ra

Seaborn Confusion Matrix với Nhãn

Vẽ ma trận nhầm lẫn cho các lớp nhị phân có nhãn

Trong phần này, bạn sẽ vẽ một ma trận nhầm lẫn cho các lớp Nhị phân với các nhãn Xác thực Đúng, Tích cực Sai, Phủ định Sai và Phủ định Đúng

Bạn cần tạo một danh sách các nhãn và chuyển đổi nó thành một mảng bằng cách sử dụng phương thức

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

7 với hình dạng

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

8. Sau đó, mảng nhãn này phải được chuyển đến thuộc tính

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

9. Điều này sẽ vẽ ma trận nhầm lẫn với chú thích nhãn

Sử dụng đoạn mã dưới đây để vẽ ma trận nhầm lẫn với các nhãn

Đoạn trích

labels = ['True Neg','False Pos','False Neg','True Pos']

labels = np.asarray(labels).reshape(2,2)

ax = sns.heatmap(cf_matrix, annot=labels, fmt='', cmap='Blues')

ax.set_title('Seaborn Confusion Matrix with labels\n\n');
ax.set_xlabel('\nPredicted Values')
ax.set_ylabel('Actual Values ');

## Ticket labels - List must be in alphabetical order
ax.xaxis.set_ticklabels(['False','True'])
ax.yaxis.set_ticklabels(['False','True'])

## Display the visualization of the Confusion Matrix.
plt.show()

đầu ra

Ma trận nhầm lẫn với nhãn

Vẽ ma trận nhầm lẫn cho các lớp nhị phân có nhãn và tỷ lệ phần trăm

Trong phần này, bạn sẽ học cách vẽ ma trận nhầm lẫn với nhãn, số lượng và tỷ lệ phần trăm

Bạn có thể sử dụng điều này để đo tỷ lệ phần trăm của từng nhãn. Ví dụ: bao nhiêu phần trăm dự đoán là Xác thực đúng, Tích cực sai, Phủ định sai và Phủ định đúng

Đối với điều này, trước tiên, bạn cần tạo một danh sách các nhãn, sau đó đếm từng nhãn trong một danh sách và đo tỷ lệ phần trăm của các nhãn trong danh sách khác

Sau đó, bạn có thể nén các danh sách khác nhau này để tạo nhãn. Phương tiện nén và tạo một danh sách. Sau đó, danh sách này phải được chuyển đổi thành một mảng bằng phương thức

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

7

Sau đó chuyển mảng cuối cùng tới thuộc tính

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

9. Điều này sẽ tạo ra một ma trận nhầm lẫn với thông tin về nhãn, số lượng và tỷ lệ phần trăm cho mỗi lớp

Sử dụng đoạn mã dưới đây để hình dung ma trận nhầm lẫn với tất cả các chi tiết

Đoạn trích

group_names = ['True Neg','False Pos','False Neg','True Pos']

group_counts = ["{0:0.0f}".format(value) for value in
                cf_matrix.flatten()]

group_percentages = ["{0:.2%}".format(value) for value in
                     cf_matrix.flatten()/np.sum(cf_matrix)]

labels = [f"{v1}\n{v2}\n{v3}" for v1, v2, v3 in
          zip(group_names,group_counts,group_percentages)]

labels = np.asarray(labels).reshape(2,2)

ax = sns.heatmap(cf_matrix, annot=labels, fmt='', cmap='Blues')

ax.set_title('Seaborn Confusion Matrix with labels\n\n');
ax.set_xlabel('\nPredicted Values')
ax.set_ylabel('Actual Values ');

## Ticket labels - List must be in alphabetical order
ax.xaxis.set_ticklabels(['False','True'])
ax.yaxis.set_ticklabels(['False','True'])

## Display the visualization of the Confusion Matrix.
plt.show()

đầu ra

Ma trận nhầm lẫn với nhãn

Đây là cách bạn có thể tạo ma trận nhầm lẫn cho mô hình học máy phân loại nhị phân

Tiếp theo, bạn sẽ tìm hiểu về cách tạo ma trận nhầm lẫn cho mô hình phân loại với nhiều lớp đầu ra

Tạo mô hình phân loại cho nhiều lớp

Trong phần này, bạn sẽ tạo một mô hình phân loại cho nhiều lớp đầu ra. Nói cách khác, nó còn được gọi là các lớp đa biến

Bạn sẽ sử dụng bộ dữ liệu mống mắt có sẵn trong thư viện bộ dữ liệu sklearn

Nó chứa tổng số 150 hàng dữ liệu. Mỗi hàng bao gồm bốn tính năng số và một lớp đầu ra. Lớp đầu ra có thể là bất kỳ loại hoa Iris nào. Cụ thể là Iris Setosa, Iris Versicolor, Iris Virginica

Để tạo mô hình, bạn sẽ tải tập dữ liệu sklearn, chia nó thành tập huấn luyện và tập thử nghiệm và điều chỉnh dữ liệu huấn luyện vào mô hình

y_pred = knn.predict(X_test)

y_pred

1

Sau khi tạo mô hình, bạn có thể sử dụng dữ liệu thử nghiệm để dự đoán các giá trị và kiểm tra xem mô hình đang hoạt động như thế nào

Bạn có thể sử dụng các lớp đầu ra thực tế từ dữ liệu thử nghiệm của mình và đầu ra dự đoán được trả về bởi phương pháp

y_pred = knn.predict(X_test)

y_pred

2 để vẽ ma trận nhầm lẫn và đánh giá độ chính xác của mô hình

Sử dụng đoạn mã dưới đây để tạo mô hình

Đoạn trích

    Model is Created

0

đầu ra

    Model is Created

Bây giờ mô hình được tạo ra

Sử dụng dữ liệu thử nghiệm từ phân tách thử nghiệm đào tạo và dự đoán giá trị đầu ra bằng phương pháp

y_pred = knn.predict(X_test)

y_pred

2 như hình bên dưới

Đoạn trích

y_pred = knn.predict(X_test)

y_pred

Bạn sẽ có đầu ra dự đoán dưới dạng một mảng. Giá trị 0, 1, 2 hiển thị danh mục dự đoán của dữ liệu thử nghiệm

đầu ra

    Model is Created

3

Bây giờ, bạn có thể sử dụng dữ liệu dự đoán có sẵn trong

from sklearn.metrics import confusion_matrix

#Generate the confusion matrix
cf_matrix = confusion_matrix(y_test, y_pred)

print(cf_matrix)

5 để tạo ma trận nhầm lẫn cho nhiều lớp

Vẽ ma trận nhầm lẫn cho nhiều lớp

Trong phần này, bạn sẽ học cách vẽ một ma trận nhầm lẫn cho nhiều lớp

Bạn có thể sử dụng phương thức

y_pred = knn.predict(X_test)

y_pred

4 có sẵn trong thư viện sklearn để tạo ma trận nhầm lẫn. Nó sẽ chứa ba hàng và cột đại diện cho danh mục hoa thực tế và danh mục hoa được dự đoán theo thứ tự tăng dần

Đoạn trích

    Model is Created

4

đầu ra

    Model is Created

5

Đầu ra bên dưới hiển thị ma trận nhầm lẫn cho số lượng loại hoa thực tế và dự đoán

Bạn có thể sử dụng ma trận này để vẽ ma trận nhầm lẫn bằng thư viện seaborn, như hình bên dưới

Đoạn trích

    Model is Created

6

đầu ra

Vẽ ma trận nhầm lẫn cho nhiều lớp với tỷ lệ phần trăm

Trong phần này, bạn sẽ vẽ ma trận nhầm lẫn cho nhiều lớp với tỷ lệ phần trăm của mỗi lớp đầu ra. Bạn có thể tính tỷ lệ phần trăm bằng cách chia các giá trị trong ma trận nhầm lẫn cho tổng của tất cả các giá trị

Sử dụng đoạn mã dưới đây để vẽ ma trận nhầm lẫn cho nhiều lớp với tỷ lệ phần trăm

Đoạn trích

    Model is Created

7

đầu ra

Vẽ ma trận nhầm lẫn cho nhiều lớp với số và tỷ lệ phần trăm

Trong phần này, bạn sẽ học cách vẽ ma trận nhầm lẫn với nhãn, số lượng và tỷ lệ phần trăm cho nhiều lớp

Bạn có thể sử dụng điều này để đo tỷ lệ phần trăm của từng nhãn. Ví dụ: bao nhiêu phần trăm dự đoán thuộc về từng loại hoa

Đối với điều này, trước tiên, bạn cần tạo một danh sách các nhãn, sau đó đếm từng nhãn trong một danh sách và đo tỷ lệ phần trăm của các nhãn trong danh sách khác

Sau đó, bạn có thể nén các danh sách khác nhau này để tạo nhãn nối. Phương tiện nén và tạo một danh sách. Sau đó, danh sách này phải được chuyển đổi thành một mảng bằng phương thức

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

7

Mảng cuối cùng này phải được chuyển đến thuộc tính

    array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
           1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
           0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
           1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
           0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
           0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1,
           1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
           0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,
           0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
           0, 1, 0, 0, 1, 1, 0, 1])

9. Điều này sẽ tạo ra một ma trận nhầm lẫn với thông tin về nhãn, số lượng và tỷ lệ phần trăm cho từng loại hoa

Sử dụng đoạn mã dưới đây để hình dung ma trận nhầm lẫn với tất cả các chi tiết

Đoạn trích

    Model is Created

8

đầu ra

Đây là cách bạn có thể vẽ ma trận nhầm lẫn cho nhiều lớp với tỷ lệ phần trăm và số

Vẽ ma trận nhầm lẫn mà không cần phân loại

Để vẽ ma trận nhầm lẫn mà không có mô hình phân loại, hãy tham khảo câu trả lời StackOverflow này

Phần kết luận

Tóm lại, bạn đã học cách vẽ ma trận nhầm lẫn cho mô hình máy học với các lớp đầu ra nhị phân và nhiều lớp đầu ra

Bạn cũng đã học cách chú thích ma trận nhầm lẫn với nhiều chi tiết hơn như nhãn, số lượng của từng nhãn và tỷ lệ phần trăm của từng nhãn để trực quan hóa tốt hơn

Thư viện Python cho ma trận nhầm lẫn là gì?

Ma trận nhầm lẫn cho KNN trong Python là gì?