השב / י לאירוע TensorFlow Everywhere המקומי שלך היום!
דף זה תורגם על ידי Cloud Translation API.
Switch to English

מטא נתונים של ML

ML Metadata (MLMD) היא ספרייה להקלטה ואחזור מטא נתונים המשויכים לתהליכי עבודה של מפתח ומדעני נתונים. MLMD הוא חלק בלתי נפרד מ- TensorFlow Extended (TFX) , אך תוכנן כך שניתן יהיה להשתמש בו באופן עצמאי.

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

MLMD עוזר לך להבין ולנתח את כל החלקים המחוברים זה לזה בצינור ה- ML שלך במקום לנתח אותם בבידוד ויכול לעזור לך לענות על שאלות אודות צינור ה- ML שלך כגון:

  • על איזה מערך נתונים התאמן המודל?
  • מה שימשו ההיפרפרמטרים לאימון המודל?
  • איזו הפעלת צינור יצרה את המודל?
  • איזה מסלול אימונים הוביל למודל זה?
  • איזו גרסה של TensorFlow יצרה את המודל הזה?
  • מתי נדחק המודל הכושל?

חנות מטא נתונים

MLMD רושם את סוגי המטא נתונים הבאים במסד נתונים שנקרא Metadata Store .

  1. מטא נתונים על החפצים שנוצרו באמצעות הרכיבים / השלבים של צינורות ה- ML שלך
  2. מטא נתונים אודות הביצועים של רכיבים / צעדים אלה
  3. מטא-נתונים אודות צינורות ומידע שושלת משויך

חנות המטא נתונים מספקת ממשקי API להקלטה ולאחזור מטא נתונים אל אחורי אחסון. גב אחסון אחסון וניתן להרחבה. MLMD מספק יישומי הפניה עבור SQLite (התומך בזיכרון ובדיסק) ו- MySQL מהקופסה.

גרפיקה זו מציגה סקירה ברמה גבוהה של הרכיבים השונים הנמצאים ב- MLMD.

סקירה כללית על מטא נתונים

אחסון אחורי מטא-נתונים ותצורת חיבורי חנות

האובייקט MetadataStore מקבל תצורת חיבור התואמת את backend אחסון בשימוש.

  • מסד נתונים מזויף מספק DB בזיכרון (באמצעות SQLite) לניסויים מהירים וריצות מקומיות. מסד הנתונים נמחק כאשר אובייקט החנות נהרס.
0750 פנים 50
  • SQLite קורא וכותב קבצים מהדיסק.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.sqlite.filename_uri = '...'
connection_config.sqlite.connection_mode = 3 # READWRITE_OPENCREATE
store = metadata_store.MetadataStore(connection_config)
  • MySQL מתחבר לשרת MySQL.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.mysql.host = '...'
connection_config.mysql.port = '...'
connection_config.mysql.database = '...'
connection_config.mysql.user = '...'
connection_config.mysql.password = '...'
store = metadata_store.MetadataStore(connection_config)

מודל נתונים

חנות המטא-נתונים משתמשת במודל הנתונים הבא כדי להקליט ולאחזר מטא-נתונים ממגב האחסון.

  • ArtifactType מתאר את סוג החפץ ואת המאפיינים שלו המאוחסנים בחנות המטא נתונים. באפשרותך לרשום סוגים אלה תוך כדי טיסה בחנות המטא נתונים בקוד, או שתוכל לטעון אותם לחנות מתבנית סדרתית. ברגע שאתה רושם סוג, ההגדרה שלו זמינה לאורך כל חיי החנות.
  • Artifact מתאר מופע ספציפי של ArtifactType , ואת המאפיינים שלו שנכתבים לחנות המטא נתונים.
  • סוג ExecutionType מתאר סוג של רכיב או שלב בתהליך העבודה, ואת פרמטרי זמן הריצה שלו.
  • Execution הוא תיעוד של הפעלת רכיב או שלב בתהליך עבודה של ML ופרמטרי זמן הריצה. ניתן לחשוב על ExecutionType של ExecutionType . הוצאות להורג נרשמות כאשר אתה מפעיל צינור או שלב ML.
  • Event הוא תיעוד של הקשר בין חפצים להוצאות להורג. כאשר מתרחשת ביצוע, האירועים מתעדים כל חפץ ששימש את הביצוע, וכל חפץ שהופק. רשומות אלה מאפשרות מעקב אחר שושלות לאורך זרימת עבודה. על ידי התבוננות בכל האירועים, MLMD יודע אילו הוצאות להורג קרו ואילו חפצים נוצרו כתוצאה מכך. לאחר מכן MLMD יכול להחזיר מכל חפץ לכל תשומותיו במעלה הזרם.
  • ContextType מתאר סוג של קבוצה רעיונית של חפצים ContextType בתהליך עבודה, ואת המאפיינים המבניים שלו. לדוגמא: פרויקטים, ריצות צנרת, ניסויים, בעלים וכו '.
  • Context הוא מופע של ContextType . זה לוכד את המידע המשותף בתוך הקבוצה. לדוגמא: שם פרויקט, מזהה התחייבות לרשימת שינוי, הערות ניסוי וכו '. יש לו שם ייחודי המוגדר על ידי המשתמש בתוך ContextType .
  • Attribution הוא תיעוד של הקשר בין חפצים והקשרים.
  • Association היא תיעוד של הקשר בין הוצאות להורג והקשרים.

