Metadata ML

ML Metadata (MLMD) adalah pustaka untuk merekam dan mengambil metadata yang terkait dengan alur kerja pengembang ML dan ilmuwan data. MLMD adalah bagian integral dari TensorFlow Extended (TFX) , tetapi dirancang agar dapat digunakan secara mandiri.

Setiap proses pipeline ML produksi menghasilkan metadata yang berisi informasi tentang berbagai komponen pipeline, eksekusinya (mis. pelatihan berjalan), dan artefak yang dihasilkan (mis. model terlatih). Jika terjadi kesalahan atau perilaku pipeline yang tidak terduga, metadata ini dapat dimanfaatkan untuk menganalisis silsilah komponen pipeline dan masalah debug. Pikirkan metadata ini sebagai setara dengan masuk dalam pengembangan perangkat lunak.

MLMD membantu Anda memahami dan menganalisis semua bagian yang saling berhubungan dari saluran ML Anda alih-alih menganalisisnya secara terpisah dan dapat membantu Anda menjawab pertanyaan tentang saluran ML Anda seperti:

  • Dataset mana yang digunakan model tersebut?
  • Apa hyperparameter yang digunakan untuk melatih model?
  • Jalur pipa mana yang menciptakan model?
  • Pelatihan mana yang menghasilkan model ini?
  • Versi TensorFlow mana yang membuat model ini?
  • Kapan model yang gagal didorong?

Penyimpanan metadata

MLMD mendaftarkan jenis metadata berikut dalam database yang disebut Metadata Store .

  1. Metadata tentang artefak yang dihasilkan melalui komponen/langkah pipeline ML Anda
  2. Metadata tentang eksekusi komponen/langkah ini
  3. Metadata tentang pipeline dan informasi silsilah terkait

Metadata Store menyediakan API untuk merekam dan mengambil metadata ke dan dari backend penyimpanan. Backend penyimpanan dapat dicolokkan dan dapat diperpanjang. MLMD menyediakan implementasi referensi untuk SQLite (yang mendukung dalam memori dan disk) dan MySQL di luar kotak.

Grafik ini menunjukkan ikhtisar tingkat tinggi dari berbagai komponen yang merupakan bagian dari MLMD.

Ikhtisar Metadata ML

Backend penyimpanan metadata dan menyimpan konfigurasi koneksi

Objek MetadataStore menerima konfigurasi koneksi yang sesuai dengan backend penyimpanan yang digunakan.

  • Fake Database menyediakan DB dalam memori (menggunakan SQLite) untuk eksperimen cepat dan proses lokal. Basis data dihapus ketika objek toko dihancurkan.
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 membaca dan menulis file dari disk.
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 terhubung ke server 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)

Demikian pula, saat menggunakan instance MySQL dengan Google CloudSQL ( quickstart , connect-overview ), seseorang juga dapat menggunakan opsi SSL jika berlaku.

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)

Model data

Penyimpanan Metadata menggunakan model data berikut untuk merekam dan mengambil metadata dari backend penyimpanan.

  • ArtifactType menjelaskan jenis artefak dan propertinya yang disimpan di penyimpanan metadata. Anda dapat mendaftarkan jenis ini dengan cepat dengan penyimpanan metadata dalam kode, atau Anda dapat memuatnya di toko dari format serial. Setelah Anda mendaftarkan suatu jenis, definisinya tersedia sepanjang masa pakai toko.
  • Artifact menjelaskan contoh spesifik dari ArtifactType , dan propertinya yang ditulis ke penyimpanan metadata.
  • ExecutionType menjelaskan jenis komponen atau langkah dalam alur kerja, dan parameter waktu prosesnya.
  • Execution adalah catatan proses komponen atau langkah dalam alur kerja ML dan parameter waktu proses. Eksekusi dapat dianggap sebagai turunan dari ExecutionType . Eksekusi dicatat saat Anda menjalankan pipeline atau langkah ML.
  • Event adalah catatan hubungan antara artefak dan eksekusi. Saat eksekusi terjadi, peristiwa merekam setiap artefak yang digunakan oleh eksekusi, dan setiap artefak yang dihasilkan. Catatan ini memungkinkan pelacakan garis keturunan di seluruh alur kerja. Dengan melihat semua peristiwa, MLMD mengetahui eksekusi apa yang terjadi dan artefak apa yang dibuat sebagai hasilnya. MLMD kemudian dapat muncul kembali dari artefak apa pun ke semua input hulunya.
  • ContextType menjelaskan jenis kelompok konseptual artefak dan eksekusi dalam alur kerja, dan properti strukturalnya. Misalnya: proyek, jalur pipa, eksperimen, pemilik, dll.
  • Context adalah turunan dari ContextType . Ini menangkap informasi bersama dalam grup. Misalnya: nama proyek, id komit daftar perubahan, anotasi eksperimen, dll. Ia memiliki nama unik yang ditentukan pengguna di dalam ContextType .
  • Attribution adalah catatan hubungan antara artefak dan konteks.
  • Association adalah catatan hubungan antara eksekusi dan konteks.

