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

TensorFlow Transform के साथ शुरुआत करें

यह मार्गदर्शिका tf.Transform की बुनियादी अवधारणाओं और उनका उपयोग करने के तरीके का परिचय देती है। यह:

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

प्रीप्रोसेसिंग फ़ंक्शन को परिभाषित करें

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

  1. कोई भी फ़ंक्शन जो टेंसर को स्वीकार करता है और लौटाता है। ये TensorFlow संचालन को ग्राफ़ में जोड़ते हैं जो कच्चे डेटा को रूपांतरित डेटा में बदलते हैं।
  2. tf.Transform द्वारा प्रदान किया गया कोई भी विश्लेषक । विश्लेषक भी टेंसर को स्वीकार करते हैं और वापस करते हैं, लेकिन TensorFlow फ़ंक्शन के विपरीत, वे ग्राफ़ में संचालन नहीं जोड़ते हैं। इसके बजाय, विश्लेषक tf.Transform बाहर एक पूर्ण-पास ऑपरेशन की गणना करने के लिए tf.Transform का कारण बनते हैं। वे आउटपुट के रूप में लौटाए गए निरंतर टेंसर को उत्पन्न करने के लिए पूरे डेटासेट पर इनपुट टेंसर मानों का उपयोग करते हैं। उदाहरण के लिए, tft.min डेटासेट पर न्यूनतम टेंसर की गणना करता है। tf.Transform विश्लेषक का एक निश्चित सेट प्रदान करता है, लेकिन इसे भविष्य के संस्करणों में विस्तारित किया जाएगा।

प्रीप्रोसेसिंग फ़ंक्शन उदाहरण

एनालाइज़र और नियमित TensorFlow फ़ंक्शंस को मिलाकर, उपयोगकर्ता डेटा बदलने के लिए लचीली पाइपलाइन बना सकते हैं। निम्नलिखित प्रीप्रोसेसिंग फ़ंक्शन तीन विशेषताओं में से प्रत्येक को अलग-अलग तरीकों से बदल देता है, और दो विशेषताओं को जोड़ता है:

import tensorflow as tf
import tensorflow_transform as tft
import tensorflow_transform.beam as tft_beam

def preprocessing_fn(inputs):
  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,
      'x_centered_times_y_normalized': x_centered_times_y_normalized,
      's_integerized': s_integerized
  }

यहाँ, x , y और s Tensor s हैं जो इनपुट सुविधाओं का प्रतिनिधित्व करते हैं। पहला नया टेंसर जो बनाया गया है, x_centered , tft.mean को x लागू tft.mean और इसे x से घटाकर बनाया गया है। tft.mean(x) टेंसर x के माध्य का प्रतिनिधित्व करने वाला एक टेंसर देता है। x_centered टेन्सर x है जिसका माध्य घटाया गया है।

दूसरा नया टेंसर, y_normalized , इसी तरह से बनाया गया है लेकिन सुविधा विधि tft.scale_to_0_1 का उपयोग कर रहा है। यह विधि x_centered गणना के समान कुछ करती है, अर्थात् अधिकतम और न्यूनतम की गणना करना और y को स्केल करने के लिए इनका उपयोग करना।

टेंसर s_integerized स्ट्रिंग हेरफेर का एक उदाहरण दिखाता है। इस मामले में, हम एक स्ट्रिंग लेते हैं और इसे एक पूर्णांक में मैप करते हैं। यह सुविधा फ़ंक्शनtft.compute_and_apply_vocabulary का उपयोग करता है। यह फ़ंक्शन इनपुट स्ट्रिंग्स द्वारा लिए गए अद्वितीय मानों की गणना करने के लिए एक विश्लेषक का उपयोग करता है, और फिर अद्वितीय मानों की तालिका में इनपुट स्ट्रिंग्स को इंडेक्स में बदलने के लिए TensorFlow संचालन का उपयोग करता है।

