Melacak dan membandingkan model menggunakan MLflow Logged Models

Model Yang Dicatat MLflow membantu Anda melacak kemajuan model sepanjang siklus hidupnya. Saat Anda melatih model, gunakan mlflow.<model-flavor>.log_model() untuk membuat LoggedModel yang menggabungkan semua informasi pentingnya dengan menggunakan ID unik. Untuk memanfaatkan kekuatan LoggedModels, mulailah dengan MLflow 3.

Untuk aplikasi GenAI, LoggedModels dapat dibuat untuk menangkap komit git atau set parameter sebagai objek khusus yang kemudian dapat ditautkan ke lintasan dan metrik. Dalam pembelajaran mendalam dan ML klasik, LoggedModels diproduksi dari eksekusi MLflow, yang merupakan konsep yang ada dalam MLflow dan dapat dianggap sebagai pekerjaan yang menjalankan kode model. Pelatihan berjalan menghasilkan model sebagai output, dan evaluasi berjalan menggunakan model yang ada sebagai input untuk menghasilkan metrik dan informasi lain yang dapat Anda gunakan untuk menilai performa model.

Objek LoggedModel bertahan di seluruh siklus hidup model, di berbagai lingkungan, dan berisi tautan ke artefak seperti metadata, metrik, parameter, dan kode yang digunakan untuk menghasilkan model. Pelacakan Model yang Dicatat memungkinkan Anda membandingkan model satu sama lain, menemukan model dengan kinerja terbaik, dan melacak informasi selama pemecahan masalah.

Model yang Dicatatkan juga dapat didaftarkan ke registri model Unity Catalog, yang menyajikan informasi tentang model dari semua eksperimen dan ruang kerja MLflow yang tersedia dalam satu lokasi terpusat. Untuk detail selengkapnya, lihat Peningkatan Registri Model dengan MLflow 3.

Alur pelacakan model untuk kecerdasan buatan generatif, pembelajaran mendalam, dan pembelajaran mesin tradisional.

Peningkatan pelacakan untuk kecerdasan buatan generatif dan model pembelajaran mendalam

AI generatif dan alur kerja pembelajaran mendalam terutama mendapat manfaat dari pelacakan terperinci yang disediakan Model Yang Dicatat.

Gen AI - data evaluasi dan pelacakan terpadu:

  • Model AI Generatif menghasilkan metrik tambahan selama evaluasi dan penyebaran, seperti data umpan balik peninjau dan jejak data.
  • Entitas LoggedModel memungkinkan Anda untuk mengkueri semua informasi yang dihasilkan oleh model menggunakan satu antarmuka.

Pembelajaran mendalam - manajemen titik pemeriksaan yang efisien:

  • Pelatihan pembelajaran mendalam membuat beberapa titik pemeriksaan, yang merupakan rekam jepret status model pada titik tertentu selama pelatihan.
  • MLflow membuat file terpisah untuk setiap titik pemeriksaan, yang berisi metrik model dan data performa. Ini memungkinkan Anda membandingkan dan mengevaluasi titik pemeriksaan untuk mengidentifikasi model berkinerja terbaik secara efisien.

Membuat Model yang Dicatat

Untuk menciptakan Model yang Dicatat, gunakan API yang sama log_model() seperti pada beban kerja MLflow yang sudah ada. Cuplikan kode berikut menunjukkan cara membuat Model Tercatat untuk AI generatif, pembelajaran mendalam, dan alur kerja ML tradisional.

Untuk contoh notebook yang lengkap dan dapat dijalankan, lihat Contoh buku catatan.

Kecerdasan Buatan Generatif (Gen AI)

Cuplikan kode berikut menunjukkan cara mengelog agen LangChain. Gunakan metode log_model() untuk varian agen Anda.

# Log the chain with MLflow, specifying its parameters
# As a new feature, the LoggedModel entity is linked to its name and params
model_info = mlflow.langchain.log_model(
  lc_model=chain,
  name="basic_chain",
  params={
    "temperature": 0.1,
    "max_tokens": 2000,
    "prompt_template": str(prompt)
  },
  model_type="agent",
  input_example={"messages": "What is MLflow?"},
)

