רכיבי פונקציית Python מותאמים אישית

קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

הגדרת רכיבים מבוססי פונקציות של Python מקלה עליך ליצור רכיבים מותאמים אישית של TFX, על ידי כך שחוסכת לך את המאמץ בהגדרת מחלקה למפרט רכיב, מחלקת ביצוע ומחלקת ממשק רכיבים. בסגנון הגדרת הרכיב הזה, אתה כותב פונקציה שמוסמנת ברמזים לסוג. הרמזים לסוג מתארים את חפצי הקלט, חפצי הפלט והפרמטרים של הרכיב שלך.

כתיבת הרכיב המותאם אישית שלך בסגנון זה היא פשוטה מאוד, כמו בדוגמה הבאה.

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

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

  return {
    'accuracy': accuracy
  }

מתחת למכסה המנוע, זה מגדיר רכיב מותאם אישית שהוא תת מחלקה של BaseComponent ה-Spec וה-Executor שלו.

אם אתה רוצה להגדיר תת-מחלקה של BaseBeamComponent כך שתוכל להשתמש בצינור קרן עם תצורה משותפת של TFX-pipeline-wise, כלומר, beam_pipeline_args בעת הידור של הצינור ( Chicago Taxi Pipeline דוגמה ) תוכל להגדיר use_beam=True ב-Decorator ולהוסיף BeamComponentParameter אחר עם ערך ברירת המחדל None בפונקציה שלך כדוגמה הבאה:

@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, למד עוד על מושגי הליבה של צינורות TFX .

כניסות, יציאות ופרמטרים

ב-TFX, הקלט והפלט עוקבים כאובייקטים של Artifact המתארים את המיקום של מאפייני המטא נתונים הקשורים לנתונים הבסיסיים; מידע זה מאוחסן ב-ML Metadata. חפצים יכולים לתאר סוגי נתונים מורכבים או סוגי נתונים פשוטים, כגון: int, float, bytes או unicode מחרוזות.

פרמטר הוא ארגומנט (int, float, bytes או unicode מחרוזת) לרכיב הידוע בזמן בניית הצינור. פרמטרים שימושיים לציון ארגומנטים והיפרפרמטרים כמו ספירת איטרציות אימון, שיעור נשירה ותצורה אחרת לרכיב שלך. פרמטרים מאוחסנים כמאפיינים של ביצוע רכיבים כשהם עוקבים ב-ML Metadata.

הַגדָרָה

כדי ליצור רכיב מותאם אישית, כתוב פונקציה המיישמת את ההיגיון המותאם אישית שלך וקשט אותה עם ה- @component מהמודול tfx.dsl.component.experimental.decorators . כדי להגדיר את סכימת הקלט והפלט של הרכיב שלך, ציין הערות לארגומנטים של הפונקציה שלך וערך החזרה באמצעות הערות מהמודול 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 יוחלף בצינור קרן מופע שנוצר על ידי _make_beam_pipeline() של BaseBeamExecutor

  • עבור כל קלט מסוג נתונים פשוט ( int , float , str או bytes ) שאינו ידוע בזמן בניית הצינור, השתמש ברמז הסוג T שים לב שבמהדורת TFX 0.22, לא ניתן להעביר ערכי בטון בזמן בניית הצינור עבור סוג זה של קלט (השתמש במקום זאת בהערת Parameter , כמתואר בסעיף הקודם). ארגומנט זה יכול להיות אופציונלי או שניתן להגדיר ארגומנט זה עם ערך ברירת מחדל. אם לרכיב שלך יש פלטי סוג נתונים פשוטים ( int , float , str או bytes ), אתה יכול להחזיר את הפלטים האלה באמצעות מופע OutputDict . החל את הרמז מסוג OutputDict כערך ההחזרה של הרכיב שלך.

  • עבור כל פלט , הוסף ארגומנט <output_name>=<T> OutputDict , כאשר <output_name> הוא שם הפלט ו- <T> הוא סוג הפלט, כגון: int , float , str או bytes .

בגוף הפונקציה שלך, חפצי קלט ופלט מועברים כאובייקטי tfx.types.Artifact ; אתה יכול לבדוק את ה-. .uri שלו כדי לקבל את המיקום המנוהל על ידי המערכת שלו ולקרוא/להגדיר כל מאפיינים. פרמטרי קלט וקלט של סוג נתונים פשוט מועברים כאובייקטים מהסוג שצוין. יש להחזיר פלטי סוג נתונים פשוטים כמילון, כאשר המפתחות הם שמות הפלט המתאימים והערכים הם ערכי ההחזר הרצויים.

רכיב הפונקציה שהושלם יכול להיראות כך:

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

@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
    ) -> tfx.v1.dsl.components.OutputDict(loss=float, accuracy=float):
  '''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 .