अंतिम कॉलम से पता चलता है कि टेंसर के संयोजन से नई सुविधाओं को बनाने के लिए TensorFlow संचालन का उपयोग करना संभव है।

प्रीप्रोसेसिंग फ़ंक्शन डेटासेट पर संचालन की एक पाइपलाइन को परिभाषित करता है। पाइपलाइन को लागू करने के लिए, हम tf.Transform API के ठोस कार्यान्वयन पर भरोसा करते हैं। अपाचे बीम कार्यान्वयन PTransform प्रदान करता है जो डेटा पर उपयोगकर्ता के प्रीप्रोसेसिंग फ़ंक्शन को लागू करता है। एक tf.Transform उपयोगकर्ता का विशिष्ट कार्यप्रवाह एक प्रीप्रोसेसिंग फ़ंक्शन का निर्माण करेगा, फिर इसे प्रशिक्षण के लिए डेटा बनाने के लिए एक बड़ी बीम पाइपलाइन में शामिल करेगा।

बैचिंग

बैचिंग TensorFlow का एक महत्वपूर्ण हिस्सा है। चूंकि tf.Transform का एक लक्ष्य tf.Transform के लिए एक TensorFlow ग्राफ़ प्रदान करना है जिसे सर्विंग ग्राफ़ (और, वैकल्पिक रूप से, प्रशिक्षण ग्राफ़) में शामिल किया जा सकता है, tf.Transform में बैचिंग भी एक महत्वपूर्ण अवधारणा है।

जबकि ऊपर के उदाहरण में स्पष्ट नहीं है, उपयोगकर्ता परिभाषित प्रीप्रोसेसिंग फ़ंक्शन टेन्सर को बैचों का प्रतिनिधित्व करता है, न कि व्यक्तिगत उदाहरणों के रूप में, जैसा कि TensorFlow के साथ प्रशिक्षण और सेवा के दौरान होता है। दूसरी ओर, विश्लेषक पूरे डेटासेट पर एक गणना करते हैं जो एक एकल मान देता है न कि मूल्यों का एक बैच। x (batch_size,) tft.mean(x) (batch_size,) आकार वाला एक Tensor , जबकि tft.mean(x) एक Tensor है जिसका आकार () । घटाव x - tft.mean(x) प्रसारण जहां का मूल्य tft.mean(x) बैच के प्रतिनिधित्व के हर तत्व से घटाया जाता है x

अपाचे बीम कार्यान्वयन

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

अपाचे बीम कार्यान्वयन दो PTransform s प्रदान करता है PTransform उपयोग प्रीप्रोसेसिंग फ़ंक्शन के लिए डेटा संसाधित करने के लिए किया जाता है। निम्नलिखित समग्र PTransform AnalyzeAndTransformDataset के उपयोग को PTransform AnalyzeAndTransformDataset :

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

raw_data_metadata = ...
transformed_dataset, transform_fn = (
    (raw_data, raw_data_metadata) | tft_beam.AnalyzeAndTransformDataset(
        preprocessing_fn))
transformed_data, transformed_metadata = transformed_dataset

transformed_data सामग्री नीचे दिखाई गई है और इसमें रूपांतरित कॉलम कच्चे डेटा के समान प्रारूप में हैं। विशेष रूप से, s_integerized के मान [0, 1, 0] ये मान इस बात पर निर्भर करते हैं कि hello और world शब्दों को पूर्णांक में कैसे मैप किया गया था, जो नियतात्मक है। कॉलम x_centered , हमने माध्य घटाया ताकि कॉलम x के मान, जो [1.0, 2.0, 3.0] , [-1.0, 0.0, 1.0] बन गए। इसी तरह, बाकी कॉलम उनके अपेक्षित मूल्यों से मेल खाते हैं।

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

