ट्रांसफॉर्म टीएफएक्स पाइपलाइन घटक

ट्रांसफॉर्म टीएफएक्स पाइपलाइन घटक एक स्कीमजेन घटक द्वारा बनाए गए डेटा स्कीमा का उपयोग करके, उदाहरणजेन घटक से उत्सर्जित tf.Examples पर फीचर इंजीनियरिंग करता है, और एक सेव्डमॉडल के साथ-साथ प्री-ट्रांसफॉर्म और पोस्ट-ट्रांसफॉर्म डेटा दोनों पर आंकड़े उत्सर्जित करता है। निष्पादित होने पर, SaveModel एक exampleGen घटक से उत्सर्जित tf.Examples को स्वीकार करेगा और रूपांतरित फीचर डेटा को उत्सर्जित करेगा।

• उपभोग: एक उदाहरणजेन घटक से tf.उदाहरण, और एक स्कीमजेन घटक से एक डेटा स्कीमा।
• उत्सर्जन: एक ट्रेनर घटक के लिए एक सेव्डमॉडल, पूर्व-परिवर्तन और बाद-परिवर्तन आँकड़े।

एक ट्रांसफ़ॉर्म घटक को कॉन्फ़िगर करना

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

transform = Transform(
    examples=example_gen.outputs['examples'],
    schema=schema_gen.outputs['schema'],
    module_file=os.path.abspath(_taxi_transform_module_file))

इसके अतिरिक्त, आप टीएफडीवी -आधारित प्री-ट्रांसफ़ॉर्म या पोस्ट-ट्रांसफ़ॉर्म सांख्यिकी गणना के लिए विकल्प प्रदान करना चाह सकते हैं। ऐसा करने के लिए, उसी मॉड्यूल के भीतर एक stats_options_updater_fn परिभाषित करें।

ट्रांसफ़ॉर्म और टेन्सरफ़्लो ट्रांसफ़ॉर्म

ट्रांसफॉर्म आपके डेटासेट पर फीचर इंजीनियरिंग करने के लिए टेन्सरफ्लो ट्रांसफॉर्म का व्यापक उपयोग करता है। TensorFlow Transform फीचर डेटा को आपके मॉडल में जाने से पहले और प्रशिक्षण प्रक्रिया के एक भाग के रूप में बदलने के लिए एक बेहतरीन टूल है। सामान्य सुविधा परिवर्तनों में शामिल हैं:

• एम्बेडिंग : उच्च-आयामी स्थान से निम्न-आयामी स्थान तक सार्थक मैपिंग ढूंढकर विरल सुविधाओं (जैसे शब्दावली द्वारा निर्मित पूर्णांक आईडी) को सघन सुविधाओं में परिवर्तित करना। एंबेडिंग के परिचय के लिए मशीन-लर्निंग क्रैश कोर्स में एंबेडिंग यूनिट देखें।
• शब्दावली निर्माण : एक शब्दावली बनाकर स्ट्रिंग्स या अन्य गैर-संख्यात्मक विशेषताओं को पूर्णांकों में परिवर्तित करना जो प्रत्येक अद्वितीय मान को एक आईडी नंबर पर मैप करता है।
• मूल्यों को सामान्य बनाना : संख्यात्मक विशेषताओं को बदलना ताकि वे सभी एक समान सीमा में आएँ।
• बकेटाइज़ेशन : अलग-अलग बकेट को मान निर्दिष्ट करके निरंतर-मूल्य वाली विशेषताओं को श्रेणीबद्ध विशेषताओं में परिवर्तित करना।
• टेक्स्ट सुविधाओं को समृद्ध करना : फीचर सेट को समृद्ध करने के लिए कच्चे डेटा जैसे टोकन, एन-ग्राम, इकाइयां, भावना इत्यादि से सुविधाओं का उत्पादन करना।

TensorFlow Transform इन और कई अन्य प्रकार के परिवर्तनों के लिए सहायता प्रदान करता है:

• अपने नवीनतम डेटा से स्वचालित रूप से एक शब्दावली उत्पन्न करें।

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

टीएफएक्स चलाने से पहले आप अपने डेटा को अपनी इच्छानुसार रूपांतरित कर सकते हैं। लेकिन यदि आप इसे TensorFlow Transform के भीतर करते हैं, तो ट्रांसफ़ॉर्म TensorFlow ग्राफ़ का हिस्सा बन जाते हैं। यह दृष्टिकोण प्रशिक्षण/सेवा में गड़बड़ी से बचने में मदद करता है।

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

