다범주 평가지표 구현¶

import numpy as np

def confusion_matrix(y_true, y_pred, C):
    """C x C 혼동행렬을 만든다.

    이범주에서는 2x2 표 하나로 끝났지만, 범주가 C 개면 C x C 가 된다.
    대각선이 맞힌 것이고, 벗어난 칸은 어느 범주를 어느 범주로 헷갈렸는지를
    말해 준다. 아래의 모든 측도가 이 행렬 하나에서 나온다.

    매개변수
    --------
    y_true : 참 범주 이름표 {0, ..., C-1}
    y_pred : 예측한 범주 이름표
    C : 범주 수

    돌려주는 값
    ----------
    M[j, k] = 참으로 j 인데 k 로 예측한 사례 수
    """
    M = np.zeros((C, C), dtype=int)
    for t, p in zip(y_true, y_pred):
        M[t, p] += 1
    return M

# 아무 자료나 넣어 (1) 의 등식이 성립하는지 단언문으로 확인한다.
rng = np.random.default_rng(0)
C, n = 4, 500
y_t = rng.integers(0, C, n)
y_p = rng.integers(0, C, n)
Mr = confusion_matrix(y_t, y_p, C)

assert Mr.sum() == n
assert np.array_equal(Mr.sum(axis=1), np.bincount(y_t, minlength=C))
assert np.array_equal(Mr.sum(axis=0), np.bincount(y_p, minlength=C))

print(f"총합   {Mr.sum()} = n = {n}")
print(f"행 합  {Mr.sum(axis=1)}  = 참 범주 개수")
print(f"열 합  {Mr.sum(axis=0)}  = 예측 범주 개수")
print(f"열 합 - 행 합 = FP - FN = {Mr.sum(axis=0) - Mr.sum(axis=1)}"
      f"  (합 {(Mr.sum(axis=0) - Mr.sum(axis=1)).sum()})")

# 완벽한 분류기는 참 범주 개수를 대각선에 늘어놓은 행렬을 만든다.
Mp = confusion_matrix(y_t, y_t, C)
print(f"완벽한 분류기의 대각선 {np.diag(Mp)},  대각합 {np.trace(Mp)} = n")
print(f"비대각 원소의 합 {Mp.sum() - np.trace(Mp)}")

총합   500 = n = 500
행 합  [115 110 133 142]  = 참 범주 개수
열 합  [113 125 141 121]  = 예측 범주 개수
열 합 - 행 합 = FP - FN = [ -2  15   8 -21]  (합 0)
완벽한 분류기의 대각선 [115 110 133 142],  대각합 500 = n
비대각 원소의 합 0

# 범주마다 셋씩, 그중 둘을 맞힌 자료다. 아래 측도들을 손으로 따라가며
# 확인하기 좋도록 작게 잡았다.
y_true = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
y_pred = np.array([0, 0, 1, 1, 1, 2, 2, 2, 0])

M = confusion_matrix(y_true, y_pred, C=3)
print(M)
print("행 합", M.sum(axis=1), "열 합", M.sum(axis=0), "총합", M.sum())

[[2 1 0]
 [0 2 1]
 [1 0 2]]
행 합 [3 3 3] 열 합 [3 3 3] 총합 9

def accuracy(M):
    """혼동행렬에서 전체 정확도를 구한다. 대각선의 합을 전체로 나눈 것이다."""
    return np.trace(M) / np.sum(M)

print(f"Accuracy: {accuracy(M):.4f}")
# Accuracy: 0.6667

# 비대각 원소로 센 꼴과 맞는지 본다.
off = M.sum() - np.trace(M)
print(f"오분류 {off}건 / {M.sum()}건,  1 - {off}/{M.sum()} = {1 - off / M.sum():.4f}")

Accuracy: 0.6667
오분류 3건 / 9건,  1 - 3/9 = 0.6667

