Tf.app.run () कैसे काम करता है?

Question

tf.app.run()Tensorflow अनुवाद डेमो में कैसे काम करता है ?

में tensorflow/models/rnn/translate/translate.py, के लिए एक कॉल है tf.app.run()। इसे कैसे संभाला जा रहा है?

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

Answer 1

if __name__ == "__main__":

इसका मतलब है कि वर्तमान फ़ाइल को एक मॉड्यूल के रूप में आयात करने के बजाय एक शेल के तहत निष्पादित किया जाता है।

tf.app.run()

जैसा कि आप फ़ाइल के माध्यम से देख सकते हैं 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))

चलो लाइन को लाइन से तोड़ते हैं:

flags_passthrough = f._parse_flags(args=args)

यह सुनिश्चित करता है कि आप कमांड लाइन से गुजरने वाले तर्क मान्य हैं, उदाहरण के लिए python my_model.py --data_dir='...' --max_iteration=10000, वास्तव में यह सुविधा अजगर मानक argparseमॉड्यूल के आधार पर लागू की गई है ।

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

के mainदाहिने हिस्से में =पहला वर्तमान फ़ंक्शन का पहला तर्क है run(main=None, argv=None) । जबकि sys.modules['__main__']वर्तमान में चल रही फ़ाइल (जैसे my_model.py) का मतलब है ।

तो दो मामले हैं:

1. आपके पास तब कॉल करने के लिए कोई mainफ़ंक्शन नहीं हैmy_model.pytf.app.run(my_main_running_function)

2. यदि आप एक है mainमें समारोह my_model.py। (यह ज्यादातर मामला है।)

अंतिम पंक्ति:

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

सुनिश्चित करता है कि आपके main(argv)या my_main_running_function(argv)फ़ंक्शन को पार्स तर्कों के साथ ठीक से कहा गया है।

Comments

शुरुआत करने वाले Tensorflow उपयोगकर्ताओं के लिए पहेली का एक गायब टुकड़ा: Tensorflow में कुछ अंतर्निहित कमांड लाइन फ्लैग हैंडलिंग तंत्र है। आप अपने झंडे को परिभाषित कर सकते हैं जैसे tf.flags.DEFINE_integer('batch_size', 128, 'Number of images to process in a batch.')और फिर यदि आप इसका उपयोग करते हैं तो tf.app.run()यह चीजें सेट कर देगा ताकि आप विश्व स्तर पर आपके द्वारा निर्धारित झंडे के पारित मूल्यों तक पहुंच सकें, जैसे tf.flags.FLAGS.batch_sizeकि आपको अपने कोड में जहां भी इसकी आवश्यकता है।

— इसरांडी

मेरी राय में (वर्तमान) तीन का यह बेहतर उत्तर है। यह "कैसे करता है tf.app.run () काम" की व्याख्या करता है, जबकि अन्य दो जवाब बस कहते हैं कि यह क्या करता है।

— थॉमस फाउन्सेन्कर

ऐसा लगता है कि झंडे को संभाला गया है abseilजिसके द्वारा TF ने abseil.io/docs/python/guides/flags

— CpILL

Answer 2

यह सिर्फ एक बहुत तेज़ आवरण है जो ध्वज फ़र्श को संभालता है और फिर अपने स्वयं के मुख्य को भेजता है। कोड देखें ।

Comments

इसका क्या मतलब है "ध्वज प्रणाम संभालता है"? शायद आप शुरुआती को सूचित करने के लिए एक लिंक जोड़ सकते हैं कि इसका क्या मतलब है?

— पिनोच्चियो

यह फ़्लैग पैकेज का उपयोग करके प्रोग्राम को दिए गए कमांड-लाइन तर्कों को पार्स करता है। (जो कुछ आवरणों के साथ कवर के तहत मानक 'argparse' लाइब्रेरी का उपयोग करता है)। यह मेरे उत्तर से जुड़े कोड से जुड़ा हुआ है।

— डग

App.py में, क्या करते हैं main = main or sys.modules['__main__'].mainऔर क्या sys.exit(main(sys.argv[:1] + flags_passthrough))मतलब है?