Fungsionalitas MLMD

Melacak input dan output dari semua komponen/langkah dalam alur kerja ML dan garis keturunannya memungkinkan platform ML mengaktifkan beberapa fitur penting. Daftar berikut memberikan gambaran umum yang tidak lengkap tentang beberapa manfaat utama.

  • Daftar semua Artefak dari jenis tertentu. Contoh: semua Model yang telah dilatih.
  • Muat dua Artefak dengan tipe yang sama untuk perbandingan. Contoh: membandingkan hasil dari dua percobaan.
  • Tampilkan DAG dari semua eksekusi terkait dan artefak input dan output dari suatu konteks. Contoh: memvisualisasikan alur kerja eksperimen untuk proses debug dan penemuan.
  • Berulang kembali melalui semua peristiwa untuk melihat bagaimana artefak dibuat. Contoh: lihat data apa yang dimasukkan ke dalam model; menegakkan rencana penyimpanan data.
  • Identifikasi semua artefak yang dibuat menggunakan artefak tertentu. Contoh: lihat semua Model yang dilatih dari kumpulan data tertentu; menandai model berdasarkan data yang buruk.
  • Tentukan apakah eksekusi telah dijalankan pada input yang sama sebelumnya. Contoh: menentukan apakah suatu komponen/langkah telah menyelesaikan pekerjaan yang sama dan keluaran sebelumnya dapat digunakan kembali.
  • Rekam dan kueri konteks alur kerja yang berjalan. Contoh: lacak pemilik dan daftar perubahan yang digunakan untuk menjalankan alur kerja; kelompokkan garis keturunan dengan eksperimen; mengelola artefak berdasarkan proyek.
  • Kemampuan penyaringan node deklaratif pada properti dan node lingkungan 1-hop. Contoh: mencari artefak dari suatu jenis dan di bawah beberapa konteks saluran; mengembalikan artefak yang diketik di mana nilai properti tertentu berada dalam kisaran; temukan eksekusi sebelumnya dalam konteks dengan input yang sama.

Lihat tutorial MLMD untuk contoh yang menunjukkan cara menggunakan MLMD API dan penyimpanan metadata untuk mengambil informasi silsilah.

Integrasikan ML Metadata ke dalam Alur Kerja ML Anda

Jika Anda adalah pengembang platform yang tertarik untuk mengintegrasikan MLMD ke dalam sistem Anda, gunakan contoh alur kerja di bawah ini untuk menggunakan API MLMD tingkat rendah untuk melacak pelaksanaan tugas pelatihan. Anda juga dapat menggunakan API Python tingkat yang lebih tinggi di lingkungan notebook untuk merekam metadata eksperimen.

Alur Contoh Metadata ML

1) Daftarkan jenis artefak

# 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) Daftarkan jenis eksekusi untuk semua langkah dalam alur kerja 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) Buat artefak dari 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) Buat eksekusi run Pelatih

# 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) Tentukan acara input dan baca data

# 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) Deklarasikan artefak keluaran

# 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) Rekam acara keluaran

# 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) Tandai eksekusi sebagai selesai

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

9) Mengelompokkan artefak dan eksekusi di bawah konteks menggunakan artefak atribusi dan pernyataan

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

Gunakan MLMD dengan server gRPC jarak jauh

Anda dapat menggunakan MLMD dengan server gRPC jarak jauh seperti yang ditunjukkan di bawah ini:

  • Mulai server
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

Secara default, server menggunakan db dalam memori palsu per permintaan dan tidak mempertahankan metadata di seluruh panggilan. Itu juga dapat dikonfigurasi dengan MLMD MetadataStoreServerConfig untuk menggunakan file SQLite atau instance MySQL. Konfigurasi dapat disimpan dalam file protobuf teks dan diteruskan ke biner dengan --metadata_store_server_config_file=path_to_the_config_file .

Contoh file MetadataStoreServerConfig dalam format teks protobuf:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • Buat rintisan klien dan gunakan dengan 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)
  • Gunakan MLMD dengan panggilan 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)

Sumber daya

Pustaka MLMD memiliki API tingkat tinggi yang dapat Anda gunakan dengan mudah dengan saluran ML Anda. Lihat dokumentasi MLMD API untuk detail selengkapnya.

Lihat Pemfilteran Node Deklaratif MLMD untuk mempelajari cara menggunakan kemampuan pemfilteran node deklaratif MLMD pada properti dan node lingkungan 1-hop.

Lihat juga tutorial MLMD untuk mempelajari cara menggunakan MLMD untuk melacak garis keturunan komponen saluran Anda.

MLMD menyediakan utilitas untuk menangani skema dan migrasi data di seluruh rilis. Lihat Panduan MLMD untuk lebih jelasnya.