इस पेज का अनुवाद Cloud Translation API से किया गया है.

TensorFlow Transform के साथ प्रीप्रोसेस डेटा

TensorFlow का फ़ीचर इंजीनियरिंग घटक विस्तारित (TFX)

यह उदाहरण कोलाब नोटबुक एक बहुत ही सरल उदाहरण प्रदान करता है कि कैसे TensorFlow Transform ( tf.Transform ) का उपयोग डेटा को प्रीप्रोसेस करने के लिए एक मॉडल को प्रशिक्षित करने और उत्पादन में संदर्भ प्रदान करने के लिए बिल्कुल समान कोड का उपयोग किया जा सकता है।

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

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

TensorFlow में एकल उदाहरण या उदाहरणों के बैच पर जोड़तोड़ के लिए अंतर्निहित समर्थन है। tf.Transform पूरे प्रशिक्षण डेटासेट पर पूर्ण पास का समर्थन करने के लिए इन क्षमताओं का विस्तार करता है।

Tf.Transform का आउटपुट tf.Transform ग्राफ़ के रूप में निर्यात किया जाता है जिसका उपयोग आप प्रशिक्षण और सेवा दोनों के लिए कर सकते हैं। प्रशिक्षण और सेवा दोनों के लिए एक ही ग्राफ का उपयोग करने से तिरछापन को रोका जा सकता है, क्योंकि दोनों चरणों में समान परिवर्तन लागू होते हैं।

पिप अपग्रेड करें

स्थानीय रूप से चलते समय सिस्टम में पिप को अपग्रेड करने से बचने के लिए, यह सुनिश्चित करने के लिए जांचें कि हम कोलाब में चल रहे हैं। स्थानीय प्रणालियों को निश्चित रूप से अलग से अपग्रेड किया जा सकता है।

try:
  import colab
  !pip install --upgrade pip
except:
  pass

टेंसरफ्लो ट्रांसफॉर्म स्थापित करें

pip install -q -U tensorflow_transform

क्या आपने रनटाइम को पुनरारंभ किया?

यदि आप Google Colab का उपयोग कर रहे हैं, जब आप पहली बार ऊपर सेल चलाते हैं, तो आपको रनटाइम को पुनरारंभ करना होगा (रनटाइम> रनटाइम पुनरारंभ करें ...)। ऐसा इसलिए है क्योंकि Colab संकुल को लोड करता है।

आयात

import pprint
import tempfile

import tensorflow as tf
import tensorflow_transform as tft

import tensorflow_transform.beam as tft_beam
from tensorflow_transform.tf_metadata import dataset_metadata
from tensorflow_transform.tf_metadata import schema_utils

डेटा: कुछ डमी डेटा बनाएं

हम अपने सरल उदाहरण के लिए कुछ सरल डमी डेटा बनाएंगे:

raw_data प्रारंभिक कच्चा डेटा है जिसे हम प्रीप्रोसेस करने जा रहे हैं
raw_data_metadata में वह स्कीमा होता है जो हमें raw_data में प्रत्येक कॉलम के प्रकार बताता है। इस मामले में, यह बहुत आसान है।

raw_data = [
      {'x': 1, 'y': 1, 's': 'hello'},
      {'x': 2, 'y': 2, 's': 'world'},
      {'x': 3, 'y': 3, 's': 'hello'}
  ]

raw_data_metadata = dataset_metadata.DatasetMetadata(
    schema_utils.schema_from_feature_spec({
        'y': tf.io.FixedLenFeature([], tf.float32),
        'x': tf.io.FixedLenFeature([], tf.float32),
        's': tf.io.FixedLenFeature([], tf.string),
    }))

ट्रांसफ़ॉर्म: प्रीप्रोसेसिंग फ़ंक्शन बनाएं

प्रीप्रोसेसिंग फ़ंक्शन tf.Transform की सबसे महत्वपूर्ण अवधारणा है। प्रीप्रोसेसिंग फ़ंक्शन वह जगह है जहां डेटासेट का परिवर्तन वास्तव में होता है। यह टेंसर का एक शब्दकोश स्वीकार करता है और लौटाता है, जहां एक टेंसर का अर्थ Tensor याSparseTensor टेंसर होता है। एपीआई कॉल के दो मुख्य समूह हैं जो आम तौर पर प्रीप्रोसेसिंग फ़ंक्शन का दिल बनाते हैं:

TensorFlow Ops: कोई भी फ़ंक्शन जो टेंसर को स्वीकार करता है और लौटाता है, जिसका आमतौर पर मतलब TensorFlow ops होता है। ये ग्राफ में TensorFlow संचालन जोड़ते हैं जो कच्चे डेटा को एक समय में एक फीचर वेक्टर में परिवर्तित डेटा में बदल देता है। ये हर उदाहरण के लिए चलेंगे, प्रशिक्षण और सेवा दोनों के दौरान।
Tensorflow ट्रांसफ़ॉर्म एनालाइज़र/मैपर: tf.Transform द्वारा प्रदान किया गया कोई भी एनालाइज़र/मैपर। ये टेंसर को भी स्वीकार करते हैं और लौटाते हैं, और इसमें आमतौर पर टेन्सरफ़्लो ऑप्स और बीम कम्प्यूटेशन का संयोजन होता है, लेकिन टेन्सरफ़्लो ऑप्स के विपरीत वे विश्लेषण के दौरान केवल बीम पाइपलाइन में चलते हैं, जिसके लिए पूरे प्रशिक्षण डेटासेट पर एक पूर्ण पास की आवश्यकता होती है। बीम गणना प्रशिक्षण के दौरान केवल एक बार चलती है, और आम तौर पर पूरे प्रशिक्षण डेटासेट पर एक पूर्ण पास बनाती है। वे टेंसर स्थिरांक बनाते हैं, जो आपके ग्राफ़ में जुड़ जाते हैं। उदाहरण के लिए, tft.min प्रशिक्षण डेटासेट पर न्यूनतम टेंसर की गणना करता है जबकि tft.scale_by_min_max पहले प्रशिक्षण डेटासेट पर न्यूनतम और अधिकतम टेंसर की गणना करता है और फिर उपयोगकर्ता द्वारा निर्दिष्ट सीमा के भीतर टेंसर को मापता है, [output_min, आउटपुट_मैक्स]। tf.Transform ऐसे एनालाइज़र/मैपर का एक निश्चित सेट प्रदान करता है, लेकिन इसे भविष्य के संस्करणों में विस्तारित किया जाएगा।

def preprocessing_fn(inputs):
    """Preprocess input columns into transformed columns."""
    x = inputs['x']
    y = inputs['y']
    s = inputs['s']
    x_centered = x - tft.mean(x)
    y_normalized = tft.scale_to_0_1(y)
    s_integerized = tft.compute_and_apply_vocabulary(s)
    x_centered_times_y_normalized = (x_centered * y_normalized)
    return {
        'x_centered': x_centered,
        'y_normalized': y_normalized,
        's_integerized': s_integerized,
        'x_centered_times_y_normalized': x_centered_times_y_normalized,
    }

यह सब एक साथ डालें

अब हम अपना डेटा बदलने के लिए तैयार हैं। हम एक डायरेक्ट रनर के साथ अपाचे बीम का उपयोग करेंगे, और तीन इनपुट की आपूर्ति करेंगे:

raw_data - कच्चा इनपुट डेटा जो हमने ऊपर बनाया है
raw_data_metadata - कच्चे डेटा के लिए स्कीमा
preprocessing_fn - वह फ़ंक्शन जिसे हमने अपना परिवर्तन करने के लिए बनाया है

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

result = pass_this | 'name this step' >> to_this_call

विधि to_this_call को बुलाया जा रहा है और pass_this नामक ऑब्जेक्ट को पास कर दिया गया है, और इस ऑपरेशन को स्टैक ट्रेस में name this step के रूप में संदर्भित किया जाएगा । to_this_call पर कॉल का परिणाम result में दिया जाता है। आप अक्सर इस तरह से एक साथ जंजीर में जकड़ी पाइपलाइन के चरणों को देखेंगे:

result = apache_beam.Pipeline() | 'first step' >> do_this_first() | 'second step' >> do_this_last()

और चूंकि यह एक नई पाइपलाइन के साथ शुरू हुआ है, आप इस तरह जारी रख सकते हैं:

next_result = result | 'doing more stuff' >> another_function()

def main():
  # Ignore the warnings
  with tft_beam.Context(temp_dir=tempfile.mkdtemp()):
    transformed_dataset, transform_fn = (  # pylint: disable=unused-variable
        (raw_data, raw_data_metadata) | tft_beam.AnalyzeAndTransformDataset(
            preprocessing_fn))

  transformed_data, transformed_metadata = transformed_dataset  # pylint: disable=unused-variable

  print('\nRaw data:\n{}\n'.format(pprint.pformat(raw_data)))
  print('Transformed data:\n{}'.format(pprint.pformat(transformed_data)))

if __name__ == '__main__':
  main()

WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:tensorflow:You are passing instance dicts and DatasetMetadata to TFT which will not provide optimal performance. Consider following the TFT guide to upgrade to the TFXIO format (Apache Arrow RecordBatch).
WARNING:tensorflow:You are passing instance dicts and DatasetMetadata to TFT which will not provide optimal performance. Consider following the TFT guide to upgrade to the TFXIO format (Apache Arrow RecordBatch).
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_transform/tf_utils.py:289: Tensor.experimental_ref (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use ref() instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_transform/tf_utils.py:289: Tensor.experimental_ref (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use ref() instead.
WARNING:tensorflow:You are passing instance dicts and DatasetMetadata to TFT which will not provide optimal performance. Consider following the TFT guide to upgrade to the TFXIO format (Apache Arrow RecordBatch).
WARNING:tensorflow:You are passing instance dicts and DatasetMetadata to TFT which will not provide optimal performance. Consider following the TFT guide to upgrade to the TFXIO format (Apache Arrow RecordBatch).
WARNING:apache_beam.options.pipeline_options:Discarding unparseable args: ['/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py', '-f', '/tmp/tmp8aif_7w8.json', '--HistoryManager.hist_file=:memory:']
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
INFO:tensorflow:Assets written to: /tmp/tmpfvgb9_2h/tftransform_tmp/319450c9d7da4ab08741bc79e129ac38/assets
2022-02-03 10:18:41.378629: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpfvgb9_2h/tftransform_tmp/319450c9d7da4ab08741bc79e129ac38/assets
INFO:tensorflow:tensorflow_text is not available.
INFO:tensorflow:tensorflow_text is not available.
INFO:tensorflow:tensorflow_decision_forests is not available.
INFO:tensorflow:tensorflow_decision_forests is not available.
INFO:tensorflow:struct2tensor is not available.
INFO:tensorflow:struct2tensor is not available.
INFO:tensorflow:Assets written to: /tmp/tmpfvgb9_2h/tftransform_tmp/1f79865adbdd4ede9a3768fcac29949c/assets
INFO:tensorflow:Assets written to: /tmp/tmpfvgb9_2h/tftransform_tmp/1f79865adbdd4ede9a3768fcac29949c/assets
INFO:tensorflow:tensorflow_text is not available.
INFO:tensorflow:tensorflow_text is not available.
INFO:tensorflow:tensorflow_decision_forests is not available.
INFO:tensorflow:tensorflow_decision_forests is not available.
INFO:tensorflow:struct2tensor is not available.
INFO:tensorflow:struct2tensor is not available.
Raw data:
[{'s': 'hello', 'x': 1, 'y': 1},
 {'s': 'world', 'x': 2, 'y': 2},
 {'s': 'hello', 'x': 3, 'y': 3}]

Transformed data:
[{'s_integerized': 0,
  'x_centered': -1.0,
  'x_centered_times_y_normalized': -0.0,
  'y_normalized': 0.0},
 {'s_integerized': 1,
  'x_centered': 0.0,
  'x_centered_times_y_normalized': 0.0,
  'y_normalized': 0.5},
 {'s_integerized': 0,
  'x_centered': 1.0,
  'x_centered_times_y_normalized': 1.0,
  'y_normalized': 1.0}]

क्या यह सही उत्तर है?

पहले, हमने ऐसा करने के लिए tf.Transform का उपयोग किया था:

x_centered = x - tft.mean(x)
y_normalized = tft.scale_to_0_1(y)
s_integerized = tft.compute_and_apply_vocabulary(s)
x_centered_times_y_normalized = (x_centered * y_normalized)

x_centered

[1, 2, 3] के इनपुट के साथ x का माध्य 2 है, और हम इसे x से घटाकर अपने x मानों को 0 पर केन्द्रित करते हैं। तो [-1.0, 0.0, 1.0] का हमारा परिणाम सही है।

y_सामान्यीकृत

हम अपने y मानों को 0 और 1 के बीच मापना चाहते थे। हमारा इनपुट [1, 2, 3] था, इसलिए [0.0, 0.5, 1.0] का हमारा परिणाम सही है।

s_integerized

हम अपने स्ट्रिंग्स को एक शब्दावली में अनुक्रमित करना चाहते थे, और हमारी शब्दावली ("हैलो" और "वर्ल्ड") में केवल 2 शब्द थे। तो ["hello", "world", "hello"] के इनपुट के साथ [0, 1, 0] का हमारा परिणाम सही है। चूंकि इस डेटा में "हैलो" सबसे अधिक बार आता है, इसलिए यह शब्दावली में पहली प्रविष्टि होगी।

x_centered_times_y_normalized

हम गुणन का उपयोग करके x_centered और y_normalized को पार करके एक नई सुविधा बनाना चाहते थे। ध्यान दें कि यह परिणामों को गुणा करता है, मूल मानों को नहीं, और [-0.0, 0.0, 1.0] का हमारा नया परिणाम सही है।