दोनों raw_data और transformed_data डेटासेट हैं। अगले दो खंड दिखाते हैं कि बीम कार्यान्वयन कैसे डेटासेट का प्रतिनिधित्व करता है और डिस्क पर डेटा को कैसे पढ़ना और लिखना है। अन्य वापसी मूल्य, transform_fn , डेटा पर लागू परिवर्तन का प्रतिनिधित्व करता है, जिसे नीचे विस्तार से कवर किया गया है।

AnalyzeAndTransformDataset AnalyzeDataset और TransformDataset के कार्यान्वयन द्वारा प्रदान किए गए दो मूलभूत परिवर्तनों की संरचना है। तो निम्नलिखित दो कोड स्निपेट बराबर हैं:

transformed_data, transform_fn = (
    my_data | tft_beam.AnalyzeAndTransformDataset(preprocessing_fn))
transform_fn = my_data | tft_beam.AnalyzeDataset(preprocessing_fn)
transformed_data = (my_data, transform_fn) | tft_beam.TransformDataset()

transform_fn एक शुद्ध कार्य है जो एक ऑपरेशन का प्रतिनिधित्व करता है जो डेटासेट की प्रत्येक पंक्ति पर लागू होता है। विशेष रूप से, विश्लेषक मान पहले से ही गणना और स्थिरांक के रूप में माना जाता है। उदाहरण में, transform_fn में स्थिरांक के रूप में कॉलम x का माध्य, न्यूनतम और अधिकतम कॉलम y और स्ट्रिंग्स को पूर्णांक में मैप करने के लिए उपयोग की जाने वाली शब्दावली शामिल है।

tf.Transform की एक महत्वपूर्ण विशेषता यह है कि transform_fn tf.Transform पंक्तियों पर एक मानचित्र का प्रतिनिधित्व करता है - यह प्रत्येक पंक्ति पर अलग से लागू होने वाला एक शुद्ध कार्य है। पंक्तियों को एकत्र करने के लिए सभी AnalyzeDataset में की AnalyzeDataset । इसके अलावा, transform_fn को एक TensorFlow Graph रूप में दर्शाया जाता है जिसे सर्विंग Graph में एम्बेड किया जा सकता है।

इस विशेष मामले में अनुकूलन के लिए AnalyzeAndTransformDataset प्रदान किया गया है। यह वही पैटर्न है जिसका उपयोग स्किकिट-लर्न में किया जाता है, जो fit , transform और fit_transform तरीके प्रदान करता fit

डेटा प्रारूप और स्कीमा

TFT बीम कार्यान्वयन दो अलग-अलग इनपुट डेटा स्वरूपों को स्वीकार करता है। "इंस्टेंस डिक्ट" प्रारूप (जैसा कि ऊपर के उदाहरण में और simple_example.py में simple_example.py ) एक सहज प्रारूप है और छोटे डेटासेट के लिए उपयुक्त है जबकि TFXIO ( अपाचे एरो ) प्रारूप बेहतर प्रदर्शन प्रदान करता है और बड़े डेटासेट के लिए उपयुक्त है।

बीम कार्यान्वयन बताता है कि पीसीओलेक्शन के साथ "मेटाडेटा" द्वारा इनपुट पीसीओलेक्शन किस प्रारूप में होगा:

(raw_data, raw_data_metadata) | tft.AnalyzeDataset(...)
  • अगर raw_data_metadata एक dataset_metadata.DatasetMetadata (नीचे देखें, "द इंस्टेंस raw_data ' raw_data " सेक्शन), तो raw_data के "इंस्टेंस raw_data " raw_data में होने की उम्मीद है.
  • यदि raw_data_metadata एक raw_data_metadata है। tfxio.TensorAdapterConfig (नीचे देखें, "TFXIO प्रारूप" अनुभाग), तो raw_data के TFXIO प्रारूप में होने की उम्मीद है।

"उदाहरण dict" प्रारूप"

