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

tff.tf_computation

Visualizza sorgente su GitHub

Decora / avvolge funzioni Python e Defuns come calcoli TFF tensorflow.

Utilizzato nei notebook

Utilizzato nelle esercitazioni

Questo simbolo può essere utilizzato sia come decoratore o un involucro applicato ad una funzione dato come argomento. Gli schemi ed esempi di utilizzo supportati sono i seguenti:

  1. Convertire una funzione inline esistente in un calcolo TFF. Questo è il modo più semplice di utilizzo, e come si può incorporare il codice non TFF esistente per l'utilizzo con il quadro TFF. In questo modo, si invoca tff.tf_computation con un paio di argomenti, il primo essendo una funzione / defun che contiene la logica, e la seconda è il tipo TFF del parametro:
 foo = tff.tf_computation(lambda x: x > 10, tf.int32)
 

Dopo l'esecuzione del frammento di codice di cui sopra, foo diventa un'istanza di classe astratta Computation . Come tutti i calcoli, ha il type_signature immobile:

 str(foo.type_signature) == '(int32 -> bool)'
 

La funzione passata come parametro non deve essere un lambda, può anche essere una funzione Python esistente o un _defun_. Ecco come costruire un calcolo da parte dell'operatore tensorflow standard di tf.add :

 foo = tff.tf_computation(tf.add, (tf.int32, tf.int32))
 

La firma di tipo risultante è come previsto:

 str(foo.type_signature) == '(<int32,int32> -> int32)'
 

Se si intende creare un calcolo che non accetta alcun argomento, l'argomento tipo è semplicemente omesso. La funzione deve essere una funzione senza argomenti così:

 foo = tf_computation(lambda: tf.constant(10))
 
  1. Decorare una funzione Python o un _defun_ tensorflow con un tipo TFF per avvolgere come una computazione TFF. L'unica differenza tra questa modalità di utilizzo e quello di cui sopra è che invece di passaggio della funzione / defun come argomento, tff.tf_computation insieme al tipo specificatore opzionale è scritto sopra il corpo della funzione / del defun.

    Ecco un esempio di un calcolo che accetta un parametro:

 @tff.tf_computation(tf.int32)
def foo(x):
  return x > 10
 

Si può pensare a questa modalità di utilizzo come un semplice zucchero sintattico per l'esempio già dato in precedenza:

 foo = tff.tf_computation(lambda x: x > 10, tf.int32)
 

Ecco un esempio di calcolo senza parametri:

 @tff.tf_computation
def foo():
  return tf.constant(10)
 

Di nuovo, questo è lo zucchero meramente sintattico per l'esempio dato in precedenza:

 foo = tff.tf_computation(lambda: tf.constant(10))
 

Se la funzione Python ha più decoratori, tff.tf_computation dovrebbe essere quello più esterno (quello che appare per primo nella sequenza).

  1. Creare un callable polimorfico a un'istanza basata su argomentazioni, in modo simile a Defuns tensorflow che sono stati definiti, senza una firma di ingresso.

    Questa modalità di utilizzo è simmetrica a quelle sopra. Uno omette semplicemente l'indicatore di tipo, e si applica tff.tf_computation come decoratore o involucro ad una funzione / defun che si aspetta i parametri.

    Ecco un esempio di avvolgere un lambda come callable polimorfa:

 foo = tff.tf_computation(lambda x, y: x > y)
 

La risultante foo può essere utilizzato nello stesso modo come se fosse avuto il tipo di stato dichiarato; il calcolo corrispondente viene semplicemente creato su richiesta, nello stesso modo come Defuns tensorflow polimorfici creano e definizioni in funzione cache calcestruzzo per ogni combinazione di tipi di argomenti.

 ...foo(1, 2)...
...foo(0.5, 0.3)...
 

Ecco un esempio di creazione di un polimorfica richiamabile tramite decoratore:

 @tff.tf_computation
def foo(x, y):
  return x > y
 

La sintassi è simmetrica per tutti gli esempi già illustrati.

*args Sia una funzione / defun, o TFF tipo specifica, o entrambi (funzione prima), o nessuno, come documentato nei 3 modelli ed esempi di utilizzo sopra.

Se invocato con una funzione come argomento, restituisce un'istanza di una computazione TFF costruito sulla base di questa funzione. Se chiamato senza uno, come nel tipico stile decoratore di utilizzo, restituisce un callable che aspetta di essere chiamato con la definizione di funzione fornito come parametro; vedere i modelli ed esempi di utilizzo sopra.