exampleGen TFX पाइपलाइन घटक

उदाहरणजेन टीएफएक्स पाइपलाइन घटक डेटा को टीएफएक्स पाइपलाइनों में शामिल करता है। यह उदाहरण उत्पन्न करने के लिए बाहरी फाइलों/सेवाओं का उपभोग करता है जिसे अन्य टीएफएक्स घटकों द्वारा पढ़ा जाएगा। यह सुसंगत और विन्यास योग्य विभाजन भी प्रदान करता है, और ML सर्वोत्तम अभ्यास के लिए डेटासेट को फेरबदल करता है।

  • उपभोग: बाहरी डेटा स्रोतों जैसे CSV, TFRecord , Avro, Parquet और BigQuery से डेटा।
  • उत्सर्जन: tf.उदाहरण रिकॉर्ड, tf.Example tf.SequenceExample रिकॉर्ड, या प्रोटो प्रारूप, पेलोड प्रारूप पर निर्भर करता है।

exampleGen और अन्य घटक

exampleGen उन घटकों को डेटा प्रदान करता है जो TensorFlow डेटा सत्यापन लाइब्रेरी का उपयोग करते हैं, जैसे कि SchemaGen , StatisticsGen , और example Validator । यह ट्रांसफ़ॉर्म को डेटा भी प्रदान करता है, जो टेंसरफ़्लो ट्रांसफ़ॉर्म लाइब्रेरी का उपयोग करता है, और अंततः अनुमान के दौरान लक्ष्य को परिनियोजित करने के लिए।

डेटा स्रोत और प्रारूप

वर्तमान में TFX की एक मानक स्थापना में इन डेटा स्रोतों और प्रारूपों के लिए पूर्ण exampleGen घटक शामिल हैं:

कस्टम निष्पादक भी उपलब्ध हैं जो इन डेटा स्रोतों और प्रारूपों के लिए exampleGen घटकों के विकास को सक्षम करते हैं:

कस्टम निष्पादकों का उपयोग और विकास कैसे करें, इस बारे में अधिक जानकारी के लिए स्रोत कोड और इस चर्चा में उपयोग के उदाहरण देखें।

इसके अलावा, ये डेटा स्रोत और प्रारूप कस्टम घटक उदाहरणों के रूप में उपलब्ध हैं:

अपाचे बीम द्वारा समर्थित डेटा प्रारूपों को अंतर्ग्रहण करना

अपाचे बीम डेटा स्रोतों और प्रारूपों की एक विस्तृत श्रृंखला से डेटा अंतर्ग्रहण का समर्थन करता है, ( नीचे देखें )। इन क्षमताओं का उपयोग टीएफएक्स के लिए कस्टम उदाहरणजेन घटकों को बनाने के लिए किया जा सकता है, जो कि कुछ मौजूदा उदाहरणजेन घटकों ( नीचे देखें ) द्वारा प्रदर्शित किया जाता है।

एक exampleGen घटक का उपयोग कैसे करें

समर्थित डेटा स्रोतों (वर्तमान में, CSV फ़ाइलें, tf.Example , tf.SequenceExample और प्रोटो प्रारूप वाली TFRecord फ़ाइलें, और BigQuery क्वेरी के परिणाम) के लिए, exampleGen पाइपलाइन घटक को सीधे परिनियोजन में उपयोग किया जा सकता है और इसके लिए बहुत कम अनुकूलन की आवश्यकता होती है। उदाहरण के लिए:

example_gen = CsvExampleGen(input_base='data_root')

या tf.Example के साथ बाहरी TFRecord आयात करने के लिए नीचे की तरह:

example_gen = ImportExampleGen(input_base=path_to_tfrecord_dir)

अवधि, संस्करण और विभाजन

एक स्पैन प्रशिक्षण उदाहरणों का एक समूह है। यदि आपका डेटा फाइल सिस्टम पर बना रहता है, तो प्रत्येक स्पैन को एक अलग निर्देशिका में संग्रहीत किया जा सकता है। एक स्पैन के शब्दार्थ को टीएफएक्स में हार्डकोड नहीं किया गया है; एक स्पैन डेटा के एक दिन, डेटा के एक घंटे या किसी अन्य समूह के अनुरूप हो सकता है जो आपके कार्य के लिए सार्थक है।

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

