Tôi đang tự hỏi làm thế nào để tính toán các biện pháp chính xác và thu hồi để phân loại đa nhãn, nghĩa là phân loại có nhiều hơn hai nhãn và mỗi trường hợp có thể có nhiều nhãn?

Một công cụ phổ biến khác để đo hiệu suất phân loại là ROC / AUC ; cái này cũng có phần mở rộng đa lớp / đa nhãn: xem [Hand 2001]

[Hand 2001]: Một khái quát đơn giản của khu vực dưới đường cong ROC cho nhiều vấn đề phân loại lớp

Dưới đây là một số thảo luận về chủ đề diễn đàn coursera về ma trận nhầm lẫn và phép đo chính xác / thu hồi đa lớp.

Ý tưởng cơ bản là tính toán tất cả độ chính xác và thu hồi tất cả các lớp, sau đó lấy trung bình chúng để có được một phép đo số thực duy nhất.

Ma trận nhầm lẫn giúp dễ dàng tính toán độ chính xác và thu hồi của một lớp.

Dưới đây là một số giải thích cơ bản về ma trận nhầm lẫn, được sao chép từ chuỗi đó:

Ma trận nhầm lẫn là một cách phân loại dương tính thật, âm tính thật, dương tính giả và âm tính giả, khi có nhiều hơn 2 lớp. Nó được sử dụng để tính toán độ chính xác và thu hồi và do đó điểm F1 cho các vấn đề đa lớp.

Các giá trị thực tế được đại diện bởi các cột. Các giá trị dự đoán được đại diện bởi các hàng.

Ví dụ:

10 ví dụ đào tạo thực tế là 8, được phân loại (dự đoán) không chính xác là 5
13 ví dụ đào tạo thực sự là 4, được phân loại không chính xác là 9

Ma trận hỗn loạn

cm =
     0 1 2 3 4 5 6 7 8 9 10
     1 298 2 1 0 1 1 3 1 1 0
     2 0 293 7 4 1 0 5 2 0 0
     3 1 3 263 0 8 0 0 3 0 2
     4 1 5 0 261 4 0 3 2 0 1
     5 0 0 10 0 254 3 0 10 2 1
     6 0 4 1 1 4 300 0 1 0 0
     7 1 3 2 0 0 0 264 0 7 1
     8 3 5 3 1 7 1 0 289 1 0
     9 0 1 3 13 1 0 11 1 289 0
    10 0 6 0 1 6 1 2 1 4 304

Đối với lớp x:

• Đúng dương: vị trí đường chéo, cm (x, x).

• Sai dương: tổng của cột x (không có đường chéo chính), tổng (cm (:, x)) - cm (x, x).

• Sai âm: tổng của hàng x (không có đường chéo chính), sum (cm (x, :), 2) -cm (x, x).

Bạn có thể tính toán độ chính xác, thu hồi và điểm F1 theo công thức khóa học.

Tính trung bình trên tất cả các lớp (có hoặc không có trọng số) mang lại giá trị cho toàn bộ mô hình.

Để phân loại nhiều nhãn, bạn có hai cách để đi Trước tiên hãy xem xét các điều sau.

• $n$
• $Y_i$$i^{th}$
• $x_i$$i^{th}$
• $h(x_i)$$i^{th}$

Dựa trên ví dụ

Các số liệu được tính toán theo cách thức dữ liệu. Đối với mỗi nhãn dự đoán, chỉ có điểm của nó được tính và sau đó các điểm này được tổng hợp trên tất cả các điểm dữ liệu.

• $\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|h(x_{i})|}$
• $\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|Y_{i}|}$

Có những số liệu khác là tốt.

Dựa trên nhãn

Ở đây những điều được thực hiện nhãn khôn ngoan. Đối với mỗi nhãn, các số liệu (ví dụ: độ chính xác, thu hồi) được tính toán và sau đó các số liệu thông minh về nhãn này được tổng hợp. Do đó, trong trường hợp này, bạn kết thúc việc tính toán độ chính xác / thu hồi cho mỗi nhãn trên toàn bộ tập dữ liệu, như bạn thực hiện để phân loại nhị phân (vì mỗi nhãn có gán nhị phân), sau đó tổng hợp nó.

Cách dễ dàng là trình bày các hình thức chung.

Đây chỉ là một phần mở rộng của tương đương nhiều lớp tiêu chuẩn.

• $\frac{1}{q}\sum_{j=1}^{q}B(TP_{j},FP_{j},TN_{j},FN_{j})$

