ClassificationMetric

Tính thước đo phân loại để đánh giá chất lượng của dữ liệu dự đoán so với dữ liệu thực tế. Phương thức này được áp dụng cho vector của các giá trị dự đoán.

vector vector::ClassificationMetric(
   const vector&              vect_true,     // vector của giá trị thực tế
   ENUM_CLASSIFICATION_METRIC metric         // loại thước đo
);

vector vector::ClassificationMetric(
   const vector&              vect_true,     // vector của giá trị thực tế
   ENUM_CLASSIFICATION_METRIC metric,        // loại thước đo
   ENUM_AVERAGE_MODE          mode           // chế độ trung bình
);

Tham số

vect_true

[in] Vector của các giá trị thực tế.

metric

[in] Loại thước đo từ liệt kê ENUM_CLASSIFICATION_METRIC. Các giá trị khác ngoài CLASSIFICATION_TOP_K_ACCURACY, CLASSIFICATION_AVERAGE_PRECISION và CLASSIFICATION_ROC_AUC (được sử dụng trong phương thức ClassificationScore) được áp dụng.

mode

[in] Chế độ trung bình từ liệt kê ENUM_AVERAGE_MODE. Được sử dụng cho các thước đo CLASSIFICATION_F1, CLASSIFICATION_JACCARD, CLASSIFICATION_PRECISION và CLASSIFICATION_RECALL.

Giá trị trả về

Một vector chứa thước đo đã tính toán. Trong trường hợp chế độ trung bình AVERAGE_NONE, vector chứa các giá trị thước đo cho từng lớp mà không tính trung bình. (Ví dụ, trong trường hợp phân loại nhị phân, sẽ có hai thước đo cho false và true tương ứng).

Ghi chú về chế độ trung bình

AVERAGE_BINARY chỉ có ý nghĩa đối với phân loại nhị phân.

AVERAGE_MICRO — tính toán thước đo toàn cục bằng cách đếm tổng số dương tính thực, âm tính giả và dương tính giả.

AVERAGE_MACRO — tính toán thước đo cho từng nhãn và tìm trung bình không trọng số của chúng. Điều này không tính đến sự mất cân bằng nhãn.

AVERAGE_WEIGHTED — tính toán thước đo cho từng nhãn và tìm trung bình có trọng số dựa trên hỗ trợ (số lượng mẫu thực tế cho mỗi nhãn). Điều này thay đổi macro để tính đến sự mất cân bằng nhãn; nó có thể dẫn đến điểm F không nằm giữa độ chính xác và độ nhạy.

Ghi chú

Trong trường hợp phân loại nhị phân, chúng ta có thể nhập không chỉ ma trận n x 2, trong đó cột đầu tiên chứa xác suất cho nhãn âm, và cột thứ hai chứa xác suất cho nhãn dương, mà còn một ma trận chỉ gồm một cột với xác suất dương. Điều này là do các mô hình phân loại nhị phân có thể trả về hai xác suất hoặc một xác suất cho nhãn dương.

Ví dụ:

vector y_true={7,2,1,0,4,1,4,9,5,9,0,6,9,0,1,5,9,7,3,4,8,4,2,7,6,8,4,2,3,6};
vector y_pred={7,2,1,0,4,1,4,9,5,9,0,6,9,0,1,5,9,7,3,4,2,9,4,9,5,9,2,7,7,0};

vector accuracy=y_pred.ClassificationMetric(y_true,CLASSIFICATION_ACCURACY);
Print("accuracy=",accuracy);
vector balanced=y_pred.ClassificationMetric(y_true,CLASSIFICATION_BALANCED_ACCURACY);
Print("balanced=",balanced);
Print("");

vector f1_micro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_F1,AVERAGE_MICRO);
Print("f1_micro=",f1_micro);
vector f1_macro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_F1,AVERAGE_MACRO);
Print("f1_macro=",f1_macro);
vector f1_weighted=y_pred.ClassificationMetric(y_true,CLASSIFICATION_F1,AVERAGE_WEIGHTED);
Print("f1_weighted=",f1_weighted);
vector f1_none=y_pred.ClassificationMetric(y_true,CLASSIFICATION_F1,AVERAGE_NONE);
Print("f1_none=",f1_none);
Print("");

