Maksymalizuj MSE modelu keras

Mam generatywne sieci przeciwników, w których dyskryminator zostaje zminimalizowany za pomocą MSE, a generator powinien zostać zmaksymalizowany. Ponieważ obaj są przeciwnikami, którzy dążą do przeciwnego celu.

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)

Co muszę dostosować, aby uzyskać model generatora, który czerpie korzyści z wysokiej wartości MSE?

AKTUALIZACJA:

Oryginalna implementacja MSE wygląda następująco:

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)

Myślę, że poprawna funkcja utraty maksymalizatora:

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)

W ten sposób otrzymujemy zawsze dodatnią wartość straty, jak w przypadku funkcji MSE, ale z odwróconym efektem.

UPDATE 2: Początkowo napisałem, że intuicyjne pierwsza myśl po prostu neguje strata będzie nie dać wynik, czego oczekiwaliśmy z powodu podstawowego pojęcia metod optymalizacyjnych (można przeczytać ciekawą dyskusję tutaj ). Po dwukrotnym sprawdzeniu obu metod łeb w łeb wynik w konkretnym zadaniu uczenia się (uwaga: nie zrobiłem testu całościowego) było to, że obie metody dały maksymalizację strat, chociaż -losspodejście zbiegło się nieco szybciej. Nie jestem pewien, czy zawsze daje najlepsze rozwiązanie, czy jakiekolwiek rozwiązanie z powodu opisanego tutaj możliwego problemu . Jeśli ktoś ma inne doświadczenie, daj mi znać.

Więc jeśli ktoś też chce spróbować -loss:

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)

Dodatkowe Szczegóły:

OP napisał:

Mam generatywne sieci przeciwników, w których dyskryminator zostaje zminimalizowany za pomocą MSE, a generator powinien zostać zmaksymalizowany. Ponieważ obaj są przeciwnikami, którzy dążą do przeciwnego celu.

Z linku dostarczonego przez Ibragil:

Tymczasem generator tworzy nowe, syntetyczne obrazy, które przekazuje do dyskryminatora. Czyni to w nadziei, że i oni zostaną uznani za autentycznych, nawet jeśli są fałszywi. Celem generatora jest generowanie znośnych odręcznych cyfr: kłamać bez przyłapania. Celem dyskryminatora jest identyfikacja obrazów pochodzących z generatora jako fałszywych.

Jest to źle postawiony problem:

W GAN naszym ostatecznym celem jest wyszkolenie naszych dwóch przeciwników, dyskryminatora i generatora, aby działali jak najlepiej przeciwko sobie. Oznacza to, że dwa podstawowe algorytmy uczenia się mają różne zadania, ale funkcja straty, dzięki której mogą osiągnąć optymalne rozwiązanie, jest taka sama, tzn. binary_crossentropyWięc zadania modeli mają zminimalizować tę utratę.

Dyskryminator modelu jest metoda kompilacji:

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

Generator modelu jest metoda kompilacji:

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

To tak samo, jak celem dwóch biegaczy jest zminimalizowanie czasu dotarcia do mety, nawet jeśli są zawodnikami w tym zadaniu.

Zatem „przeciwny cel” nie oznacza zadania przeciwnego, tj. Minimalizacji straty (tj. Minimalizacji czasu w przykładzie biegacza).

Mam nadzieję, że to pomoże.

Pytanie nie jest dla mnie bardzo jasne. Podejrzewam, że chcesz maksymalizować zamiast minimalizować, stosując kryterium MSE.

Możesz zaimplementować własną niestandardową funkcję utraty, która oblicza -MSE; odwrócenie znaku utraty, a tym samym osiągnięcie odwrócenia w kierunku opadania gradientu.

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

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

Inną opcją jest po prostu podanie negatywnego etapu uczenia się - ale nie jestem pewien, czy Keras pozwala ci to zrobić. Warte spróbowania.