Bagaimana cara mengatur bobot kelas untuk kelas yang tidak seimbang di Keras?

Saya tahu bahwa ada kemungkinan Keras dengan class_weightskamus parameter yang pas, tapi saya tidak bisa menemukan contoh. Akankah seseorang dengan baik hati menyediakannya?

Ngomong-ngomong, dalam hal ini praksis yang tepat hanya untuk membebani kelas minoritas secara proporsional dengan perwakilannya yang kurang?

Jika Anda berbicara tentang kasus biasa, di mana jaringan Anda hanya menghasilkan satu output, maka asumsi Anda sudah benar. Untuk memaksa algoritme Anda memperlakukan setiap instance dari kelas 1 sebagai 50 instance dari kelas 0, Anda harus:

1. Tetapkan kamus dengan label Anda dan bobotnya yang terkait

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

2. Beri makan kamus sebagai parameter:

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

EDIT: "memperlakukan setiap instance dari kelas 1 sebagai 50 instance dari kelas 0 " berarti bahwa dalam fungsi kerugian Anda, Anda memberikan nilai yang lebih tinggi untuk instance ini. Oleh karena itu, kerugian menjadi rata-rata tertimbang, di mana berat masing-masing sampel ditentukan oleh class_weight dan kelas yang sesuai.

Dari Keras docs: class_weight : Indeks kelas pemetaan kamus opsional (integer) ke nilai weight (float), digunakan untuk memberi bobot pada fungsi kerugian (hanya selama pelatihan).

Anda cukup menerapkan class_weightdari sklearn:

1. Mari kita impor modulnya terlebih dahulu

   from sklearn.utils import class_weight

2. Untuk menghitung bobot kelas, lakukan hal berikut

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

3. Ketiga dan terakhir menambahkannya ke model pas

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

Perhatian : Saya mengedit posting ini dan mengubah nama variabel dari class_weight menjadi class_weight s agar tidak menimpa modul yang diimpor. Sesuaikan sesuai saat menyalin kode dari komentar.

Saya menggunakan aturan semacam ini untuk 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.logmenghaluskan beban untuk kelas yang sangat tidak seimbang! Ini mengembalikan:

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

CATATAN: Lihat komentar, jawaban ini sudah usang.

Untuk menimbang semua kelas secara merata, Anda sekarang dapat mengatur class_weight menjadi "otomatis" seperti:

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

class_weight baik-baik saja tetapi seperti yang dikatakan @Aokok ini tidak akan berhasil jika Anda adalah kelas multilabel enkode satu-panas. Dalam hal ini, gunakan sample_weight :

sample_weight: array opsional dengan panjang yang sama dengan x, berisi bobot untuk diterapkan pada kehilangan model untuk setiap sampel. Dalam hal data temporal, Anda bisa melewatkan array 2D dengan bentuk (sampel, sequence_length), untuk menerapkan bobot yang berbeda untuk setiap catatan waktu setiap sampel. Dalam hal ini Anda harus memastikan untuk menentukan sample_weight_mode = "temporal" dalam kompilasi ().

sample_weights digunakan untuk memberikan bobot untuk setiap sampel pelatihan . Itu berarti bahwa Anda harus lulus array 1D dengan jumlah elemen yang sama dengan sampel pelatihan Anda (menunjukkan bobot untuk masing-masing sampel).

class_weights digunakan untuk memberikan bobot atau bias untuk setiap kelas output . Ini berarti Anda harus memberikan bobot untuk setiap kelas yang Anda coba klasifikasikan.

sample_weight harus diberi array numpy, karena bentuknya akan dievaluasi.

Lihat juga jawaban ini: https://stackoverflow.com/questions/48315094/using-sample-weight-in-keras-for-afterence-labelling

Menambahkan ke solusi di https://github.com/keras-team/keras/issues/2115 . Jika Anda membutuhkan lebih dari pembobotan kelas di mana Anda ingin biaya yang berbeda untuk positif palsu dan negatif palsu. Dengan versi keras baru sekarang Anda hanya dapat mengesampingkan fungsi kerugian masing-masing seperti yang diberikan di bawah ini. Perhatikan bahwa itu weightsadalah matriks persegi.

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

Saya menemukan contoh pengkodean bobot kelas dalam fungsi kerugian menggunakan dataset minist. Lihat tautan di sini: 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()}

Ini bekerja dengan generator atau standar. Kelas terbesar Anda akan memiliki bobot 1 sedangkan yang lain akan memiliki nilai lebih besar dari 1 relatif terhadap kelas terbesar.

bobot kelas menerima input jenis kamus