Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

tf.GradientTape

Versione TensorFlow 1 Visualizza sorgente su GitHub

Registrare le operazioni per la differenziazione automatica.

Utilizzato nei notebook

Utilizzato nella guida Utilizzato nei tutorial

Le operazioni vengono registrate se vengono eseguite all'interno di questo gestore di contesto e almeno uno dei loro input viene "guardato".

Le variabili tf.Variable (create da tf.Variable o tf.compat.v1.get_variable , dove trainable=True è l'impostazione predefinita in entrambi i casi) vengono automaticamente guardate. I tensori possono essere guardati manualmente invocando il metodo watch su questo gestore di contesto.

Ad esempio, considera la funzione y = x * x . Il gradiente in x = 3.0 può essere calcolato come:

 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
 

I GradientTapes possono essere nidificati per calcolare derivati ​​di ordine superiore. Per esempio,

 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
 

Per impostazione predefinita, le risorse detenute da GradientTape vengono rilasciate non appena viene chiamato il metodo GradientTape.gradient (). Per calcolare più gradienti sullo stesso calcolo, creare un nastro gradiente persistente. Ciò consente più chiamate al metodo gradiente () poiché le risorse vengono rilasciate quando l'oggetto nastro viene garbage collection. Per esempio:

 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
 

Per impostazione predefinita, GradientTape controllerà automaticamente tutte le variabili allenabili a cui si accede all'interno del contesto. Se si desidera un controllo watch_accessed_variables=False su quali variabili vengono monitorate, è possibile disabilitare il tracciamento automatico passando watch_accessed_variables=False al costruttore del nastro:

 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.
 

Tieni presente che quando usi i modelli devi assicurarti che le tue variabili esistano quando usi watch_accessed_variables=False . Altrimenti è abbastanza facile rendere la tua prima iterazione senza pendenze:

 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.
 

Si noti che solo i tensori con tipi reali o complessi sono differenziabili.

persistent Booleano che controlla se viene creato un nastro gradiente persistente. Falso per impostazione predefinita, il che significa che è possibile effettuare al massimo una chiamata al metodo gradiente () su questo oggetto.
watch_accessed_variables Booleano che controlla se il nastro viene automaticamente watch qualsiasi (addestrabili) variabili raggiunti mentre il nastro è attiva. I gradienti di significato predefiniti su True possono essere richiesti da qualsiasi risultato calcolato nel nastro derivato dalla lettura di una Variable allenabile. Se i falsi utenti devono watch esplicitamente qualsiasi Variable cui desiderano richiedere gradienti.

metodi

batch_jacobian

Vedi la fonte

Calcola e impila ad esempio i jacobiani.

Vedi l' articolo di Wikipedia per la definizione di un giacobino. Questa funzione è essenzialmente un'implementazione efficiente di quanto segue:

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

Si noti che rispetto a GradientTape.jacobian che calcola il gradiente di ciascun valore di output rispetto a ciascun valore di input, questa funzione è utile quando target[i,...] è indipendente dalla source[j,...] per j != i Questa ipotesi consente un calcolo più efficiente rispetto a GradientTape.jacobian . L'output, così come le attivazioni intermedie, sono di dimensione inferiore ed evitano un mucchio di zeri ridondanti che porterebbe al calcolo jacobiano data l'assunto di indipendenza.

Esempio di utilizzo:

 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 tensore con rango 2 o superiore e con forma [b, y1, ..., y_n]. target[i,...] dovrebbe dipendere solo dalla source[i,...] .
source Un tensore con rango 2 o superiore e con forma [b, x1, ..., x_m].
unconnected_gradients un valore che può contenere "nessuno" o "zero" e modifica il valore che verrà restituito se la destinazione e le origini non sono collegate. I possibili valori ed effetti sono dettagliati in "UnconnectedGradients" e il valore predefinito è "none".
parallel_iterations Una manopola per controllare quante iterazioni vengono inviate in parallelo. Questa manopola può essere utilizzata per controllare l'utilizzo totale della memoria.
experimental_use_pfor Se vero, usa pfor per calcolare il giacobino. Else usa un tf.while_loop.

ritorna
Un tensore t con forma [b, y_1, ..., y_n, x1, ..., x_m] dove t[i, ...] è la Jacobiana di target[i, ...] wrt source[i, ...] , ovvero i giacobini impilati per esempio.

alza
RuntimeError Se chiamato su un nastro non persistente con l'esecuzione desiderosa abilitata e senza abilitare speriment_use_pfor.
ValueError Se la vettorializzazione del calcolo jacobiano fallisce o se la prima dimensione del target e della source non corrispondono.

gradient

Vedi la fonte

Calcola il gradiente utilizzando le operazioni registrate nel contesto di questo nastro.

args
target un elenco o una struttura nidificata di tensori o variabili da differenziare.
sources un elenco o una struttura nidificata di tensori o variabili. target sarà differenziato rispetto agli elementi nelle sources .
output_gradients un elenco di gradienti, uno per ogni elemento del bersaglio. Il valore predefinito è Nessuno.
unconnected_gradients un valore che può contenere "nessuno" o "zero" e modifica il valore che verrà restituito se la destinazione e le origini non sono collegate. I possibili valori ed effetti sono dettagliati in "UnconnectedGradients" e il valore predefinito è "none".

ritorna
un elenco o una struttura nidificata di Tensor (o IndexedSlices o None), una per ogni elemento nelle sources . La struttura restituita è uguale alla struttura delle sources .

alza
RuntimeError se chiamato nel contesto del nastro o se chiamato più volte su un nastro non persistente.
ValueError se la destinazione è una variabile o se i gradienti non collegati vengono chiamati con un valore sconosciuto.

jacobian

Vedi la fonte

Calcola il jacobian usando le operazioni registrate nel contesto di questo nastro.

Vedi l' articolo di Wikipedia per la definizione di un giacobino.

Esempio di utilizzo:

 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 Tensore da differenziare.
sources un elenco o una struttura nidificata di tensori o variabili. target sarà differenziato rispetto agli elementi nelle sources .
unconnected_gradients un valore che può contenere "nessuno" o "zero" e modifica il valore che verrà restituito se la destinazione e le origini non sono collegate. I possibili valori ed effetti sono dettagliati in "UnconnectedGradients" e il valore predefinito è "none".
parallel_iterations Una manopola per controllare quante iterazioni vengono inviate in parallelo. Questa manopola può essere utilizzata per controllare l'utilizzo totale della memoria.
experimental_use_pfor Se vero, vettorializza il calcolo jacobiano. Altrimenti ricade in una sequenza while_loop. La vettorializzazione può talvolta fallire o portare a un uso eccessivo della memoria. Questa opzione può essere utilizzata per disabilitare la vettorializzazione in questi casi.

ritorna
Un elenco o una struttura nidificata di tensori (o nessuna), una per ogni elemento nelle sources . La struttura restituita è uguale alla struttura delle sources . Nota se qualsiasi sfumatura è scarsa (IndexedSlices), la funzione jacobian attualmente la rende densa e restituisce invece un Tensore. Questo potrebbe cambiare in futuro.