इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TFX में TensorFlow 2.x

TensorFlow 2.0 को 2019 में जारी किया गया था , जिसमें केरस के तंग एकीकरण , डिफ़ॉल्ट रूप से उत्सुक निष्पादन और अन्य नई सुविधाओं और सुधारों के बीच पायथनिक कार्य निष्पादन शामिल है।

यह गाइड टीएफएक्स में TF 2.x का एक व्यापक तकनीकी अवलोकन प्रदान करता है।

किस संस्करण का उपयोग करें?

TFX TensorFlow 2.x के साथ संगत है, और TensorFlow 1.x (विशेष रूप से एस्टिमेटर्स) में मौजूद उच्च-स्तरीय API काम करना जारी रखते हैं।

TensorFlow 2.x में नई परियोजनाएँ शुरू करें

चूंकि TensorFlow 2.x TensorFlow 1.x की उच्च-स्तरीय क्षमताओं को बरकरार रखता है, इसलिए नई परियोजनाओं पर पुराने संस्करण का उपयोग करने का कोई लाभ नहीं है, भले ही आप नई सुविधाओं का उपयोग करने की योजना न करें।

इसलिए, यदि आप एक नया TFX प्रोजेक्ट शुरू कर रहे हैं, तो हम अनुशंसा करते हैं कि आप TensorFlow 2.x का उपयोग करें। आप अपने कोड को बाद में केयर्स और अन्य नई सुविधाओं के लिए पूर्ण समर्थन के रूप में अद्यतन करना चाहते हैं और उपलब्ध हो सकते हैं, और यदि आप TensorFlow 2.x से अपग्रेड करने की कोशिश कर रहे हैं, तो TensorFlow 2.x के साथ शुरू होने पर परिवर्तनों का दायरा बहुत सीमित होगा। भविष्य।

मौजूदा प्रोजेक्ट्स को TensorFlow 2.x में बदलना

TensorFlow 1.x के लिए लिखा गया कोड TensorFlow 2.x के साथ काफी हद तक संगत है और TFX में काम करना जारी रखेगा।

हालाँकि, यदि आप सुधार और नई सुविधाओं का लाभ उठाना चाहते हैं, क्योंकि वे TF 2.x में उपलब्ध हैं, तो आप TF 2.x पर माइग्रेट करने के निर्देशों का पालन कर सकते हैं।

क़ीमत लगानेवाला

अनुमानक एपीआई को TensorFlow 2.x में बनाए रखा गया है, लेकिन नई सुविधाओं और विकास का ध्यान नहीं है। TensorFlow 1.x या 2.x में एस्टिमेटर्स का उपयोग करके लिखा गया कोड TFX में अपेक्षित रूप से काम करता रहेगा।

शुद्ध एस्टिमेटर का उपयोग कर यहां एंड-टू-एंड TFX उदाहरण है: टैक्सी उदाहरण (एस्टिमेटर)

model_to_estimator साथ model_to_estimator

केरस मॉडल को tf.keras.estimator.model_to_estimator फ़ंक्शन के साथ लपेटा जा सकता है, जो उन्हें tf.keras.estimator.model_to_estimator लिए काम करने की अनुमति देता है। इसका उपयोग करने के लिए:

  1. केरस मॉडल बनाएँ।
  2. संकलित मॉडल को model_to_estimator में पास करें।
  3. ट्रेनर में model_to_estimator के परिणाम का उपयोग करें, जिस तरह से आप आमतौर पर एक अनुमानक का उपयोग करेंगे।
# Build a Keras model.
def _keras_model_builder():
  """Creates a Keras model."""
  ...

  model = tf.keras.Model(inputs=inputs, outputs=output)
  model.compile()

  return model


# Write a typical trainer function
def trainer_fn(trainer_fn_args, schema):
  """Build the estimator, using model_to_estimator."""
  ...

  # Model to estimator
  estimator = tf.keras.estimator.model_to_estimator(
      keras_model=_keras_model_builder(), config=run_config)

  return {
      'estimator': estimator,
      ...
  }

