TensorFlow 2.0 को 2019 में जारी किया गया था , जिसमें केरस का कड़ा एकीकरण , डिफ़ॉल्ट रूप से उत्सुक निष्पादन और पायथोनिक फ़ंक्शन निष्पादन , अन्य नई सुविधाओं और सुधारों के साथ था।
यह मार्गदर्शिका टीएफएक्स में टीएफ 2.x का व्यापक तकनीकी अवलोकन प्रदान करती है।
किस संस्करण का उपयोग करें?
TFX TensorFlow 2.x के साथ संगत है, और TensorFlow 1.x (विशेष रूप से अनुमानक) में मौजूद उच्च-स्तरीय API काम करना जारी रखते हैं।
TensorFlow 2.x में नए प्रोजेक्ट प्रारंभ करें
चूंकि TensorFlow 2.x, TensorFlow 1.x की उच्च-स्तरीय क्षमताओं को बरकरार रखता है, इसलिए नई परियोजनाओं पर पुराने संस्करण का उपयोग करने का कोई फायदा नहीं है, भले ही आप नई सुविधाओं का उपयोग करने की योजना नहीं बनाते हों।
इसलिए, यदि आप एक नया TFX प्रोजेक्ट शुरू कर रहे हैं, तो हम अनुशंसा करते हैं कि आप TensorFlow 2.x का उपयोग करें। आप अपना कोड बाद में अपडेट करना चाह सकते हैं क्योंकि केरस और अन्य नई सुविधाओं के लिए पूर्ण समर्थन उपलब्ध हो जाएगा, और यदि आप TensorFlow 1.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 में अपेक्षा के अनुरूप काम करता रहेगा।
यहां शुद्ध अनुमानक का उपयोग करके एक एंड-टू-एंड टीएफएक्स उदाहरण दिया गया है: टैक्सी उदाहरण (अनुमानक)
model_to_estimator के साथ केरस
केरस मॉडल को tf.keras.estimator.model_to_estimator फ़ंक्शन के साथ लपेटा जा सकता है, जो उन्हें एस्टिमेटर्स की तरह काम करने की अनुमति देता है। इसका उपयोग करने के लिए:
- एक केरस मॉडल बनाएं.
- संकलित मॉडल को
model_to_estimatorमें पास करें। - ट्रेनर में
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,
...
}
ट्रेनर की उपयोगकर्ता मॉड्यूल फ़ाइल के अलावा, बाकी पाइपलाइन अपरिवर्तित रहती है।
मूल केरस (यानी बिना model_to_estimator के केरस)
उदाहरण और कोलाब
यहां देशी केरस के कई उदाहरण दिए गए हैं:
- पेंगुइन ( मॉड्यूल फ़ाइल ): 'हैलो वर्ल्ड' शुरू से अंत तक उदाहरण।
- एमएनआईएसटी ( मॉड्यूल फ़ाइल ): छवि और टीएफलाइट एंड-टू-एंड उदाहरण।
- टैक्सी ( मॉड्यूल फ़ाइल ): उन्नत ट्रांसफ़ॉर्म उपयोग के साथ एंड-टू-एंड उदाहरण।
हमारे पास एक प्रति-घटक केरस कोलाब भी है।
टीएफएक्स घटक
निम्नलिखित अनुभाग बताते हैं कि कैसे संबंधित टीएफएक्स घटक देशी केरस का समर्थन करते हैं।
परिवर्तन
ट्रांसफ़ॉर्म के पास वर्तमान में केरस मॉडल के लिए प्रयोगात्मक समर्थन है।
ट्रांसफ़ॉर्म घटक का उपयोग बिना किसी बदलाव के मूल केरस के लिए किया जा सकता है। TensorFlow और tf.Transform ops का उपयोग करते हुए preprocessing_fn परिभाषा समान रहती है।
मूल केरस के लिए सर्विंग फ़ंक्शन और इवल फ़ंक्शन बदल दिए गए हैं। विवरण पर निम्नलिखित प्रशिक्षक और मूल्यांकनकर्ता अनुभागों में चर्चा की जाएगी।
ट्रेनर
देशी केरस को कॉन्फ़िगर करने के लिए, डिफ़ॉल्ट अनुमानक आधारित निष्पादक को बदलने के लिए ट्रेनर घटक के लिए GenericExecutor सेट करने की आवश्यकता होती है। विवरण के लिए, कृपया यहां देखें।
ट्रांसफॉर्म के साथ केरस मॉड्यूल फ़ाइल
प्रशिक्षण मॉड्यूल फ़ाइल में एक run_fn होना चाहिए जिसे GenericExecutor द्वारा कॉल किया जाएगा, एक सामान्य Keras 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 schema from tft.
train_dataset = _input_fn(fn_args.train_files, fn_args.data_accessor,
tf_transform_output.transformed_metadata.schema)
eval_dataset = _input_fn(fn_args.eval_files, fn_args.data_accessor,
tf_transform_output.transformed_metadata.schema)
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
उपरोक्त सर्विंग फ़ंक्शन में, tft.TransformFeaturesLayer परत का उपयोग करके, अनुमान के लिए tf.Transform परिवर्तनों को कच्चे डेटा पर लागू करने की आवश्यकता है। पिछला _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 data schema.
train_dataset = _input_fn(fn_args.train_files, fn_args.data_accessor, schema)
eval_dataset = _input_fn(fn_args.eval_files, fn_args.data_accessor, schema)
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.वितरण.रणनीति
इस समय TFX केवल एकल कार्यकर्ता रणनीतियों (उदाहरण के लिए, मिररडस्ट्रैटेजी , वनडिवाइसस्ट्रेटजी ) का समर्थन करता है।
वितरण रणनीति का उपयोग करने के लिए, एक उपयुक्त tf.distribute.Strategy बनाएं और केरस मॉडल के निर्माण और संकलन को एक रणनीति दायरे में ले जाएं।
उदाहरण के लिए, उपरोक्त 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(...)
MirroredStrategy द्वारा उपयोग किए गए डिवाइस (सीपीयू/जीपीयू) को सत्यापित करने के लिए, सूचना स्तर टेंसरफ़्लो लॉगिंग सक्षम करें:
import logging
logging.getLogger("tensorflow").setLevel(logging.INFO)
और आपको लॉग में Using MirroredStrategy with devices (...) देखने में सक्षम होना चाहिए।
मूल्यांकनकर्ता
TFMA v0.2x में, मॉडलवैलिडेटर और इवैल्यूएटर को एक नए इवैल्यूएटर घटक में जोड़ दिया गया है। नया मूल्यांकनकर्ता घटक एकल मॉडल मूल्यांकन दोनों कर सकता है और पिछले मॉडल की तुलना में वर्तमान मॉडल को मान्य भी कर सकता है। इस परिवर्तन के साथ, पुशर घटक अब मॉडलवैलिडेटर के बजाय इवैल्यूएटर से आशीर्वाद परिणाम का उपभोग करता है।
नया इवैल्यूएटर केरस मॉडल के साथ-साथ एस्टिमेटर मॉडल का भी समर्थन करता है। _eval_input_receiver_fn और eval सहेजे गए मॉडल जिनकी पहले आवश्यकता थी, अब Keras के साथ उनकी आवश्यकता नहीं होगी, क्योंकि Evaluator अब उसी SavedModel पर आधारित है जिसका उपयोग सेवा के लिए किया जाता है।