Мне интересно, как рассчитать точность и вспомнить меры для мультиклассовой классификации с несколькими метками, то есть классификации, где существует более двух меток, и где каждый экземпляр может иметь несколько меток?

Еще одним популярным инструментом для измерения эффективности классификатора является ROC / AUC ; у этого тоже есть расширение мультикласса / мультиметки: см. [Hand 2001]

[Рука 2001]: простое обобщение области под кривой ROC для множественных задач классификации классов

Вот некоторая дискуссия на форуме, конечно, о матрице путаницы и мультиклассовом измерении точности / отзыва.

Основная идея состоит в том, чтобы вычислить всю точность и вспомнить все классы, а затем усреднить их, чтобы получить одно измерение действительного числа.

Путаница позволяет легко вычислить точность и вызвать класс.

Ниже приведены некоторые основные объяснения о путанице матрицы, скопированной из этого потока:

Матрица путаницы - это способ классификации истинных положительных, отрицательных, ложных и отрицательных результатов, когда существует более двух классов. Он используется для вычисления точности и отзыва и, следовательно, f1-показателя для задач нескольких классов.

Фактические значения представлены столбцами. Предсказанные значения представлены строками.

Примеры:

10 обучающих примеров, которые на самом деле 8, классифицированы (предсказаны) неправильно как 5
13 обучающих примеров, которые на самом деле 4, неправильно классифицированы как 9

Матрица путаницы

см =
     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

Для класса х:

• Правда положительный: диагональная позиция, см (х, х).

• Ложное значение: сумма столбца х (без главной диагонали), сумма (см (:, х)) - см (х, х).

• Ложный минус: сумма строки x (без главной диагонали), сумма (см (x, :), 2) -см (x, x).

Вы можете вычислить точность, вспомнить и F1 балл по формуле курса.

Усреднение по всем классам (с или без взвешивания) дает значения для всей модели.

Для классификации по нескольким меткам у вас есть два пути. Сначала рассмотрите следующее.

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

Пример на основе

Метрики рассчитываются для каждого типа данных. Для каждой прогнозируемой метки вычисляется только ее оценка, а затем эти оценки агрегируются по всем точкам данных.

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

Есть и другие метрики.

На основе метки

Здесь все сделано по меткам. Для каждой метки вычисляются метрики (например, точность, отзыв), а затем эти метрики по меткам агрегируются. Следовательно, в этом случае вы в конечном итоге вычисляете точность / отзыв для каждой метки по всему набору данных, как вы делаете для двоичной классификации (так как каждая метка имеет двоичное назначение), а затем агрегируете ее.

Самый простой способ - представить общую форму.

Это просто расширение стандартного многоклассового эквивалента.

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

Вы можете быть заинтересованы , чтобы посмотреть в код для метрики мульт-метки здесь , которая входит в состав пакета млдр в R . Также вам может быть интересно заглянуть в библиотеку Java с несколькими метками MULAN .

Это хорошая статья, посвященная различным метрикам: обзор алгоритмов обучения по нескольким меткам

Я не знаю о части с несколькими метками, но для классификации с помощью нескольких классов эти ссылки помогут вам

Эта ссылка объясняет, как построить матрицу путаницы, которую можно использовать для расчета точности и отзыва для каждой категории.

И эта ссылка объясняет, как рассчитать показатели micro-f1 и macro-f1 для оценки классификатора в целом.

надеюсь, что вы нашли это полезным.

эта ссылка помогла мне .. https://www.youtube.com/watch?v=HBi-P5j0Kec Я надеюсь, что это поможет и вам

скажем распределение как ниже

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

точность для А будет

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... по сути, взять истинный положительный класс и разделить на данные столбца по строкам

Напомним, что будет

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

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

psst ... по сути взять истинный положительный класс и разделить на данные строки по столбцам

как только вы получите все значения, возьмите макросреднее

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)

Проверьте эти слайды с cs205.org в Гарварде . Как только вы попадаете в раздел «Измерения ошибок», обсуждается точность и отзыв в настройках нескольких классов (например, «один против всех» или «один против одного») и в матрицах путаницы. Путаница матриц это то, что вы действительно хотите здесь.

К вашему сведению, в программном пакете Python scikits.learn есть встроенные методы для автоматического вычисления таких вещей, как матрица путаницы, из классификаторов, обученных на многоклассовых данных. Возможно, он также может напрямую рассчитывать графики точного вызова. Стоит посмотреть.

Из Озгура и др. (2005) можно увидеть, что вы должны вычислять Precision и Recall, следуя нормальным выражениям, но вместо усреднения по общему количеству N экземпляров в вашем наборе данных, вы должны использовать N = [экземпляров, по крайней мере с одной меткой с рассматриваемый класс назначен на].

вот упомянутое упоминание: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Точно так же, как в обычном случае, с наборами:

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

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

Вот простые функции Python, которые делают именно это:

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