ट्रेनर की उपयोगकर्ता मॉड्यूल फ़ाइल के अलावा, बाकी पाइपलाइन अपरिवर्तित रहती है। यहाँ मॉडल -to_estimator के साथ Keras का उपयोग करते हुए एक एंड-टू-एंड TFX उदाहरण है: Iris उदाहरण (model_to_estimator)

मूल निवासी (यानी model_to_estimator बिना model_to_estimator )

उदाहरण और कोलाब

यहाँ देशी केरस के साथ कई उदाहरण हैं:

हमारे पास एक प्रति-घटक केरस कोलाब भी है

TFX घटक

निम्नलिखित अनुभाग बताते हैं कि कैसे संबंधित TFX घटक देशी करेस का समर्थन करते हैं।

परिवर्तन

वर्तमान में ट्रांसफॉर्म को केरस मॉडल के लिए प्रयोगात्मक समर्थन प्राप्त है।

परिवर्तन के बिना ही ट्रांसफॉर्म घटक का उपयोग देशी केरस के लिए किया जा सकता है। TproorFlow और tf.Transform ऑप्स का उपयोग करते हुए preprocessing_fn परिभाषा समान रहती है।

सेवारत समारोह और eval समारोह देशी Keras के लिए बदल रहे हैं। निम्नलिखित ट्रेनर और मूल्यांकन अनुभागों में विवरण पर चर्चा की जाएगी।

ट्रेनर

मूल GenericExecutor को कॉन्फ़िगर करने के लिए, डिफ़ॉल्ट अनुमानक आधारित निष्पादक को बदलने के लिए ट्रेनर घटक के लिए GenericExecutor को सेट करने की आवश्यकता है। जानकारी के लिए, कृपया यहाँ देखें

करैस मॉड्यूल फ़ाइल ट्रांसफॉर्म के साथ

प्रशिक्षण मॉड्यूल फ़ाइल में एक run_fn होना चाहिए जिसे GenericExecutor द्वारा बुलाया जाएगा, एक विशिष्ट run_fn इस तरह दिखेगा:

def run_fn(fn_args: TrainerFnArgs):
  """Train the model based on given args.

  Args:
    fn_args: Holds args used to train the model as name/value pairs.
  """
  tf_transform_output = tft.TFTransformOutput(fn_args.transform_output)

  # Train and eval files contains transformed examples.
  # _input_fn read dataset based on transformed feature_spec from tft.
  train_dataset = _input_fn(fn_args.train_files, tf_transform_output, 40)
  eval_dataset = _input_fn(fn_args.eval_files, tf_transform_output, 40)

  model = _build_keras_model()

  model.fit(
      train_dataset,
      steps_per_epoch=fn_args.train_steps,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)

  signatures = {
      'serving_default':
          _get_serve_tf_examples_fn(model,
                                    tf_transform_output).get_concrete_function(
                                        tf.TensorSpec(
                                            shape=[None],
                                            dtype=tf.string,
                                            name='examples')),
  }
  model.save(fn_args.serving_model_dir, save_format='tf', signatures=signatures)

ऊपर run_fn , प्रशिक्षित मॉडल का निर्यात करते समय एक सेवारत हस्ताक्षर की आवश्यकता होती है ताकि मॉडल भविष्यवाणी के लिए कच्चे उदाहरण ले सके। एक विशिष्ट सेवारत समारोह इस तरह दिखेगा:

def _get_serve_tf_examples_fn(model, tf_transform_output):
  """Returns a function that parses a serialized tf.Example."""

  # the layer is added as an attribute to the model in order to make sure that
  # the model assets are handled correctly when exporting.
  model.tft_layer = tf_transform_output.transform_features_layer()

  @tf.function
  def serve_tf_examples_fn(serialized_tf_examples):
    """Returns the output to be used in the serving signature."""
    feature_spec = tf_transform_output.raw_feature_spec()
    feature_spec.pop(_LABEL_KEY)
    parsed_features = tf.io.parse_example(serialized_tf_examples, feature_spec)

    transformed_features = model.tft_layer(parsed_features)

    return model(transformed_features)

  return serve_tf_examples_fn

