Keras'ta dengesiz sınıflar için sınıf ağırlıkları nasıl belirlenir?

Keras'da class_weightsparametre sözlüğü ile uydurma ihtimalinin olduğunu biliyorum , ancak hiçbir örnek bulamadım. Biri bir tane sağlamak için çok nazik misiniz?

Bu arada, bu durumda uygun praksis, azınlık sınıfını düşük beyanına göre orantılı olarak arttırmak için mi?

Ağınızın yalnızca bir çıktı ürettiği normal durum hakkında konuşuyorsanız, varsayımınız doğrudur. Algoritmanınızı sınıf 1'in her örneğine 0 sınıfının 50 örneği olarak göstermeye zorlamak için yapmanız gereken:

1. Etiketlerinizle ve bunlarla ilişkili ağırlıklarıyla bir sözlük tanımlayın.

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

2. Sözlüğü parametre olarak besleyin:

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

EDIT: " sınıf 1'in her örneğine sınıf 0'ın 50 örneği olarak bak ", kayıp fonksiyonunuzda bu örneklere daha yüksek değer atayacağınız anlamına gelir. Dolayısıyla, kayıp, her bir numunenin ağırlığının class_weight ve karşılık gelen sınıf ile belirtildiği ağırlıklı bir ortalamaya dönüşür .

Keras docs'dan : class_weight : İsteğe bağlı sözlük eşleme sınıf indekslerini (tamsayılar) ağırlık (değişken) değerine eşleme, kayıp işlevini ağırlıklandırmak için kullanılır (sadece eğitim sırasında).

Sadece uygulamak class_weightdan sklearn:

1. Önce modülü içe aktaralım

   from sklearn.utils import class_weight

2. Sınıf ağırlığını hesaplamak için aşağıdakileri yapın

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

3. Üçüncü ve son olarak model montajına ekleyin

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

Dikkat : Bu yazıyı düzenledim ve içe aktarılan modülün üzerine yazmamak için değişken adını class_weight'den class_weight s'ye değiştirdim . Yorumlardan kod kopyalarken uygun şekilde ayarlayın.

Bu tür kuralları kullanıyorum 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.logçok dengesiz sınıfların ağırlıklarını düzeltir! Bu döner:

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

NOT: Yorumlara bakın, bu cevap modası geçmiş.

Tüm sınıfları eşit olarak ağırlıklandırmak için, şimdi class_weight ayarını "auto" olarak ayarlayabilirsiniz:

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

class_weight gayet iyi ancak @Aalok'un dediği gibi, bir sıcak kodlama çok etiketli sınıflarsanız bu işe yaramaz. Bu durumda, sample_weight kullanın :

sample_weight: Her numune için modelin kaybına uygulanacak ağırlıkları içeren, x ile aynı uzunlukta isteğe bağlı dizi. Geçici veri söz konusu olduğunda, her bir numunenin her zaman adımına farklı bir ağırlık uygulamak için şekilli bir 2D diziyi (örnekler, sıra_ uzunluğu) geçirebilirsiniz. Bu durumda compile () 'deki sample_weight_mode = "temporal"' ı belirttiğinizden emin olmalısınız.

sample_weights , her eğitim numunesi için bir ağırlık sağlamak için kullanılır . Bu, antrenman numunelerinizle aynı sayıda elemana sahip bir 1D dizisini geçmeniz gerektiği anlamına gelir (bu numunelerin her birinin ağırlığını gösterir).

class_weights , her çıktı sınıfı için bir ağırlık veya önyargı sağlamak için kullanılır . Bu, sınıflandırmaya çalıştığınız her sınıf için bir ağırlık geçirmeniz gerektiği anlamına gelir.

sample_weight bir şekil dizisi verilmelidir, çünkü şekli değerlendirilecektir.

Ayrıca bu cevaba bakınız: https://stackoverflow.com/questions/48315094/using-sample-weight-in-keras-for-sequence-labelling

Çözüme https://github.com/keras-team/keras/issues/2115 adresinden ekleyin . Yanlış pozitifler ve yanlış negatifler için farklı maliyetler istediğiniz yerde sınıflandırmadan daha fazlasına ihtiyacınız varsa. Şimdi yeni keras versiyonuyla ilgili kayıp fonksiyonunu aşağıda verilen şekilde geçersiz kılabilirsiniz. Bunun weightsbir kare matris olduğunu unutmayın .

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

Bakanlık veri setini kullanarak kayıp fonksiyonunda sınıf ağırlıklarını kodlayan aşağıdaki örneği buldum. Buraya bakınız: 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()}

Bu bir jeneratör veya standart ile çalışır. En büyük sınıfınızın ağırlığı 1, diğerlerinin ise en büyük sınıfa göre 1'den büyük değerleri olacaktır.

sınıf ağırlıkları bir sözlük türü girişini kabul eder.