— hAcKnRoCk

यह मेरे लिए अजीब लगता है, मुख्य फ़ंक्शन को सभी में क्यों लपेटें यदि आप इसे सीधे सीधे कॉल कर सकते हैं main()?

— चार्ली पार्कर

hAcKnRoCk: यदि फ़ाइल में कोई मुख्य नहीं है, तो यह इसके बजाय sys.modules [' main '] में उपयोग करता है । Sys.exit का मतलब मुख्य कमांड को चलाना है जो इस तरह से आर्गन्स और किसी भी झंडे का उपयोग करके पाया जाता है, और मुख्य के वापसी मूल्य के साथ बाहर निकलने के लिए। @CharlieParker - Google के मौजूदा अजगर ऐप पुस्तकालयों जैसे कि gflags और google-apputils के साथ संगतता के लिए। उदाहरण के लिए, github.com/google/google-apputils

— dga

Answer 3

में कुछ खास नहीं है tf.app। यह सिर्फ एक सामान्य प्रविष्टि बिंदु स्क्रिप्ट है , जो

एक वैकल्पिक 'मुख्य' फ़ंक्शन और 'argv' सूची के साथ प्रोग्राम चलाता है।

इसका तंत्रिका नेटवर्क से कोई लेना-देना नहीं है और यह किसी भी तर्कों से गुजरते हुए इसे मुख्य कार्य कहता है।

Answer 4

सरल शब्दों में, का काम tf.app.run()करने के लिए है पहले की तरह बाद में उपयोग के लिए वैश्विक झंडे सेट:

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

और फिर तर्कों के एक सेट के साथ अपने कस्टम मुख्य फ़ंक्शन को चलाएं ।

TensorFlow NMT कोडबेस में उदाहरण के लिए, प्रशिक्षण / अनुमान के लिए कार्यक्रम के निष्पादन के लिए बहुत पहले प्रवेश बिंदु इस बिंदु पर शुरू होता है (नीचे कोड देखें)

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)

उपयोग करने वाले तर्कों को पार्स करने के बाद argparse, tf.app.run()आप "मुख्य" फ़ंक्शन को चलाते हैं जिसे इस तरह परिभाषित किया गया है:

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)

इसलिए, वैश्विक उपयोग के लिए झंडे स्थापित करने के बाद, tf.app.run()बस चलता हैmain फ़ंक्शन को जिसे आप argvइसके मापदंडों के रूप में पास करते हैं ।

पुनश्च: जैसा कि साल्वाडोर डाली का जवाब कहता है, यह सिर्फ एक अच्छा सॉफ्टवेयर इंजीनियरिंग अभ्यास है, मुझे लगता है, हालांकि मुझे यकीन नहीं है कि टेन्सरफ्लो mainसामान्य सीपीयथॉन का उपयोग करके चलाए गए फ़ंक्शन की तुलना में किसी भी अनुकूलित रन का प्रदर्शन करता है ।

Answer 5

Google कोड पुस्तकालयों / बायनेरिज़ / अजगर लिपियों में पहुँचने वाले वैश्विक झंडों पर बहुत कुछ निर्भर करता है और इसलिए tf.app.run () उन झंडों को फ़्लैग्स (या कुछ इसी तरह) वैरिएबल में वैश्विक स्थिति बनाने के लिए बाहर निकालता है और फिर अजगर को मुख्य कहता है ( ) जैसा होना चाहिए।

यदि उनके पास यह कॉल tf.app.run () के लिए नहीं है, तो उपयोगकर्ता FLAG को पार्स करना भूल सकते हैं, जिससे इन पुस्तकालयों / बायनेरिज़ / स्क्रिप्ट्स को FLAG की एक्सेस नहीं मिल सकती है, जिनकी उन्हें आवश्यकता है।

Answer 6

2.0 संगत जवाब : यदि आप tf.app.run()में उपयोग करना चाहते हैं Tensorflow 2.0, तो हमें कमांड का उपयोग करना चाहिए,

tf.compat.v1.app.run()या आप कोड को tf_upgrade_v2परिवर्तित करने के लिए उपयोग कर सकते हैं ।1.x2.0