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

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

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

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

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

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

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

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

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

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

סקירת מטא נתונים של ML

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

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

  • מסד נתונים מזויף מספק DB בזיכרון (באמצעות SQLite) עבור ניסויים מהירים והרצות מקומיות. מסד הנתונים נמחק כאשר אובייקט החנות מושמד.
import ml_metadata as mlmd
from ml_metadata.metadata_store import metadata_store
from ml_metadata.proto import metadata_store_pb2

connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.fake_database.SetInParent() # Sets an empty fake database proto.
store = metadata_store.MetadataStore(connection_config)
  • 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)

באופן דומה, כאשר משתמשים במופע MySQL עם Google CloudSQL ( התחלה מהירה , חיבור-סקירה ), אפשר גם להשתמש באפשרות SSL אם רלוונטי.

connection_config.mysql.ssl_options.key = '...'
connection_config.mysql.ssl_options.cert = '...'
connection_config.mysql.ssl_options.ca = '...'
connection_config.mysql.ssl_options.capath = '...'
connection_config.mysql.ssl_options.cipher = '...'
connection_config.mysql.ssl_options.verify_server_cert = '...'
store = metadata_store.MetadataStore(connection_config)
  • PostgreSQL מתחבר לשרת PostgreSQL.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.postgresql.host = '...'
connection_config.postgresql.port = '...'
connection_config.postgresql.user = '...'
connection_config.postgresql.password = '...'
connection_config.postgresql.dbname = '...'
store = metadata_store.MetadataStore(connection_config)

באופן דומה, כאשר משתמשים במופע PostgreSQL עם Google CloudSQL ( התחלה מהירה , חיבור-סקירה ), אפשר גם להשתמש באפשרות SSL אם ישנה. 

connection_config.postgresql.ssloption.sslmode = '...' # disable, allow, verify-ca, verify-full, etc.
connection_config.postgresql.ssloption.sslcert = '...'
connection_config.postgresql.ssloption.sslkey = '...'
connection_config.postgresql.ssloption.sslpassword = '...'
connection_config.postgresql.ssloption.sslrootcert = '...'
store = metadata_store.MetadataStore(connection_config)

מודל נתונים

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

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

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

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

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

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

שלב ML Metadata בתהליכי העבודה שלך ב-ML

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

זרימת דוגמה ל-ML Metadata

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)

# Query all registered Artifact types.
artifact_types = store.get_artifact_types()

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)

# Query a registered Execution type with the returned id
[registered_type] = store.get_execution_types_by_id([trainer_type_id])

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])

# Query all registered Artifacts
artifacts = store.get_artifacts()

# Plus, there are many ways to query the same Artifact
[stored_data_artifact] = store.get_artifacts_by_id([data_artifact_id])
artifacts_with_uri = store.get_artifacts_by_uri(data_artifact.uri)
artifacts_with_conditions = store.get_artifacts(
      list_options=mlmd.ListOptions(
          filter_query='uri LIKE "%/data" AND properties.day.int_value > 0'))

4) צור ביצוע של ריצת המאמן

# Register the Execution of a Trainer run
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])

# Query all registered Execution
executions = store.get_executions_by_id([run_id])
# Similarly, the same execution can be queried with conditions.
executions_with_conditions = store.get_executions(
    list_options = mlmd.ListOptions(
        filter_query='type = "Trainer" AND properties.state.string_value IS NOT NULL'))

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])

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])

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])

# Query the Artifacts and Executions that are linked to the Context.
experiment_artifacts = store.get_artifacts_by_context(experiment_id)
experiment_executions = store.get_executions_by_context(experiment_id)

# You can also use neighborhood queries to fetch these artifacts and executions
# with conditions.
experiment_artifacts_with_conditions = store.get_artifacts(
    list_options = mlmd.ListOptions(
        filter_query=('contexts_a.type = "Experiment" AND contexts_a.name = "exp1"')))
experiment_executions_with_conditions = store.get_executions(
    list_options = mlmd.ListOptions(
        filter_query=('contexts_a.id = {}'.format(experiment_id))))

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

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

  • הפעל שרת
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

כברירת מחדל, השרת משתמש ב-db מזויף בזיכרון לכל בקשה ואינו מחזיק את המטא נתונים על פני שיחות. ניתן גם להגדיר אותו עם MLMD MetadataStoreServerConfig לשימוש בקבצי SQLite או במופעי MySQL. ניתן לאחסן את התצורה בקובץ protobuf טקסט ולהעביר לקובץ הבינארי עם --metadata_store_server_config_file=path_to_the_config_file .

דוגמה לקובץ MetadataStoreServerConfig בפורמט פרוטובוף טקסט:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • צור את בדל הלקוח והשתמש בו ב- Python
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 שלך. עיין בתיעוד MLMD API לפרטים נוספים.

עיין ב-MLMD Declarative Nodes Filtering כדי ללמוד כיצד להשתמש ביכולות סינון צמתים הצהרתיים של MLMD בנכסים ובצמתים שכונתיים של 1 הופ.

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

MLMD מספקת כלי עזר לטיפול בהעברת סכימה ונתונים בין מהדורות. עיין במדריך MLMD לפרטים נוספים.