def per_class_metrics(M):
    """범주마다 정밀도·재현율·F1 을 구한다.

    다범주에서는 범주 하나를 양성으로, 나머지 전부를 음성으로 보고 이범주
    측도를 그대로 쓴다. 정밀도는 열 합으로, 재현율은 행 합으로 나눈다 —
    어느 쪽으로 나누느냐가 둘을 가르는 전부다.
    """
    C = M.shape[0]
    precisions = np.zeros(C)
    recalls = np.zeros(C)
    f1s = np.zeros(C)

    for c in range(C):
        col_sum = M[:, c].sum()       # total predicted as c
        row_sum = M[c, :].sum()       # total truly in class c
        tp = M[c, c]

        precisions[c] = tp / col_sum if col_sum > 0 else 0.0
        recalls[c] = tp / row_sum if row_sum > 0 else 0.0
        if precisions[c] + recalls[c] > 0:
            f1s[c] = 2 * precisions[c] * recalls[c] / (precisions[c] + recalls[c])

    return precisions, recalls, f1s

prec, rec, f1 = per_class_metrics(M)
for c in range(3):
    print(f"Class {c}: Prec={prec[c]:.3f}  Rec={rec[c]:.3f}  F1={f1[c]:.3f}")

# FP 와 FN 이 범주마다 같은지 — (2) 의 조건 — 확인한다.
print(f"FP {M.sum(axis=0) - np.diag(M)},  FN {M.sum(axis=1) - np.diag(M)}")

Class 0: Prec=0.667  Rec=0.667  F1=0.667
Class 1: Prec=0.667  Rec=0.667  F1=0.667
Class 2: Prec=0.667  Rec=0.667  F1=0.667
FP [1 1 1],  FN [1 1 1]

def macro_f1(M):
    """거시평균 F1. 범주마다의 F1 을 그냥 평균한다.

    범주 크기를 무시하므로 작은 범주도 큰 범주와 같은 무게를 갖는다.
    희귀 범주의 성능이 중요할 때 이쪽을 본다.
    """
    _, _, f1s = per_class_metrics(M)
    return np.mean(f1s)

def micro_f1(M):
    """미시평균 F1. 범주를 가리지 않고 TP·FP·FN 을 모두 더한 뒤 계산한다.

    사례마다 같은 무게를 주므로 큰 범주가 결과를 좌우한다. 단일 이름표
    분류에서는 미시평균 F1 이 전체 정확도와 정확히 같아진다.
    """
    C = M.shape[0]
    tp_total = fp_total = fn_total = 0
    for c in range(C):
        tp = M[c, c]
        fp = M[:, c].sum() - tp
        fn = M[c, :].sum() - tp
        tp_total += tp
        fp_total += fp
        fn_total += fn
    prec = tp_total / (tp_total + fp_total) if (tp_total + fp_total) > 0 else 0
    rec = tp_total / (tp_total + fn_total) if (tp_total + fn_total) > 0 else 0
    if prec + rec == 0:
        return 0.0
    return 2 * prec * rec / (prec + rec)

print(f"Macro F1: {macro_f1(M):.4f}")
print(f"Micro F1: {micro_f1(M):.4f}")
print(f"Accuracy: {accuracy(M):.4f}   <- 미시 F1 과 같아야 한다")

# 어긋나는 보기: 언제나 "건강" 만 예측하는 선별검사.
M_screen = np.array([[900, 0, 0], [70, 0, 0], [30, 0, 0]])
print(f"선별검사  정확도 {accuracy(M_screen):.4f}"
      f"  미시 F1 {micro_f1(M_screen):.4f}"
      f"  거시 F1 {macro_f1(M_screen):.4f}")

Macro F1: 0.6667
Micro F1: 0.6667
Accuracy: 0.6667   <- 미시 F1 과 같아야 한다
선별검사  정확도 0.9000  미시 F1 0.9000  거시 F1 0.3158

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix as sk_confusion_matrix

# 직접 구현한 것이 sklearn 과 맞는지 실제 자료에서 확인한다.
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42)

