Como definir pesos de classe para classes desequilibradas em Keras?

Eu sei que existe uma possibilidade no Keras com o class_weightsdicionário de parâmetros no ajuste, mas não encontrei nenhum exemplo. Alguém seria tão gentil em fornecer um?

A propósito, nesse caso, a práxis apropriada é simplesmente ponderar a classe minoritária proporcionalmente à sua sub-representação?

Se você está falando sobre o caso regular, em que sua rede produz apenas uma saída, sua suposição está correta. Para forçar seu algoritmo a tratar todas as instâncias da classe 1 como 50 instâncias da classe 0, você deve:

1. Defina um dicionário com seus rótulos e seus pesos associados

   class_weight = {0: 1.,
                   1: 50.,
                   2: 2.}
   

2. Alimente o dicionário como um parâmetro:

   model.fit(X_train, Y_train, nb_epoch=5, batch_size=32, class_weight=class_weight)

EDIT: "tratar todas as instâncias da classe 1 como 50 instâncias da classe 0 " significa que na sua função de perda você atribui um valor mais alto a essas instâncias. Portanto, a perda se torna uma média ponderada, onde o peso de cada amostra é especificado por class_weight e sua classe correspondente.

Do Keras docs: class_weight : índices de classe de mapeamento de dicionário opcionais (números inteiros) para um valor de peso (flutuante), usado para ponderar a função de perda (apenas durante o treinamento).

Você pode simplesmente implementar o class_weightde sklearn:

1. Vamos importar o módulo primeiro

   from sklearn.utils import class_weight

2. Para calcular o peso da classe, faça o seguinte

   class_weights = class_weight.compute_class_weight('balanced',
                                                    np.unique(y_train),
                                                    y_train)
   

3. Em terceiro e último lugar, adicione-o ao encaixe do modelo

   model.fit(X_train, y_train, class_weight=class_weights)

Atenção : Editei este post e alterei o nome da variável de class_weight para class_weight s para não sobrescrever o módulo importado. Ajuste de acordo ao copiar o código dos comentários.

Eu uso esse tipo de regra para class_weight:

import numpy as np
import math

# labels_dict : {ind_label: count_label}
# mu : parameter to tune 

def create_class_weight(labels_dict,mu=0.15):
    total = np.sum(labels_dict.values())
    keys = labels_dict.keys()
    class_weight = dict()

    for key in keys:
        score = math.log(mu*total/float(labels_dict[key]))
        class_weight[key] = score if score > 1.0 else 1.0

    return class_weight

# random labels_dict
labels_dict = {0: 2813, 1: 78, 2: 2814, 3: 78, 4: 7914, 5: 248, 6: 7914, 7: 248}

create_class_weight(labels_dict)

math.logsuaviza os pesos para classes muito desequilibradas! Isso retorna:

{0: 1.0,
 1: 3.749820767859636,
 2: 1.0,
 3: 3.749820767859636,
 4: 1.0,
 5: 2.5931008483842453,
 6: 1.0,
 7: 2.5931008483842453}

NOTA: Veja os comentários, esta resposta está desatualizada.

Para ponderar todas as classes igualmente, agora você pode simplesmente definir class_weight como "auto" da seguinte forma:

model.fit(X_train, Y_train, nb_epoch=5, batch_size=32, class_weight = 'auto')

class_weight é bom, mas como @Aalok disse que isso não funcionará se você for um tipo de codificação de classes com várias tags. Nesse caso, use sample_weight :

sample_weight: matriz opcional do mesmo comprimento que x, contendo pesos a serem aplicados à perda do modelo para cada amostra. No caso de dados temporais, você pode passar uma matriz 2D com forma (amostras, comprimento_de_ sequência), para aplicar um peso diferente a cada passo de tempo de cada amostra. Nesse caso, certifique-se de especificar sample_weight_mode = "temporal" em compile ().

sample_weights é usado para fornecer um peso para cada amostra de treinamento . Isso significa que você deve passar uma matriz 1D com o mesmo número de elementos que suas amostras de treinamento (indicando o peso de cada uma dessas amostras).

class_weights é usado para fornecer um peso ou viés para cada classe de saída . Isso significa que você deve passar um peso para cada classe que você está tentando classificar.

sample_weight deve receber uma matriz numpy, pois sua forma será avaliada.

Consulte também esta resposta: https://stackoverflow.com/questions/48315094/using-sample-weight-in-keras-for-sequence-labelling

Adicionando à solução em https://github.com/keras-team/keras/issues/2115 . Se você precisar de mais do que ponderação de classe, em que deseja custos diferentes para falsos positivos e falsos negativos. Com a nova versão do keras agora você pode simplesmente substituir a respectiva função de perda, conforme indicado abaixo. Observe que weightsé uma matriz quadrada.

from tensorflow.python import keras
from itertools import product
import numpy as np
from tensorflow.python.keras.utils import losses_utils

class WeightedCategoricalCrossentropy(keras.losses.CategoricalCrossentropy):

    def __init__(
        self,
        weights,
        from_logits=False,
        label_smoothing=0,
        reduction=losses_utils.ReductionV2.SUM_OVER_BATCH_SIZE,
        name='categorical_crossentropy',
    ):
        super().__init__(
            from_logits, label_smoothing, reduction, name=f"weighted_{name}"
        )
        self.weights = weights

    def call(self, y_true, y_pred):
        weights = self.weights
        nb_cl = len(weights)
        final_mask = keras.backend.zeros_like(y_pred[:, 0])
        y_pred_max = keras.backend.max(y_pred, axis=1)
        y_pred_max = keras.backend.reshape(
            y_pred_max, (keras.backend.shape(y_pred)[0], 1))
        y_pred_max_mat = keras.backend.cast(
            keras.backend.equal(y_pred, y_pred_max), keras.backend.floatx())
        for c_p, c_t in product(range(nb_cl), range(nb_cl)):
            final_mask += (
                weights[c_t, c_p] * y_pred_max_mat[:, c_p] * y_true[:, c_t])
        return super().call(y_true, y_pred) * final_mask

Encontrei o exemplo a seguir de codificação de pesos de classe na função de perda usando o conjunto de dados minist. Veja o link aqui: https://github.com/keras-team/keras/issues/2115

def w_categorical_crossentropy(y_true, y_pred, weights):
    nb_cl = len(weights)
    final_mask = K.zeros_like(y_pred[:, 0])
    y_pred_max = K.max(y_pred, axis=1)
    y_pred_max = K.reshape(y_pred_max, (K.shape(y_pred)[0], 1))
    y_pred_max_mat = K.equal(y_pred, y_pred_max)
    for c_p, c_t in product(range(nb_cl), range(nb_cl)):
        final_mask += (weights[c_t, c_p] * y_pred_max_mat[:, c_p] * y_true[:, c_t])
    return K.categorical_crossentropy(y_pred, y_true) * final_mask

from collections import Counter
itemCt = Counter(trainGen.classes)
maxCt = float(max(itemCt.values()))
cw = {clsID : maxCt/numImg for clsID, numImg in itemCt.items()}

Isso funciona com um gerador ou padrão. Sua classe maior terá um peso 1, enquanto os outros terão valores maiores que 1 em relação à maior classe.

pesos de classe aceita uma entrada de tipo de dicionário