SIG TFX-Addons समुदाय में शामिल हों और TFX को और बेहतर बनाने में मदद करें! SIG TFX-Addons में शामिल हों

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

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

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

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

एक बार जब आपका 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 Transform इन और कई अन्य प्रकार के परिवर्तनों के लिए समर्थन प्रदान करता है:

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

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

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

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

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

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

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

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

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

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

टीएफएक्स ट्रांसफॉर्म घटक डेटा को पढ़ने और लिखने से संबंधित एपीआई कॉल को संभालने और डिस्क पर आउटपुट सहेजे गए मॉडल को लिखकर ट्रांसफॉर्म के उपयोग को सरल बनाता है। एक TFX उपयोगकर्ता के रूप में, आपको केवल preprocessing_fn नामक एक फ़ंक्शन को परिभाषित करना होगा। preprocessing_fn आप उन कार्यों की एक श्रृंखला को परिभाषित करते हैं जो टेंसर के आउटपुट डिक्टेट का उत्पादन करने के लिए टेंसर के इनपुट निर्देश में हेरफेर करते हैं। आप TensorFlow Transform API स्केल_ to_0_1 और कंप्यूट_और_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:
    # Preserve this feature as a dense float, setting nan's to the mean.
    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 . के इनपुट को समझना

preprocessing_fn टेंसर पर संचालन की एक श्रृंखला का वर्णन करता है (अर्थात, Tensor एस या SparseTensor एस) और इसलिए preprocessing_fn सही ढंग से लिखने के लिए यह समझना आवश्यक है कि आपके डेटा को टेंसर के रूप में कैसे दर्शाया जाता है। preprocessing_fn का इनपुट स्कीमा द्वारा निर्धारित किया preprocessing_fn है। एक Schema प्रोटो में Feature एस की एक सूची होती है, और ट्रांसफ़ॉर्म इन्हें "फ़ीचर स्पेक" (कभी-कभी "पार्सिंग स्पेक" कहा जाता है) में परिवर्तित करता है, जो एक ऐसा निर्देश है जिसकी कुंजियां फीचर नाम हैं और जिनके मान FixedLenFeature या VarLenFeature (या अन्य) में से एक हैं। TensorFlow Transform द्वारा उपयोग नहीं किए जाने वाले विकल्प)।

Schema से फीचर स्पेक का अनुमान लगाने के नियम हैं:

  • shape सेट वाली प्रत्येक feature का परिणाम tf.FixedLenFeature साथ आकार और default_value=Nonepresence.min_fraction tf.FixedLenFeature 1 होना चाहिए अन्यथा और त्रुटि का परिणाम होगा, क्योंकि जब कोई डिफ़ॉल्ट मान नहीं होता है, तो एक tf.FixedLenFeature को हमेशा मौजूद रहने की सुविधा की आवश्यकता होती है।
  • shape सेट नहीं होने वाली प्रत्येक feature का परिणाम VarLenFeature
  • प्रत्येक sparse_feature परिणामस्वरूप एक tf.SparseFeature जिसका size और is_sorted SparseFeature संदेश के fixed_shape और is_sorted फ़ील्ड द्वारा निर्धारित किया जाता है।
  • के रूप में इस्तेमाल विशेषताएं index_feature या value_feature एक की sparse_feature सुविधा कल्पना में उत्पन्न अपने स्वयं के प्रवेश नहीं होगा।
  • feature type फील्ड (या sparse_feature प्रोटो की वैल्यू फीचर) और फीचर स्पेक के dtype के बीच dtype निम्न तालिका द्वारा दिया गया है:
type dtype
schema_pb2.INT tf.int64
schema_pb2.FLOAT tf.float32
schema_pb2.BYTES tf.string

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

आमतौर पर एक शब्दावली उत्पन्न करने के लिए TensorFlow Transform का उपयोग करना चाहता है और स्ट्रिंग को पूर्णांक में बदलने के लिए उस शब्दावली को लागू करता है। जब इस कार्यप्रवाह निम्नलिखित, input_fn मॉडल इच्छा उत्पादन integerized स्ट्रिंग में निर्माण किया। हालांकि लेबल एक अपवाद हैं, क्योंकि मॉडल के लिए आउटपुट (पूर्णांक) लेबल को स्ट्रिंग्स पर वापस मैप करने में सक्षम होने के लिए, मॉडल को एक स्ट्रिंग लेबल को आउटपुट करने के लिए 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 पर 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

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