Zastanawiam się, jak obliczyć dokładność i przywołać miary dla wieloklasowej klasyfikacji wielopłaszczyznowej, tj. Klasyfikacji, w której występują więcej niż dwie etykiety i gdzie każde wystąpienie może mieć wiele etykiet?

Innym popularnym narzędziem do pomiaru wydajności klasyfikatora jest ROC / AUC ; ten również ma rozszerzenie dla wielu klas / wielu etykiet: patrz [Hand 2001]

[Hand 2001]: Proste uogólnienie obszaru pod krzywą ROC do problemów klasyfikacji wielu klas

Oto kilka dyskusji na temat wątku forum Oczywiście na temat macierzy pomyłek i wieloklasowego pomiaru precyzji / wycofania.

Podstawową ideą jest obliczenie całej precyzji i przywołanie wszystkich klas, a następnie uśrednienie ich w celu uzyskania pojedynczego pomiaru liczby rzeczywistej.

Macierz nieporozumień ułatwia obliczenie precyzji i przywołanie klasy.

Poniżej znajduje się podstawowe wyjaśnienie dotyczące macierzy pomyłek, skopiowane z tego wątku:

Macierz dezorientacji jest sposobem klasyfikowania prawdziwych pozytywów, prawdziwych negatywów, fałszywych alarmów i fałszywych negatywów, gdy istnieją więcej niż 2 klasy. Służy do obliczania precyzji i przywoływania, a tym samym f1-score dla problemów wielu klas.

Rzeczywiste wartości są reprezentowane przez kolumny. Przewidywane wartości są reprezentowane przez rzędy.

Przykłady:

10 przykładów szkolenia, które w rzeczywistości są 8, są niepoprawnie sklasyfikowane (przewidywane) jako 5
13 przykładów szkolenia, które są właściwie 4, są niepoprawnie sklasyfikowane jako 9

Macierz pomieszania

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

Dla klasy x:

• Prawdziwie dodatni: pozycja ukośna, cm (x, x).

• Fałszywie dodatni: suma kolumny x (bez głównej przekątnej), suma (cm (:, x)) - cm (x, x).

• Fałszywy ujemny: suma rzędu x (bez głównej przekątnej), suma (cm (x, :), 2) -cm (x, x).

Możesz obliczyć precyzję, wycofanie i wynik F1 według formuły kursu.

Uśrednianie dla wszystkich klas (z wagą lub bez) daje wartości dla całego modelu.

W przypadku klasyfikacji obejmującej wiele marek masz dwie możliwości. Najpierw rozważ poniższe.

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

Na podstawie przykładu

Metryki obliczane są w sposób dla poszczególnych punktów danych. Dla każdej przewidywanej etykiety obliczany jest tylko jej wynik, a następnie wyniki te są agregowane we wszystkich punktach danych.

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

Istnieją również inne wskaźniki.

Na podstawie etykiet

Tutaj rzeczy są zrobione pod względem etykiet. Dla każdej etykiety obliczane są dane (np. Precyzja, przywołanie), a następnie te agregowane w oparciu o etykiety. Dlatego w tym przypadku obliczasz dokładność / przywołanie dla każdej etykiety w całym zestawie danych, podobnie jak w przypadku klasyfikacji binarnej (ponieważ każda etykieta ma przypisanie binarne), a następnie agregujesz ją.

Najprostszym sposobem jest przedstawienie ogólnej formy.

To tylko rozszerzenie standardowego ekwiwalentu wielu klas.

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

Możesz być zainteresowany, aby zajrzeć do kodu dla metryk mult-label tutaj , który jest częścią pakietu mldr w R . Być może zainteresuje Cię także biblioteka wielu etykiet Java MULAN .

Jest to fajny artykuł na temat różnych wskaźników: Przegląd algorytmów uczenia się wielu marek

Nie wiem o części z wieloma etykietami, ale w klasyfikacji mutli-class te linki pomogą ci

Ten link wyjaśnia, jak zbudować macierz nieporozumień, której można użyć do obliczenia dokładności i przywołania dla każdej kategorii

Link ten wyjaśnia, jak obliczyć miary mikro-f1 i makro-f1 w celu oceny klasyfikatora jako całości.

mam nadzieję, że okaże się to przydatne.

ten link pomógł mi .. https://www.youtube.com/watch?v=HBi-P5j0Kec Mam nadzieję, że to również pomoże

powiedz rozkład jak poniżej

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

precyzja dla A byłaby

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... zasadniczo bierze prawdziwy wynik dodatni klasy i dzieli przez dane kolumny między wierszami

przypominam, że byłoby

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

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

psst ... zasadniczo bierze prawdziwy pozytyw klasy i dzieli przez dane wiersza między kolumnami

po uzyskaniu wszystkich wartości weź średnią makro

śr. (P) = P (A) + P (B) + P (C) + P (D) / 4

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

F1 = 2 * średnia (P) * średnia (R) / średnia (P) + średnia (R)

Sprawdź te slajdy z cs205.org na Harvard . Po przejściu do sekcji Miary błędów omawia się precyzję i przywołanie w ustawieniach wielu klas (np. Jeden na wszystkich lub jeden na jednym) i macierze pomieszania. Macierze zamieszania są tym, czego naprawdę chcesz.

Do Twojej wiadomości, w pakiecie oprogramowania Python scikits.learn istnieją wbudowane metody automatycznego obliczania takich rzeczy, jak macierz nieporozumień na podstawie klasyfikatorów przeszkolonych w zakresie danych wieloklasowych. Prawdopodobnie może również bezpośrednio obliczyć dla ciebie wykresy dokładnego przywołania. Warte zobaczenia.

Z Ozgur i in. (2005) można zobaczyć, że należy obliczyć Precyzja i Przywołaj zgodnie z normalnymi wyrażeniami, ale zamiast uśredniać całkowitą liczbę N wystąpień w zbiorze danych, należy użyć N = [wystąpienia z co najmniej jedną etykietą z klasa, do której przypisano].

tutaj jest wspomniane odniesienie: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Dokładnie tak samo, jak zrobiłbyś to w przypadku ogólnym, z zestawami:

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

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

Oto proste funkcje Pythona, które dokładnie to robią:

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