Penjelasan Matriks Kekeliruan
Pelajar akan membina matriks kekeliruan daripada ramalan dan nilai sebenar, kemudian memperoleh bilangan positif benar, negatif palsu dan kiraan berkaitan.
Penjelasan Matriks Kekeliruan ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Melangkaui Ketepatan: Memahami Ralat
Ketepatan memberitahu anda peratusan ramalan yang betul, tetapi menganggap semua ralat adalah sama. Sebenarnya, jenis ralat yang berbeza boleh membawa akibat yang sangat berbeza. Penapis spam yang menghantar e-mel sah ke folder spam memang menyusahkan; model diagnosis perubatan yang terlepas kes kanser boleh mengancam nyawa.
Matriks kekeliruan ialah alat yang memecahkan prestasi pengelas kepada jadual 2×2 (untuk pengelasan binari) yang menunjukkan setiap gabungan label sebenar dan label ramalan yang mungkin. Alat ini mendedahkan bukan sahaja sejauh mana model itu tersilap, tetapi juga bagaimana model itu tersilap.
Empat Sel dalam Matriks Kekeliruan
Untuk pengelasan binari dengan kelas Positif (1) dan Negatif (0), matriks kekeliruan mempunyai empat sel:
- Positif Benar (TP) — sebenar positif, diramalkan positif. Pengesanan yang betul.
- Negatif Benar (TN) — sebenar negatif, diramalkan negatif. Penolakan yang betul.
- Positif Palsu (FP) — sebenar negatif, diramalkan positif. Ralat Jenis I; amaran palsu.
- Negatif Palsu (FN) — sebenar positif, diramalkan negatif. Ralat Jenis II; pengesanan yang terlepas.
Keempat-empat kiraan diperlukan untuk mencirikan tingkah laku pengelas dengan lengkap.
import numpy as np
# Medical test example:
# Positive = disease present, Negative = disease absent
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
TP = ((y_pred == 1) & (y_true == 1)).sum()
TN = ((y_pred == 0) & (y_true == 0)).sum()
FP = ((y_pred == 1) & (y_true == 0)).sum()
FN = ((y_pred == 0) & (y_true == 1)).sum()
print(f'TP={TP} FP={FP}')
print(f'FN={FN} TN={TN}')
print(f'Total: {TP+TN+FP+FN}')Membina Matriks Kekeliruan dengan scikit-learn
Fungsi confusion_matrix() scikit-learn mengambil label sebenar dan label ramalan, lalu mengembalikan matriks sebagai tatasusunan NumPy. Konvensyen dalam scikit-learn ialah baris = kelas sebenar, lajur = kelas ramalan.
Untuk pengelasan binari dengan label [0, 1], susun atur matriks ialah:
- Baris 0, Lajur 0 = TN (sebenar 0, diramalkan 0)
- Baris 0, Lajur 1 = FP (sebenar 0, diramalkan 1)
- Baris 1, Lajur 0 = FN (sebenar 1, diramalkan 0)
- Baris 1, Lajur 1 = TP (sebenar 1, diramalkan 1)
from sklearn.metrics import confusion_matrix
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)
model = LogisticRegression(max_iter=1000)
model.fit(X_train_s, y_train)
y_pred = model.predict(X_test_s)
cm = confusion_matrix(y_test, y_pred)
print('Confusion matrix:')
print(cm)
print('\nRows=Actual, Cols=Predicted')Memvisualkan Matriks Kekeliruan sebagai heatmap
Matriks kekeliruan yang divisualkan sebagai heatmap menjadikan kiraan mudah dibaca dengan serta-merta. Nombor besar pada pepenjuru (dari kiri atas ke kanan bawah) menunjukkan ramalan yang betul. Nombor besar di luar pepenjuru menunjukkan ralat yang perlu disiasat.
Gunakan heatmap() seaborn dengan annot=True dan fmt='d' untuk memaparkan kiraan integer di dalam setiap sel. Menambahkan nama kelas sasaran menjadikan plot itu mudah difahami tanpa perlu merujuk kepada petunjuk.
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
class_names = ['Malignant', 'Benign'] # breast cancer dataset
plt.figure(figsize=(7, 6))
sns.heatmap(
cm,
annot=True,
fmt='d',
cmap='Blues',
xticklabels=class_names,
yticklabels=class_names
)
plt.ylabel('Actual Label')
plt.xlabel('Predicted Label')
plt.title('Confusion Matrix — Breast Cancer Classifier')
plt.show()Menerbitkan Ketepatan daripada Matriks Kekeliruan
Setiap metrik pengelasan boleh diterbitkan daripada empat sel matriks kekeliruan. Ketepatan ialah yang paling mudah — pecahan ramalan yang berada pada pepenjuru (TP + TN) daripada semua ramalan:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
Semua ramalan adalah betul. Semua ramalan = TP + TN + FP + FN. Jika set ujian anda mempunyai 100 contoh dan anda memperoleh TP=40, TN=50, FP=5, FN=5, maka ketepatan = 90/100 = 0.90. Namun, 5 ralat FN (positif yang terlepas) mungkin jauh lebih besar akibatnya berbanding 5 ralat FP.
from sklearn.metrics import confusion_matrix, accuracy_score
import numpy as np
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
cm = confusion_matrix(y_true, y_pred)
TN, FP, FN, TP = cm.ravel() # for 2x2 matrix
# Manual accuracy
manual_acc = (TP + TN) / (TP + TN + FP + FN)
sklearn_acc = accuracy_score(y_true, y_pred)
print(f'TP={TP}, TN={TN}, FP={FP}, FN={FN}')
print(f'Manual accuracy: {manual_acc:.2f}')
print(f'sklearn accuracy: {sklearn_acc:.2f}')Ralat Jenis I dan Jenis II
Dalam statistik dan ML, ralat mempunyai nama formal yang mencerminkan tahap keseriusannya dalam konteks yang berbeza:
- Ralat Jenis I = Positif Palsu. Anda membunyikan penggera sedangkan tiada apa-apa yang perlu dibimbangkan. Contoh: menandai transaksi sah sebagai penipuan, menghantar seseorang ke hospital tanpa keperluan.
- Ralat Jenis II = Negatif Palsu. Anda terlepas kejadian sebenar. Contoh: meluluskan transaksi penipuan, menghantar pulang pesakit kanser dengan menganggapnya sihat.
Dalam kebanyakan masalah pengelasan dunia sebenar, ralat Jenis I dan Jenis II mempunyai kos yang sangat berbeza. Oleh itu, satu nombor ketepatan sahaja tidak mencukupi untuk membuat keputusan.
Matriks Kekeliruan untuk Masalah Berbilang Kelas
Untuk masalah k kelas, matriks kekeliruan berukuran k×k. Setiap baris mewakili kelas sebenar dan setiap lajur mewakili kelas ramalan. Unsur pada pepenjuru ialah ramalan yang betul; unsur di luar pepenjuru ialah pengelasan yang tersilap.
Matriks kekeliruan berbilang kelas mendedahkan kelas yang paling kerap dikelirukan oleh model. Contohnya, pengecam digit mungkin kerap mengelirukan 4 dengan 9 kerana rupanya serupa. Wawasan ini membantu penambahbaikan yang disasarkan: kumpulkan lebih banyak contoh latihan bagi kelas yang dikelirukan, tambahkan ciri yang membezakannya, atau lakukan pemprosesan selepas ramalan untuk pasangan tertentu itu.
from sklearn.metrics import confusion_matrix
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = DecisionTreeClassifier(max_depth=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(9, 7))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Digit Confusion Matrix (10 classes)')
plt.show()Matriks Kekeliruan Dinormalkan
Apabila kelas mempunyai bilangan contoh yang berbeza (ketidakseimbangan kelas), kiraan mutlak dalam matriks kekeliruan boleh mengelirukan. Matriks kekeliruan dinormalkan membahagikan setiap baris dengan jumlah contoh sebenar dalam kelas tersebut, lalu menukarkan kiraan mentah kepada kadar dapatan semula (bahagian yang dikenal pasti dengan betul).
Pengelas yang sempurna mempunyai 1.0 pada setiap sel pepenjuru dan 0.0 di tempat lain. Matriks yang dinormalkan memudahkan perbandingan prestasi mengikut kelas tanpa mengira saiz kelas.
from sklearn.metrics import confusion_matrix
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
cm = confusion_matrix(y_test, y_pred)
# Normalise by row (actual class total)
cm_norm = cm.astype(float) / cm.sum(axis=1, keepdims=True)
plt.figure(figsize=(9, 7))
sns.heatmap(cm_norm, annot=True, fmt='.2f', cmap='Blues')
plt.ylabel('Actual Class')
plt.xlabel('Predicted Class')
plt.title('Normalised Confusion Matrix (row = recall per class)')
plt.show()
# Per-class recall from diagonal
print('Per-class recall:', np.diag(cm_norm).round(3))ConfusionMatrixDisplay: Alat Rasmi scikit-learn
Scikit-learn menyediakan ConfusionMatrixDisplay sebagai alat aras tinggi untuk memplot matriks kekeliruan tanpa memerlukan seaborn. Anda boleh menciptanya secara langsung daripada tatasusunan matriks kekeliruan atau dengan memanggil from_estimator(), yang menjalankan ramalan secara dalaman.
Menetapkan display_labels kepada nama kelas anda menjadikan plot itu terus dapat menerangkan dirinya sendiri. Paparan itu turut menyertakan bar warna pilihan yang membantu pembaca menganggarkan nilai sebelum membaca nombor tepat.
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
class_names = load_breast_cancer().target_names # ['malignant', 'benign']
# Method 1: from_estimator (runs predict internally)
disp = ConfusionMatrixDisplay.from_estimator(
model,
X_test_s,
y_test,
display_labels=class_names,
cmap='Blues'
)
disp.ax_.set_title('Confusion Matrix')Perkara yang Diberitahu oleh Matriks Kekeliruan kepada Anda
Pengelas yang dilatih dengan baik sepatutnya mempunyai kebanyakan contoh pada pepenjuru. Apabila anda melihat nombor besar di luar pepenjuru, kenal pasti puncanya:
- Banyak FP (positif palsu): model terlalu agresif — rendahkan ambang keputusan atau tambahkan regularisasi.
- Banyak FN (negatif palsu): model terlepas terlalu banyak positif sebenar — rendahkan ambang atau tingkatkan dapatan semula.
- Ralat simetri antara kelas A dan B: kedua-dua kelas terlalu serupa dalam ruang ciri — tambahkan ciri yang membezakannya.
- Ralat tertumpu pada satu kelas sebenar: kelas tersebut kurang diwakili atau lebih sukar dipelajari — lakukan pensampelan berlebihan atau kumpulkan lebih banyak data.
Daripada Matriks Kekeliruan kepada Laporan Pengelasan Lengkap
Setiap metrik dalam classification_report() diterbitkan daripada matriks kekeliruan. Memahami matriks ini bermakna memahami semua metrik serentak. Daripada TP, TN, FP dan FN, anda boleh mengira:
- Ketepatan = (TP+TN)/N
- Kejituan = TP/(TP+FP)
- Dapatan semula = TP/(TP+FN)
- Kekhususan = TN/(TN+FP)
- F1 = 2×Kejituan×Dapatan semula/(Kejituan+Dapatan semula)
Dalam pelajaran seterusnya, anda akan menguasai semua metrik terbitan ini dan mempelajari masa yang sesuai untuk memilih setiap satunya.
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np
y_true = np.array([1, 0, 1, 1, 0, 0, 1, 0, 1, 0])
y_pred = np.array([1, 0, 1, 0, 1, 0, 1, 0, 0, 0])
cm = confusion_matrix(y_true, y_pred)
TN, FP, FN, TP = cm.ravel()
# Compute all metrics from raw counts
precision = TP / (TP + FP) if (TP + FP) > 0 else 0
recall = TP / (TP + FN) if (TP + FN) > 0 else 0
f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
print(f'Precision: {precision:.2f}')
print(f'Recall: {recall:.2f}')
print(f'F1-Score: {f1:.2f}')
print('\nscikit-learn report:')
print(classification_report(y_true, y_pred))Semakan Pantas
Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini, anda telah mempelajari bahawa: matriks kekeliruan memecahkan ralat pengelas kepada Positif Sebenar, Negatif Sebenar, Positif Palsu dan Negatif Palsu, Negatif Palsu (ralat Jenis II) dan Positif Palsu (ralat Jenis I) mempunyai kesan dunia sebenar yang sangat berbeza, dan semua metrik pengelasan — ketepatan, kejituan, dapatan semula dan F1 — diterbitkan daripada empat kiraan dalam matriks kekeliruan ini. Seterusnya, kita akan menguasai kejituan, dapatan semula dan skor F1 dengan lebih mendalam, serta mempelajari pertukaran penting antara ketiga-tiganya yang membimbing penilaian pengelas dalam situasi dunia sebenar.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Penjelasan Matriks Kekeliruan” percuma?
Ya — teks penuh “Penjelasan Matriks Kekeliruan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Penjelasan Matriks Kekeliruan”?
Pelajar akan membina matriks kekeliruan daripada ramalan dan nilai sebenar, kemudian memperoleh bilangan positif benar, negatif palsu dan kiraan berkaitan. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Penjelasan Matriks Kekeliruan” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Daripada Regresi kepada Pengelasan: Keputusan Ambang
- Regresi Logistik dan Fungsi Sigmoid
- Penjelasan Matriks Kekeliruan
- Kejituan, Ingatan Semula dan Skor F1 dalam Amalan