सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

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

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

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

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

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

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 एक ही मॉड्यूल के भीतर।

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

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

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

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

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

TensorFlow रूपांतरण preprocessing_fn

टीएफएक्स ट्रांसफॉर्म घटक डेटा को पढ़ने और लिखने से संबंधित एपीआई कॉल को संभालने और डिस्क पर आउटपुट सहेजे गए मॉडल को लिखकर ट्रांसफॉर्म के उपयोग को सरल बनाता है। एक TFX उपयोगकर्ता के रूप में, आप केवल नामक केवल एक समारोह को परिभाषित करने के लिए है preprocessing_fn । में preprocessing_fn आप कार्यों कि tensors के इनपुट dict हेरफेर tensors के उत्पादन में dict का उत्पादन करने की एक श्रृंखला परिभाषित करते हैं। आप scale_to_0_1 तरह सहायक कार्यों खोजने के लिए और compute_and_apply_vocabulary कर सकते हैं TensorFlow एपीआई रूपांतरण या जिन्हें आप नीचे देख नियमित 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 . के इनपुट को समझना

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

से एक सुविधा कल्पना का निष्कर्ष निकालते के लिए नियमों को Schema हैं

  • प्रत्येक feature के साथ shape सेट एक में परिणाम होगा tf.FixedLenFeature आकार और साथ default_value=Nonepresence.min_fraction होना चाहिए 1 अन्यथा और त्रुटि परिणाम होगा, क्योंकि जब कोई डिफ़ॉल्ट मान है, एक tf.FixedLenFeature सुविधा हमेशा उपस्थित रहने की आवश्यकता है।
  • प्रत्येक feature के साथ shape सेट नहीं एक में परिणाम होगा VarLenFeature
  • प्रत्येक sparse_feature एक में परिणाम होगा tf.SparseFeature जिसका size और is_sorted द्वारा निर्धारित किया जाता fixed_shape और is_sorted के क्षेत्र SparseFeature संदेश।
  • के रूप में इस्तेमाल विशेषताएं index_feature या value_feature एक की sparse_feature सुविधा कल्पना में उत्पन्न अपने स्वयं के प्रवेश नहीं होगा।
  • के बीच पत्राचार type के क्षेत्र feature (या एक का मान सुविधा sparse_feature आद्य) और 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)

  ...

Preprocessing समारोह ऊपर कच्चे इनपुट सुविधा (जो भी preprocessing फ़ंक्शन के परिणाम के हिस्से के रूप में लौटा दी जाएगी) और कॉल लेता 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 StatsOptions भीतर या (ii) का उपयोग करके शब्दकोश tft.annotate_asset