vector jaccard_micro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_JACCARD,AVERAGE_MICRO);
Print("jaccard_micro=",jaccard_micro);
vector jaccard_macro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_JACCARD,AVERAGE_MACRO);
Print("jaccard_macro=",jaccard_macro);
vector jaccard_weighted=y_pred.ClassificationMetric(y_true,CLASSIFICATION_JACCARD,AVERAGE_WEIGHTED);
Print("jaccard_weighted=",jaccard_weighted);
vector jaccard_none=y_pred.ClassificationMetric(y_true,CLASSIFICATION_JACCARD,AVERAGE_NONE);
Print("jaccard_none=",jaccard_none);
Print("");

vector precision_micro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_PRECISION,AVERAGE_MICRO);
Print("precision_micro=",precision_micro);
vector precision_macro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_PRECISION,AVERAGE_MACRO);
Print("precision_macro=",precision_macro);
vector precision_weighted=y_pred.ClassificationMetric(y_true,CLASSIFICATION_PRECISION,AVERAGE_WEIGHTED);
Print("precision_weighted=",precision_weighted);
vector precision_none=y_pred.ClassificationMetric(y_true,CLASSIFICATION_PRECISION,AVERAGE_NONE);
Print("precision_none=",precision_none);
Print("");

vector recall_micro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_RECALL,AVERAGE_MICRO);
Print("recall_micro=",recall_micro);
vector recall_macro=y_pred.ClassificationMetric(y_true,CLASSIFICATION_RECALL,AVERAGE_MACRO);
Print("recall_macro=",recall_macro);
vector recall_weighted=y_pred.ClassificationMetric(y_true,CLASSIFICATION_RECALL,AVERAGE_WEIGHTED);
Print("recall_weighted=",recall_weighted);
vector recall_none=y_pred.ClassificationMetric(y_true,CLASSIFICATION_RECALL,AVERAGE_NONE);
Print("recall_none=",recall_none);
Print("");

//--- phân loại nhị phân
vector y_pred_bin={0,1,0,1,1,0,0,0,1};
vector y_true_bin={1,0,0,0,1,0,1,1,1};

vector f1_bin=y_pred_bin.ClassificationMetric(y_true_bin,CLASSIFICATION_F1,AVERAGE_BINARY);
Print("f1_bin=",f1_bin);
vector jaccard_bin=y_pred_bin.ClassificationMetric(y_true_bin,CLASSIFICATION_JACCARD,AVERAGE_BINARY);
Print("jaccard_bin=",jaccard_bin);
vector precision_bin=y_pred_bin.ClassificationMetric(y_true_bin,CLASSIFICATION_PRECISION,AVERAGE_BINARY);
Print("precision_bin=",precision_bin);
vector recall_bin=y_pred_bin.ClassificationMetric(y_true_bin,CLASSIFICATION_RECALL,AVERAGE_BINARY);
Print("recall_bin=",recall_bin);

/*
  accuracy=[0.6666666666666666]
  balanced=[0.6433333333333333]

  f1_micro=[0.6666666666666666]
  f1_macro=[0.6122510822510823]
  f1_weighted=[0.632049062049062]
  f1_none=[0.8571428571428571,1,0.3333333333333333,0.6666666666666666,0.6666666666666665,0.8,0.5,0.5714285714285715,0,0.7272727272727273]

  jaccard_micro=[0.5]
  jaccard_macro=[0.4921428571428572]
  jaccard_weighted=[0.5056349206349205]
  jaccard_none=[0.75,1,0.2,0.5,0.5,0.6666666666666666,0.3333333333333333,0.4,0,0.5714285714285714]

  precision_micro=[0.6666666666666666]
  precision_macro=[0.6571428571428571]
  precision_weighted=[0.6706349206349207]
  precision_none=[0.75,1,0.3333333333333333,1,0.75,0.6666666666666666,1,0.5,0,0.5714285714285714]

  recall_micro=[0.6666666666666666]
  recall_macro=[0.6433333333333333]
  recall_weighted=[0.6666666666666666]
  recall_none=[1,1,0.3333333333333333,0.5,0.6,1,0.3333333333333333,0.6666666666666666,0,1]

  f1_bin=[0.4444444444444445]
  jaccard_bin=[0.2857142857142857]
  precision_bin=[0.5]
  recall_bin=[0.4]
*/