Macierz pomyłek wyjaśniona
Utwórz macierz pomyłek na podstawie predykcji i wartości rzeczywistych, a następnie wyznacz prawdziwie dodatnie, fałszywie ujemne i powiązane liczności.
Macierz pomyłek wyjaśniona to bezpłatna lekcja Machine Learning Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Machine Learning Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Poza dokładnością: zrozumienie błędów
Dokładność informuje o odsetku poprawnych predykcji, ale traktuje wszystkie błędy jednakowo. W rzeczywistości różne rodzaje błędów mają bardzo różne konsekwencje. Filtr antyspamowy, który przenosi prawidłową wiadomość do folderu spamu, jest irytujący; model diagnozy medycznej, który nie wykrywa przypadku raka, może zagrażać życiu.
Macierz pomyłek to narzędzie, które rozkłada działanie klasyfikatora na tabelę 2×2 (w przypadku klasyfikacji binarnej), pokazując każdą możliwą kombinację etykiet rzeczywistych i przewidywanych. Ujawnia nie tylko, jak bardzo model się myli, ale także w jaki sposób to robi.
Cztery pola macierzy pomyłek
W klasyfikacji binarnej z klasami Positive (1) i Negative (0) macierz pomyłek ma cztery pola:
- True Positive (TP) — rzeczywiście pozytywny, przewidziany jako pozytywny. Poprawne wykrycie.
- True Negative (TN) — rzeczywiście negatywny, przewidziany jako negatywny. Poprawne odrzucenie.
- False Positive (FP) — rzeczywiście negatywny, przewidziany jako pozytywny. Błąd I rodzaju; fałszywy alarm.
- False Negative (FN) — rzeczywiście pozytywny, przewidziany jako negatywny. Błąd II rodzaju; przeoczenie.
Do pełnego scharakteryzowania działania klasyfikatora potrzebne są wszystkie cztery wartości.
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}')Budowanie macierzy pomyłek za pomocą scikit-learn
Funkcja confusion_matrix() biblioteki scikit-learn przyjmuje rzeczywiste i przewidywane etykiety, a następnie zwraca macierz jako tablicę NumPy. W scikit-learn obowiązuje konwencja: wiersze = rzeczywista klasa, kolumny = przewidywana klasa.
W przypadku klasyfikacji binarnej z etykietami [0, 1] układ macierzy jest następujący:
- Row 0, Col 0 = TN (rzeczywiste 0, przewidziane 0)
- Row 0, Col 1 = FP (rzeczywiste 0, przewidziane 1)
- Row 1, Col 0 = FN (rzeczywiste 1, przewidziane 0)
- Row 1, Col 1 = TP (rzeczywiste 1, przewidziane 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')Wizualizacja macierzy pomyłek jako mapy cieplnej
Wizualizacja macierzy pomyłek jako mapa cieplna sprawia, że wartości są od razu czytelne. Duże liczby na przekątnej (od lewego górnego do prawego dolnego rogu) wskazują poprawne predykcje. Duże liczby poza przekątną wskazują błędy wymagające analizy.
Użyj funkcji heatmap() biblioteki seaborn z parametrami annot=True i fmt='d', aby wyświetlić całkowite liczby wewnątrz poszczególnych pól. Dodanie nazw klas docelowych sprawia, że wykres jest zrozumiały bez konieczności korzystania z legendy.
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()Wyprowadzanie dokładności z macierzy pomyłek
Każdą metrykę klasyfikacji można wyprowadzić z czterech pól macierzy pomyłek. Dokładność jest najprostszą z nich — to ułamek predykcji znajdujących się na przekątnej (TP + TN) w stosunku do wszystkich predykcji:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
Wszystkie predykcje są poprawne. Wszystkie predykcje = TP + TN + FP + FN. Jeśli zbiór testowy zawiera 100 przykładów, a TP=40, TN=50, FP=5, FN=5, wtedy dokładność = 90/100 = 0.90. Jednak 5 błędów FN (przeoczonych przypadków pozytywnych) może mieć znacznie poważniejsze konsekwencje niż 5 błędów 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}')Błędy I i II rodzaju
W statystyce i uczeniu maszynowym błędy mają formalne nazwy odzwierciedlające ich znaczenie w różnych kontekstach:
- Błąd I rodzaju = False Positive. Podnoszą Państwo alarm, mimo że nie ma powodu do obaw. Przykład: oznaczenie prawidłowej transakcji jako oszustwa, niepotrzebne wysłanie kogoś do szpitala.
- Błąd II rodzaju = False Negative. Przeoczają Państwo rzeczywiste zdarzenie. Przykład: zatwierdzenie oszukańczej transakcji, odesłanie osoby chorej na raka do domu jako zdrowej.
W większości rzeczywistych problemów klasyfikacyjnych błędy I i II rodzaju mają zupełnie różne koszty, dlatego pojedyncza wartość dokładności nie wystarcza do podejmowania decyzji.
Macierz pomyłek w problemach wieloklasowych
W problemie obejmującym k klas macierz pomyłek ma rozmiar k×k. Każdy wiersz reprezentuje rzeczywistą klasę, a każda kolumna — przewidywaną klasę. Elementy na przekątnej oznaczają poprawne predykcje, a elementy poza przekątną — błędne klasyfikacje.
Wieloklasowe macierze pomyłek pokazują, które klasy model najczęściej ze sobą myli. Na przykład rozpoznawarka cyfr może często mylić cyfry 4 i 9, ponieważ wyglądają podobnie. Taka wiedza pomaga ukierunkować ulepszenia: zebrać więcej przykładów treningowych mylonych klas, dodać cechy, które je odróżniają, albo przetwarzać końcowo predykcje dla konkretnych par.
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()Znormalizowana macierz pomyłek
Gdy klasy mają różną liczbę przykładów (niezrównoważenie klas), bezwzględne wartości w macierzy pomyłek mogą wprowadzać w błąd. Znormalizowana macierz pomyłek dzieli każdy wiersz przez całkowitą liczbę rzeczywistych przykładów danej klasy, przekształcając surowe liczby w wartości czułości (odsetek poprawnie rozpoznanych przykładów).
W przypadku idealnego klasyfikatora każda komórka na przekątnej ma wartość 1.0, a wszystkie pozostałe — 0.0. Znormalizowana macierz ułatwia porównywanie jakości dla poszczególnych klas niezależnie od ich liczebności.
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: oficjalne narzędzie scikit-learn
Scikit-learn udostępnia ConfusionMatrixDisplay jako wysokopoziomowe narzędzie do tworzenia wykresów macierzy pomyłek bez konieczności używania seaborn. Można utworzyć je bezpośrednio z tablicy macierzy pomyłek albo wywołać from_estimator(), które wewnętrznie wykonuje predykcję.
Ustawienie display_labels na nazwy klas sprawia, że wykres staje się od razu zrozumiały. Widok zawiera także opcjonalny pasek kolorów, który pomaga czytelnikom oszacować wartości przed odczytaniem dokładnych liczb.
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')Co pokazuje macierz pomyłek
Dobrze wytrenowany klasyfikator powinien mieć większość przykładów na przekątnej. Gdy widzą Państwo duże wartości poza przekątną, należy zdiagnozować przyczynę:
- Wiele FP (false positives): model jest zbyt agresywny — należy obniżyć próg decyzyjny lub dodać regularyzację.
- Wiele FN (false negatives): model pomija zbyt wiele rzeczywistych przypadków pozytywnych — należy obniżyć próg lub poprawić czułość.
- Symetryczne błędy między klasami A i B: obie klasy są zbyt podobne w przestrzeni cech — należy dodać cechy je rozróżniające.
- Błędy skupione w jednej rzeczywistej klasie: ta klasa jest niedostatecznie reprezentowana lub trudniejsza do nauczenia — należy zastosować nadpróbkowanie albo zebrać więcej danych.
Od macierzy pomyłek do pełnego raportu klasyfikacji
Każda metryka w classification_report() jest wyprowadzana z macierzy pomyłek. Zrozumienie tej macierzy oznacza jednoczesne zrozumienie wszystkich metryk. Na podstawie TP, TN, FP i FN można obliczyć:
- Accuracy = (TP+TN)/N
- Precision = TP/(TP+FP)
- Recall = TP/(TP+FN)
- Specificity = TN/(TN+FP)
- F1 = 2×Precision×Recall/(Precision+Recall)
W następnej lekcji opanują Państwo wszystkie te metryki pochodne i dowiedzą się, kiedy każda z nich jest właściwym wyborem.
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))Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat koncepcji uczenia maszynowego w Pythonie omówionych w tej lekcji.
Podsumowanie lekcji
W tej lekcji nauczyli się Państwo, że: macierz pomyłek rozkłada błędy klasyfikatora na przypadki True Positive, True Negative, False Positive i False Negative, False Negative (błędy typu II) i False Positive (błędy typu I) mają bardzo różne konsekwencje w świecie rzeczywistym, a wszystkie metryki klasyfikacji — accuracy, precision, recall i F1 — są wyprowadzane z tych czterech wartości macierzy pomyłek. Następnie szczegółowo omówimy precision, recall i F1-score oraz poznamy kluczowy kompromis między nimi, który pomaga oceniać klasyfikatory stosowane w rzeczywistych zastosowaniach.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 30
- Lekcje
- 120
Często zadawane pytania
Czy lekcja „Macierz pomyłek wyjaśniona” jest bezpłatna?
Tak — pełny tekst „Macierz pomyłek wyjaśniona” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Machine Learning Academy, przejdź na CoddyKit PRO. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Macierz pomyłek wyjaśniona”?
Utwórz macierz pomyłek na podstawie predykcji i wartości rzeczywistych, a następnie wyznacz prawdziwie dodatnie, fałszywie ujemne i powiązane liczności. Ćwiczysz Machine Learning Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Machine Learning Academy?
Nie wymagamy żadnego doświadczenia. Machine Learning Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Macierz pomyłek wyjaśniona”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Machine Learning Academy?
Tak. Każda lekcja Machine Learning Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Od regresji do klasyfikacji: decyzje progowe
- Regresja logistyczna i funkcja sigmoid
- Macierz pomyłek wyjaśniona
- Precyzja, czułość i F1-score w praktyce