एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

टीएफएक्स पायथन फ़ंक्शन घटक ट्यूटोरियल

इस नोटबुक में टीएफएक्स इंटरएक्टिव कॉन्टेक्स्ट के भीतर और स्थानीय रूप से ऑर्केस्ट्रेटेड टीएफएक्स पाइपलाइन में पायथन फ़ंक्शन घटकों को लिखने और चलाने के उदाहरण हैं।

अधिक संदर्भ और जानकारी के लिए, कस्टम पायथन समारोह घटकों TFX प्रलेखन साइट पर पेज।

सेट अप

हम पहले टीएफएक्स स्थापित करेंगे और आवश्यक मॉड्यूल आयात करेंगे। टीएफएक्स को पायथन 3 की आवश्यकता है।

सिस्टम पायथन संस्करण की जाँच करें

import sys
sys.version
'3.7.5 (default, Feb 23 2021, 13:22:40) \n[GCC 8.4.0]'

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

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

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

टीएफएक्स स्थापित करें

pip install -U tfx

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

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

पैकेज आयात करें

हम टीएफएक्स आयात करते हैं और इसके संस्करण की जांच करते हैं।

# Check version
from tfx import v1 as tfx
tfx.__version__
'1.2.0'

कस्टम पायथन फ़ंक्शन घटक

इस खंड में, हम पायथन फ़ंक्शंस से घटक बनाएंगे। हम कोई वास्तविक एमएल समस्या नहीं करेंगे - इन सरल कार्यों का उपयोग केवल पायथन फ़ंक्शन घटक विकास प्रक्रिया को चित्रित करने के लिए किया जाता है।

देखें अजगर समारोह आधारित घटक गाइड अधिक प्रलेखन के लिए।

पायथन कस्टम घटक बनाएं

हम एक फ़ंक्शन लिखकर शुरू करते हैं जो कुछ डमी डेटा उत्पन्न करता है। यह अपने स्वयं के पायथन मॉड्यूल फ़ाइल में लिखा गया है।

%%writefile my_generator.py

import os
import tensorflow as tf  # Used for writing files.

from tfx import v1 as tfx

# Non-public APIs, just for showcase.
from tfx.types.experimental.simple_artifacts import Dataset

@tfx.dsl.components.component
def MyGenerator(data: tfx.dsl.components.OutputArtifact[Dataset]):
  """Create a file with dummy data in the output artifact."""
  with tf.io.gfile.GFile(os.path.join(data.uri, 'data_file.txt'), 'w') as f:
    f.write('Dummy data')

  # Set metadata and ensure that it gets passed to downstream components.
  data.set_string_custom_property('my_custom_field', 'my_custom_value')
Writing my_generator.py

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

%%writefile my_consumer.py

import hashlib
import os
import tensorflow as tf

from tfx import v1 as tfx

# Non-public APIs, just for showcase.
from tfx.types.experimental.simple_artifacts import Dataset
from tfx.types.standard_artifacts import String

@tfx.dsl.components.component
def MyConsumer(data: tfx.dsl.components.InputArtifact[Dataset],
               hash: tfx.dsl.components.OutputArtifact[String],
               algorithm: tfx.dsl.components.Parameter[str] = 'sha256'):
  """Reads the contents of data and calculate."""
  with tf.io.gfile.GFile(
      os.path.join(data.uri, 'data_file.txt'), 'r') as f:
    contents = f.read()
  h = hashlib.new(algorithm)
  h.update(tf.compat.as_bytes(contents))
  hash.value = h.hexdigest()

  # Read a custom property from the input artifact and set to the output.
  custom_value = data.get_string_custom_property('my_custom_field')
  hash.set_string_custom_property('input_custom_field', custom_value)
Writing my_consumer.py

इंटरएक्टिव कॉन्टेक्स्ट के साथ इन-नोटबुक चलाएं

अब, हम TFX InteractiveContext में अपने नए घटकों के उपयोग को प्रदर्शित करेंगे।

आप TFX नोटबुक InteractiveContext साथ क्या कर सकते के बारे में अधिक जानकारी के लिए, इन-नोटबुक देख TFX Keras घटक ट्यूटोरियल

from my_generator import MyGenerator
from my_consumer import MyConsumer

इंटरएक्टिव कॉन्टेक्स्ट का निर्माण करें

# Here, we create an InteractiveContext using default parameters. This will
# use a temporary directory with an ephemeral ML Metadata database instance.
# To use your own pipeline root or database, the optional properties
# `pipeline_root` and `metadata_connection_config` may be passed to
# InteractiveContext. Calls to InteractiveContext are no-ops outside of the
# notebook.
from tfx.orchestration.experimental.interactive.interactive_context import InteractiveContext
context = InteractiveContext()
WARNING:absl:InteractiveContext pipeline_root argument not provided: using temporary directory /tmp/tfx-interactive-2021-09-30T02_05_44.574837-wib0wzgy as root for pipeline outputs.
WARNING:absl:InteractiveContext metadata_connection_config not provided: using SQLite ML Metadata database at /tmp/tfx-interactive-2021-09-30T02_05_44.574837-wib0wzgy/metadata.sqlite.

