Como tf.app.run()
funciona a demonstração de tradução do Tensorflow?
Em tensorflow/models/rnn/translate/translate.py
, há uma chamada para tf.app.run()
. Como está sendo tratado?
if __name__ == "__main__":
tf.app.run()
Como tf.app.run()
funciona a demonstração de tradução do Tensorflow?
Em tensorflow/models/rnn/translate/translate.py
, há uma chamada para tf.app.run()
. Como está sendo tratado?
if __name__ == "__main__":
tf.app.run()
Respostas:
if __name__ == "__main__":
significa que o arquivo atual é executado em um shell em vez de importado como um módulo.
tf.app.run()
Como você pode ver através do arquivo 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 quebrar linha por linha:
flags_passthrough = f._parse_flags(args=args)
Isso garante que o argumento que você passa pela linha de comando seja válido; por exemplo
python my_model.py --data_dir='...' --max_iteration=10000
, esse recurso é implementado com base no argparse
módulo padrão python .
main = main or sys.modules['__main__'].main
O primeiro main
no lado direito de =
é o primeiro argumento da função atual run(main=None, argv=None)
. Enquanto sys.modules['__main__']
significa atual arquivo em execução (por exemplo my_model.py
).
Portanto, existem dois casos:
Você não tem uma main
função em my_model.py
Então você tem que chamartf.app.run(my_main_running_function)
você tem uma main
função my_model.py
. (Este é principalmente o caso.)
Última linha:
sys.exit(main(sys.argv[:1] + flags_passthrough))
garante que sua função main(argv)
ou my_main_running_function(argv)
seja chamada com argumentos analisados corretamente.
abseil
qual TF deve ter absorvido abseil.io/docs/python/guides/flags
É apenas um invólucro muito rápido que lida com a análise de sinalizadores e depois despacha para o seu próprio main. Veja o código .
main = main or sys.modules['__main__'].main
e o que sys.exit(main(sys.argv[:1] + flags_passthrough))
significa?
main()
?
Não há nada de especial tf.app
. Este é apenas um script de ponto de entrada genérico , que
Executa o programa com uma função opcional 'main' e uma lista 'argv'.
Não tem nada a ver com redes neurais e apenas chama a função principal, passando por quaisquer argumentos a ela.
Em termos simples, o trabalho de tf.app.run()
é primeiro definir os sinalizadores globais para uso posterior, como:
from tensorflow.python.platform import flags
f = flags.FLAGS
e, em seguida, execute sua função principal personalizada com um conjunto de argumentos.
Por exemplo, na base de código TensorFlow NMT , o primeiro ponto de entrada para a execução do programa para treinamento / inferência começa neste ponto (veja o código abaixo)
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)
Após analisar os argumentos usando argparse
, tf.app.run()
você executa a função "main", definida 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)
Portanto, depois de definir os sinalizadores para uso global, tf.app.run()
basta executar a main
função que você passar para ela argv
como seus parâmetros.
PS: Como a resposta de Salvador Dali diz, acho que é apenas uma boa prática de engenharia de software, embora não tenha certeza se o TensorFlow executa uma execução otimizada da main
função do que aquela executada usando o CPython normal.
O código do Google depende muito do acesso de sinalizadores globais nos scripts libraries / binaries / python e, portanto, tf.app.run () analisa esses sinalizadores para criar um estado global na variável FLAGs (ou algo semelhante) e depois chama python main ( ) Como deveria.
Se eles não tiverem essa chamada para tf.app.run (), os usuários poderão esquecer de analisar FLAGs, fazendo com que essas bibliotecas / binários / scripts não tenham acesso aos FLAGs necessários.
2.0 compatível Resposta : Se você quiser usar tf.app.run()
em Tensorflow 2.0
, devemos usar o comando,
tf.compat.v1.app.run()
ou você pode usar tf_upgrade_v2
para converter o 1.x
código em 2.0
.
tf.flags.DEFINE_integer('batch_size', 128, 'Number of images to process in a batch.')
e, se usá-tf.app.run()
lo, configurará as coisas para que você possa acessar globalmente os valores passados dos sinalizadores que você definiu, comotf.flags.FLAGS.batch_size
de onde você precisar no seu código.