פונקציונליות MLMD

מעקב אחר הכניסות והתפוקות של כל הרכיבים / השלבים בתהליך עבודה של ML ושושלתם מאפשרת לפלטפורמות ML לאפשר כמה תכונות חשובות. הרשימה הבאה מספקת סקירה לא ממצה של כמה מהיתרונות העיקריים.

  • ציין את כל החפצים מסוג מסוים. דוגמה: כל הדגמים שעברו הכשרה.
  • טען שני חפצים מאותו סוג לשם השוואה. דוגמה: השווה תוצאות משני ניסויים.
  • הראה DAG של כל ההוצאות להורג הקשורות וממצאי הקלט והפלט שלהם בהקשר. דוגמה: דמיינו את זרימת העבודה של ניסוי לצורך איתור באגים וגילוי.
  • חזור אחורה בכל האירועים כדי לראות כיצד נוצר חפץ. דוגמאות: ראה אילו נתונים נכנסו למודל; לאכוף תוכניות לשמירת נתונים.
  • זהה את כל החפצים שנוצרו באמצעות חפץ נתון. דוגמאות: ראה את כל הדגמים שהוכשרו ממערך נתונים ספציפי; לסמן מודלים על בסיס נתונים רעים.
  • קבע אם כבר בוצעה ביצוע באותן תשומות בעבר. דוגמא: קבעו אם רכיב / שלב כבר השלימו את אותה עבודה וניתן להשתמש רק בפלט הקודם.
  • הקלט ושאיל את ההקשר של ריצות זרימת העבודה. דוגמאות: עקוב אחר הבעלים ורשימת השינויים המשמשים להפעלת זרימת עבודה; קיבץ השושלת לפי ניסויים; לנהל חפצים על ידי פרויקטים.

עיין במדריך MLMD לדוגמא המראה כיצד להשתמש ב- API MLMD ובחנות המטא נתונים כדי לאחזר מידע על שושלת.

שלב מטא נתונים של ML בתהליכי העבודה שלך ב- ML

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

זרימת דוגמה למטא נתונים של ML

1) רשום סוגי חפצים

# Create ArtifactTypes, e.g., Data and Model
data_type = metadata_store_pb2.ArtifactType()
data_type.name = "DataSet"
data_type.properties["day"] = metadata_store_pb2.INT
data_type.properties["split"] = metadata_store_pb2.STRING
data_type_id = store.put_artifact_type(data_type)

model_type = metadata_store_pb2.ArtifactType()
model_type.name = "SavedModel"
model_type.properties["version"] = metadata_store_pb2.INT
model_type.properties["name"] = metadata_store_pb2.STRING
model_type_id = store.put_artifact_type(model_type)

2) רשום סוגי ביצוע עבור כל השלבים בתהליך העבודה של ML

# Create an ExecutionType, e.g., Trainer
trainer_type = metadata_store_pb2.ExecutionType()
trainer_type.name = "Trainer"
trainer_type.properties["state"] = metadata_store_pb2.STRING
trainer_type_id = store.put_execution_type(trainer_type)

3) צור חפץ של DataSet ArtifactType

# Create an input artifact of type DataSet
data_artifact = metadata_store_pb2.Artifact()
data_artifact.uri = 'path/to/data'
data_artifact.properties["day"].int_value = 1
data_artifact.properties["split"].string_value = 'train'
data_artifact.type_id = data_type_id
data_artifact_id = store.put_artifacts([data_artifact])[0]