इसके विपरीत, TensorFlow ट्रांसफॉर्म को उन परिवर्तनों के लिए डिज़ाइन किया गया है जिनके लिए पहले से ज्ञात नहीं होने वाले मानों की गणना करने के लिए डेटा पर पूर्ण पास की आवश्यकता होती है। उदाहरण के लिए, शब्दावली निर्माण के लिए डेटा पर पूर्ण पारगमन की आवश्यकता होती है।

Apache Beam का उपयोग करके मानों की गणना करने के अलावा, TensorFlow Transform उपयोगकर्ताओं को इन मानों को TensorFlow ग्राफ़ में एम्बेड करने की अनुमति देता है, जिसे बाद में प्रशिक्षण ग्राफ़ में लोड किया जा सकता है। उदाहरण के लिए, सुविधाओं को सामान्य करते समय, tft.scale_to_z_score फ़ंक्शन किसी सुविधा के माध्य और मानक विचलन की गणना करेगा, और फ़ंक्शन के TensorFlow ग्राफ़ में एक प्रतिनिधित्व भी करेगा, जो माध्य को घटाता है और मानक विचलन से विभाजित करता है। केवल आँकड़े ही नहीं, बल्कि TensorFlow ग्राफ़ उत्सर्जित करके, TensorFlow Transform आपकी प्रीप्रोसेसिंग पाइपलाइन को लिखने की प्रक्रिया को सरल बनाता है।

चूंकि प्रीप्रोसेसिंग को एक ग्राफ के रूप में व्यक्त किया जाता है, यह सर्वर पर हो सकता है, और यह प्रशिक्षण और सेवा के बीच सुसंगत होने की गारंटी है। यह स्थिरता प्रशिक्षण/सेवा संबंधी तिरछापन के एक स्रोत को समाप्त कर देती है।

TensorFlow ट्रांसफ़ॉर्म उपयोगकर्ताओं को TensorFlow कोड का उपयोग करके अपनी प्रीप्रोसेसिंग पाइपलाइन निर्दिष्ट करने की अनुमति देता है। इसका मतलब यह है कि एक पाइपलाइन का निर्माण TensorFlow ग्राफ़ की तरह ही किया जाता है। यदि इस ग्राफ़ में केवल TensorFlow ऑप्स का उपयोग किया जाता है, तो पाइपलाइन एक शुद्ध मानचित्र होगा जो इनपुट के बैच स्वीकार करता है और आउटपुट के बैच लौटाता है। ऐसी पाइपलाइन tf.Estimator API का उपयोग करते समय इस ग्राफ़ को आपके input_fn अंदर रखने के बराबर होगी। कंप्यूटिंग क्वांटाइल्स जैसे पूर्ण-पास संचालन को निर्दिष्ट करने के लिए, टेन्सरफ्लो ट्रांसफॉर्म analyzers नामक विशेष फ़ंक्शन प्रदान करता है जो टेन्सरफ्लो ऑप्स की तरह दिखाई देते हैं, लेकिन वास्तव में एक स्थगित गणना निर्दिष्ट करते हैं जो अपाचे बीम द्वारा की जाएगी, और आउटपुट को ग्राफ़ में डाला जाएगा स्थिर। जबकि एक सामान्य TensorFlow ऑप अपने इनपुट के रूप में एक बैच लेगा, उस बैच पर कुछ गणना करेगा और एक बैच उत्सर्जित करेगा, एक analyzer सभी बैचों पर वैश्विक कमी (अपाचे बीम में कार्यान्वित) करेगा और परिणाम लौटाएगा।

साधारण TensorFlow ऑप्स और TensorFlow ट्रांसफ़ॉर्म एनालाइज़र को मिलाकर, उपयोगकर्ता अपने डेटा को प्रीप्रोसेस करने के लिए जटिल पाइपलाइन बना सकते हैं। उदाहरण के लिए tft.scale_to_z_score फ़ंक्शन एक इनपुट टेंसर लेता है और उस टेंसर को माध्य 0 और विचरण 1 के लिए सामान्यीकृत कर देता है। यह हुड के नीचे mean और var विश्लेषकों को कॉल करके ऐसा करता है, जो प्रभावी रूप से इनपुट टेंसर के माध्य और विचरण के बराबर ग्राफ़ में स्थिरांक उत्पन्न करेगा। इसके बाद यह माध्य घटाने और मानक विचलन से विभाजित करने के लिए TensorFlow ऑप्स का उपयोग करेगा।

TensorFlow ट्रांसफ़ॉर्म preprocessing_fn

