Comment fonctionne tf.app.run ()?

Comment tf.app.run()fonctionne la démo de Tensorflow?

Dans tensorflow/models/rnn/translate/translate.py, il y a un appel à tf.app.run(). Comment cela est-il géré?

if __name__ == "__main__":
    tf.app.run() 

if __name__ == "__main__":

signifie que le fichier courant est exécuté sous un shell au lieu d'être importé en tant que module.

tf.app.run()

Comme vous pouvez le voir à travers le fichier app.py

def run(main=None, argv=None):
  """Runs the program with an optional 'main' function and 'argv' list."""
  f = flags.FLAGS

  # Extract the args from the optional `argv` list.
  args = argv[1:] if argv else None

  # Parse the known flags from that list, or from the command
  # line otherwise.
  # pylint: disable=protected-access
  flags_passthrough = f._parse_flags(args=args)
  # pylint: enable=protected-access

  main = main or sys.modules['__main__'].main

  # Call the main function, passing through any arguments
  # to the final program.
  sys.exit(main(sys.argv[:1] + flags_passthrough))

Coupons ligne par ligne:

flags_passthrough = f._parse_flags(args=args)

Cela garantit que l'argument que vous passez à travers la ligne de commande est valide, par exemple, en python my_model.py --data_dir='...' --max_iteration=10000fait, cette fonctionnalité est implémentée sur la base du argparsemodule standard python .

main = main or sys.modules['__main__'].main

Le premier mainà droite de =est le premier argument de la fonction courante run(main=None, argv=None) . Alors que sys.modules['__main__']signifie le fichier en cours d'exécution (par exemple my_model.py).

Il y a donc deux cas:

1. Vous n'avez pas de mainfonction dans my_model.pyEnsuite, vous devez appelertf.app.run(my_main_running_function)

2. vous avez une mainfonction dans my_model.py. (C'est surtout le cas.)

Dernière ligne:

sys.exit(main(sys.argv[:1] + flags_passthrough))

garantit que votre fonction main(argv)ou my_main_running_function(argv)est appelée correctement avec des arguments analysés.

C'est juste un wrapper très rapide qui gère l'analyse des indicateurs, puis les distribue à votre propre main. Voir le code .

Il n'y a rien de spécial tf.app. Ceci est juste un script de point d'entrée générique , qui

Exécute le programme avec une fonction optionnelle «main» et une liste «argv».

Cela n'a rien à voir avec les réseaux de neurones et il appelle simplement la fonction principale, en lui passant des arguments.

En termes simples, le travail de tf.app.run()consiste à définir d' abord les indicateurs globaux pour une utilisation ultérieure, comme:

from tensorflow.python.platform import flags
f = flags.FLAGS

puis exécutez votre fonction principale personnalisée avec un ensemble d'arguments.

Par exemple, dans la base de code TensorFlow NMT , le tout premier point d'entrée pour l'exécution du programme pour l'apprentissage / l'inférence commence à ce stade (voir le code ci-dessous)

if __name__ == "__main__":
  nmt_parser = argparse.ArgumentParser()
  add_arguments(nmt_parser)
  FLAGS, unparsed = nmt_parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

Après avoir analysé les arguments en utilisant argparse, avec tf.app.run()vous exécutez la fonction "main" qui est définie comme:

def main(unused_argv):
  default_hparams = create_hparams(FLAGS)
  train_fn = train.train
  inference_fn = inference.inference
  run_main(FLAGS, default_hparams, train_fn, inference_fn)

Ainsi, après avoir défini les indicateurs pour une utilisation globale, tf.app.run()lance simplement la mainfonction que vous lui passez avec argvcomme paramètres.

PS: Comme le dit la réponse de Salvador Dali , c'est juste une bonne pratique d'ingénierie logicielle, je suppose, même si je ne suis pas sûr que TensorFlow exécute une exécution optimisée de la mainfonction que celle qui a été exécutée en utilisant CPython normal.

Le code de Google dépend beaucoup de l'accès aux indicateurs globaux dans les bibliothèques / binaires / scripts python et donc tf.app.run () analyse ces indicateurs pour créer un état global dans la variable FLAGs (ou quelque chose de similaire) puis appelle python main ( ) Comme il se doit.

S'ils n'avaient pas cet appel à tf.app.run (), alors les utilisateurs pourraient oublier de faire l'analyse des FLAG, ce qui empêcherait ces bibliothèques / binaires / scripts d'avoir accès aux FLAG dont ils ont besoin.

Réponse compatible 2.0 : Si vous souhaitez utiliser tf.app.run()dans Tensorflow 2.0, nous devons utiliser la commande,

tf.compat.v1.app.run()ou vous pouvez utiliser tf_upgrade_v2pour convertir le 1.xcode en 2.0.