पिछले कोड उदाहरणों में, raw_data_metadata को परिभाषित करने raw_data_metadata कोड छोड़ा गया है। मेटाडेटा में स्कीमा होता है जो डेटा के लेआउट को परिभाषित करता है ताकि इसे विभिन्न स्वरूपों से पढ़ा और लिखा जा सके। यहां तक ​​​​कि अंतिम खंड में दिखाया गया इन-मेमोरी प्रारूप स्व-वर्णन नहीं है और इसे टेंसर के रूप में व्याख्या करने के लिए स्कीमा की आवश्यकता होती है।

उदाहरण डेटा के लिए स्कीमा की परिभाषा यहां दी गई है:

from tensorflow_transform.tf_metadata import dataset_metadata
from tensorflow_transform.tf_metadata import schema_utils

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

Schema प्रोटो में डेटा को इसके ऑन-डिस्क या इन-मेमोरी प्रारूप से टेंसर में पार्स करने के लिए आवश्यक जानकारी होती है। यह आमतौर पर tf.io.FixedLenFeature , tf.io.VarLenFeature , और tf.io.SparseFeature मानों के लिए एक tf.io.FixedLenFeature मानचित्रण सुविधा कुंजियों के साथ schema_utils.schema_from_feature_spec को कॉल करके बनाया गया है। अधिक विवरण के लिए tf.parse_example लिए दस्तावेज़ देखें।

ऊपर हम यह इंगित करने के लिए tf.io.FixedLenFeature का उपयोग करते हैं कि प्रत्येक सुविधा में एक निश्चित संख्या में मान होते हैं, इस मामले में एक एकल स्केलर मान। क्योंकि tf.Transform बैच इंस्टेंस, सुविधा का प्रतिनिधित्व करने वाले वास्तविक Tensor का आकार (None,) जहां अज्ञात आयाम बैच आयाम है।

TFXIO प्रारूप

इस प्रारूप के साथ, डेटा को एक pyarrow.RecordBatch में निहित होने की उम्मीद है। सारणीबद्ध डेटा के लिए, हमारा अपाचे बीम कार्यान्वयन एरो RecordBatch स्वीकार करता है जिसमें निम्न प्रकार के कॉलम होते हैं:

  • pa.list_(<primitive>) , जहां <primitive> pa.int64() , pa.float32() pa.binary() या pa.large_binary()

  • pa.large_list(<primitive>)

ऊपर इस्तेमाल किया गया खिलौना इनपुट डेटासेट, जब RecordBatch रूप में RecordBatch , तो निम्न जैसा दिखता है:

raw_data = [
    pa.record_batch([
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([['hello'], ['world'], ['hello']], pa.list_(pa.binary())),
    ], ['x', 'y', 's'])
]

DatasetMetadata के समान "इंस्टेंस dict" प्रारूप के साथ होने की आवश्यकता है, एक tfxio.TensorAdapterConfig को RecordBatch es के साथ आने की आवश्यकता है। इसमें RecordBatch es की एरो स्कीमा, और TensorRepresentations जो विशिष्ट रूप से यह निर्धारित करती हैं कि कैसे RecordBatch es में कॉलम को RecordBatch रूप में व्याख्या किया जा सकता है (जिसमें tf.Tensor, tf.SparseTensor शामिल है, लेकिन इन्हीं तक सीमित नहीं है)।

TensorRepresentations एक Dict[Text, TensorRepresentation] जो एक Tensor के बीच संबंध स्थापित करता है जिसे preprocessing_fn स्वीकार करता है और RecordBatch es में कॉलम करता है। उदाहरण के लिए:

tensor_representation = {
    'x': text_format.Parse(
        """dense_tensor { column_name: "col1" shape { dim { size: 2 } } }"""
        schema_pb2.TensorRepresentation())
}

इसका मतलब है कि preprocessing_fn में inputs['x'] एक सघन tf.Tensor होना चाहिए, जिसका मान इनपुट RecordBatch es में 'col1' नाम के कॉलम से आता है, और इसका (बैच) आकार [batch_size, 2] होना चाहिए।