4) צור את הביצוע עבור ריצת Trainer (בדרך כלל tfx.components.Trainer ExecutionType)

trainer_run = metadata_store_pb2.Execution()
trainer_run.type_id = trainer_type_id
trainer_run.properties["state"].string_value = "RUNNING"
run_id = store.put_executions([trainer_run])[0]

5) הגדירו את אירוע הקלט וקראו נתונים

# Define the input event
input_event = metadata_store_pb2.Event()
input_event.artifact_id = data_artifact_id
input_event.execution_id = run_id
input_event.type = metadata_store_pb2.Event.DECLARED_INPUT

# Record the input event in the metadata store
store.put_events([input_event])

6) הכריז על חפץ הפלט

# Declare the output artifact of type SavedModel
model_artifact = metadata_store_pb2.Artifact()
model_artifact.uri = 'path/to/model/file'
model_artifact.properties["version"].int_value = 1
model_artifact.properties["name"].string_value = 'MNIST-v1'
model_artifact.type_id = model_type_id
model_artifact_id = store.put_artifacts([model_artifact])[0]

7) הקלט את אירוע הפלט

# Declare the output event
output_event = metadata_store_pb2.Event()
output_event.artifact_id = model_artifact_id
output_event.execution_id = run_id
output_event.type = metadata_store_pb2.Event.DECLARED_OUTPUT

# Submit output event to the Metadata Store
store.put_events([output_event])

8) סמן את הביצוע כהושלמה

trainer_run.id = run_id
trainer_run.properties["state"].string_value = "COMPLETED"
store.put_executions([trainer_run])

9) קבץ חפצים והוצאות להורג תחת הקשר תוך שימוש בחפצי ייחוס וטענות

# Create a ContextType, e.g., Experiment with a note property
experiment_type = metadata_store_pb2.ContextType()
experiment_type.name = "Experiment"
experiment_type.properties["note"] = metadata_store_pb2.STRING
experiment_type_id = store.put_context_type(experiment_type)

# Group the model and the trainer run to an experiment.
my_experiment = metadata_store_pb2.Context()
my_experiment.type_id = experiment_type_id
# Give the experiment a name
my_experiment.name = "exp1"
my_experiment.properties["note"].string_value = "My first experiment."
experiment_id = store.put_contexts([my_experiment])[0]

attribution = metadata_store_pb2.Attribution()
attribution.artifact_id = model_artifact_id
attribution.context_id = experiment_id

association = metadata_store_pb2.Association()
association.execution_id = run_id
association.context_id = experiment_id

store.put_attributions_and_associations([attribution], [association])

השתמש ב- MLMD עם שרת gRPC מרוחק

אתה יכול להשתמש ב- MLMD עם שרתי gRPC מרוחקים כמוצג להלן:

  • הפעל שרת
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
  • צור את תאי הלקוח והשתמש בו בפייתון
from grpc import insecure_channel
from ml_metadata.proto import metadata_store_pb2
from ml_metadata.proto import metadata_store_service_pb2
from ml_metadata.proto import metadata_store_service_pb2_grpc

channel = insecure_channel('localhost:8080')
stub = metadata_store_service_pb2_grpc.MetadataStoreServiceStub(channel)
  • השתמש ב- MLMD עם שיחות RPC
# Create ArtifactTypes, e.g., Data and Model
data_type = metadata_store_pb2.ArtifactType()
data_type.name = "DataSet"
data_type.properties["day"] = metadata_store_pb2.INT
data_type.properties["split"] = metadata_store_pb2.STRING

request = metadata_store_service_pb2.PutArtifactTypeRequest()
request.all_fields_match = True
request.artifact_type.CopyFrom(data_type)
stub.PutArtifactType(request)

model_type = metadata_store_pb2.ArtifactType()
model_type.name = "SavedModel"
model_type.properties["version"] = metadata_store_pb2.INT
model_type.properties["name"] = metadata_store_pb2.STRING

request.artifact_type.CopyFrom(model_type)
stub.PutArtifactType(request)

אֶמְצָעִי

לספריית MLMD יש ממשק API ברמה גבוהה שתוכל להשתמש בו בקלות עם צינורות ה- ML שלך. לפרטים נוספים, עיין בתיעוד ה- API של MLMD .

עיין גם במדריך MLMD כדי ללמוד כיצד להשתמש ב- MLMD כדי להתחקות אחר שושלת רכיבי הצינור שלך.