# Inspect the LoggedModel and its properties
logged_model = mlflow.get_logged_model(model_info.model_id)
print(logged_model.model_id, logged_model.params)

Mulai pekerjaan evaluasi dan tautkan metrik ke Model yang Dicatat dengan memberikan model_id yang unik untuk LoggedModel:

# Start a run to represent the evaluation job
with mlflow.start_run() as evaluation_run:
  eval_dataset: mlflow.entities.Dataset = mlflow.data.from_pandas(
    df=eval_df,
    name="eval_dataset",
  )
  # Run the agent evaluation
  result = mlflow.evaluate(
    model=f"models:/{logged_model.model_id}",
    data=eval_dataset,
    model_type="databricks-agent"
  )
  # Log evaluation metrics and associate with agent
  mlflow.log_metrics(
    metrics=result.metrics,
    dataset=eval_dataset,
    # Specify the ID of the agent logged above
    model_id=logged_model.model_id
  )

Pembelajaran mendalam

Cuplikan kode berikut menunjukkan cara membuat Model Tercatat selama pelatihan pembelajaran mendalam. Gunakan metode log_model() untuk varian dari model MLflow Anda.

# Start a run to represent the training job
with mlflow.start_run():
  # Load the training dataset with MLflow. We will link training metrics to this dataset.
  train_dataset: Dataset = mlflow.data.from_pandas(train_df, name="train")
  X_train, y_train = prepare_data(train_dataset.df)

  criterion = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(scripted_model.parameters(), lr=0.01)

  for epoch in range(101):
      X_train, y_train = X_train.to(device), y_train.to(device)
      out = scripted_model(X_train)
      loss = criterion(out, y_train)
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()

      # Obtain input and output examples for MLflow Model signature creation
      with torch.no_grad():
          input_example = X_train[:1]
          output_example = scripted_model(input_example)

      # Log a checkpoint with metrics every 10 epochs
      if epoch % 10 == 0:
          # Each newly created LoggedModel checkpoint is linked with its
          # name, params, and step
          model_info = mlflow.pytorch.log_model(
              pytorch_model=scripted_model,
              name=f"torch-iris-{epoch}",
              params={
                  "n_layers": 3,
                  "activation": "ReLU",
                  "criterion": "CrossEntropyLoss",
                  "optimizer": "Adam"
              },
              step=epoch,
              signature=mlflow.models.infer_signature(
                  model_input=input_example.cpu().numpy(),
                  model_output=output_example.cpu().numpy(),
              ),
              input_example=X_train.cpu().numpy(),
          )
          # Log metric on training dataset at step and link to LoggedModel
          mlflow.log_metric(
              key="accuracy",
              value=compute_accuracy(scripted_model, X_train, y_train),
              step=epoch,
              model_id=model_info.model_id,
              dataset=train_dataset
          )

ML Tradisional

Cuplikan kode berikut menunjukkan cara mencatat model sklearn dan menautkan metrik ke Logged Model. Gunakan metode log_model() untuk varian dari model MLflow Anda.

## Log the model
model_info = mlflow.sklearn.log_model(
  sk_model=lr,
  name="elasticnet",
  params={
    "alpha": 0.5,
    "l1_ratio": 0.5,
  },
  input_example = train_x
)

# Inspect the LoggedModel and its properties
logged_model = mlflow.get_logged_model(model_info.model_id)
print(logged_model.model_id, logged_model.params)

# Evaluate the model on the training dataset and log metrics
# These metrics are now linked to the LoggedModel entity
predictions = lr.predict(train_x)
(rmse, mae, r2) = compute_metrics(train_y, predictions)
mlflow.log_metrics(
  metrics={
    "rmse": rmse,
    "r2": r2,
    "mae": mae,
  },
  model_id=logged_model.model_id,
  dataset=train_dataset
)

Contoh buku catatan