clf = LogisticRegression(solver='lbfgs', max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

C = 3
M_ours = confusion_matrix(y_test, y_pred, C)
M_sklearn = sk_confusion_matrix(y_test, y_pred)

print("Our confusion matrix:")
print(M_ours)
print("\nscikit-learn confusion matrix:")
print(M_sklearn)
print("\nscikit-learn classification report:")
print(classification_report(y_test, y_pred, digits=4))
print(f"Our Macro F1:  {macro_f1(M_ours):.4f}")
print(f"Our Micro F1:  {micro_f1(M_ours):.4f}")

Our confusion matrix:
[[19  0  0]
 [ 0 13  0]
 [ 0  0 13]]

scikit-learn confusion matrix:
[[19  0  0]
 [ 0 13  0]
 [ 0  0 13]]

scikit-learn classification report:
              precision    recall  f1-score   support

           0     1.0000    1.0000    1.0000        19
           1     1.0000    1.0000    1.0000        13
           2     1.0000    1.0000    1.0000        13

    accuracy                         1.0000        45
   macro avg     1.0000    1.0000    1.0000        45
weighted avg     1.0000    1.0000    1.0000        45

Our Macro F1:  1.0000
Our Micro F1:  1.0000

import matplotlib.pyplot as plt

def plot_confusion_matrix(M, class_names=None):
    """혼동행렬을 열지도로 그린다.

    범주가 많으면 숫자표만으로는 어디가 문제인지 눈에 들어오지 않는다.
    색으로 칠하면 대각선을 벗어난 짙은 칸이 바로 보인다.
    """
    C = M.shape[0]
    if class_names is None:
        class_names = [str(i) for i in range(C)]

    fig, ax = plt.subplots(figsize=(5, 4))
    im = ax.imshow(M, cmap='Blues')
    ax.set_xticks(range(C))
    ax.set_yticks(range(C))
    ax.set_xticklabels(class_names)
    ax.set_yticklabels(class_names)
    ax.set_xlabel("Predicted")
    ax.set_ylabel("True")
    ax.set_title("Confusion Matrix")

    for i in range(C):
        for j in range(C):
            ax.text(j, i, str(M[i, j]), ha='center', va='center',
                    color='white' if M[i, j] > M.max() / 2 else 'black')

    fig.colorbar(im)
    plt.tight_layout()
    plt.show()

plot_confusion_matrix(M_ours, class_names=iris.target_names)

print(f"색 눈금 0 ~ {M_ours.max()},  대각 칸 {np.diag(M_ours)}"
      f" -> 색의 짙기 {np.round(np.diag(M_ours) / M_ours.max(), 3)}")

# 치우친 보기에서 날것의 도수가 무엇을 가리는지 본다.
M_bad = np.array([[870, 20, 10], [40, 30, 0], [30, 0, 0]])
print(f"색 눈금 0 ~ {M_bad.max()},  범주 2 의 칸들 {M_bad[2]}"
      f" -> 색의 짙기 {np.round(M_bad[2] / M_bad.max(), 4)}")
rownorm = M_bad / M_bad.sum(axis=1, keepdims=True)
print(f"행으로 정규화한 대각선(= 재현율) {np.round(np.diag(rownorm), 3)}")
print(f"정확도 {accuracy(M_bad):.4f}")

색 눈금 0 ~ 19,  대각 칸 [19 13 13] -> 색의 짙기 [1.    0.684 0.684]
색 눈금 0 ~ 870,  범주 2 의 칸들 [30  0  0] -> 색의 짙기 [0.0345 0.     0.    ]
행으로 정규화한 대각선(= 재현율) [0.967 0.429 0.   ]
정확도 0.9000

def weighted_f1(M):
    """가중평균 F1. 범주별 F1 을 그 범주의 크기로 가중해 평균한다.

        거시평균과 미시평균의 사이에 놓인다. 범주 크기를 반영하되 범주별
        성능을 따로 셈에 넣고 싶을 때 쓴다.
        """
    _, _, f1s = per_class_metrics(M)
    supports = M.sum(axis=1)          # row sums = class sizes
    total = supports.sum()
    return np.sum(f1s * supports) / total