Maximiza el MSE de un modelo keras

Tengo una red generativa de confrontación, donde el discriminador se minimiza con el MSE y el generador se debe maximizar. Porque ambos son oponentes que persiguen el objetivo opuesto.

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)

¿Qué debo adaptar para obtener un modelo generador que se beneficia de un alto valor de MSE?

ACTUALIZAR:

La implementación original de MSE tiene el siguiente aspecto:

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)

Creo que la función de pérdida de maximizador correcta:

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)

De esta forma siempre obtenemos un valor de pérdida positivo, como en el caso de la función MSE, pero con efecto inverso.

ACTUALIZACIÓN 2: Inicialmente escribí, que el primer pensamiento intuitivo para simplemente negar la pérdida NO dará al resultado lo que esperábamos debido al concepto base de los métodos de optimización (puede leer una discusión interesante aquí ). Después de que verifiqué ambos métodos, el resultado en una tarea de aprendizaje en particular (Nota: no hice una prueba completa) fue que ambos métodos dieron la maximización de la pérdida, aunque el -lossenfoque convergió un poco más rápido. No estoy seguro de si siempre da la mejor solución o alguna solución debido al posible problema descrito aquí . Si alguien tiene otra experiencia, hágamelo saber.

Entonces, si alguien quiere intentarlo -losstambién:

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)

Detalles adicionales:

OP escribió:

Tengo una red generativa de confrontación, donde el discriminador se minimiza con el MSE y el generador se debe maximizar. Porque ambos son oponentes que persiguen el objetivo opuesto.

Desde el enlace proporcionado por Ibragil:

Mientras tanto, el generador está creando nuevas imágenes sintéticas que pasa al discriminador. Lo hace con la esperanza de que ellos también se consideren auténticos, aunque sean falsos. El objetivo del generador es generar dígitos pasables escritos a mano: mentir sin ser atrapado. El objetivo del discriminador es identificar las imágenes que provienen del generador como falsas.

Entonces este es un problema mal planteado:

En GAN, nuestro objetivo final es capacitar a nuestros dos contrapartes, el discriminador y el generador para que funcionen lo mejor posible el uno contra el otro. Significa que los dos algoritmos básicos de aprendizaje tienen tareas diferentes, pero la función de pérdida con la que pueden lograr la solución óptima es la misma, es decirbinary_crossentropy , , las tareas de los modelos son minimizar esta pérdida.

Un discriminador el modelo de método de compilación:

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

Un generador de modelo es el método de compilación:

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

Es lo mismo que el objetivo de dos corredores para minimizar su tiempo de llegar a la meta, incluso si son competidores en esta tarea.

Entonces, el "objetivo opuesto" no significa tarea opuesta, es decir, minimizar la pérdida (es decir, minimizar el tiempo en el ejemplo del corredor).

Espero que ayude.

La pregunta no es muy clara para mí. Supongo que desea maximizar en lugar de minimizar, mientras usa el criterio del MSE.

Puede implementar su propia función de pérdida personalizada, que calcula el -MSE; voltear el signo de la pérdida, y así lograr un giro en la dirección de descenso del gradiente.

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

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

Otra opción es simplemente proporcionar un paso de aprendizaje negativo, pero no estoy seguro de que Keras le permita hacer esto. Vale la pena intentarlo.