TensorRepresentation TensorFlow मेटाडेटा में परिभाषित एक TensorRepresentation है।

TensorFlow के साथ संगतता

tf.Transform ऊपर दिए गए transform_fn tf.Transform को TF 1.x या TF 2.x SavedModel के रूप में निर्यात करने के लिए समर्थन प्रदान करता है। 0.30 रिलीज़ से पहले डिफ़ॉल्ट व्यवहार ने एक TF 1.x SavedModel निर्यात किया। 0.30 रिलीज के साथ शुरू, डिफ़ॉल्ट व्यवहार एक TF 2.x सहेजे गए मॉडल को निर्यात करना है जब तक कि TF 2.x व्यवहार स्पष्ट रूप से अक्षम न हों (उदाहरण के लिए tf.compat.v1.disable_v2_behavior() को कॉल tf.compat.v1.disable_v2_behavior() )।

यदि TF 1.x अवधारणाओं जैसे कि Estimators और Sessions का उपयोग कर रहे हैं, तो आप पिछले व्यवहार को force_tf_compat_v1=True tft_beam.Context लिए force_tf_compat_v1=True पास करके बनाए रख सकते हैं यदि tf.Transform का उपयोग स्टैंडअलोन लाइब्रेरी या TFX में ट्रांसफ़ॉर्म घटक के रूप में करते हैं।

transform_fn fn को TF 2.x SavedModel के रूप में निर्यात करते समय, preprocessing_fn को tf.function का उपयोग करके tf.function करने योग्य होने की उम्मीद है। इसके अतिरिक्त, यदि आपकी पाइपलाइन दूरस्थ रूप से चल रही है (उदाहरण के लिए DataflowRunner साथ), तो सुनिश्चित करें कि preprocessing_fn और किसी भी निर्भरता को यहां वर्णित अनुसार ठीक से पैक किया गया है

TF 2.x SavedModel को निर्यात करने के लिए tf.Transform का उपयोग करने के साथ ज्ञात समस्याएं यहां प्रलेखित हैं

अपाचे बीम के साथ इनपुट और आउटपुट

अब तक, हमने पायथन सूचियों ( RecordBatch es या उदाहरण शब्दकोशों) में इनपुट और आउटपुट डेटा देखा है। यह एक सरलीकरण है जो अपाचे बीम की सूचियों के साथ काम करने की क्षमता के साथ-साथ डेटा के मुख्य प्रतिनिधित्व, PCollection पर PCollection

एक PCollection एक डेटा प्रतिनिधित्व है जो बीम पाइपलाइन का एक हिस्सा बनाता है। AnalyzeDataset और TransformDataset सहित विभिन्न PTransform s को लागू AnalyzeDataset और पाइपलाइन को चलाकर एक बीम पाइपलाइन बनाई जाती है। मुख्य बाइनरी की स्मृति में एक PCollection नहीं बनाया जाता है, बल्कि इसके बजाय श्रमिकों के बीच वितरित किया जाता है (हालांकि यह खंड इन-मेमोरी निष्पादन मोड का उपयोग करता है)।

पूर्व-डिब्बाबंद PCollection स्रोत ( TFXIO )

हमारा कार्यान्वयन जिस RecordBatch प्रारूप को स्वीकार करता है वह एक सामान्य प्रारूप है जिसे अन्य TFX पुस्तकालय स्वीकार करते हैं। इसलिए TFX सुविधाजनक "स्रोत" (उर्फ TFXIO ) प्रदान करता है जो डिस्क पर विभिन्न स्वरूपों की फाइलें पढ़ता है और RecordBatch es का उत्पादन RecordBatch और अनुमानित TensorRepresentations सहित TensorAdapterConfig भी दे सकता है।

वे TFXIO s पैकेज tfx_bsl ( tfx_bsl.public.tfxio ) में पाए जा सकते हैं।

उदाहरण: "जनगणना आय" डेटासेट

