मोबाइल के लिए टीएफएक्स

परिचय

यह मार्गदर्शिका दर्शाती है कि कैसे Tensorflow Extended (TFX) मशीन लर्निंग मॉडल बना सकता है और उनका मूल्यांकन कर सकता है जिन्हें डिवाइस पर तैनात किया जाएगा। TFX अब TFLite के लिए मूल समर्थन प्रदान करता है, जिससे मोबाइल उपकरणों पर अत्यधिक कुशल अनुमान करना संभव हो जाता है।

यह मार्गदर्शिका आपको उन परिवर्तनों के बारे में बताती है जो TFLite मॉडल बनाने और उनका मूल्यांकन करने के लिए किसी भी पाइपलाइन में किए जा सकते हैं। हम यहां एक संपूर्ण उदाहरण प्रदान करते हैं, यह प्रदर्शित करते हुए कि TFX कैसे MNIST डेटासेट से प्रशिक्षित TFLite मॉडल को प्रशिक्षित और मूल्यांकन कर सकता है। इसके अलावा, हम दिखाते हैं कि कैसे एक ही पाइपलाइन का उपयोग मानक केरस-आधारित सहेजे गए मॉडल के साथ-साथ टीएफलाइट एक दोनों को एक साथ निर्यात करने के लिए किया जा सकता है, जिससे उपयोगकर्ता दोनों की गुणवत्ता की तुलना कर सकते हैं।

हम मानते हैं कि आप TFX, हमारे घटकों और हमारी पाइपलाइनों से परिचित हैं। यदि नहीं, तो कृपया इस ट्यूटोरियल को देखें।

कदम

TFX में TFlite मॉडल बनाने और उसका मूल्यांकन करने के लिए केवल दो चरणों की आवश्यकता है। पहला कदम प्रशिक्षित टेंसरफ्लो मॉडल को टीएफलाइट मॉडल में बदलने के लिए टीएफएक्स ट्रेनर के संदर्भ में टीएफलाइट रीराइटर का आह्वान कर रहा है। दूसरा चरण टीएफलाइट मॉडल का मूल्यांकन करने के लिए मूल्यांकनकर्ता को कॉन्फ़िगर कर रहा है। अब हम बारी-बारी से प्रत्येक पर चर्चा करते हैं।

ट्रेनर के भीतर TFLite पुनर्लेखक को आमंत्रित करना।

TFX ट्रेनर एक मॉड्यूल फ़ाइल में उपयोगकर्ता द्वारा परिभाषित run_fn निर्दिष्ट करने की अपेक्षा करता है। यह run_fn प्रशिक्षित किए जाने वाले मॉडल को परिभाषित करता है, इसे निर्दिष्ट संख्या में पुनरावृत्तियों के लिए प्रशिक्षित करता है, और प्रशिक्षित मॉडल को निर्यात करता है।

इस खंड के बाकी हिस्सों में, हम कोड स्निपेट प्रदान करते हैं जो टीएफलाइट रीराइटर को लागू करने और टीएफलाइट मॉडल को निर्यात करने के लिए आवश्यक परिवर्तन दिखाते हैं। यह सभी कोड MNIST TFLite मॉड्यूल के run_fn में स्थित है।

जैसा कि नीचे दिए गए कोड में दिखाया गया है, हमें पहले एक सिग्नेचर बनाना होगा जो इनपुट के रूप में हर फीचर के लिए एक Tensor लेता है। ध्यान दें कि यह TFX के अधिकांश मौजूदा मॉडलों से एक प्रस्थान है, जो इनपुट के रूप में क्रमबद्ध tf.Example protos लेते हैं।

 signatures = {
      'serving_default':
          _get_serve_tf_examples_fn(
              model, tf_transform_output).get_concrete_function(
                  tf.TensorSpec(
                      shape=[None, 784],
                      dtype=tf.float32,
                      name='image_floats'))
  }

फिर केरस मॉडल को एक सहेजे गए मॉडल के रूप में उसी तरह सहेजा जाता है जैसे यह सामान्य रूप से होता है।

  temp_saving_model_dir = os.path.join(fn_args.serving_model_dir, 'temp')
  model.save(temp_saving_model_dir, save_format='tf', signatures=signatures)

अंत में, हम TFLite पुनर्लेखक ( tfrw ) का एक उदाहरण बनाते हैं, और इसे TFLite मॉडल प्राप्त करने के लिए SavedModel पर लागू करते हैं। हम इस TFLite मॉडल को serving_model_dir के कॉलर द्वारा प्रदान किए गए service_model_dir में run_fn करते हैं। इस तरह, टीएफलाइट मॉडल को उस स्थान पर संग्रहीत किया जाता है जहां सभी डाउनस्ट्रीम टीएफएक्स घटकों को मॉडल खोजने की उम्मीद होगी।

  tfrw = rewriter_factory.create_rewriter(
      rewriter_factory.TFLITE_REWRITER, name='tflite_rewriter')
  converters.rewrite_saved_model(temp_saving_model_dir,
                                 fn_args.serving_model_dir,
                                 tfrw,
                                 rewriter.ModelType.TFLITE_MODEL)

TFlite मॉडल का मूल्यांकन।

टीएफएक्स मूल्यांकनकर्ता मेट्रिक्स की एक विस्तृत श्रृंखला में उनकी गुणवत्ता को समझने के लिए प्रशिक्षित मॉडलों का विश्लेषण करने की क्षमता प्रदान करता है। सहेजे गए मॉडल का विश्लेषण करने के अलावा, टीएफएक्स मूल्यांकनकर्ता अब टीएफलाइट मॉडल का भी विश्लेषण करने में सक्षम है।

निम्नलिखित कोड स्निपेट ( एमएनआईएसटी पाइपलाइन से पुन: प्रस्तुत), दिखाता है कि एक मूल्यांकनकर्ता को कैसे कॉन्फ़िगर किया जाए जो एक टीएफलाइट मॉडल का विश्लेषण करता है।

  # Informs the evaluator that the model is a TFLite model.
  eval_config_lite.model_specs[0].model_type = 'tf_lite'

  ...

  # Uses TFMA to compute the evaluation statistics over features of a TFLite
  # model.
  model_analyzer_lite = Evaluator(
      examples=example_gen.outputs['examples'],
      model=trainer_lite.outputs['model'],
      eval_config=eval_config_lite,
  ).with_id('mnist_lite')

जैसा कि ऊपर दिखाया गया है, हमें केवल एक ही बदलाव करने की आवश्यकता है, वह है model_type फ़ील्ड को tf_lite पर सेट करना। TFlite मॉडल का विश्लेषण करने के लिए किसी अन्य कॉन्फ़िगरेशन परिवर्तन की आवश्यकता नहीं है। भले ही एक TFLite मॉडल या एक सहेजे गए मॉडल का विश्लेषण किया गया हो, Evaluator के आउटपुट में बिल्कुल समान संरचना होगी।

हालांकि, कृपया ध्यान दें कि मूल्यांकनकर्ता यह मानता है कि TFLite मॉडल को tflite नाम की फ़ाइल में Trainer_lite.outputs['model'] में सहेजा गया है।