एक अवधि के भीतर प्रत्येक संस्करण को आगे कई विभाजनों में विभाजित किया जा सकता है। स्पैन को विभाजित करने के लिए सबसे आम उपयोग-मामला इसे प्रशिक्षण और eval डेटा में विभाजित करना है।

स्पैन और स्प्लिट्स

कस्टम इनपुट/आउटपुट स्प्लिट

ट्रेन/इवल स्प्लिट अनुपात को अनुकूलित करने के लिए जिसे exampleGen आउटपुट करेगा, exampleGen घटक के लिए output_config सेट करें। उदाहरण के लिए:

# Input has a single split 'input_dir/*'.
# Output 2 splits: train:eval=3:1.
output = proto.Output(
             split_config=example_gen_pb2.SplitConfig(splits=[
                 proto.SplitConfig.Split(name='train', hash_buckets=3),
                 proto.SplitConfig.Split(name='eval', hash_buckets=1)
             ]))
example_gen = CsvExampleGen(input_base=input_dir, output_config=output)

ध्यान दें कि इस उदाहरण में hash_buckets कैसे सेट किए गए थे।

एक इनपुट स्रोत के लिए जो पहले ही विभाजित हो चुका है, exampleGen घटक के लिए input_config सेट करें:


# Input train split is 'input_dir/train/*', eval split is 'input_dir/eval/*'.
# Output splits are generated one-to-one mapping from input splits.
input = proto.Input(splits=[
                example_gen_pb2.Input.Split(name='train', pattern='train/*'),
                example_gen_pb2.Input.Split(name='eval', pattern='eval/*')
            ])
example_gen = CsvExampleGen(input_base=input_dir, input_config=input)

फ़ाइल आधारित उदाहरण जीन (जैसे CsvExampleGen और ImportExampleGen) के लिए, pattern एक ग्लोब सापेक्ष फ़ाइल पैटर्न है जो इनपुट बेस पथ द्वारा दी गई रूट निर्देशिका के साथ इनपुट फ़ाइलों को मैप करता है। क्वेरी-आधारित उदाहरण जेन (जैसे BigQueryExampleGen, PrestoExampleGen) के लिए, pattern एक SQL क्वेरी है।

डिफ़ॉल्ट रूप से, पूरे इनपुट बेस डीआईआर को सिंगल इनपुट स्प्लिट के रूप में माना जाता है, और ट्रेन और eval आउटपुट स्प्लिट 2: 1 अनुपात के साथ उत्पन्न होता है।

exampleGen के इनपुट और आउटपुट स्प्लिट कॉन्फ़िगरेशन के लिए कृपया proto/example_gen.proto देखें। और कस्टम स्प्लिट्स डाउनस्ट्रीम का उपयोग करने के लिए डाउनस्ट्रीम घटक मार्गदर्शिका देखें।

बंटवारे का तरीका

hash_buckets विभाजन विधि का उपयोग करते समय, संपूर्ण रिकॉर्ड के बजाय, उदाहरणों को विभाजित करने के लिए एक सुविधा का उपयोग किया जा सकता है। यदि कोई सुविधा मौजूद है, तो उदाहरणजेन उस सुविधा के फिंगरप्रिंट का उपयोग विभाजन कुंजी के रूप में करेगा।

इस सुविधा का उपयोग उदाहरणों के कुछ गुणों को स्थिर विभाजन wrt बनाए रखने के लिए किया जा सकता है: उदाहरण के लिए, एक उपयोगकर्ता को हमेशा उसी विभाजन में रखा जाएगा यदि "user_id" को विभाजन सुविधा नाम के रूप में चुना गया था।

"फीचर" का अर्थ क्या है और निर्दिष्ट नाम के साथ "फीचर" का मिलान कैसे किया जाए, इसकी व्याख्या, exampleGen कार्यान्वयन और उदाहरणों के प्रकार पर निर्भर करती है।

तैयार किए गए exampleGen कार्यान्वयन के लिए:

  • यदि यह tf.Example उत्पन्न करता है, तो एक "फीचर" का अर्थ है tf.Example.features.feature में एक प्रविष्टि।
  • यदि यह tf.SequenceExample उत्पन्न करता है, तो एक "फीचर" का अर्थ tf.SequenceExample.context.feature में एक प्रविष्टि है।
  • केवल int64 और बाइट्स सुविधाएँ समर्थित हैं।

