Saya bertanya-tanya bagaimana cara menghitung pengukuran presisi dan penarikan untuk klasifikasi multilabel multilabel, yaitu klasifikasi di mana terdapat lebih dari dua label, dan di mana setiap instance dapat memiliki beberapa label?

Alat lain yang populer untuk mengukur kinerja classifier adalah ROC / AUC ; yang satu ini juga memiliki ekstensi multi-kelas / multi-label: lihat [Hand 2001]

[Hand 2001]: Generalisasi sederhana dari area di bawah kurva ROC ke berbagai masalah klasifikasi kelas

Berikut adalah beberapa diskusi tentang topik forum coursera tentang matriks kebingungan dan pengukuran presisi / recall multi-kelas.

Ide dasarnya adalah untuk menghitung semua presisi dan memanggil kembali semua kelas, kemudian rata-rata mereka untuk mendapatkan pengukuran bilangan real tunggal.

Matriks kebingungan memudahkan untuk menghitung presisi dan penarikan kembali suatu kelas.

Di bawah ini adalah beberapa penjelasan dasar tentang matriks kebingungan, disalin dari utas itu:

Matriks kebingungan adalah cara untuk mengklasifikasikan positif sejati, negatif sejati, positif palsu, dan negatif palsu, ketika ada lebih dari 2 kelas. Ini digunakan untuk menghitung presisi dan daya ingat dan karenanya skor f1 untuk masalah multi-kelas.

Nilai aktual diwakili oleh kolom. Nilai prediksi diwakili oleh baris.

Contoh:

10 contoh pelatihan yang sebenarnya 8, diklasifikasikan (diperkirakan) salah sebagai 5
13 contoh pelatihan yang sebenarnya 4, diklasifikasikan salah 9

Matriks Kebingungan

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

Untuk kelas x:

• Benar positif: posisi diagonal, cm (x, x).

• False positive: jumlah kolom x (tanpa diagonal utama), jumlah (cm (:, x)) - cm (x, x).

• False negative: jumlah baris x (tanpa diagonal utama), jumlah (cm (x, :), 2) -cm (x, x).

Anda dapat menghitung ketepatan, mengingat dan skor F1 mengikuti rumus kursus.

Rata-rata semua kelas (dengan atau tanpa bobot) memberikan nilai untuk seluruh model.

Untuk klasifikasi multi-label Anda memiliki dua cara untuk pergi Pertama pertimbangkan yang berikut ini.

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

Berbasis contoh

Metrik dihitung dengan cara per titik data. Untuk setiap label yang diprediksi, hanya skornya yang dihitung, dan kemudian skor ini dikumpulkan di semua titik data.

• $\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}|}$

Ada metrik lain juga.

Berbasis label

Di sini hal-hal dilakukan label-bijaksana. Untuk setiap label, metrik (mis. Presisi, penarikan kembali) dihitung dan kemudian metrik bijaksana-label ini dikumpulkan. Oleh karena itu, dalam hal ini Anda akhirnya menghitung presisi / recall untuk setiap label di seluruh dataset, seperti yang Anda lakukan untuk klasifikasi biner (karena masing-masing label memiliki tugas biner), kemudian menggabungkannya.

Cara mudah adalah mempresentasikan bentuk umum.

Ini hanyalah perpanjangan dari standar multi-kelas yang setara.

• $\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$

Anda mungkin tertarik untuk melihat ke dalam kode untuk metrik mult-label di sini , yang merupakan bagian dari paket mldr di R . Anda juga mungkin tertarik untuk melihat perpustakaan multi-label Java MULAN .

Ini adalah makalah yang bagus untuk masuk ke metrik yang berbeda: Tinjauan tentang Algoritma Pembelajaran Multi-Label

Saya tidak tahu tentang bagian multi-label tetapi untuk klasifikasi kelas mutli tautan itu akan membantu Anda

Tautan ini menjelaskan cara membuat matriks kebingungan yang dapat Anda gunakan untuk menghitung presisi dan penarikan kembali untuk setiap kategori

Dan tautan ini menjelaskan cara menghitung ukuran micro-f1 dan macro-f1 untuk mengevaluasi pengklasifikasi secara keseluruhan.

Semoga bermanfaat.

tautan ini membantu saya .. https://www.youtube.com/watch?v=HBi-P5j0Kec saya berharap ini akan membantu Anda juga

katakan distribusinya seperti di bawah ini

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

presisi untuk A akan menjadi

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... pada dasarnya mengambil nilai positif sebenarnya dari kelas dan membaginya dengan data kolom di seluruh baris

ingat untuk menjadi

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

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

psst ... pada dasarnya mengambil true positive class dan membaginya dengan data baris lintas kolom

setelah Anda mendapatkan semua nilai, ambil rata-rata makro

rata-rata (P) = P (A) + P (B) + P (C) + P (D) / 4

rata-rata (R) = R (A) + R (B) + R (C) + R (D) / 4

F1 = 2 * rata-rata (P) * rata-rata (R) / rata-rata (P) + rata-rata (R)

Lihatlah slide-slide ini dari cs205.org di Harvard . Setelah Anda sampai ke bagian tentang Tindakan Kesalahan, ada diskusi tentang presisi dan penarikan kembali dalam pengaturan multi-kelas (misalnya, satu-vs-semua atau satu-vs-satu) dan matriks kebingungan. Matriks kebingungan adalah apa yang benar-benar Anda inginkan di sini.

FYI, dalam paket perangkat lunak Python scikits.learn , ada metode bawaan untuk secara otomatis menghitung hal-hal seperti matriks kebingungan dari pengklasifikasi yang dilatih tentang data multi-kelas. Ini mungkin dapat secara langsung menghitung plot penarikan kembali presisi untuk Anda juga. Layak dilihat.

Dari Ozgur et al (2005) adalah mungkin untuk melihat bahwa Anda harus menghitung Precision dan Recall mengikuti ekspresi normal, tetapi alih-alih rata-rata atas jumlah N total dalam dataset Anda, Anda harus menggunakan N = [instance dengan setidaknya satu label dengan kelas yang dimaksud ditugaskan untuk].

di sini adalah referensi yang disebutkan: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Persis seperti cara Anda melakukannya pada umumnya, dengan set:

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

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

Berikut adalah fungsi Python sederhana yang melakukan hal itu:

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']))