Se usó la API de Cloud Translation para traducir esta página.
Switch to English

tf.keras.optimizers.Optimizer

TensorFlow 1 versión Ver código fuente en GitHub

Clase base para los optimizadores Keras.

Usted no debe utilizar esta clase directamente, pero una vez instantiate de sus subclases, tales como tf.keras.optimizers.SGD , tf.keras.optimizers.Adam , etc.

Uso

 # Create an optimizer with the desired parameters.
opt = tf.keras.optimizers.SGD(learning_rate=0.1)
# `loss` is a callable that takes no argument and returns the value
# to minimize.
loss = lambda: 3 * var1 * var1 + 2 * var2 * var2
# In graph mode, returns op that minimizes the loss by updating the listed
# variables.
opt_op = opt.minimize(loss, var_list=[var1, var2])
opt_op.run()
# In eager mode, simply call minimize to update the list of variables.
opt.minimize(loss, var_list=[var1, var2])
 

El uso en bucles de formación personalizados

En los modelos Keras, a veces las variables se crean cuando el modelo se llama en primer lugar, en lugar de tiempo de construcción. Ejemplos incluyen 1) modelos secuenciales sin entrada de forma predefinida, o 2) modelos de subclase. Pase var_list como exigible en estos casos.

Ejemplo:

 opt = tf.keras.optimizers.SGD(learning_rate=0.1)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(num_hidden, activation='relu'))
model.add(tf.keras.layers.Dense(num_classes, activation='sigmoid'))
loss_fn = lambda: tf.keras.losses.mse(model(input), output)
var_list_fn = lambda: model.trainable_weights
for input, output in data:
  opt.minimize(loss_fn, var_list_fn)
 

El procesamiento de los gradientes antes de aplicarlas

Llamar a minimize() se encarga de tanto el cálculo de los gradientes y su aplicación a las variables. Si desea procesar los gradientes antes de aplicarlos en su lugar puede utilizar el optimizador en tres pasos:

  1. Calcular los gradientes con tf.GradientTape .
  2. Procesar los gradientes como desee.
  3. Aplicar los gradientes procesadas con apply_gradients() .

Ejemplo:

 # Create an optimizer.
opt = tf.keras.optimizers.SGD(learning_rate=0.1)

# Compute the gradients for a list of variables.
with tf.GradientTape() as tape:
  loss = <call_loss_function>
vars = <list_of_variables>
grads = tape.gradient(loss, vars)

# Process the gradients, for example cap them, etc.
# capped_grads = [MyCapper(g) for g in grads]
processed_grads = [process_gradient(g) for g in grads]

# Ask the optimizer to apply the processed gradients.
opt.apply_gradients(zip(processed_grads, var_list))
 

Uso con tf.distribute.Strategy

Esta clase optimizador es tf.distribute.Strategy conscientes, lo que significa que resume de forma automática gradientes en todas las réplicas. Para gradientes promedio, se divide su pérdida por el tamaño del lote mundial, que se realiza de forma automática si se utiliza tf.keras incorporados en los bucles de formación o evaluación. Ver la reduction argumento de la pérdida que debe ser ajustado a tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE para promediar o tf.keras.losses.Reduction.SUM por no.

Para gradientes agregados mismo, llame apply_gradients con experimental_aggregate_gradients establece en false. Esto es útil si necesita procesar gradientes agregados.

Si no está utilizando estos y desea gradientes promedio, se debe utilizar tf.math.reduce_sum a sumar sus pérdidas por ejemplo, y luego dividir por el tamaño global de lote. Tenga en cuenta que cuando se utiliza tf.distribute.Strategy , el primer componente de la forma de un tensor es el tamaño del lote de réplica local, que es apagado por un factor igual al número de réplicas se utiliza para calcular un solo paso. Como resultado, el uso de tf.math.reduce_mean dará la respuesta incorrecta, dando lugar a gradientes que pueden ser muchas veces demasiado grande.

Limitaciones variables

optimizadores de toda Keras respetan las restricciones variables. Si la función de restricción se pasa a cualquier variable, la restricción se aplicará a la variable después de la gradiente se ha aplicado a la variable. Importante: Si gradiente es tensor escasa, no se admite la restricción variable.

el hilo de compatibilidad

Todo el optimizador está actualmente hilo compatibles, no apta para subprocesos. El usuario necesita para realizar la sincronización si fuera necesario.

ranuras

Muchas subclases optimizador, como Adam y Adagrad asignar y gestionar las variables adicionales asociados con las variables para entrenar. Estos se llaman ranuras. Las ranuras tienen nombres y se puede pedir al optimizador para los nombres de las ranuras que utiliza. Una vez que tenga un nombre de ranura puede pedir al optimizador para la variable que crea para contener el valor ranura.

