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

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

इस शैली में अपना कस्टम घटक लिखना बहुत सरल है, जैसा कि निम्नलिखित उदाहरण में है।

class MyOutput(TypedDict):
  accuracy: float

@component
def MyValidationComponent(
    model: InputArtifact[Model],
    blessing: OutputArtifact[Model],
    accuracy_threshold: Parameter[int] = 10,
) -> MyOutput:
  '''My simple custom model validation component.'''

  accuracy = evaluate_model(model)
  if accuracy >= accuracy_threshold:
    write_output_blessing(blessing)

  return {
    'accuracy': accuracy
  }

हुड के तहत, यह एक कस्टम घटक को परिभाषित करता है जो BaseComponent और इसके स्पेक और एक्ज़ीक्यूटर वर्गों का उपवर्ग है।

ध्यान दें: नीचे वर्णित सुविधा ( @component(use_beam=True) के साथ एक फ़ंक्शन को एनोटेट करके बेसबीमकंपोनेंट आधारित घटक) प्रयोगात्मक है और कोई सार्वजनिक बैकवर्ड संगतता गारंटी नहीं है।

यदि आप BaseBeamComponent के एक उपवर्ग को इस प्रकार परिभाषित करना चाहते हैं कि आप पाइपलाइन ( शिकागो टैक्सी पाइपलाइन उदाहरण ) को संकलित करते समय TFX-पाइपलाइन-वार साझा कॉन्फ़िगरेशन के साथ एक बीम पाइपलाइन का उपयोग कर सकें, यानी, beam_pipeline_args आप डेकोरेटर में use_beam=True सेट कर सकते हैं और जोड़ सकते हैं निम्नलिखित उदाहरण के रूप में आपके फ़ंक्शन में डिफ़ॉल्ट मान None वाला एक और BeamComponentParameter :

@component(use_beam=True)
def MyDataProcessor(
    examples: InputArtifact[Example],
    processed_examples: OutputArtifact[Example],
    beam_pipeline: BeamComponentParameter[beam.Pipeline] = None,
    ) -> None:
  '''My simple custom model validation component.'''

  with beam_pipeline as p:
    # data pipeline definition with beam_pipeline begins
    ...
    # data pipeline definition with beam_pipeline ends

यदि आप टीएफएक्स पाइपलाइनों में नए हैं, तो टीएफएक्स पाइपलाइनों की मुख्य अवधारणाओं के बारे में और जानें ।

इनपुट, आउटपुट और पैरामीटर

टीएफएक्स में, इनपुट और आउटपुट को आर्टिफैक्ट ऑब्जेक्ट के रूप में ट्रैक किया जाता है जो अंतर्निहित डेटा से जुड़े स्थान और मेटाडेटा गुणों का वर्णन करता है; यह जानकारी एमएल मेटाडेटा में संग्रहीत है। कलाकृतियाँ जटिल डेटा प्रकारों या सरल डेटा प्रकारों का वर्णन कर सकती हैं, जैसे: इंट, फ्लोट, बाइट्स, या यूनिकोड स्ट्रिंग्स।

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

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

परिभाषा

एक कस्टम घटक बनाने के लिए, एक फ़ंक्शन लिखें जो आपके कस्टम तर्क को लागू करता है और इसे tfx.dsl.component.experimental.decorators मॉड्यूल से @component डेकोरेटर के साथ सजाता है। अपने घटक के इनपुट और आउटपुट स्कीमा को परिभाषित करने के लिए, tfx.dsl.component.experimental.annotations मॉड्यूल से एनोटेशन का उपयोग करके अपने फ़ंक्शन के तर्कों और रिटर्न मान को एनोटेट करें:

• प्रत्येक आर्टिफैक्ट इनपुट के लिए, InputArtifact[ArtifactType] प्रकार का संकेत एनोटेशन लागू करें। ArtifactType विरूपण साक्ष्य के प्रकार से बदलें, जो tfx.types.Artifact का उपवर्ग है। ये इनपुट वैकल्पिक तर्क हो सकते हैं।

• प्रत्येक आउटपुट आर्टिफैक्ट के लिए, OutputArtifact[ArtifactType] प्रकार संकेत एनोटेशन लागू करें। ArtifactType विरूपण साक्ष्य के प्रकार से बदलें, जो tfx.types.Artifact का उपवर्ग है। घटक आउटपुट कलाकृतियों को फ़ंक्शन के इनपुट तर्क के रूप में पारित किया जाना चाहिए, ताकि आपका घटक सिस्टम-प्रबंधित स्थान पर आउटपुट लिख सके और उचित आर्टिफैक्ट मेटाडेटा गुण सेट कर सके। यह तर्क वैकल्पिक हो सकता है या इस तर्क को डिफ़ॉल्ट मान के साथ परिभाषित किया जा सकता है।

