Massimizza il MSE di un modello di keras

Ho una rete generativa contraddittoria, in cui il discriminatore viene minimizzato con l'MSE e il generatore dovrebbe essere massimizzato. Perché entrambi sono avversari che perseguono l'obiettivo opposto.

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)

Cosa devo adattare per ottenere un modello di generatore che beneficia di un valore MSE elevato?

AGGIORNARE:

L' implementazione originale di MSE è simile alla seguente:

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)

Penso che la corretta funzione di perdita del massimizzatore:

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)

In questo modo otteniamo sempre un valore di perdita positivo, come nel caso della funzione MSE, ma con effetto inverso.

AGGIORNAMENTO 2: Inizialmente ho scritto che l'intuitivo primo pensiero di semplicemente annullare la perdita NON darà il risultato quello che ci aspettavamo a causa del concetto base dei metodi di ottimizzazione (puoi leggere una discussione interessante qui ). Dopo aver ricontrollato entrambi i metodi testa a testa il risultato in un particolare compito di apprendimento (Nota: non ho fatto un test a tutto campo) è stato che entrambi i metodi hanno dato la massimizzazione della perdita, sebbene l' -lossapproccio convergesse un po 'più velocemente. Non sono sicuro che fornisca sempre la soluzione migliore o qualsiasi soluzione a causa del possibile problema descritto qui . Se qualcuno ha altra esperienza, per favore fatemelo sapere.

Quindi, se qualcuno vuole provare -lossanche a:

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)

Dettagli aggiuntivi:

OP ha scritto:

Ho una rete generativa contraddittoria, in cui il discriminatore viene minimizzato con l'MSE e il generatore dovrebbe essere massimizzato. Perché entrambi sono avversari che perseguono l'obiettivo opposto.

Dal link fornito da Ibragil:

Nel frattempo, il generatore sta creando nuove immagini sintetiche che passa al discriminatore. Lo fa nella speranza che anche loro siano considerati autentici, anche se falsi. L'obiettivo del generatore è generare cifre scritte a mano accettabili: mentire senza essere scoperti. L'obiettivo del discriminatore è identificare le immagini provenienti dal generatore come false.

Quindi questo è un problema sbagliato:

In GAN il nostro obiettivo finale è quello di formare le nostre due controparti, il discriminatore e il generatore, affinché si comportino il meglio possibile l'uno contro l'altro. Significa, che l'apprendimento algoritmo due basi hanno compiti diversi ma la funzione di perdita con cui possono realizzare la soluzione ottimale è la stessa cioè binary_crossentropy, così compiti delle modelle sono per minimizzare questa perdita.

Un discriminatore modello del metodo di compilazione:

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

Un generatore di modello del metodo di compilazione:

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

È uguale all'obiettivo di due corridori di ridurre al minimo il tempo necessario per raggiungere il traguardo, anche se sono concorrenti in questo compito.

Quindi "obiettivo opposto" non significa compito opposto, ovvero minimizzare la perdita (ovvero ridurre al minimo il tempo nell'esempio del corridore).

Spero possa essere d'aiuto.

La domanda non è molto chiara per me. Suppongo che tu voglia massimizzare anziché minimizzare, mentre usi il criterio dell'MSE.

È possibile implementare la propria funzione di perdita personalizzata, che calcola il -MSE; capovolgendo il segno della perdita e ottenendo così un ribaltamento nella direzione di discesa del gradiente.

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

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

Un'altra opzione è quella di fornire semplicemente un passaggio di apprendimento negativo, ma non sono sicuro che Keras ti permetta di farlo. Vale la pena provare.