Maksimalkan MSE model keras

Saya memiliki jaringan permusuhan generatif, di mana pembeda diminimalkan dengan MSE dan generator harus dimaksimalkan. Karena keduanya adalah lawan yang mengejar tujuan yang berlawanan.

generator = Sequential()
generator.add(Dense(units=50, activation='sigmoid', input_shape=(15,)))
generator.add(Dense(units=1, activation='sigmoid'))
generator.compile(loss='mse', optimizer='adam')

generator.train_on_batch(x_data, y_data)

Apa yang harus saya adaptasi, untuk mendapatkan model generator yang mendapat untung dari nilai MSE yang tinggi?

MEMPERBARUI:

Implementasi MSE asli terlihat seperti berikut:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(y_pred - y_true), axis=-1)

Saya pikir fungsi loss maximizer yang benar:

def mean_squared_error_max(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(1 / (y_pred - y_true)), axis=-1)

Dengan cara ini kita selalu mendapatkan nilai kerugian positif, seperti dalam kasus fungsi MSE, tetapi dengan efek terbalik.

UPDATE 2: Awalnya saya menulis, bahwa pemikiran pertama intuitif untuk meniadakan kerugian TIDAK akan memberikan hasil yang kami harapkan karena konsep dasar dari metode optimalisasi (Anda dapat membaca diskusi yang menarik di sini ). Setelah saya mengecek kedua metode head to head hasil dalam tugas belajar tertentu (Catatan: Saya tidak melakukan tes habis-habisan) adalah bahwa kedua metode memberikan maksimalisasi kerugian, meskipun -losspendekatannya terkonvergensi sedikit lebih cepat. Saya tidak yakin apakah selalu memberikan solusi terbaik atau solusi apa pun karena masalah yang mungkin dijelaskan di sini . Jika seseorang memiliki pengalaman lain, beri tahu saya.

Jadi, jika seseorang ingin mencoba -lossjuga:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return - K.mean(K.square(y_pred - y_true), axis=-1)

Detil tambahan:

OP menulis:

Saya memiliki jaringan permusuhan generatif, di mana pembeda diminimalkan dengan MSE dan generator harus dimaksimalkan. Karena keduanya adalah lawan yang mengejar tujuan yang berlawanan.

Dari tautan yang disediakan oleh Ibragil:

Sementara itu, generator membuat gambar sintetis baru yang diteruskan ke pembeda. Itu dilakukan dengan harapan bahwa mereka juga akan dianggap otentik, meskipun mereka palsu. Tujuan generator adalah untuk menghasilkan angka tulisan tangan yang lumayan: untuk berbohong tanpa ketahuan. Tujuan pembeda adalah untuk mengidentifikasi gambar yang berasal dari generator sebagai palsu.

Jadi ini adalah masalah yang keliru:

Di GAN tujuan akhir kami untuk melatih dua pihak lawan kami, pembeda dan generator untuk melakukan yang terbaik satu sama lain. Ini berarti, bahwa algorythm pembelajaran dua dasar memiliki tugas yang berbeda tetapi fungsi kerugian yang dengannya mereka dapat mencapai solusi optimal adalah sama yaitu binary_crossentropy, sehingga tugas model adalah untuk meminimalkan kehilangan ini.

Sebuah diskriminator Model ini metode kompilasi:

self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)

Sebuah Generator Model ini metode kompilasi:

self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)

Itu sama seperti tujuan dua pelari untuk meminimalkan waktu mereka mencapai finish meskipun mereka adalah pesaing dalam tugas ini.

Jadi "tujuan yang berlawanan" tidak berarti tugas yang berlawanan yaitu meminimalkan kerugian (yaitu meminimalkan waktu dalam contoh pelari).

Saya harap ini membantu.

Pertanyaannya tidak begitu jelas bagi saya. Saya kira Anda ingin memaksimalkan bukannya meminimalkan, saat menggunakan kriteria MSE.

Anda dapat mengimplementasikan fungsi kehilangan kustom Anda sendiri, yang menghitung -MSE; membalik tanda kerugian, dan dengan demikian mencapai flip dalam arah penurunan gradien.

def negative_mse(y,yhat): 
    return - K.mean(K.sum(K.square(y-yhat)))

model.compile(loss=negative_mse, optimizer='adam')

Pilihan lain adalah dengan menyediakan langkah belajar negatif - tetapi saya tidak yakin Keras memungkinkan Anda untuk melakukan ini. Layak dicoba.