निम्नलिखित मामलों में, exampleGen रनटाइम त्रुटियाँ फेंकता है:

  • निर्दिष्ट सुविधा नाम उदाहरण में मौजूद नहीं है।
  • खाली सुविधा: tf.train.Feature() ।
  • गैर समर्थित सुविधा प्रकार, जैसे, फ्लोट सुविधाएँ।

उदाहरणों में एक विशेषता के आधार पर ट्रेन/eval स्प्लिट को आउटपुट करने के लिए, exampleGen घटक के लिए output_config सेट करें। उदाहरण के लिए:

# Input has a single split 'input_dir/*'.
# Output 2 splits based on 'user_id' features: train:eval=3:1.
output = proto.Output(
             split_config=proto.SplitConfig(splits=[
                 proto.SplitConfig.Split(name='train', hash_buckets=3),
                 proto.SplitConfig.Split(name='eval', hash_buckets=1)
             ],
             partition_feature_name='user_id'))
example_gen = CsvExampleGen(input_base=input_dir, output_config=output)

ध्यान दें कि इस उदाहरण में partition_feature_name कैसे सेट किया गया था।

अवधि

इनपुट ग्लोब पैटर्न में '{SPAN}' स्पेक का उपयोग करके स्पैन को पुनः प्राप्त किया जा सकता है:

  • यह युक्ति अंकों से मेल खाती है और डेटा को प्रासंगिक SPAN संख्याओं में मैप करती है। उदाहरण के लिए, 'data_{SPAN}-*.tfrecord' 'data_12-a.tfrecord', 'date_12-b.tfrecord' जैसी फ़ाइलें एकत्रित करेगा।
  • वैकल्पिक रूप से, इस युक्ति को मैप किए जाने पर पूर्णांकों की चौड़ाई के साथ निर्दिष्ट किया जा सकता है। उदाहरण के लिए, 'data_{SPAN:2}.file' मैप को 'data_02.file' और 'data_27.file' (क्रमशः स्पैन-2 और स्पैन-27 के लिए इनपुट के रूप में) जैसी फाइलों में मैप करता है, लेकिन 'data_1. फ़ाइल' और न ही 'data_123.file'।
  • जब स्पैन स्पेक गुम होता है, तो इसे हमेशा स्पैन '0' माना जाता है।
  • यदि SPAN निर्दिष्ट है, तो पाइपलाइन नवीनतम अवधि को संसाधित करेगी, और स्पैन संख्या को मेटाडेटा में संग्रहीत करेगी।

उदाहरण के लिए, मान लें कि इनपुट डेटा हैं:

  • '/tmp/span-1/ट्रेन/डेटा'
  • '/tmp/span-1/eval/डेटा'
  • '/tmp/span-2/ट्रेन/डेटा'
  • '/tmp/span-2/eval/डेटा'

और इनपुट config नीचे के रूप में दिखाया गया है:

splits {
  name: 'train'
  pattern: 'span-{SPAN}/train/*'
}
splits {
  name: 'eval'
  pattern: 'span-{SPAN}/eval/*'
}

पाइपलाइन को ट्रिगर करते समय, यह संसाधित करेगा:

  • '/tmp/span-2/train/data' ट्रेन स्प्लिट के रूप में
  • '/tmp/span-2/eval/data' eval विभाजन के रूप में

स्पैन नंबर के साथ '2'। यदि बाद में '/tmp/span-3/...' तैयार हैं, तो बस पाइपलाइन को फिर से ट्रिगर करें और यह प्रोसेसिंग के लिए स्पैन '3' उठाएगा। स्पैन स्पेक का उपयोग करने के लिए कोड उदाहरण नीचे दिखाया गया है:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

एक निश्चित अवधि को पुनः प्राप्त करना रेंजकॉन्फिग के साथ किया जा सकता है, जिसका विवरण नीचे दिया गया है।

दिनांक