टीएफएक्स ट्रांसफॉर्म घटक डेटा को पढ़ने और लिखने से संबंधित एपीआई कॉल को संभालकर और आउटपुट सेव्डमॉडल को डिस्क पर लिखकर ट्रांसफॉर्म के उपयोग को सरल बनाता है। एक टीएफएक्स उपयोगकर्ता के रूप में, आपको केवल preprocessing_fn नामक एक फ़ंक्शन को परिभाषित करना होगा। preprocessing_fn में आप फ़ंक्शंस की एक श्रृंखला को परिभाषित करते हैं जो टेंसर के आउटपुट निर्देश का उत्पादन करने के लिए टेंसर के इनपुट निर्देश में हेरफेर करते हैं। आप TensorFlow Transform API में scale_to_0_1 और compute_and_apply_vocabulary जैसे सहायक फ़ंक्शन पा सकते हैं या नीचे दिखाए अनुसार नियमित TensorFlow फ़ंक्शंस का उपयोग कर सकते हैं।

def preprocessing_fn(inputs):
  """tf.transform's callback function for preprocessing inputs.

  Args:
    inputs: map from feature keys to raw not-yet-transformed features.

  Returns:
    Map from string feature key to transformed feature operations.
  """
  outputs = {}
  for key in _DENSE_FLOAT_FEATURE_KEYS:
    # If sparse make it dense, setting nan's to 0 or '', and apply zscore.
    outputs[_transformed_name(key)] = transform.scale_to_z_score(
        _fill_in_missing(inputs[key]))

  for key in _VOCAB_FEATURE_KEYS:
    # Build a vocabulary for this feature.
    outputs[_transformed_name(
        key)] = transform.compute_and_apply_vocabulary(
            _fill_in_missing(inputs[key]),
            top_k=_VOCAB_SIZE,
            num_oov_buckets=_OOV_SIZE)

  for key in _BUCKET_FEATURE_KEYS:
    outputs[_transformed_name(key)] = transform.bucketize(
        _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT)

  for key in _CATEGORICAL_FEATURE_KEYS:
    outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])

  # Was this passenger a big tipper?
  taxi_fare = _fill_in_missing(inputs[_FARE_KEY])
  tips = _fill_in_missing(inputs[_LABEL_KEY])
  outputs[_transformed_name(_LABEL_KEY)] = tf.where(
      tf.is_nan(taxi_fare),
      tf.cast(tf.zeros_like(taxi_fare), tf.int64),
      # Test if the tip was > 20% of the fare.
      tf.cast(
          tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))

  return outputs

प्रीप्रोसेसिंग_एफएन में इनपुट को समझना

preprocessing_fn टेंसर (यानी, Tensor एस, SparseTensor एस, या RaggedTensor एस) पर संचालन की एक श्रृंखला का वर्णन करता है। preprocessing_fn सही ढंग से परिभाषित करने के लिए यह समझना आवश्यक है कि डेटा को टेंसर के रूप में कैसे दर्शाया जाता है। preprocessing_fn का इनपुट स्कीमा द्वारा निर्धारित किया जाता है। एक Schema प्रोटो को अंततः एक "फीचर स्पेक" (कभी-कभी "पार्सिंग स्पेक" भी कहा जाता है) में बदल दिया जाता है, जिसका उपयोग डेटा पार्सिंग के लिए किया जाता है, रूपांतरण तर्क के बारे में अधिक विवरण यहां देखें।

स्ट्रिंग लेबल को संभालने के लिए TensorFlow ट्रांसफ़ॉर्म का उपयोग करना

आमतौर पर कोई शब्दावली उत्पन्न करने और स्ट्रिंग को पूर्णांक में बदलने के लिए उस शब्दावली को लागू करने के लिए TensorFlow Transform का उपयोग करना चाहता है। इस वर्कफ़्लो का पालन करते समय, मॉडल में निर्मित input_fn पूर्णांकित स्ट्रिंग को आउटपुट करेगा। हालाँकि लेबल एक अपवाद हैं, क्योंकि मॉडल को आउटपुट (पूर्णांक) लेबल को स्ट्रिंग्स पर वापस मैप करने में सक्षम होने के लिए, मॉडल को लेबल के संभावित मानों की सूची के साथ, स्ट्रिंग लेबल को आउटपुट करने के लिए input_fn आवश्यकता होती है। उदाहरण के लिए यदि लेबल cat और dog हैं तो input_fn का आउटपुट ये कच्चे तार होना चाहिए, और कुंजियाँ ["cat", "dog"] एक पैरामीटर के रूप में अनुमानक में पारित करने की आवश्यकता है (नीचे विवरण देखें)।

पूर्णांकों में स्ट्रिंग लेबल की मैपिंग को संभालने के लिए, आपको शब्दावली उत्पन्न करने के लिए TensorFlow Transform का उपयोग करना चाहिए। हम इसे नीचे दिए गए कोड स्निपेट में प्रदर्शित करते हैं:

def _preprocessing_fn(inputs):
  """Preprocess input features into transformed features."""

  ...


  education = inputs[features.RAW_LABEL_KEY]
  _ = tft.vocabulary(education, vocab_filename=features.RAW_LABEL_KEY)

  ...

उपरोक्त प्रीप्रोसेसिंग फ़ंक्शन रॉ इनपुट सुविधा लेता है (जिसे प्रीप्रोसेसिंग फ़ंक्शन के आउटपुट के हिस्से के रूप में भी लौटाया जाएगा) और उस पर tft.vocabulary कॉल करता है। इसके परिणामस्वरूप education के लिए एक शब्दावली तैयार होती है जिसे मॉडल में एक्सेस किया जा सकता है।

उदाहरण यह भी दिखाता है कि किसी लेबल को कैसे रूपांतरित किया जाए और फिर रूपांतरित लेबल के लिए शब्दावली कैसे तैयार की जाए। विशेष रूप से यह कच्चे लेबल की education लेता है और लेबल को पूर्णांक में परिवर्तित किए बिना, शीर्ष 5 लेबल (आवृत्ति द्वारा) को छोड़कर सभी को UNKNOWN में परिवर्तित करता है।

मॉडल कोड में, क्लासिफायर को label_vocabulary तर्क के रूप में tft.vocabulary द्वारा उत्पन्न शब्दावली दी जानी चाहिए। यह पहले इस शब्दावली को एक सहायक फ़ंक्शन के साथ एक सूची के रूप में पढ़कर किया जाता है। यह नीचे स्निपेट में दिखाया गया है। ध्यान दें कि उदाहरण कोड ऊपर चर्चा किए गए रूपांतरित लेबल का उपयोग करता है लेकिन यहां हम कच्चे लेबल का उपयोग करने के लिए कोड दिखाते हैं।

def create_estimator(pipeline_inputs, hparams):

  ...

  tf_transform_output = trainer_util.TFTransformOutput(
      pipeline_inputs.transform_dir)

  # vocabulary_by_name() returns a Python list.
  label_vocabulary = tf_transform_output.vocabulary_by_name(
      features.RAW_LABEL_KEY)

  return tf.contrib.learn.DNNLinearCombinedClassifier(
      ...
      n_classes=len(label_vocab),
      label_vocabulary=label_vocab,
      ...)

परिवर्तन-पूर्व और परिवर्तन-पश्चात आँकड़ों को कॉन्फ़िगर करना

जैसा कि ऊपर उल्लेख किया गया है, ट्रांसफ़ॉर्म घटक प्री-ट्रांसफ़ॉर्म और पोस्ट-ट्रांसफ़ॉर्म दोनों आँकड़ों की गणना करने के लिए TFDV को आमंत्रित करता है। TFDV इनपुट के रूप में एक वैकल्पिक StatsOptions ऑब्जेक्ट लेता है। उपयोगकर्ता कुछ अतिरिक्त आँकड़े (उदाहरण के लिए एनएलपी आँकड़े) सक्षम करने के लिए या मान्य सीमाएँ निर्धारित करने के लिए इस ऑब्जेक्ट को कॉन्फ़िगर करना चाह सकते हैं (उदाहरण के लिए न्यूनतम / अधिकतम टोकन आवृत्ति)। ऐसा करने के लिए, मॉड्यूल फ़ाइल में stats_options_updater_fn परिभाषित करें।

def stats_options_updater_fn(stats_type, stats_options):
  ...
  if stats_type == stats_options_util.StatsType.PRE_TRANSFORM:
    # Update stats_options to modify pre-transform statistics computation.
    # Most constraints are specified in the schema which can be accessed
    # via stats_options.schema.
  if stats_type == stats_options_util.StatsType.POST_TRANSFORM
    # Update stats_options to modify post-transform statistics computation.
    # Most constraints are specified in the schema which can be accessed
    # via stats_options.schema.
  return stats_options

परिवर्तन के बाद के आँकड़े अक्सर किसी फीचर को प्रीप्रोसेस करने के लिए उपयोग की जाने वाली शब्दावली के ज्ञान से लाभान्वित होते हैं। प्रत्येक टीएफटी-जनरेटेड शब्दावली के लिए पथ मैपिंग के लिए शब्दावली नाम StatsOptions (और इसलिए TFDV) को प्रदान किया जाता है। इसके अतिरिक्त, बाहरी रूप से निर्मित शब्दावलियों के लिए मैपिंग को या तो (i) सीधे StatsOptions के भीतर vocab_paths शब्दकोश को संशोधित करके या (ii) tft.annotate_asset का उपयोग करके जोड़ा जा सकता है।