• प्रत्येक पैरामीटर के लिए, प्रकार संकेत एनोटेशन Parameter[T] का उपयोग करें। T पैरामीटर के प्रकार से बदलें। वर्तमान में हम केवल आदिम पायथन प्रकारों का समर्थन करते हैं: bool , int , float , str , या bytes ।

• बीम पाइपलाइन के लिए, प्रकार संकेत एनोटेशन BeamComponentParameter[beam.Pipeline] का उपयोग करें। डिफ़ॉल्ट मान को None पर सेट करें। None का मान BaseBeamExecutor के _make_beam_pipeline() द्वारा बनाई गई तत्काल बीम पाइपलाइन द्वारा प्रतिस्थापित किया जाएगा

• पाइपलाइन निर्माण के समय ज्ञात प्रत्येक सरल डेटा प्रकार इनपुट ( int , float , str या bytes ) के लिए, प्रकार संकेत T उपयोग करें। ध्यान दें कि टीएफएक्स 0.22 रिलीज में, इस प्रकार के इनपुट के लिए पाइपलाइन निर्माण के समय ठोस मान पारित नहीं किया जा सकता है (इसके बजाय Parameter एनोटेशन का उपयोग करें, जैसा कि पिछले अनुभाग में वर्णित है)। यह तर्क वैकल्पिक हो सकता है या इस तर्क को डिफ़ॉल्ट मान के साथ परिभाषित किया जा सकता है। यदि आपके घटक में सरल डेटा प्रकार आउटपुट ( int , float , str या bytes ) हैं, तो आप रिटर्न प्रकार एनोटेशन के रूप में TypedDict का उपयोग करके और उचित डिक्ट ऑब्जेक्ट लौटाकर इन आउटपुट को वापस कर सकते हैं।

आपके फ़ंक्शन के मुख्य भाग में, इनपुट और आउटपुट कलाकृतियों को tfx.types.Artifact ऑब्जेक्ट के रूप में पारित किया जाता है; आप इसके सिस्टम-प्रबंधित स्थान को प्राप्त करने और किसी भी गुण को पढ़ने/सेट करने के लिए इसके .uri निरीक्षण कर सकते हैं। इनपुट पैरामीटर और सरल डेटा प्रकार इनपुट निर्दिष्ट प्रकार की वस्तुओं के रूप में पारित किए जाते हैं। सरल डेटा प्रकार के आउटपुट को एक शब्दकोश के रूप में लौटाया जाना चाहिए, जहां कुंजियाँ उपयुक्त आउटपुट नाम हैं और मान वांछित रिटर्न मान हैं।

पूरा किया गया फ़ंक्शन घटक इस तरह दिख सकता है:

from typing import TypedDict
import tfx.v1 as tfx
from tfx.dsl.component.experimental.decorators import component

class MyOutput(TypedDict):
  loss: float
  accuracy: float

@component
def MyTrainerComponent(
    training_data: tfx.dsl.components.InputArtifact[tfx.types.standard_artifacts.Examples],
    model: tfx.dsl.components.OutputArtifact[tfx.types.standard_artifacts.Model],
    dropout_hyperparameter: float,
    num_iterations: tfx.dsl.components.Parameter[int] = 10
) -> MyOutput:
  '''My simple trainer component.'''

  records = read_examples(training_data.uri)
  model_obj = train_model(records, num_iterations, dropout_hyperparameter)
  model_obj.write_to(model.uri)

  return {
    'loss': model_obj.loss,
    'accuracy': model_obj.accuracy
  }

# Example usage in a pipeline graph definition:
# ...
trainer = MyTrainerComponent(
    examples=example_gen.outputs['examples'],
    dropout_hyperparameter=other_component.outputs['dropout'],
    num_iterations=1000)
pusher = Pusher(model=trainer.outputs['model'])
# ...

पिछला उदाहरण MyTrainerComponent Python फ़ंक्शन-आधारित कस्टम घटक के रूप में परिभाषित करता है। यह घटक अपने इनपुट के रूप में एक examples आर्टिफैक्ट का उपभोग करता है, और इसके आउटपुट के रूप में एक model आर्टिफैक्ट का उत्पादन करता है। घटक अपने सिस्टम-प्रबंधित स्थान पर आर्टिफैक्ट को पढ़ने या लिखने के लिए artifact_instance.uri का उपयोग करता है। घटक एक num_iterations इनपुट पैरामीटर और एक dropout_hyperparameter सरल डेटा प्रकार मान लेता है, और घटक loss और accuracy मेट्रिक्स को सरल डेटा प्रकार आउटपुट मान के रूप में आउटपुट करता है। आउटपुट model आर्टिफैक्ट का उपयोग Pusher घटक द्वारा किया जाता है।