निम्नलिखित उदाहरण के लिए डिस्क पर डेटा पढ़ना और लिखना और डेटा को PCollection (सूची नहीं) के रूप में प्रस्तुत करना दोनों की आवश्यकता है, देखें: census_example.py । नीचे हम दिखाते हैं कि डेटा कैसे डाउनलोड करें और इस उदाहरण को कैसे चलाएं। "जनगणना आय" डेटासेट यूसीआई मशीन लर्निंग रिपोजिटरी द्वारा प्रदान किया जाता है। इस डेटासेट में श्रेणीबद्ध और संख्यात्मक डेटा दोनों शामिल हैं।

डेटा CSV प्रारूप में है, यहाँ पहली दो पंक्तियाँ हैं:

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K

डेटासेट के कॉलम या तो श्रेणीबद्ध या संख्यात्मक होते हैं। यह डेटासेट एक वर्गीकरण समस्या का वर्णन करता है: अंतिम कॉलम की भविष्यवाणी करना जहां व्यक्ति प्रति वर्ष 50K से अधिक या कम कमाता है। हालाँकि, tf.Transform के दृष्टिकोण से, यह लेबल केवल एक अन्य श्रेणीबद्ध स्तंभ है।

हम एक पूर्व-डिब्बाबंद TFXIO , BeamRecordCsvTFXIO का उपयोग CSV लाइनों को RecordBatches में अनुवाद करने के लिए करते हैं। TFXIO को दो महत्वपूर्ण जानकारी की आवश्यकता है:

  • एक TensorFlow मेटाडेटा स्कीमा जिसमें प्रत्येक CSV कॉलम के बारे में प्रकार और आकार की जानकारी होती है। TensorRepresentation s स्कीमा का एक वैकल्पिक हिस्सा हैं; यदि प्रदान नहीं किया गया है (जो इस उदाहरण में है), तो उनका अनुमान प्रकार और आकार की जानकारी से लगाया जाएगा। टीएफ पार्सिंग स्पेक्स (इस उदाहरण में दिखाया गया है) से अनुवाद करने के लिए हमारे द्वारा प्रदान किए गए सहायक फ़ंक्शन का उपयोग करके या TensorFlow डेटा सत्यापन चलाकर स्कीमा प्राप्त कर सकते हैं।

  • कॉलम नामों की एक सूची, जिस क्रम में वे CSV फ़ाइल में दिखाई देते हैं। ध्यान दें कि उन नामों को स्कीमा में फीचर नामों से मेल खाना चाहिए।

इस उदाहरण में हम education-num सुविधा को गायब होने देते हैं। इसका मतलब है कि इसे tf.io.VarLenFeature में tf.io.VarLenFeature के रूप में और preprocessing_fn में tf.SparseTensor रूप में tf.SparseTensor गया है। अन्य सुविधाएं preprocessing_fn में उसी नाम के tf.Tensor s बन tf.Tensor

csv_tfxio = tfxio.BeamRecordCsvTFXIO(
    physical_format='text', column_names=ordered_columns, schema=SCHEMA)

record_batches = (
    p
    | 'ReadTrainData' >> textio.ReadFromText(train_data_file)
    | ...  # fix up csv lines
    | 'ToRecordBatches' >> csv_tfxio.BeamSource())

tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

। ध्यान दें कि हम सीएसवी लाइनों के बाद कुछ अतिरिक्त ठीक-अप में पढ़ा जाता है करना था अन्यथा, हम पर भरोसा करते हैं सकता है CsvTFXIO दोनों फ़ाइलों को पढ़ने और अनुवाद के लिए संभाल करने RecordBatch तों:

csv_tfxio = tfxio.CsvTFXIO(train_data_file, column_name=ordered_columns,
                           schema=SCHEMA)
record_batches = p | 'TFXIORead' >> csv_tfxio.BeamSource()
tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

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

