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

tf.GradientTape

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

Registro de operaciones para diferenciación automática.

Usado en los cuadernos

Usado en la guía Usado en los tutoriales

Las operaciones se registran si se ejecutan dentro de este administrador de contexto y al menos una de sus entradas está siendo "observada".

Las variables entrenables (creadas por tf.Variable o tf.compat.v1.get_variable , donde trainable=True es el valor predeterminado en ambos casos) se observan automáticamente. Los tensores pueden observarse manualmente invocando el método de watch en este administrador de contexto.

Por ejemplo, considere la función y = x * x . El gradiente en x = 3.0 se puede calcular como:

 x = tf.constant(3.0)
with tf.GradientTape() as g:
  g.watch(x)
  y = x * x
dy_dx = g.gradient(y, x) # Will compute to 6.0
 

GradientTapes se puede anidar para calcular derivados de orden superior. Por ejemplo,

 x = tf.constant(3.0)
with tf.GradientTape() as g:
  g.watch(x)
  with tf.GradientTape() as gg:
    gg.watch(x)
    y = x * x
  dy_dx = gg.gradient(y, x)     # Will compute to 6.0
d2y_dx2 = g.gradient(dy_dx, x)  # Will compute to 2.0
 

Por defecto, los recursos que posee GradientTape se liberan tan pronto como se llama al método GradientTape.gradient (). Para calcular múltiples gradientes sobre el mismo cálculo, cree una cinta de gradiente persistente. Esto permite múltiples llamadas al método gradiente () a medida que se liberan recursos cuando el objeto de cinta se recolecta basura. Por ejemplo:

 x = tf.constant(3.0)
with tf.GradientTape(persistent=True) as g:
  g.watch(x)
  y = x * x
  z = y * y
dz_dx = g.gradient(z, x)  # 108.0 (4*x^3 at x = 3)
dy_dx = g.gradient(y, x)  # 6.0
del g  # Drop the reference to the tape
 

De forma predeterminada, GradientTape observará automáticamente cualquier variable entrenable a la que se acceda dentro del contexto. Si desea un control detallado sobre qué variables se observan, puede deshabilitar el seguimiento automático pasando watch_accessed_variables=False al constructor de la cinta:

 with tf.GradientTape(watch_accessed_variables=False) as tape:
  tape.watch(variable_a)
  y = variable_a ** 2  # Gradients will be available for `variable_a`.
  z = variable_b ** 3  # No gradients will be available since `variable_b` is
                       # not being watched.
 

Tenga en cuenta que cuando use modelos, debe asegurarse de que sus variables existan cuando use watch_accessed_variables=False . De lo contrario, es bastante fácil hacer que su primera iteración no tenga gradientes:

 a = tf.keras.layers.Dense(32)
b = tf.keras.layers.Dense(32)

with tf.GradientTape(watch_accessed_variables=False) as tape:
  tape.watch(a.variables)  # Since `a.build` has not been called at this point
                           # `a.variables` will return an empty list and the
                           # tape will not be watching anything.
  result = b(a(inputs))
  tape.gradient(result, a.variables)  # The result of this computation will be
                                      # a list of `None`s since a's variables
                                      # are not being watched.
 

Tenga en cuenta que solo los tensores con tipos reales o complejos son diferenciables.

persistent Booleano que controla si se crea una cinta de degradado persistente. Falso por defecto, lo que significa que a lo sumo se puede hacer una llamada al método gradient () en este objeto.
watch_accessed_variables Booleano que controla si la cinta watch automáticamente cualquier variable (entrenable) a la que se acceda mientras la cinta está activa. Los valores predeterminados de gradientes de significado verdadero se pueden solicitar a cualquier resultado calculado en la cinta derivada de la lectura de una Variable entrenable. Si los usuarios falsos deben watch explícitamente cualquier Variable la que desean solicitar gradientes.

Métodos

batch_jacobian

Ver fuente

Calcula y apila por ejemplo jacobianos.

Vea el artículo de Wikipedia para la definición de un jacobiano. Esta función es esencialmente una implementación eficiente de lo siguiente:

tf.stack([self.jacobian(y[i], x[i]) for i in range(x.shape[0])]) .

Tenga en cuenta que, en comparación con GradientTape.jacobian que calcula el gradiente de cada valor de salida con cada valor de entrada, esta función es útil cuando el target[i,...] es independiente de la source[j,...] para j != i Esta suposición permite un cálculo más eficiente en comparación con GradientTape.jacobian . La salida, así como las activaciones intermedias, son de menor dimensión y evitan un montón de ceros redundantes que darían como resultado el cálculo jacobiano dado el supuesto de independencia.

Ejemplo de uso:

 with tf.GradientTape() as g:
  x = tf.constant([[1., 2.], [3., 4.]], dtype=tf.float32)
  g.watch(x)
  y = x * x
batch_jacobian = g.batch_jacobian(y, x)
# batch_jacobian is [[[2,  0], [0,  4]], [[6,  0], [0,  8]]]
 