Esto puede ser útil si desea iniciar la sesión de depuración de un algoritmo de entrenamiento, las estadísticas del informe sobre las ranuras, etc.

hiperparámetros

Estos son argumentos pasados al constructor optimizador subclase (el __init__ método), y después se pasan a self._set_hyper() . Pueden ser valores regulares Python (como 1.0), tensores, o callables. Si son exigibles, el exigible será llamado durante apply_gradients() para obtener el valor para el parámetro hiper.

Hiperparámetros se pueden sobrescribir a través de código de usuario:

Ejemplo:

 # Create an optimizer with the desired parameters.
opt = tf.keras.optimizers.SGD(learning_rate=0.1)
# `loss` is a callable that takes no argument and returns the value
# to minimize.
loss = lambda: 3 * var1 + 2 * var2
# In eager mode, simply call minimize to update the list of variables.
opt.minimize(loss, var_list=[var1, var2])
# update learning rate
opt.learning_rate = 0.05
opt.minimize(loss, var_list=[var1, var2])
 

tasa de aprendizaje exigible

Optimizador acepta una tasa de aprendizaje se puede llamar de dos maneras. La primera forma es a través incorporado o personalizado tf.keras.optimizers.schedules.LearningRateSchedule . El horario será llamado en cada iteración con el schedule(iteration) , un tf.Variable poseído por el optimizador.

Ejemplo:

var = tf.Variable(np.random.random(size=(1,)))
learning_rate = tf.keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=.01, decay_steps=20, decay_rate=.1)
opt = tf.keras.optimizers.SGD(learning_rate=learning_rate)
loss = lambda: 3 * var
opt.minimize(loss, var_list=[var])
<tf.Variable...

La segunda forma es a través de una función exigible que no acepta ningún argumento.

Ejemplo:

var = tf.Variable(np.random.random(size=(1,)))
def lr_callable():
  return .1
opt = tf.keras.optimizers.SGD(learning_rate=lr_callable)
loss = lambda: 3 * var
opt.minimize(loss, var_list=[var])
<tf.Variable...

La creación de un optimizador de encargo

Si tiene la intención de crear su propio algoritmo de optimización, sólo tiene que heredar de esta clase y anular los métodos siguientes:

  • _resource_apply_dense (actualización variable dada tensor de gradiente es denso)
  • _resource_apply_sparse (tensor gradiente variable de actualización dado es escasa)
  • _create_slots (si su algoritmo optimizador requiere variables adicionales)
  • get_config (serialización del optimizador, incluye todos los parámetros de hiper)

name Una cadena no vacía. El nombre que se utilizará para acumuladores creados para el optimizador.
**kwargs argumentos de palabra clave. Permitido ser { clipnorm , clipvalue , lr , decay }. clipnorm es gradientes de clip por norma; clipvalue es gradientes de clip de valor, decay se incluye por compatibilidad hacia atrás para permitir que la decadencia de tiempo dependiente de la tasa de aprendizaje. lr se incluye para la compatibilidad con versiones anteriores, recomienda el uso de learning_rate lugar.

ValueError Si está mal formado nombre.

iterations Variable. El número de los pasos de formación de este optimizador se ha ejecutado.
weights Devoluciones variables de este optimizador basado en el orden creado.

Métodos

add_slot

Ver fuente

Agregar una nueva variable ranura para var .

add_weight

Ver fuente

apply_gradients

Ver fuente

Aplicar gradientes a las variables.

Esta es la segunda parte de minimize() . Devuelve una Operation que se aplica gradientes.

El método resume gradientes de todas las réplicas en presencia de tf.distribute.Strategy por defecto. Puede agregarse gradientes mismo pasando experimental_aggregate_gradients=False .

Ejemplo:

 grads = tape.gradient(loss, vars)
grads = tf.distribute.get_replica_context().all_reduce('sum', grads)
# Processing aggregated gradients.
optimizer.apply_gradients(zip(grads, vars),
    experimental_aggregate_gradients=False)

 

args
grads_and_vars Lista de (gradiente, variables) pares.
name nombre opcional para la operación devuelto. Por defecto al nombre pasa al Optimizer constructor.
experimental_aggregate_gradients Ya sea para resumir los gradientes de diferentes réplicas en el presense de tf.distribute.Strategy . Si es falso, es responsabilidad de los usuarios agregar los gradientes. Por defecto en True.

Devoluciones
Una Operation que aplica los gradientes especificados. Las iterations se incrementarán automáticamente por 1.

aumentos
TypeError Si grads_and_vars está mal formado.
ValueError Si ninguna de las variables tiene gradientes.

from_config

Ver fuente

Crea un optimizador de su configuración.

Este método es el reverso de get_config , capaz de crear instancias de la misma optimizador del diccionario config.

argumentos
config