python - that - install tensorflow ubuntu
¿Cómo funciona tf.app.run()? (5)
El código de Google depende en gran medida de que las banderas globales estén accediendo en bibliotecas / binarios / scripts de python, por lo que tf.app.run () analiza esas banderas para crear un estado global en la variable FLAGs (o algo similar) y luego llama a python main ( ) como debería.
Si no tenían esta llamada a tf.app.run (), los usuarios podrían olvidarse de analizar los FLAG, lo que llevaría a que estas bibliotecas / binarios / scripts no tuvieran acceso a los FLAG que necesitan.
¿Cómo funciona
tf.app.run()
en Tensorflow traducir demo?
En
tensorflow/models/rnn/translate/translate.py
, hay una llamada a
tf.app.run()
.
¿Cómo se está manejando?
if __name__ == "__main__":
tf.app.run()
En términos simples, el trabajo de
tf.app.run()
es establecer
primero
los indicadores globales para su uso posterior como:
from tensorflow.python.platform import flags
f = flags.FLAGS
y luego ejecuta tu función principal personalizada con un conjunto de argumentos.
Por ejemplo, en la base de código NMT de TensorFlow , el primer punto de entrada para la ejecución del programa de capacitación / inferencia comienza en este punto (ver el código a continuación)
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)
Después de analizar los argumentos usando
argparse
, con
tf.app.run()
ejecuta la función "main" que se define como:
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)
Entonces, después de establecer las banderas para uso global,
tf.app.run()
simplemente ejecuta esa función
main
que le pasa con
argv
como sus parámetros.
PD: Supongo que, como dice
la respuesta de Salvador Dalí
, es solo una buena práctica de ingeniería de software, aunque no estoy seguro de si TensorFlow realiza alguna ejecución optimizada de la función
main
de la que se realizó utilizando CPython normal.
Es solo un contenedor muy rápido que maneja el análisis de banderas y luego se envía a su propio main. Mira el code .
No hay nada especial en
tf.app
.
Esto es solo un
script de punto de entrada genérico
, que
Ejecuta el programa con una función ''principal'' opcional y una lista ''argv''.
No tiene nada que ver con las redes neuronales y solo llama a la función principal, pasándole cualquier argumento.
if __name__ == "__main__":
significa que el archivo actual se ejecuta bajo un shell en lugar de importarse como un módulo.
tf.app.run()
Como puede ver a través del archivo
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))
Vamos a romper línea por línea:
flags_passthrough = f._parse_flags(args=args)
Esto garantiza que el argumento que pasa a través de la línea de comando es válido, por ejemplo,
python my_model.py --data_dir=''...'' --max_iteration=10000
En realidad, esta característica se implementa en
argparse
módulo de
argparse
estándar de
argparse
.
main = main or sys.modules[''__main__''].main
El primer
main
en el lado derecho de
=
es el primer argumento de la
run(main=None, argv=None)
función actual
run(main=None, argv=None)
.
Mientras que
sys.modules[''__main__'']
significa el archivo actual en ejecución (por ejemplo,
my_model.py
).
Entonces hay dos casos:
-
No tiene una función
main
enmy_model.py
Luego debe llamar atf.app.run(my_main_running_function)
-
Tiene una función
main
enmy_model.py
. (Este es principalmente el caso).
Última línea:
sys.exit(main(sys.argv[:1] + flags_passthrough))
asegura que su función
main(argv)
o
my_main_running_function(argv)
se llame con argumentos analizados correctamente.