ऊपर सेवारत समारोह में, tf.Transform परिवर्तनों को tft.TransformFeaturesLayer परत का उपयोग करके, अनुमान के लिए कच्चे डेटा पर लागू किया जाना चाहिए। पिछला _serving_input_receiver_fn जो एस्टिमेटर्स के लिए आवश्यक था, अब _serving_input_receiver_fn की आवश्यकता नहीं होगी।

करैस मॉड्यूल फाइल बिना ट्रांसफॉर्म के

यह ऊपर दिखाए गए मॉड्यूल फ़ाइल के समान है, लेकिन परिवर्तनों के बिना:

def _get_serve_tf_examples_fn(model, schema):

  @tf.function
  def serve_tf_examples_fn(serialized_tf_examples):
    feature_spec = _get_raw_feature_spec(schema)
    feature_spec.pop(_LABEL_KEY)
    parsed_features = tf.io.parse_example(serialized_tf_examples, feature_spec)
    return model(parsed_features)

  return serve_tf_examples_fn


def run_fn(fn_args: TrainerFnArgs):
  schema = io_utils.parse_pbtxt_file(fn_args.schema_file, schema_pb2.Schema())

  # Train and eval files contains raw examples.
  # _input_fn reads the dataset based on raw feature_spec from schema.
  train_dataset = _input_fn(fn_args.train_files, schema, 40)
  eval_dataset = _input_fn(fn_args.eval_files, schema, 40)

  model = _build_keras_model()

  model.fit(
      train_dataset,
      steps_per_epoch=fn_args.train_steps,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)

  signatures = {
      'serving_default':
          _get_serve_tf_examples_fn(model, schema).get_concrete_function(
              tf.TensorSpec(shape=[None], dtype=tf.string, name='examples')),
  }
  model.save(fn_args.serving_model_dir, save_format='tf', signatures=signatures)
tf.distribute.Strategy

इस समय TFX केवल एकल कार्यकर्ता रणनीतियों (जैसे, का समर्थन करता है MirroredStrategy , OneDeviceStrategy )।

एक वितरण रणनीति का उपयोग करने के लिए, एक उपयुक्त tf.distribute.Strategy बनाएं और रणनीति के दायरे में Keras मॉडल के निर्माण और संकलन को स्थानांतरित करें।

उदाहरण के लिए, उपरोक्त model = _build_keras_model() साथ बदलें:

  mirrored_strategy = tf.distribute.MirroredStrategy()
  with mirrored_strategy.scope():
    model = _build_keras_model()

  # Rest of the code can be unchanged.
  model.fit(...)

डिवाइस (CPU / GPU) द्वारा इस्तेमाल किया सत्यापित करने के लिए MirroredStrategy , सक्षम जानकारी स्तर tensorflow प्रवेश:

import logging
logging.getLogger("tensorflow").setLevel(logging.INFO)

और आपको लॉग में Using MirroredStrategy with devices (...) सक्षम होना चाहिए।

मूल्यांकनकर्ता

TFMA v0.2x में, ModelValidator और Evaluator को एक नए Evaluator घटक में जोड़ा गया है। नया मूल्यांकनकर्ता घटक एकल मॉडल मूल्यांकन दोनों कर सकता है और पिछले मॉडल की तुलना में वर्तमान मॉडल को मान्य भी कर सकता है। इस परिवर्तन के साथ, पुशर घटक अब ModelValidator के बजाय मूल्यांकनकर्ता से आशीर्वाद परिणाम प्राप्त करता है।

नया इवैल्यूएटर केरस मॉडल के साथ-साथ एस्टिमेटर मॉडल का समर्थन करता है। _eval_input_receiver_fn और eval सहेजे गए मॉडल जो पहले आवश्यक थे, अब SavedModel साथ की आवश्यकता नहीं होगी, क्योंकि अब मूल्यांकनकर्ता उसी SavedModel पर आधारित है जो सेवा के लिए उपयोग किया जाता है।

अधिक जानकारी के लिए मूल्यांकनकर्ता देखें