Misalnya buku catatan yang mengilustrasikan penggunaan LoggedModels, lihat halaman berikut ini:

Melihat model dan melacak kemajuan

Anda dapat melihat Model yang Dicatat di antarmuka pengguna ruang kerja:

  1. Buka tab Eksperimen di ruang kerja Anda.
  2. Pilih eksperimen. Kemudian, pilih tab Model .

Halaman ini berisi semua Model Yang Dicatat yang terkait dengan eksperimen, bersama dengan metrik, parameter, dan artefaknya.

UI pelacakan model.

Anda dapat membuat bagan untuk melacak metrik di seluruh percobaan.

Bagan grafik metrik untuk pelacakan model dalam antarmuka pengguna.

Mencari dan memfilter Model yang Dicatat

Dari tab Model , Anda dapat mencari dan memfilter Model yang Dicatat berdasarkan atribut, parameter, tag, dan metriknya.

UI pelacakan model untuk mencari model yang dicatat.

Anda dapat memfilter metrik berdasarkan performa khusus himpunan data, dan hanya model dengan nilai metrik yang cocok pada himpunan data yang diberikan yang dikembalikan. Jika filter himpunan data disediakan tanpa filter metrik apa pun, model dengan metrik apa pun pada himpunan data tersebut dikembalikan.

Anda dapat memfilter berdasarkan atribut berikut:

  • model_id
  • model_name
  • status
  • artifact_uri
  • creation_time (numerik)
  • last_updated_time (numerik)

Gunakan operator berikut untuk mencari dan memfilter atribut, parameter, dan tag seperti string:

  • =,!=,IN,NOT IN

Gunakan operator perbandingan berikut untuk mencari dan memfilter atribut dan metrik numerik,:

  • =, , !=>, <, , >=,<=

Cari Model yang Dicatat secara Programatis

Anda dapat mencari Model Yang Dicatat menggunakan API MLflow:

## Get a Logged Model using a model_id
mlflow.get_logged_model(model_id = <my-model-id>)

## Get all Logged Models that you have access to
mlflow.search_logged_models()

## Get all Logged Models with a specific name
mlflow.search_logged_models(
  filter_string = "model_name = <my-model-name>"
)

## Get all Logged Models created within a certain time range
mlflow.search_logged_models(
  filter_string = "creation_time >= <creation_time_start> AND creation_time <= <creation_time_end>"
)

## Get all Logged Models with a specific param value
mlflow.search_logged_models(
  filter_string = "params.<param_name> = <param_value_1>"
)

## Get all Logged Models with specific tag values
mlflow.search_logged_models(
  filter_string = "tags.<tag_name> IN (<tag_value_1>, <tag_value_2>)"
)

## Get all Logged Models greater than a specific metric value on a dataset, then order by that metric value
mlflow.search_logged_models(
  filter_string = "metrics.<metric_name> >= <metric_value>",
  datasets = [
    {"dataset_name": <dataset_name>, "dataset_digest": <dataset_digest>}
  ],
  order_by = [
    {"field_name": metrics.<metric_name>, "dataset_name": <dataset_name>,"dataset_digest": <dataset_digest>}
  ]
)

Untuk informasi selengkapnya dan parameter pencarian tambahan, lihat dokumentasi MLflow 3 API.

Pencarian berjalan berdasarkan input dan output model

Anda dapat mencari eksekusi menurut ID model untuk mengembalikan semua eksekusi yang memiliki Model yang Tercatat sebagai input atau output. Untuk informasi selengkapnya tentang sintaks string filter, lihat pemfilteran untuk proses.

Pencarian UI pelacakan model berdasarkan ID model yang dicatat.

Anda dapat mencari run menggunakan MLflow API.

## Get all Runs with a particular model as an input or output by model id
mlflow.search_runs(filter_string = "models.model_id = <my-model-id>")

Langkah selanjutnya

Untuk mempelajari selengkapnya tentang fitur baru MLflow 3 lainnya, lihat artikel berikut ini:

  • Last updated on