Cette page a été traduite par l'API Cloud Translation.
Switch to English

tff.tf_computation

Voir la source sur GitHub

Décore / enveloppe fonctions Python et Defuns que les calculs TFF tensorflow.

Utilisé dans les ordinateurs portables

Utilisé dans les tutoriels

Ce symbole peut être utilisé comme un décorateur ou un emballage appliqué à une fonction donnée comme un argument. Les modèles pris en charge et des exemples d'utilisation sont les suivantes:

  1. Convertir une ligne de fonction existante dans un calcul de TFF. Ceci est le plus simple mode d'utilisation, et comment on peut intégrer le code existant non-TFF pour une utilisation avec le cadre de TFF. Dans ce mode, on invoque tff.tf_computation avec une paire d'arguments, la première étant une fonction / defun qui contient la logique, et le second étant le type de la FFT du paramètre:
 foo = tff.tf_computation(lambda x: x > 10, tf.int32)
 

Après l' exécution de l'extrait de code ci - dessus, foo devient une instance de la classe de base abstraite Computation . Comme tous les calculs, il a la type_signature propriété:

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

La fonction passée en paramètre ne doit pas être un lambda, il peut aussi être une fonction Python existant ou un defun. Voici comment construire un calcul de l'opérateur standard tensorflow tf.add :

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

La signature de type obtenu est comme prévu:

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

Si on a l'intention de créer un calcul qui n'accepte pas d'arguments, l'argument de type est simplement omis. La fonction doit être une fonction sans argument ainsi:

 foo = tf_computation(lambda: tf.constant(10))
 
  1. Décorer une fonction ou d'un python defun tensorflow avec un type de la FFT de l'envelopper comme un calcul de la FFT. La seule différence entre ce mode d'utilisation et celle mentionnée ci - dessus est que , au lieu de passer de la fonction / defun comme argument, tff.tf_computation avec le spécificateur de type facultatif est écrite au- dessus du corps de la fonction / defun.

    Voici un exemple d'un calcul qui accepte un paramètre:

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

On peut penser à ce mode d'utilisation comme un simple sucre syntaxique pour l'exemple déjà donné plus tôt:

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

Voici un exemple d'un calcul sans paramètre:

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

Encore une fois, ce sucre est simplement syntaxique pour l'exemple donné plus tôt:

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

Si la fonction python a plusieurs décorateurs, tff.tf_computation devrait être le plus à l'extérieur (celui qui apparaît en premier dans la séquence).

  1. Créer un appelable polymorphes à instancier fondée sur des arguments, de façon similaire à tensorflow Defuns qui ont été définis sans la signature d'entrée.

    Ce mode d'utilisation est symétrique à ceux ci-dessus. On omet simplement le spécificateur de type, et applique tff.tf_computation comme un décorateur ou un emballage à une fonction / defun qui ne se attend paramètres.

    Voici un exemple d'envelopper un lambda comme appelable polymorphes:

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

Le résultat foo peut être utilisé de la même manière que si elle était le type avait été déclaré; le calcul correspondant est simplement créé à la demande, de la même manière que la façon dont Defuns de tensorflow polymorphes créer et définitions de fonctions de béton de cache pour chaque combinaison de types d'arguments.

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

Voici un exemple de création d'un appelable polymorphes par décorateur:

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

La syntaxe est symétrique à tous les exemples déjà affichés.

*args Soit une fonction / defun ou spécification de type TFF, ou les deux (première fonction), ou aucun des deux, comme indiqué dans les schémas 3 et des exemples d'utilisation ci-dessus.

Si elle est invoquée avec une fonction comme argument, renvoie une instance d'un calcul de TFF construit sur la base de cette fonction. Appelée sans un, comme dans le style typique décorateur d'utilisation, retourne une appelable qui attend d'être appelé à la définition de la fonction fournie en tant que paramètre; voir les modèles et exemples d'utilisation ci-dessus.