רכיב InfraValidator TFX Pipeline

InfraValidator הוא רכיב TFX המשמש כשכבת אזהרה מוקדמת לפני דחיפת דגם לייצור. השם "מאמת אינפרא" בא מהעובדה שהוא מאמת את המודל במודל המשרת את "תשתית" בפועל. אם Evaluator אמור להבטיח את הביצועים של המודל, InfraValidator אמור להבטיח שהמודל תקין מבחינה מכנית ומונע מדגמים גרועים להידחף.

איך זה עובד?

InfraValidator לוקח את המודל, משיק שרת מודל עם ארגז חול עם הדגם, ובודק אם ניתן לטעון אותו בהצלחה ולבצע שאילתה אופציונלית. תוצאת אימות האינפרא תופק בפלט blessing באותו אופן כפי שעושה Evaluator .

InfraValidator מתמקד בתאימות בין שרת המודל הבינארי (למשל TensorFlow Serving ) לבין המודל לפריסה. למרות השם "מאמת ה-"infra", באחריות המשתמש להגדיר את הסביבה בצורה נכונה, ו-infra validator מקיים אינטראקציה רק ​​עם שרת הדגם בסביבה המוגדרת על ידי המשתמש כדי לראות אם זה עובד כשורה. הגדרה נכונה של סביבה זו תבטיח שאימות אינפרא עובר או נכשל יעיד אם המודל יהיה ניתן לשרת בסביבת ההגשה של הייצור. זה מרמז על חלק מהדברים הבאים, אך לא רק:

  1. InfraValidator משתמש באותו דגם שרת בינארי שישמש בייצור. זוהי הרמה המינימלית שאליה חייבת להתכנס סביבת אימות האינפרא.
  2. InfraValidator משתמש באותם משאבים (כגון כמות הקצאה וסוג המעבד, הזיכרון והמאיצים) שישמשו בייצור.
  3. InfraValidator משתמש באותה דגם תצורת שרת כפי שתשמש בייצור.

בהתאם למצב, המשתמשים יכולים לבחור באיזו מידה InfraValidator צריך להיות זהה לסביבת הייצור. מבחינה טכנית, ניתן לאמת מודל אינפרא בסביבת Docker מקומית ולאחר מכן להגיש אותו בסביבה שונה לחלוטין (למשל אשכול Kubernetes) ללא בעיה. עם זאת, InfraValidator לא יבדוק את הפער הזה.

מצב פעולה

בהתאם לתצורה, אימות אינפרא נעשה באחד מהמצבים הבאים:

  • מצב LOAD_ONLY : בדיקה אם הדגם נטען בהצלחה בתשתית המשרתת או לא. אוֹ
  • מצב LOAD_AND_QUERY : מצב LOAD_ONLY בתוספת שליחת כמה בקשות לדוגמה כדי לבדוק אם הדגם מסוגל לשרת מסקנות. ל-InfraValidator לא אכפת שהתחזית הייתה נכונה או לא. חשוב רק אם הבקשה הצליחה או לא.

איך אני משתמש בו?

בדרך כלל InfraValidator מוגדר ליד רכיב Evaluator, והפלט שלו מוזן ל-Pusher. אם InfraValidator נכשל, המודל לא יידחף.

evaluator = Evaluator(
    model=trainer.outputs['model'],
    examples=example_gen.outputs['examples'],
    baseline_model=model_resolver.outputs['model'],
    eval_config=tfx.proto.EvalConfig(...)
)

infra_validator = InfraValidator(
    model=trainer.outputs['model'],
    serving_spec=tfx.proto.ServingSpec(...)
)

pusher = Pusher(
    model=trainer.outputs['model'],
    model_blessing=evaluator.outputs['blessing'],
    infra_blessing=infra_validator.outputs['blessing'],
    push_destination=tfx.proto.PushDestination(...)
)

הגדרת רכיב InfraValidator.

ישנם שלושה סוגים של פרוטו להגדרת InfraValidator.

ServingSpec

ServingSpec היא התצורה החשובה ביותר עבור InfraValidator. זה מגדיר:

  • איזה סוג של שרת דגם להפעיל
  • איפה להפעיל אותו

עבור סוגי שרתי מודל (הנקראים Serving Binary) אנו תומכים

פלטפורמות ההגשה הבאות נתמכות כרגע:

  • Docker מקומי (יש להתקין את Docker מראש)
  • Kubernetes (תמיכה מוגבלת עבור KubeflowDagRunner בלבד)

הבחירה להגשה בינארית ולפלטפורמת הגשה נעשית על ידי ציון של בלוק oneof של ServingSpec . לדוגמה כדי להשתמש ב-TensorFlow Serving בינארי הפועל באשכול Kubernetes, יש להגדיר את השדה tensorflow_serving ו- kubernetes .