Args
target Un tensor con rango 2 o superior y con forma [b, y1, ..., y_n]. target[i,...] solo debe depender de la source[i,...] .
source Un tensor con rango 2 o superior y con forma [b, x1, ..., x_m].
unconnected_gradients un valor que puede contener 'ninguno' o 'cero' y altera el valor que se devolverá si el objetivo y las fuentes están desconectados. Los posibles valores y efectos se detallan en 'UnconnectedGradients' y su valor predeterminado es 'none'.
parallel_iterations Una perilla para controlar cuántas iteraciones se envían en paralelo. Esta perilla se puede usar para controlar el uso total de la memoria.
experimental_use_pfor Si es cierto, usa pfor para calcular el jacobiano. Else usa un tf.while_loop.

Devoluciones
Un tensor t con forma [b, y_1, ..., y_n, x1, ..., x_m] donde t[i, ...] es el jacobiano del target[i, ...] wrt source[i, ...] , es decir, apilados por ejemplo jacobianos.

Plantea
RuntimeError Si se llama en una cinta no persistente con ejecución ansiosa habilitada y sin habilitar experimental_use_pfor.
ValueError Si la vectorización del cálculo jacobiano falla o si la primera dimensión del target y la source no coinciden.

gradient

Ver fuente

Calcula el gradiente utilizando operaciones registradas en el contexto de esta cinta.

Args
target Una lista o estructura anidada de tensores o variables a diferenciar.
sources una lista o estructura anidada de tensores o variables. target se diferenciará de los elementos en las sources .
output_gradients Una lista de gradientes, uno para cada elemento de destino. Por defecto es Ninguno.
unconnected_gradients un valor que puede contener 'ninguno' o 'cero' y altera el valor que se devolverá si el objetivo y las fuentes no están conectados. Los posibles valores y efectos se detallan en 'UnconnectedGradients' y su valor predeterminado es 'none'.

Devoluciones
una lista o estructura anidada de Tensores (o IndexedSlices, o None), uno para cada elemento en las sources . La estructura devuelta es la misma que la estructura de las sources .

Plantea
RuntimeError si se llama dentro del contexto de la cinta, o si se llama más de una vez en una cinta no persistente.
ValueError si el objetivo es una variable o si se llama a gradientes no conectados con un valor desconocido.

jacobian

Ver fuente

Calcula el jacobiano utilizando operaciones grabadas en el contexto de esta cinta.

Vea el artículo de Wikipedia para la definición de un jacobiano.

Ejemplo de uso:

 with tf.GradientTape() as g:
  x  = tf.constant([1.0, 2.0])
  g.watch(x)
  y = x * x
jacobian = g.jacobian(y, x)
# jacobian value is [[2., 0.], [0., 4.]]
 

Args
target Tensor a diferenciar.
sources una lista o estructura anidada de tensores o variables. target se diferenciará de los elementos en las sources .
unconnected_gradients un valor que puede contener 'ninguno' o 'cero' y altera el valor que se devolverá si el objetivo y las fuentes están desconectados. Los posibles valores y efectos se detallan en 'UnconnectedGradients' y su valor predeterminado es 'none'.
parallel_iterations Una perilla para controlar cuántas iteraciones se envían en paralelo. Esta perilla se puede usar para controlar el uso total de la memoria.
experimental_use_pfor Si es cierto, vectoriza el cálculo jacobiano. Else vuelve a caer en un secuencial while_loop. La vectorización a veces puede fallar o conducir al uso excesivo de memoria. Esta opción se puede usar para deshabilitar la vectorización en tales casos.

Devoluciones
Una lista o estructura anidada de Tensores (o Ninguno), uno para cada elemento en las sources . La estructura devuelta es la misma que la estructura de las sources . Tenga en cuenta que si algún gradiente es escaso (IndexedSlices), la función jacobian actualmente lo hace denso y devuelve un Tensor en su lugar. Esto puede cambiar en el futuro.

Plantea
RuntimeError Si se llama en una cinta no persistente con ejecución ansiosa habilitada y sin habilitar experimental_use_pfor.
ValueError Si la vectorización de la computación jacobiana falla.

reset

Ver fuente

Borra toda la información almacenada en esta cinta.

Equivalente a salir y volver a ingresar al administrador de contexto de cinta con una nueva cinta. Por ejemplo, los dos siguientes bloques de código son equivalentes:

 with tf.GradientTape() as t:
  loss = loss_fn()
with tf.GradientTape() as t:
  loss += other_loss_fn()
t.gradient(loss, ...)  # Only differentiates other_loss_fn, not loss_fn


# The following is equivalent to the above
with tf.GradientTape() as t:
  loss = loss_fn()
  t.reset()
  loss += other_loss_fn()
t.gradient(loss, ...)  # Only differentiates other_loss_fn, not loss_fn
 

Esto es útil si no desea salir del administrador de contexto para la cinta, o no puede porque el punto de reinicio deseado está dentro de una construcción de flujo de control:

 with tf.GradientTape() as t:
  loss = ...
  if loss > k:
    t.reset()
 

stop_recording

Ver fuente

Detiene temporalmente las operaciones de grabación en esta cinta.

Las operaciones ejecutadas mientras este administrador de contexto está activo no se grabará