• $B(\sum_{j=1}^{q}TP_{j},\sum_{j=1}^{q}FP_{j},\sum_{j=1}^{q}TN_{j},\sum_{j=1}^{q}FN_{j})$

$TP_{j},FP_{j},TN_{j},FN_{j}$$j^{th}$

$B$

Bạn có thể quan tâm để có một cái nhìn vào mã cho các số liệu mult-nhãn ở đây , đó là một phần của gói mldr trong R . Ngoài ra, bạn có thể quan tâm đến việc xem xét thư viện đa nhãn Java MULAN .

Đây là một bài viết hay để đi vào các số liệu khác nhau: Đánh giá về các thuật toán học tập đa nhãn

Tôi không biết về phần đa nhãn nhưng đối với phân loại lớp mutli, các liên kết đó sẽ giúp bạn

Liên kết này giải thích cách xây dựng ma trận nhầm lẫn mà bạn có thể sử dụng để tính độ chính xác và thu hồi cho từng danh mục

Và liên kết này giải thích cách tính toán các biện pháp micro-F1 và macro-F1 để đánh giá toàn bộ phân loại.

Hy vọng rằng bạn thấy rằng hữu ích.

liên kết này đã giúp tôi .. https://www.youtube.com/watch?v=HBi-P5j0Kec tôi hy vọng nó cũng sẽ giúp bạn

nói phân phối như dưới đây

    A   B   C   D
A   100 80  10  10
B   0    9   0   1
C   0    1   8   1
D   0    1   0   9

độ chính xác cho A sẽ là

P (A) = 100/100 + 0 + 0 +0 = 100

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... về cơ bản lấy tích cực thực sự của lớp và chia cho dữ liệu cột giữa các hàng

nhớ lại cho một

R (A) = 100 / 100+ 80 + 10 + 10 = 0,5

R (B) = 9 / 9+ 0 + 0 + 1 = 0,9

psst ... về cơ bản lấy tích cực thực sự của lớp và chia cho dữ liệu hàng trên các cột

một khi bạn nhận được tất cả các giá trị, lấy trung bình vĩ mô

avg (P) = P (A) + P (B) + P (C) + P (D) / 4

avg (R) = R (A) + R (B) + R (C) + R (D) / 4

F1 = 2 * avg (P) * avg (R) / avg (P) + avg (R)

Kiểm tra các slide này từ cs205.org tại Harvard . Khi bạn đến phần về Các biện pháp lỗi, sẽ có thảo luận về độ chính xác và thu hồi trong cài đặt nhiều lớp (ví dụ: một đấu một hoặc tất cả hoặc một đấu một) và ma trận nhầm lẫn. Ma trận nhầm lẫn là những gì bạn thực sự muốn ở đây.

FYI, trong gói phần mềm Python scikits.learn , có các phương thức tích hợp để tự động tính toán những thứ như ma trận nhầm lẫn từ các trình phân loại được đào tạo trên dữ liệu nhiều lớp. Nó có thể có thể trực tiếp tính toán các lô thu hồi chính xác cho bạn. Đáng xem.

Từ Ozgur et al (2005) có thể thấy rằng bạn nên tính Chính xác và Nhớ lại theo các biểu thức bình thường, nhưng thay vì tính trung bình trên tổng số N trường hợp trong tập dữ liệu của bạn, bạn nên sử dụng N = [trường hợp có ít nhất một nhãn với lớp trong câu hỏi được giao cho].

đây là tài liệu tham khảo được đề cập: http://citeseerx.ist.psu.edu/viewdoc/doad?doi=10.1.1.104.8244&rep=rep1&type=pdf

Chính xác giống như cách bạn sẽ làm trong trường hợp chung, với các bộ:

http://en.wikipedia.org/wiki/F1_score

http://en.wikipedia.org/wiki/Precision_and_recall

Dưới đây là các hàm Python đơn giản thực hiện chính xác điều đó:

def precision(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    len1 = len(y_pred)
    if len1 == 0:
        return 0
    else:
        return len(i) / len1


def recall(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    return len(i) / len(y_true)


def f1(y_true, y_pred):
    p = precision(y_true, y_pred)
    r = recall(y_true, y_pred)
    if p + r == 0:
        return 0
    else:
        return 2 * (p * r) / (p + r)


if __name__ == '__main__':
    print(f1(['A', 'B', 'C'], ['A', 'B']))