Guide de style du code TensorFlow

Style Python

Suivez le guide de style Python PEP 8 , sauf que TensorFlow utilise 2 espaces au lieu de 4. Veuillez vous conformer au guide de style Google Python et utilisez pylint pour vérifier vos modifications Python.

pylint

Pour installer pylint :

$ pip install pylint

Pour vérifier un fichier avec pylint à partir du répertoire racine du code source TensorFlow : 

$ pylint --rcfile=tensorflow/tools/ci_build/pylintrc tensorflow/python/keras/losses.py

Versions Python prises en charge

Pour les versions Python prises en charge, consultez le guide d'installation de TensorFlow .

Consultez l' état de la build continue de TensorFlow pour les builds officielles et prises en charge par la communauté.

Style de codage C++

Les modifications apportées au code TensorFlow C++ doivent être conformes au guide de style Google C++ et aux détails de style spécifiques à TensorFlow . Utilisez clang-format pour vérifier vos modifications C/C++.

Pour installer sur Ubuntu 16+, faites :

$ apt-get install -y clang-format

Vous pouvez vérifier le format d'un fichier C/C++ avec les éléments suivants : 

$ clang-format <my_cc_file> --style=google > /tmp/my_cc_file.cc
$ diff <my_cc_file> /tmp/my_cc_file.cc

Autres langues

Conventions TensorFlow et utilisations spéciales

Opérations Python

Une opération TensorFlow est une fonction qui, étant donné les tenseurs d'entrée, renvoie les tenseurs de sortie (ou ajoute une opération à un graphique lors de la création de graphiques).

  • Le premier argument doit être des tenseurs, suivis des paramètres Python de base. Le dernier argument est name avec la valeur par défaut None .
  • Les arguments tensoriels doivent être soit un seul tenseur, soit un itérable de tenseurs. Autrement dit, un « Tenseur ou une liste de Tenseurs » est trop large. Voir assert_proper_iterable .
  • Les opérations qui prennent des tenseurs comme arguments doivent appeler convert_to_tensor pour convertir les entrées non tensorielles en tenseurs si elles utilisent des opérations C++. Notez que les arguments sont toujours décrits comme un objet Tensor d'un type spécifique dans la documentation.
  • Chaque opération Python doit avoir un name_scope . Comme vu ci-dessous, transmettez le nom de l’opération sous forme de chaîne.
  • Les opérations doivent contenir un commentaire Python détaillé avec des déclarations Args et Returns qui expliquent à la fois le type et la signification de chaque valeur. Les formes, types ou rangs possibles doivent être spécifiés dans la description. Voir les détails de la documentation.
  • Pour une convivialité accrue, incluez un exemple d'utilisation avec les entrées/sorties de l'opération dans la section Exemple.
  • Évitez d'utiliser explicitement tf.Tensor.eval ou tf.Session.run . Par exemple, pour écrire une logique qui dépend de la valeur Tensor, utilisez le flux de contrôle TensorFlow. Vous pouvez également restreindre l’exécution de l’opération uniquement lorsque l’exécution rapide est activée ( tf.executing_eagerly() ).

Exemple:

def my_op(tensor_in, other_tensor_in, my_param, other_param=0.5,
          output_collections=(), name=None):
  """My operation that adds two tensors with given coefficients.

  Args:
    tensor_in: `Tensor`, input tensor.
    other_tensor_in: `Tensor`, same shape as `tensor_in`, other input tensor.
    my_param: `float`, coefficient for `tensor_in`.
    other_param: `float`, coefficient for `other_tensor_in`.
    output_collections: `tuple` of `string`s, name of the collection to
                        collect result of this op.
    name: `string`, name of the operation.

  Returns:
    `Tensor` of same shape as `tensor_in`, sum of input values with coefficients.

  Example:
    >>> my_op([1., 2.], [3., 4.], my_param=0.5, other_param=0.6,
              output_collections=['MY_OPS'], name='add_t1t2')
    [2.3, 3.4]
  """
  with tf.name_scope(name or "my_op"):
    tensor_in = tf.convert_to_tensor(tensor_in)
    other_tensor_in = tf.convert_to_tensor(other_tensor_in)
    result = my_param * tensor_in + other_param * other_tensor_in
    tf.add_to_collection(output_collections, result)
    return result

Usage:

output = my_op(t1, t2, my_param=0.5, other_param=0.6,
               output_collections=['MY_OPS'], name='add_t1t2')