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

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

• खपत: tf.ExampleGen घटक से उदाहरण, और SchemaGen घटक से डेटा स्कीमा।
• एमिट्स: ए सेव्ड मॉडल टू ए ट्रेनर कंपोनेंट, प्री-ट्रांसफॉर्म और पोस्ट-ट्रांसफॉर्म स्टैटिस्टिक्स।

एक रूपांतरण घटक को कॉन्फ़िगर करना

एक बार आपका 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))

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

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

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

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

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

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

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

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

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

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

नोट: ये संगणनाएँ अपाचे बीम में हुड के नीचे लागू की गई हैं।

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

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

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

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

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

टीएफएक्स ट्रांसफॉर्म घटक डेटा पढ़ने और लिखने से संबंधित एपीआई कॉल को संभालने और डिस्क पर आउटपुट सहेजे गए मॉडल को लिखने से ट्रांसफॉर्म के उपयोग को सरल बनाता है। एक TFX उपयोगकर्ता के रूप में, आपको केवल preprocessing_fn नामक एक फ़ंक्शन को परिभाषित करना होगा। preprocessing_fn में आप उन कार्यों की एक श्रृंखला को परिभाषित करते हैं जो टेंसरों के आउटपुट तानाशाही का उत्पादन करने के लिए टेंसरों के इनपुट तानाशाही में हेरफेर करते हैं। आप TensorFlow Transform API के स्केल_टू_0_1 और कंप्यूट_और_लागू_शब्दावली जैसे सहायक फ़ंक्शन ढूंढ सकते हैं या नीचे दिखाए गए अनुसार नियमित 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 s, SparseTensor s, या RaggedTensor s) पर संचालन की एक श्रृंखला का वर्णन करता है। preprocessing_fn को सही ढंग से परिभाषित करने के लिए यह समझना आवश्यक है कि डेटा को टेंसर के रूप में कैसे दर्शाया जाता है। preprocessing_fn का इनपुट स्कीमा द्वारा निर्धारित किया जाता है। एक Schema प्रोटो को अंततः एक "फीचर स्पेक" (कभी-कभी "पार्सिंग स्पेक" कहा जाता है) में परिवर्तित किया जाता है जिसका उपयोग डेटा पार्सिंग के लिए किया जाता है, यहां रूपांतरण तर्क के बारे में अधिक विवरण देखें।

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

आम तौर पर कोई शब्दावली उत्पन्न करने के लिए 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 में परिवर्तित करता है।

मॉडल कोड में, क्लासिफायर को tft.vocabulary द्वारा उत्पन्न शब्दावली को label_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 का उपयोग करके जोड़ा जा सकता है।