def preprocessing_fn(inputs):
  """Preprocess input columns into transformed columns."""
  # Since we are modifying some features and leaving others unchanged, we
  # start by setting `outputs` to a copy of `inputs.
  outputs = inputs.copy()

  # Scale numeric columns to have range [0, 1].
  for key in NUMERIC_FEATURE_KEYS:
    outputs[key] = tft.scale_to_0_1(outputs[key])

  for key in OPTIONAL_NUMERIC_FEATURE_KEYS:
    # This is a SparseTensor because it is optional. Here we fill in a default
    # value when it is missing.
      sparse = tf.sparse.SparseTensor(outputs[key].indices, outputs[key].values,
                                      [outputs[key].dense_shape[0], 1])
      dense = tf.sparse.to_dense(sp_input=sparse, default_value=0.)
    # Reshaping from a batch of vectors of size 1 to a batch to scalars.
    dense = tf.squeeze(dense, axis=1)
    outputs[key] = tft.scale_to_0_1(dense)

  # For all categorical columns except the label column, we generate a
  # vocabulary but do not modify the feature.  This vocabulary is instead
  # used in the trainer, by means of a feature column, to convert the feature
  # from a string to an integer id.
  for key in CATEGORICAL_FEATURE_KEYS:
    tft.vocabulary(inputs[key], vocab_filename=key)

  # For the label column we provide the mapping from string to index.
  initializer = tf.lookup.KeyValueTensorInitializer(
      keys=['>50K', '<=50K'],
      values=tf.cast(tf.range(2), tf.int64),
      key_dtype=tf.string,
      value_dtype=tf.int64)
  table = tf.lookup.StaticHashTable(initializer, default_value=-1)

  outputs[LABEL_KEY] = table.lookup(outputs[LABEL_KEY])

  return outputs

पिछले उदाहरण से एक अंतर यह है कि लेबल कॉलम मैन्युअल रूप से स्ट्रिंग से इंडेक्स में मैपिंग निर्दिष्ट करता है। तो '>50' को 0 मैप किया जाता है और '<=50K' को 1 में मैप किया जाता है क्योंकि यह जानना उपयोगी होता है कि प्रशिक्षित मॉडल में कौन सा इंडेक्स किस लेबल से मेल खाता है।

record_batches चर pyarrow.RecordBatch es के एक PCollection का प्रतिनिधित्व करता है। tensor_adapter_config द्वारा दिया जाता है csv_tfxio , जिसमें से मान लिया जाता है SCHEMA (और अंततः, इस उदाहरण में, TF पार्स चश्मा से)।

अंतिम चरण परिवर्तित डेटा को डिस्क में लिखना है और कच्चे डेटा को पढ़ने के समान रूप है। ऐसा करने के लिए उपयोग किया जाने वाला स्कीमा AnalyzeAndTransformDataset के आउटपुट का AnalyzeAndTransformDataset जो आउटपुट डेटा के लिए एक स्कीमा का अनुमान लगाता है। डिस्क पर लिखने के लिए कोड नीचे दिखाया गया है। स्कीमा मेटाडेटा का एक हिस्सा है, लेकिन tf.Transform API में दोनों का परस्पर उपयोग करता है (यानी मेटाडेटा को ExampleProtoCoder पास करें)। ध्यान रखें कि यह एक अलग प्रारूप में लिखता है। textio.WriteToText बजाय, TFRecord प्रारूप के लिए बीम के अंतर्निहित समर्थन का उपयोग करें और डेटा को Example प्रोटो के रूप में एन्कोड करने के लिए एक कोडर का उपयोग करें। प्रशिक्षण के लिए उपयोग करने के लिए यह एक बेहतर प्रारूप है, जैसा कि अगले भाग में दिखाया गया है। transformed_eval_data_base लिखे गए व्यक्तिगत शार्क के लिए आधार फ़ाइल नाम प्रदान करता है।

