עזרה להגן על שונית המחסום הגדולה עם TensorFlow על Kaggle הצטרפו אתגר

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

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

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

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

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

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

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

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

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

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

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

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

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

  • מסד מזויף מספק 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 ( QuickStart , Connect-סקירה ), אפשר גם להשתמש באפשרות 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)

מודל נתונים

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

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

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

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

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

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

שלב מטא נתונים של 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)

# 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 קובץ בפורמט Protobuf טקסט:

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 שלך. עיין בתיעוד API MLMD לפרטים נוספים.

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

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

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