साथ सहभागी अपने घटक चलाने context.run()

इसके बाद, हम अपने घटकों सहभागी नोटबुक के भीतर के साथ चलाने के context.run() । हमारा उपभोक्ता घटक जनरेटर घटक के आउटपुट का उपयोग करता है।

generator = MyGenerator()
context.run(generator)
WARNING: Logging before InitGoogleLogging() is written to STDERR
I0930 02:05:44.621371 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
consumer = MyConsumer(
    data=generator.outputs['data'],
    algorithm='md5')
context.run(consumer)
I0930 02:05:44.660826 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type

निष्पादन के बाद, हम डिस्क पर उपभोक्ता घटक के "हैश" आउटपुट आर्टिफैक्ट की सामग्री का निरीक्षण कर सकते हैं।

tail -v {consumer.outputs['hash'].get()[0].uri}
==> /tmp/tfx-interactive-2021-09-30T02_05_44.574837-wib0wzgy/MyConsumer/hash/2/value <==
0015fe7975d1a2794b59aa12635703f1

बस इतना ही, और अब आपने अपने स्वयं के कस्टम घटकों को लिखा और निष्पादित किया है!

एक पाइपलाइन परिभाषा लिखें

इसके बाद, हम इन्हीं घटकों का उपयोग करके एक पाइपलाइन लिखेंगे। जबकि का उपयोग कर InteractiveContext एक नोटबुक के भीतर प्रयोग के लिए अच्छी तरह से काम करता है, एक पाइप लाइन निर्धारित करते समय उत्पादन के उपयोग के लिए स्थानीय या दूरदराज के धावकों पर अपने पाइपलाइन नियोजित करने देता है।

यहां, हम आपकी मशीन पर स्थानीय रूप से चल रहे LocalDagRunner के उपयोग को प्रदर्शित करेंगे। उत्पादन निष्पादन के लिए, एयरफ्लो या क्यूबफ्लो रनर अधिक उपयुक्त हो सकते हैं।

एक पाइपलाइन का निर्माण

import os
import tempfile
from tfx import v1 as tfx

# Select a persistent TFX root directory to store your output artifacts.
# For demonstration purposes only, we use a temporary directory.
PIPELINE_ROOT = tempfile.mkdtemp()
# Select a pipeline name so that multiple runs of the same logical pipeline
# can be grouped.
PIPELINE_NAME = "function-based-pipeline"
# We use a ML Metadata configuration that uses a local SQLite database in
# the pipeline root directory. Other backends for ML Metadata are available
# for production usage.
METADATA_CONNECTION_CONFIG = tfx.orchestration.metadata.sqlite_metadata_connection_config(
    os.path.join(PIPELINE_ROOT, 'metadata.sqlite'))

def function_based_pipeline():
  # Here, we construct our generator and consumer components in the same way.
  generator = MyGenerator()
  consumer = MyConsumer(
      data=generator.outputs['data'],
      algorithm='md5')

  return tfx.dsl.Pipeline(
      pipeline_name=PIPELINE_NAME,
      pipeline_root=PIPELINE_ROOT,
      components=[generator, consumer],
      metadata_connection_config=METADATA_CONNECTION_CONFIG)

my_pipeline = function_based_pipeline()

के साथ अपने पाइप लाइन चलाने LocalDagRunner

tfx.orchestration.LocalDagRunner().run(my_pipeline)
I0930 02:05:44.833285 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.840090 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.846822 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.853597 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.863385 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.878916 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.894802 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type
I0930 02:05:44.913914 16837 rdbms_metadata_access_object.cc:686] No property is defined for the Type

हम इस पाइपलाइन निष्पादन द्वारा उत्पन्न आउटपुट कलाकृतियों का निरीक्षण कर सकते हैं।

find {PIPELINE_ROOT}
/tmp/tmpm4plox37
/tmp/tmpm4plox37/metadata.sqlite
/tmp/tmpm4plox37/MyConsumer
/tmp/tmpm4plox37/MyConsumer/.system
/tmp/tmpm4plox37/MyConsumer/.system/executor_execution
/tmp/tmpm4plox37/MyConsumer/.system/executor_execution/2
/tmp/tmpm4plox37/MyConsumer/hash
/tmp/tmpm4plox37/MyConsumer/hash/2
/tmp/tmpm4plox37/MyConsumer/hash/2/value
/tmp/tmpm4plox37/MyGenerator
/tmp/tmpm4plox37/MyGenerator/data
/tmp/tmpm4plox37/MyGenerator/data/1
/tmp/tmpm4plox37/MyGenerator/data/1/data_file.txt
/tmp/tmpm4plox37/MyGenerator/.system
/tmp/tmpm4plox37/MyGenerator/.system/executor_execution
/tmp/tmpm4plox37/MyGenerator/.system/executor_execution/1

अब आपने अपने स्वयं के कस्टम घटकों को लिखा है और LocalDagRunner पर उनके निष्पादन को व्यवस्थित किया है! अगले चरणों के लिए, पर अतिरिक्त ट्यूटोरियल और गाइड की जाँच TFX वेबसाइट