transformed_data | "WriteTrainData" >> tfrecordio.WriteToTFRecord(
    transformed_eval_data_base,
    coder=tft.coders.ExampleProtoCoder(transformed_metadata))

प्रशिक्षण डेटा के अलावा, transform_fn fn को मेटाडेटा के साथ भी लिखा जाता है:

_ = (
    transform_fn
    | 'WriteTransformFn' >> tft_beam.WriteTransformFn(working_dir))
transformed_metadata | 'WriteMetadata' >> tft_beam.WriteMetadata(
    transformed_metadata_file, pipeline=p)

p.run().wait_until_finish() साथ संपूर्ण बीम पाइपलाइन चलाएँ। इस बिंदु तक, बीम पाइपलाइन एक आस्थगित, वितरित गणना का प्रतिनिधित्व करती है। यह क्या किया जाएगा के लिए निर्देश प्रदान करता है, लेकिन निर्देशों को निष्पादित नहीं किया गया है। यह अंतिम कॉल निर्दिष्ट पाइपलाइन को निष्पादित करता है।

जनगणना डेटासेट डाउनलोड करें

निम्नलिखित शेल कमांड का उपयोग करके जनगणना डेटासेट डाउनलोड करें:

  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data
  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test

census_example.py स्क्रिप्ट census_example.py , इस डेटा वाली निर्देशिका को पहले तर्क के रूप में पास करें। स्क्रिप्ट प्रीप्रोसेस्ड डेटा जोड़ने के लिए एक अस्थायी उप-निर्देशिका बनाती है।

TensorFlow प्रशिक्षण के साथ एकीकृत करें

census_example.py का अंतिम खंड दिखाता है कि किसी मॉडल को प्रशिक्षित करने के लिए पूर्व- census_example.py डेटा का उपयोग कैसे किया जाता है। विवरण के लिए अनुमानक दस्तावेज़ देखें। पहला कदम एक Estimator का निर्माण करना है जिसके लिए पूर्व-संसाधित स्तंभों के विवरण की आवश्यकता होती है। प्रत्येक संख्यात्मक कॉलम को एक real_valued_column रूप में वर्णित किया गया है जो एक निश्चित आकार (इस उदाहरण में 1 ) के साथ घने वेक्टर के चारों ओर एक आवरण है। प्रत्येक श्रेणीबद्ध कॉलम को स्ट्रिंग से पूर्णांक में मैप किया जाता है और फिर indicator_column में पास किया जाता है। tft.TFTransformOutput का उपयोग प्रत्येक श्रेणीबद्ध सुविधा के लिए शब्दावली फ़ाइल पथ खोजने के लिए किया जाता है।

real_valued_columns = [feature_column.real_valued_column(key)
                       for key in NUMERIC_FEATURE_KEYS]

one_hot_columns = [
    tf.feature_column.indicator_column(
        tf.feature_column.categorical_column_with_vocabulary_file(
            key=key,
            vocabulary_file=tf_transform_output.vocabulary_file_by_name(
                vocab_filename=key)))
    for key in CATEGORICAL_FEATURE_KEYS]

estimator = tf.estimator.LinearClassifier(real_valued_columns + one_hot_columns)

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

def _make_training_input_fn(tf_transform_output, transformed_examples,
                            batch_size):
  ...
  def input_fn():
    """Input function for training and eval."""
    dataset = tf.data.experimental.make_batched_features_dataset(
        ..., tf_transform_output.transformed_feature_spec(), ...)

    transformed_features = tf.compat.v1.data.make_one_shot_iterator(
        dataset).get_next()
    ...

  return input_fn

शेष कोड Estimator वर्ग का उपयोग करने जैसा ही है। उदाहरण में मॉडल को SavedModel गए मॉडल प्रारूप में निर्यात करने के लिए कोड भी शामिल है। निर्यात किए गए मॉडल का उपयोग Tensorflow Serving या Cloud ML Engine द्वारा किया जा सकता है।