infra_validator=InfraValidator(
    model=trainer.outputs['model'],
    serving_spec=tfx.proto.ServingSpec(
        tensorflow_serving=tfx.proto.TensorFlowServing(
            tags=['latest']
        ),
        kubernetes=tfx.proto.KubernetesConfig()
    )
)

כדי להגדיר עוד יותר ServingSpec , בדוק את הגדרת ה-protobuf .

ValidationSpec

תצורה אופציונלית להתאמת קריטריוני אימות האינפרא או זרימת העבודה.

infra_validator=InfraValidator(
    model=trainer.outputs['model'],
    serving_spec=tfx.proto.ServingSpec(...),
    validation_spec=tfx.proto.ValidationSpec(
        # How much time to wait for model to load before automatically making
        # validation fail.
        max_loading_time_seconds=60,
        # How many times to retry if infra validation fails.
        num_tries=3
    )
)

לכל שדות ValidationSpec יש ערך ברירת מחדל קול. בדוק פרטים נוספים מהגדרת הפרוטובוף .

RequestSpec

תצורה אופציונלית כדי לציין כיצד לבנות בקשות לדוגמה בעת הפעלת אימות אינפרא במצב LOAD_AND_QUERY . על מנת להשתמש במצב LOAD_AND_QUERY , נדרש לציין שני מאפייני ביצוע request_spec וכן examples של ערוץ קלט בהגדרת הרכיב.

infra_validator = InfraValidator(
    model=trainer.outputs['model'],
    # This is the source for the data that will be used to build a request.
    examples=example_gen.outputs['examples'],
    serving_spec=tfx.proto.ServingSpec(
        # Depending on what kind of model server you're using, RequestSpec
        # should specify the compatible one.
        tensorflow_serving=tfx.proto.TensorFlowServing(tags=['latest']),
        local_docker=tfx.proto.LocalDockerConfig(),
    ),
    request_spec=tfx.proto.RequestSpec(
        # InfraValidator will look at how "classification" signature is defined
        # in the model, and automatically convert some samples from `examples`
        # artifact to prediction RPC requests.
        tensorflow_serving=tfx.proto.TensorFlowServingRequestSpec(
            signature_names=['classification']
        ),
        num_examples=10  # How many requests to make.
    )
)

הפקת SavedModel עם חימום

(מגרסה 0.30.0)

מכיוון ש-InfraValidator מאמת מודל עם בקשות אמיתיות, הוא יכול בקלות לעשות שימוש חוזר בבקשות אימות אלו בתור בקשות חימום של SavedModel. InfraValidator מספק אפשרות ( RequestSpec.make_warmup ) לייצא SavedModel עם חימום.

infra_validator = InfraValidator(
    ...,
    request_spec=tfx.proto.RequestSpec(..., make_warmup=True)
)

אז חפץ InfraBlessing הפלט יכיל SavedModel עם חימום, וניתן גם לדחוף אותו על ידי ה- Pusher , בדיוק כמו חפץ Model .

מגבלות

InfraValidator הנוכחי לא הושלם עדיין, ויש לו כמה מגבלות.

  • ניתן לאמת רק פורמט מודל TensorFlow SavedModel .
  • בעת הפעלת TFX על Kubernetes, הצינור צריך להתבצע על ידי KubeflowDagRunner בתוך Kubeflow Pipelines. שרת הדגם יושק באותו אשכול Kubernetes ובמרחב השמות שבו משתמש Kubeflow.
  • InfraValidator מתמקד בעיקר בפריסות ל- TensorFlow Serving , ולמרות שהוא עדיין שימושי, הוא פחות מדויק עבור פריסות ל- TensorFlow Lite ו- TensorFlow.js , או מסגרות מסקנה אחרות.

  • יש תמיכה מוגבלת במצב LOAD_AND_QUERY עבור חתימת שיטת Predict (שהיא השיטה היחידה הניתנת לייצוא ב-TensorFlow 2). InfraValidator מחייב את חתימת Predict כדי לצרוך tf.Example מסודר כקלט היחיד.

    @tf.function
def parse_and_run(serialized_example):
  features = tf.io.parse_example(serialized_example, FEATURES)
  return model(features)

model.save('path/to/save', signatures={
  # This exports "Predict" method signature under name "serving_default".
  'serving_default': parse_and_run.get_concrete_function(
      tf.TensorSpec(shape=[None], dtype=tf.string, name='examples'))
})
    • עיין בקוד לדוגמה של Penguin כדי לראות כיצד חתימה זו מקיימת אינטראקציה עם רכיבים אחרים ב-TFX.