यदि आपका डेटा स्रोत तिथि के अनुसार फाइल सिस्टम पर व्यवस्थित है, तो TFX मैपिंग तिथियों को सीधे स्पैन नंबरों तक सपोर्ट करता है। दिनांक से अवधि तक मानचित्रण का प्रतिनिधित्व करने के लिए तीन विनिर्देश हैं: {YYYY}, {MM} और {DD}:

  • यदि कोई निर्दिष्ट किया गया है तो इनपुट ग्लोब पैटर्न में तीन स्पेक्स पूरी तरह से मौजूद होने चाहिए:
  • या तो {SPAN} विनिर्देश या दिनांक विनिर्देशों के इस सेट को विशेष रूप से निर्दिष्ट किया जा सकता है।
  • YYYY से वर्ष के साथ एक कैलेंडर तिथि, MM से महीना और DD से महीने के दिन की गणना की जाती है, फिर अवधि संख्या की गणना यूनिक्स युग (यानी 1970-01-01) के बाद के दिनों की संख्या के रूप में की जाती है। उदाहरण के लिए, 'log-{YYYY}{MM}{DD}.data' एक फ़ाइल 'log-19700101.data' से मेल खाता है और इसे Span-0 के इनपुट के रूप में और 'log-20170101.data' के लिए इनपुट के रूप में खपत करता है। स्पैन-17167।
  • यदि दिनांक विनिर्देशों का यह सेट निर्दिष्ट किया गया है, तो पाइपलाइन नवीनतम नवीनतम तिथि को संसाधित करेगी, और मेटाडेटा में संबंधित अवधि संख्या संग्रहीत करेगी।

उदाहरण के लिए, मान लें कि कैलेंडर तिथि द्वारा व्यवस्थित इनपुट डेटा हैं:

  • '/tmp/1970-01-02/ट्रेन/डेटा'
  • '/tmp/1970-01-02/eval/डेटा'
  • '/tmp/1970-01-03/ट्रेन/डेटा'
  • '/tmp/1970-01-03/eval/डेटा'

और इनपुट config नीचे के रूप में दिखाया गया है:

splits {
  name: 'train'
  pattern: '{YYYY}-{MM}-{DD}/train/*'
}
splits {
  name: 'eval'
  pattern: '{YYYY}-{MM}-{DD}/eval/*'
}

पाइपलाइन को ट्रिगर करते समय, यह संसाधित करेगा:

  • '/tmp/1970-01-03/ट्रेन/डेटा' ट्रेन विभाजन के रूप में
  • '/tmp/1970-01-03/eval/data' eval विभाजन के रूप में

स्पैन नंबर के साथ '2'। यदि बाद में '/tmp/1970-01-04/...' तैयार हैं, तो बस पाइपलाइन को फिर से चालू करें और यह प्रसंस्करण के लिए अवधि '3' उठाएगा। नीचे दिनांक युक्ति का उपयोग करने के लिए कोड उदाहरण दिखाता है:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='{YYYY}-{MM}-{DD}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='{YYYY}-{MM}-{DD}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

संस्करण

इनपुट ग्लोब पैटर्न में '{VERSION}' युक्ति का उपयोग करके संस्करण को पुनः प्राप्त किया जा सकता है:

  • यह स्पेक अंकों से मेल खाता है और डेटा को स्पैन के अंतर्गत प्रासंगिक संस्करण संख्याओं में मैप करता है। ध्यान दें कि संस्करण स्पेक का उपयोग स्पैन या डेट स्पेक के संयोजन में किया जा सकता है।
  • इस स्पेक को वैकल्पिक रूप से चौड़ाई के साथ उसी तरह निर्दिष्ट किया जा सकता है जैसे SPAN स्पेक। उदाहरण के लिए 'स्पैन-{SPAN}/संस्करण-{संस्करण:4}/डेटा-*'।
  • जब VERSION युक्ति अनुपलब्ध हो, तो संस्करण कोई नहीं पर सेट होता है।
  • यदि SPAN और VERSION दोनों निर्दिष्ट हैं, तो पाइपलाइन नवीनतम अवधि के लिए नवीनतम संस्करण को संसाधित करेगी, और संस्करण संख्या को मेटाडेटा में संग्रहीत करेगी।
  • यदि VERSION निर्दिष्ट है, लेकिन SPAN (या दिनांक विनिर्देश) नहीं है, तो एक त्रुटि उत्पन्न होगी।

उदाहरण के लिए, मान लें कि इनपुट डेटा हैं:

  • '/tmp/span-1/ver-1/ट्रेन/डेटा'
  • '/tmp/span-1/ver-1/eval/डेटा'
  • '/tmp/span-2/ver-1/ट्रेन/डेटा'
  • '/tmp/span-2/ver-1/eval/data'
  • '/tmp/span-2/ver-2/train/data'
  • '/tmp/span-2/ver-2/eval/data'

और इनपुट config नीचे के रूप में दिखाया गया है:

splits {
  name: 'train'
  pattern: 'span-{SPAN}/ver-{VERSION}/train/*'
}
splits {
  name: 'eval'
  pattern: 'span-{SPAN}/ver-{VERSION}/eval/*'
}

पाइपलाइन को ट्रिगर करते समय, यह संसाधित करेगा:

  • ट्रेन स्प्लिट के रूप में '/tmp/span-2/ver-2/train/data'
  • '/tmp/span-2/ver-2/eval/data' eval विभाजन के रूप में

अवधि संख्या के साथ '2' और संस्करण संख्या '2' के रूप में। यदि बाद में '/tmp/span-2/ver-3/...' तैयार हैं, तो बस पाइपलाइन को फिर से ट्रिगर करें और यह प्रोसेसिंग के लिए स्पैन '2' और संस्करण '3' उठाएगा। नीचे संस्करण युक्ति का उपयोग करने के लिए कोड उदाहरण दिखाता है:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN}/ver-{VERSION}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN}/ver-{VERSION}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

रेंज कॉन्फिग

TFX रेंज कॉन्फिगरेशन का उपयोग करते हुए फ़ाइल-आधारित ExampleGen में एक विशिष्ट अवधि की पुनर्प्राप्ति और प्रसंस्करण का समर्थन करता है, विभिन्न TFX संस्थाओं के लिए श्रेणियों का वर्णन करने के लिए उपयोग किया जाने वाला एक सार कॉन्फ़िगरेशन। एक विशिष्ट अवधि को पुनः प्राप्त करने के लिए, फ़ाइल-आधारित exampleGen घटक के लिए range_config सेट करें। उदाहरण के लिए, मान लें कि इनपुट डेटा हैं:

  • '/tmp/span-01/ट्रेन/डेटा'
  • '/tmp/span-01/eval/डेटा'
  • '/tmp/span-02/ट्रेन/डेटा'
  • '/tmp/span-02/eval/डेटा'

अवधि '1' के साथ डेटा को विशेष रूप से पुनर्प्राप्त और संसाधित करने के लिए, हम इनपुट कॉन्फ़िगरेशन के अतिरिक्त एक श्रेणी कॉन्फ़िगरेशन निर्दिष्ट करते हैं। ध्यान दें कि exampleGen केवल सिंगल-स्पैन स्टैटिक रेंज (विशिष्ट व्यक्तिगत स्पैन के प्रसंस्करण को निर्दिष्ट करने के लिए) का समर्थन करता है। इस प्रकार, StaticRange के लिए, start_span_number को end_span_number के बराबर होना चाहिए। शून्य-पैडिंग के लिए प्रदान की गई अवधि, और अवधि की चौड़ाई की जानकारी (यदि प्रदान की गई है) का उपयोग करते हुए, exampleGen प्रदान किए गए स्प्लिट पैटर्न में SPAN स्पेक को वांछित अवधि संख्या के साथ बदल देगा। उपयोग का एक उदाहरण नीचे दिखाया गया है:

# In cases where files have zero-padding, the width modifier in SPAN spec is
# required so TFX can correctly substitute spec with zero-padded span number.
input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN:2}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN:2}/eval/*')
            ])
# Specify the span number to be processed here using StaticRange.
range = proto.RangeConfig(
                static_range=proto.StaticRange(
                        start_span_number=1, end_span_number=1)
            )

# After substitution, the train and eval split patterns will be
# 'input_dir/span-01/train/*' and 'input_dir/span-01/eval/*', respectively.
example_gen = CsvExampleGen(input_base=input_dir, input_config=input,
                            range_config=range)

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

  • '/tmp/1970-01-02/ट्रेन/डेटा'
  • '/tmp/1970-01-02/eval/डेटा'
  • '/tmp/1970-01-03/ट्रेन/डेटा'
  • '/tmp/1970-01-03/eval/डेटा'

2 जनवरी, 1970 को विशेष रूप से डेटा पुनर्प्राप्त करने और संसाधित करने के लिए, हम निम्नलिखित कार्य करते हैं:

from  tfx.components.example_gen import utils

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='{YYYY}-{MM}-{DD}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='{YYYY}-{MM}-{DD}/eval/*')
            ])
# Specify date to be converted to span number to be processed using StaticRange.
span = utils.date_to_span_number(1970, 1, 2)
range = proto.RangeConfig(
                static_range=range_config_pb2.StaticRange(
                        start_span_number=span, end_span_number=span)
            )

# After substitution, the train and eval split patterns will be
# 'input_dir/1970-01-02/train/*' and 'input_dir/1970-01-02/eval/*',
# respectively.
example_gen = CsvExampleGen(input_base=input_dir, input_config=input,
                            range_config=range)

कस्टम उदाहरणGen

यदि वर्तमान में उपलब्ध exampleGen घटक आपकी आवश्यकताओं के अनुरूप नहीं हैं, तो आप एक कस्टम exampleGen बना सकते हैं, जो आपको विभिन्न डेटा स्रोतों से या विभिन्न डेटा स्वरूपों में पढ़ने में सक्षम करेगा।

फ़ाइल-आधारित उदाहरणजेन अनुकूलन (प्रायोगिक)

सबसे पहले, कस्टम बीम PTransform के साथ BaseExampleGenExecutor का विस्तार करें, जो आपकी ट्रेन/eval इनपुट स्प्लिट से TF उदाहरणों में रूपांतरण प्रदान करता है। उदाहरण के लिए, CsvExampleGen निष्पादक इनपुट CSV स्प्लिट से TF उदाहरणों में रूपांतरण प्रदान करता है।

फिर, उपरोक्त निष्पादक के साथ एक घटक बनाएं, जैसा कि CsvExampleGen घटक में किया गया है। वैकल्पिक रूप से, एक कस्टम एक्ज़ीक्यूटर को नीचे दिखाए गए अनुसार मानक exampleGen घटक में पास करें।

from tfx.components.base import executor_spec
from tfx.components.example_gen.csv_example_gen import executor

example_gen = FileBasedExampleGen(
    input_base=os.path.join(base_dir, 'data/simple'),
    custom_executor_spec=executor_spec.ExecutorClassSpec(executor.Executor))

अब, हम इस पद्धति का उपयोग करके एवरो और लकड़ी की छत फ़ाइलों को पढ़ने का भी समर्थन करते हैं।

अतिरिक्त डेटा प्रारूप

अपाचे बीम कई अतिरिक्त डेटा प्रारूपों को पढ़ने का समर्थन करता है। बीम I/O ट्रांसफॉर्म के माध्यम से। आप एवरो उदाहरण के समान पैटर्न का उपयोग करके बीम I/O ट्रांसफॉर्म का लाभ उठाकर कस्टम उदाहरणजेन घटक बना सकते हैं

  return (pipeline
          | 'ReadFromAvro' >> beam.io.ReadFromAvro(avro_pattern)
          | 'ToTFExample' >> beam.Map(utils.dict_to_example))

इस लेखन के रूप में बीम पायथन एसडीके के लिए वर्तमान में समर्थित स्वरूपों और डेटा स्रोतों में शामिल हैं:

  • अमेज़न S3
  • अपाचे एवरो
  • अपाचे हडूप
  • अपाचे काफ्का
  • अपाचे लकड़ी की छत
  • Google क्लाउड BigQuery
  • Google क्लाउड बिगटेबल
  • Google क्लाउड डेटास्टोर
  • Google क्लाउड पब/उप
  • Google क्लाउड स्टोरेज (जीसीएस)
  • मोंगोडीबी

नवीनतम सूची के लिए बीम दस्तावेज़ देखें।

प्रश्न-आधारित उदाहरण-जन अनुकूलन (प्रायोगिक)

सबसे पहले, एक कस्टम बीम PTransform के साथ BaseExampleGenExecutor का विस्तार करें, जो बाहरी डेटा स्रोत से पढ़ता है। फिर, QueryBasedExampleGen को विस्तारित करके एक साधारण घटक बनाएं।

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

यदि कस्टम exampleGen घटक के लिए कनेक्शन कॉन्फ़िगरेशन की आवश्यकता है, तो एक नया प्रोटोबफ़ बनाएं और इसे custom_config के माध्यम से पास करें, जो अब एक वैकल्पिक निष्पादन पैरामीटर है। कॉन्फ़िगर किए गए घटक का उपयोग कैसे करें, इसका एक उदाहरण नीचे दिया गया है।

from tfx.examples.custom_components.presto_example_gen.proto import presto_config_pb2
from tfx.examples.custom_components.presto_example_gen.presto_component.component import PrestoExampleGen

presto_config = presto_config_pb2.PrestoConnConfig(host='localhost', port=8080)
example_gen = PrestoExampleGen(presto_config, query='SELECT * FROM chicago_taxi_trips')

उदाहरणजेन डाउनस्ट्रीम घटक

कस्टम स्प्लिट कॉन्फ़िगरेशन डाउनस्ट्रीम घटकों के लिए समर्थित है।

सांख्यिकीGen

डिफ़ॉल्ट व्यवहार सभी विभाजनों के लिए आँकड़े बनाना है।

किसी भी विभाजन को बाहर करने के लिए, सांख्यिकीजेन घटक के लिए exclude_splits सेट करें। उदाहरण के लिए:

# Exclude the 'eval' split.
statistics_gen = StatisticsGen(
             examples=example_gen.outputs['examples'],
             exclude_splits=['eval'])

स्कीमाजेन

डिफ़ॉल्ट व्यवहार सभी विभाजनों के आधार पर एक स्कीमा उत्पन्न करना है।

किसी भी विभाजन को बाहर करने के लिए, exclude_splits घटक के लिए बहिष्कृत_स्प्लिट सेट करें। उदाहरण के लिए:

# Exclude the 'eval' split.
schema_gen = SchemaGen(
             statistics=statistics_gen.outputs['statistics'],
             exclude_splits=['eval'])

उदाहरण सत्यापनकर्ता

डिफ़ॉल्ट व्यवहार एक स्कीमा के विरुद्ध इनपुट उदाहरणों पर सभी विभाजनों के आंकड़ों को मान्य करना है।

किसी भी विभाजन को बाहर करने के लिए, exclude_splits घटक के लिए बहिष्कृत_स्प्लिट सेट करें। उदाहरण के लिए:

# Exclude the 'eval' split.
example_validator = ExampleValidator(
             statistics=statistics_gen.outputs['statistics'],
             schema=schema_gen.outputs['schema'],
             exclude_splits=['eval'])

परिवर्तन

डिफ़ॉल्ट व्यवहार 'ट्रेन' विभाजन से मेटाडेटा का विश्लेषण और उत्पादन होता है और सभी विभाजनों को बदल देता है।

विश्लेषण स्प्लिट्स और ट्रांसफॉर्म स्प्लिट्स को निर्दिष्ट करने के लिए, ट्रांसफॉर्म घटक के लिए splits_config सेट करें। उदाहरण के लिए:

# Analyze the 'train' split and transform all splits.
transform = Transform(
      examples=example_gen.outputs['examples'],
      schema=schema_gen.outputs['schema'],
      module_file=_taxi_module_file,
      splits_config=proto.SplitsConfig(analyze=['train'],
                                               transform=['train', 'eval']))

ट्रेनर और ट्यूनर

डिफ़ॉल्ट व्यवहार 'ट्रेन' विभाजन पर ट्रेन है और 'eval' विभाजन पर मूल्यांकन करता है।

ट्रेन के विभाजन को निर्दिष्ट करने और विभाजन का मूल्यांकन करने के लिए, ट्रेनर घटक के लिए train_args और eval_args सेट करें। उदाहरण के लिए:

# Train on the 'train' split and evaluate on the 'eval' split.
Trainer = Trainer(
      module_file=_taxi_module_file,
      examples=transform.outputs['transformed_examples'],
      schema=schema_gen.outputs['schema'],
      transform_graph=transform.outputs['transform_graph'],
      train_args=proto.TrainArgs(splits=['train'], num_steps=10000),
      eval_args=proto.EvalArgs(splits=['eval'], num_steps=5000))

मूल्यांकनकर्ता

डिफ़ॉल्ट व्यवहार 'eval' विभाजन पर गणना की गई मीट्रिक प्रदान करता है।

कस्टम विभाजन पर मूल्यांकन के आंकड़ों की गणना करने के लिए, मूल्यांकनकर्ता घटक के लिए example_splits सेट करें। उदाहरण के लिए:

# Compute metrics on the 'eval1' split and the 'eval2' split.
evaluator = Evaluator(
      examples=example_gen.outputs['examples'],
      model=trainer.outputs['model'],
      example_splits=['eval1', 'eval2'])

अधिक विवरण CsvExampleGen API संदर्भ , FileBasedExampleGen API कार्यान्वयन और ImportExampleGen API संदर्भ में उपलब्ध हैं।