MLOPS

維基百科：MLOps是ModelOps的子集，是數(shù)據(jù)科學(xué)家和操作專業(yè)人員之間進行協(xié)作和交流的一種做法，可幫助管理生產(chǎn)機器學(xué)習(xí)生命周期。與DevOps或DataOps方法相似，MLOps旨在提高自動化程度并提高生產(chǎn)ML的質(zhì)量，同時還關(guān)注業(yè)務(wù)和法規(guī)要求。

MLOps的概念本身也在發(fā)展之中，不同的公司對他的描述也不一樣,但基本都是沿用DevOps的思路來定義。

Google：MLOps是一種機器學(xué)習(xí)工程文化和做法，旨在統(tǒng)一機器學(xué)習(xí)系統(tǒng)開發(fā)（Dev）和機器學(xué)習(xí)系統(tǒng)運維（Ops）。實施MLOps意味著您*將在機器學(xué)習(xí)系統(tǒng)構(gòu)建流程的所有步驟（包括集成、測試、發(fā)布、部署和基礎(chǔ)架構(gòu)管理）中實現(xiàn)自動化和監(jiān)控。

Microsoft：MLOps是基于可提高工作流效率的DevOps原理和做法。目標是更快試驗和開發(fā)模型，更快地將模型部署到生產(chǎn)環(huán)境，質(zhì)量保證和端到端世系跟蹤。

Amazon：ML考慮了AI/ML項目在項目管理、CI/CD和質(zhì)量保證方面的獨特方面，幫助客戶縮短交付時間，減少缺陷并提高數(shù)據(jù)科學(xué)家的工作效率。

a4e2c59d03fd24cd41cf2a76f24f70ef.png

機器學(xué)習(xí)、數(shù)據(jù)工程和 DevOps 都在這個領(lǐng)域融合在一起。換句話說，它將機器學(xué)習(xí)與設(shè)計，構(gòu)建和維護系統(tǒng)的任務(wù)聯(lián)系起來。

fd847413e385b0a4c1caf8dd3e1321bc.png

MLflow 是什么？

MLflow 是一個開源平臺，旨在管理整個機器學(xué)習(xí)生命周期。這包括實驗跟蹤、模型開發(fā)和選擇、部署以及監(jiān)控等方面。在 MLOps 中，MLflow 對于協(xié)作和自動化 ML 流程特別有價值。

MLflow VS Kubeflow

MLflow 和 Kubeflow 都是開源工具,旨在簡化機器學(xué)習(xí)工作流程的管理,但它們的重點和使用場景有所不同。

1、MLflow 是一個用于管理機器學(xué)習(xí)生命周期的開源平臺,包括實驗跟蹤、項目打包、模型管理等。 2、它側(cè)重于為數(shù)據(jù)科學(xué)家提供一個組織代碼、數(shù)據(jù)、模型以及運行結(jié)果的平臺,并使之便于復(fù)制和共享。 3、MLflow 支持多種機器學(xué)習(xí)庫,如 TensorFlow、PyTorch、XGBoost 等。 4、它由四個核心組件組成:Tracking、Projects、Models 和 Model Registry。

1、Kubeflow 是一個基于 Kubernetes 的開源機器學(xué)習(xí)平臺,專注于機器學(xué)習(xí)工作流程的編排和部署。 2、它為機器學(xué)習(xí)工作流程提供了一個可移植、可擴展和部署友好的環(huán)境。 3、Kubeflow 提供了多個組件支持不同階段的工作,如數(shù)據(jù)準備、訓(xùn)練、模型服務(wù)、notebook等。 4、它利用 Kubernetes 的優(yōu)勢,如容器編排、自動化擴展、故障恢復(fù)等,適用于生產(chǎn)環(huán)境部署。

相似之處:

1、兩者都是用于支持和簡化機器學(xué)習(xí)工作流程的開源工具。 2、它們都提供了跟蹤實驗、管理模型等功能。

不同之處:

1、MLflow 更側(cè)重于為數(shù)據(jù)科學(xué)家提供一個組織和管理實驗的平臺,而 Kubeflow 更注重機器學(xué)習(xí)工作流的編排和生產(chǎn)部署。 2、MLflow 支持多種機器學(xué)習(xí)庫,而 Kubeflow 基于 Kubernetes,為部署提供了更好的支持和可擴展性。 3、MLflow 通常用于較小規(guī)模的實驗管理,而 Kubeflow 更適用于生產(chǎn)級別的大規(guī)模部署。

兩者可以結(jié)合使用,MLflow 用于管理實驗和模型,而 Kubeflow 則用于在 Kubernetes 上進行模型的部署和服務(wù)。它們?yōu)椴煌A段的機器學(xué)習(xí)工作流程提供了支持和簡化

使用場景

MLflow： 主要關(guān)注機器學(xué)習(xí)的生命周期管理，包括實驗跟蹤、模型管理、部署和監(jiān)控。它適用于各種深度學(xué)習(xí)框架，提供自動日志記錄、定制序列化以及統(tǒng)一的界面。MLflow 的模型注冊表非常適合大型組織，其中不同團隊可能在處理多種模型，提供版本控制、注釋以及模型生命周期階段的定義等特性。此外，MLflow 通過包括 Docker 和 GPU 支持的部署功能，確保了不同環(huán)境中的一致行為。

Kubeflow： 是一個全面的、開源的機器學(xué)習(xí)平臺，旨在管理 Kubernetes 上的端到端機器學(xué)習(xí)工作流程。它提供了一個可伸縮且靈活的工具包，用于部署、監(jiān)控和管理復(fù)雜的 ML 系統(tǒng)。Kubeflow 主要是為了在 Kubernetes 上編排整個 ML 工作流程，從數(shù)據(jù)預(yù)處理到模型訓(xùn)練、服務(wù)和監(jiān)控。Kubeflow 通過其流水線提供了強大的解決方案，用于構(gòu)建和部署可重復(fù)使用的 ML 工作流程，并支持連續(xù)集成和交付（CI/CD），便于快速實驗和產(chǎn)品化。此外，Kubeflow 提供對多個 ML 框架的支持，例如 TensorFlow、PyTorch 和 XGBoost，并且其 Katib 組件自動化了超參數(shù)的調(diào)整。

總的來說，MLflow 在實驗跟蹤、模型管理和部署方面更加突出，特別適用于需要詳細記錄和比較實驗結(jié)果的情況。而 Kubeflow 則更適用于需要在 Kubernetes 上進行端到端機器學(xué)習(xí)操作的復(fù)雜場景，特別是當涉及到分布式訓(xùn)練和可擴展的模型服務(wù)時

MLflow 的組件：

image.png

1. MLflow Tracking： 這是一個API和用戶界面，可以在ML運行過程中記錄參數(shù)、代碼版本、指標和產(chǎn)品，并在以后可視化結(jié)果。它適應(yīng)于任何環(huán)境，允許你記錄到本地文件或服務(wù)器，并比較多個運行。團隊還可以使用它來比較來自不同用戶的結(jié)果。

2. MLflow Projects： 這是一種簡化打包和重用數(shù)據(jù)科學(xué)代碼的方式。每個項目是一個包含代碼或Git倉庫的目錄，還有一個描述文件用于指定依賴關(guān)系和執(zhí)行指令。當你使用Tracking API時，MLflow會自動跟蹤項目的版本和參數(shù)，使得可以輕松地從GitHub或你的Git倉庫運行項目，并將它們鏈接到多步驟的工作流中。

3. MLflow Models： 它允許你以不同的格式打包ML模型，并提供各種部署工具。每個模型保存為一個目錄，其中包含一個描述文件列出其支持的格式。MLflow提供了將常見模型類型部署到各種平臺的工具，包括基于Docker的REST服務(wù)器、Azure ML、AWS SageMaker和Apache Spark用于批處理和流媒體推理。當你使用Tracking API輸出MLflow模型時，MLflow會自動跟蹤其來源，包括項目和運行它們的來源。

4. MLflow Model Registry： 這是一個集中式模型存儲，具有API和用戶界面，用于協(xié)作管理MLflow模型的整個生命周期。它包括模型血統(tǒng)、版本控制、階段轉(zhuǎn)換和注釋，以實現(xiàn)有效的模型管理。

5. MLflow recipes: 的前身是mlflow pipeline,mlflow pipeline 于 2022 年 11 月 7 日棄用,，用于機器學(xué)習(xí)中用到的各種步驟通過recipes編排形成一個可復(fù)用且容易拓展的mlflow套件。recipes可以緩存中間運行的結(jié)果，使得任務(wù)可以從失敗節(jié)點開始執(zhí)行，節(jié)省算力資源。

MLflow 的工作流程：

image.png

1. 實驗： 通過記錄參數(shù)、指標和輸出來進行實驗。MLflow UI 有助于跟蹤和比較這些實驗。
2. 打包： 使用 MLflow Projects 打包數(shù)據(jù)科學(xué)代碼，實現(xiàn)一致的執(zhí)行和協(xié)作。
3. 模型保存與服務(wù)： 使用 MLflow 統(tǒng)一格式保存模型，并通過多種機制（如本地 REST API 端點）提供服務(wù)。
4. 模型注冊與部署： 在模型注冊表中注冊模型進行版本控制和部署。將模型部署到各種環(huán)境，如 Kubernetes、云平臺或 Databricks。
5. 監(jiān)控和維護： 部署后，使用 MLflow 監(jiān)控模型性能并管理其生命周期。

如何使用 MLflow:

1. 設(shè)置： 安裝 MLflow 并設(shè)置環(huán)境。這可能涉及配置跟蹤服務(wù)器以進行協(xié)作工作。
2. 運行實驗： 使用 MLflow 記錄實驗。這涉及跟蹤每次運行的參數(shù)、指標和輸出。
3. 模型開發(fā)和記錄： 使用 MLflow 的 API 訓(xùn)練和記錄模型，適用于各種 ML 框架。
4. 模型評估和可視化： 使用 SHAP 等工具評估模型，并使用 MLflow UI 可視化結(jié)果。
5. 部署： 使用 MLflow 的部署工具在多種環(huán)境中部署模型，如本地服務(wù)器或 Kubernetes。

在可視化方面，MLflow 在 UI 中支持以表格和圖表形式顯示指標歷史，提供了對模型性能隨時間的變化或在不同運行中的比較的清晰了解。

pip install mlflow
mlflow server
http://localhost:5000

docker啟動：
docker pull ghcr.io/mlflow/mlflow:v2.7.1 
docker run -d -it --name mlflow_demo -p 5001:5000 -p 8081:8080 ghcr.io/mlflow/mlflow:v2.7.1 /bin/bash
docker cp mlflow-2.7.1 a4b3d1454fd1:/
docker exec -it a4b3d1454fd1 /bin/bash 

mkdir /mlflow_workspace
cd /mlflow_workspace/
## 運行模型訓(xùn)練實驗, 使用本地python環(huán)境
export GIT_PYTHON_REFRESH=quiet ; mlflow run --env-manager local /mlflow-2.7.1/examples/sklearn_elasticnet_wine -P alpha=0.7

啟動mlflow ui服務(wù)
nohup mlflow ui -h 0.0.0.0 -p 5000 > mlflow_ui.log 2>&1 &

啟動模型服務(wù)
mlflow models serve --env-manager local -h 0.0.0.0   --port 8080   -m runs:/ee55b2f4bd844dc99bdff3865ffa3d43/model

測試

創(chuàng)建實驗：

from mlflow import MlflowClient
#  mlflow.set_tracking_uri(uri="http://10.0.102.50:15000")   # 全局設(shè)置
client = MlflowClient(tracking_uri="http://10.0.102.50:15000") # 可與不同的跟蹤服務(wù)器交互
all_experiments = client.search_experiments()

default_experiment = [
    {"name": experiment.name, "lifecycle_stage": experiment.lifecycle_stage}
    for experiment in all_experiments
    if experiment.name == "Default"
][0]
# Provide an Experiment description that will appear in the UI
experiment_description = (
    "This is the grocery forecasting project. "
    "This experiment contains the produce models for apples."
)

# Provide searchable tags that define characteristics of the Runs that
# will be in this Experiment
experiment_tags = {
    "project_name": "grocery-forecasting",
    "store_dept": "produce",
    "team": "stores-ml",
    "project_quarter": "Q3-2023",
    "mlflow.note.content": experiment_description,
}

# Create the Experiment, providing a unique name
produce_apples_experiment = client.create_experiment(
    name="Apple_Models", tags=experiment_tags
)

image.png

實驗追蹤

import torch
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

import mlflow
import mlflow.pytorch

# 定義超參數(shù)
learning_rate = 0.01
batch_size = 128
epochs = 10

# 開始一個新的實驗
mlflow.set_experiment("pytorch_mnist")

# 加載數(shù)據(jù)集
train_dataset = datasets.MNIST("data", train=True, download=True,
                               transform=transforms.Compose([
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.1307,), (0.3081,))
                               ]))
test_dataset = datasets.MNIST("data", train=False, download=True,
                              transform=transforms.Compose([
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.1307,), (0.3081,))
                              ]))
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)

# 定義模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.fc1 = torch.nn.Linear(320, 50)
        self.fc2 = torch.nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2(x), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

model = Net()

# 定義優(yōu)化器和損失函數(shù)
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
criterion = torch.nn.CrossEntropyLoss()

# 使用 MLflow 進行實驗追蹤
with mlflow.start_run():
    # 記錄實驗參數(shù)
    mlflow.log_param("learning_rate", learning_rate)
    mlflow.log_param("batch_size", batch_size)
    mlflow.log_param("epochs", epochs)

    for epoch in range(epochs):
        # 訓(xùn)練模型
        model.train()
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

        # 測試模型
        model.eval()
        test_loss = 0
        correct = 0
        with torch.no_grad():
            for data, target in test_loader:
                output = model(data)
                test_loss += criterion(output, target).item()
                pred = output.argmax(dim=1, keepdim=True)
                correct += pred.eq(target.view_as(pred)).sum().item()

        # 記錄實驗結(jié)果
        test_loss /= len(test_loader.dataset)
        test_accuracy = 100\. * correct / len(test_loader.dataset)
        # 調(diào)用mlflow api
        mlflow.log_metric("test_loss", test_loss, step=epoch)
        mlflow.log_metric("test_accuracy", test_accuracy, step=epoch)

        # 保存模型
        mlflow.pytorch.log_model(model, "models", epoch)

        # 輸出實驗結(jié)果
        print(f"Epoch {epoch+1}: test_loss={test_loss:.4f}, test_accuracy={test_accuracy:.2f}%")

使用 set_experiment 開始一個新的實驗。使用 log_param 記錄實驗的超參數(shù)，使用 log_metric 記錄實驗結(jié)果，以及使用 log_model 記錄模型。這些記錄將被保存到 MLflow 服務(wù)器或本地文件系統(tǒng)中，以便查看和比較不同實驗的結(jié)果。

在啟動訓(xùn)練后，本地會出現(xiàn)一個mlruns 目錄，它是 MLflow 默認的存儲實驗數(shù)據(jù)和結(jié)果的目錄。MLflow 會將每個實驗的信息保存到一個單獨的子目錄中，其中包括實驗參數(shù)、指標、文件等等。mlruns 目錄可以存儲在本地文件系統(tǒng)中，也可以存儲在遠程服務(wù)器或云存儲中?？梢允褂?MLflow UI 查看和比較不同實驗的結(jié)果

使用 mlflow ui 命令可以啟動 MLflow UI，以便查看和比較不同實驗的結(jié)果。例如，假設(shè)將 mlruns 目錄存儲在本地文件系統(tǒng)的 /path/to/mlruns 目錄中，我們可以使用以下命令啟動 MLflow UI：

mlflow ui --backend-store-uri <mlruns文件夾所在的目錄>

image.png

加載模型：

使用 mlflow.pytorch.load_model 函數(shù)加載之前保存的 PyTorch 模型。該函數(shù)接受三個參數(shù)：

1、model_uri：模型的 URI，可以是本地文件路徑或遠程服務(wù)器地址。 2、map_location：可選參數(shù)，指定模型應(yīng)該加載到哪個設(shè)備上。 3、model：可選參數(shù)，指定模型的類型。如果未指定，則使用 torch.nn.Module。

import torch
import mlflow.pytorch

# 從 MLflow 加載模型
model = mlflow.pytorch.load_model("models")

# 如果有g(shù)pu的話
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)

# 使用模型進行推理
with torch.no_grad():
    inputs = torch.randn(1, 1, 28, 28).to(device)
    outputs = model(inputs)
    print(outputs)

加載模型時，需要指定模型的 URI，可以是本地文件路徑或遠程服務(wù)器地址。在前面的示例中，模型保存在 MLflow 中，其 URI 為 "models"。如果將模型保存在本地文件系統(tǒng)中，則可以將 URI 設(shè)置為文件路徑，例如 "/path/to/pytorch_model"。

如果模型使用了 GPU 進行訓(xùn)練并保存在 GPU 上，需要使用 map_location 參數(shù)指定模型應(yīng)該加載到哪個設(shè)備上。如上實例使用了 torch.device 函數(shù)指定了設(shè)備。

Projects

項目可以是遠程存儲庫或本地目錄。與MLflow模型不同，MLflow項目旨在實現(xiàn)機器學(xué)習(xí)項目的可移植性和分布性

MLflow項目由名為“MLProject”的一個YAML聲明文件來定義，其中公開了相應(yīng)項目的一系列規(guī)范內(nèi)容。

模型實現(xiàn)的關(guān)鍵特征在MLProject文件中指定，這些特征包括：

• 模型接收的輸入?yún)?shù)
• 參數(shù)的數(shù)據(jù)類型
• 用于執(zhí)行所述模型的命令，以及
• 項目運行的環(huán)境

image.png

conda.yaml

name: tutorial
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip
  - pip:
      - scikit-learn==1.2.0
      - mlflow>=1.0
      - pandas

MLproject定義：

name: tutorial

python_env: python_env.yaml

entry_points:
  main:
    parameters:
      alpha: {type: float, default: 0.5}
      l1_ratio: {type: float, default: 0.1}
    command: "python train.py {alpha} {l1_ratio}"

mlflow run sklearn_elasticnet_wine -P alpha=0.5 // 本地
mlflow run git@github.com:FernandoLpz/MLflow-example.git -P tree_depth=3 // 遠程

image.png

image.png

image.png

模型訓(xùn)練
$: mlflow run --env-manager local examples/sklearn_elasticnet_wine -P alpha=0.5

將模型打包成鏡像
$: mlflow models build-docker --model-uri "runs:/f933482ecd664890a6fa097dfd6bdef7/model" --name "my-image-name" 

運行一個模型，指定服務(wù)端口
$: mlflow models serve --env-manager local -h 0.0.0.0 -m my_model

模型

MLflow模型允許將機器學(xué)習(xí)模型打包成標準格式，以便通過REST API、Microsoft Azure ML、Amazon SageMaker或Apache Spark等不同服務(wù)直接使用，打包方面，MLflow生成一個包含兩個文件的目錄，一個是模型，另一個是指定模型打包和加載細節(jié)的文件。如下。

image.png

artifact_path: model
flavors:
  python_function:
    env:
      conda: conda.yaml
      virtualenv: python_env.yaml
    loader_module: mlflow.sklearn
    model_path: model.pkl
    predict_fn: predict
    python_version: 3.8.18
  sklearn:
    code: null
    pickled_model: model.pkl
    serialization_format: cloudpickle
    sklearn_version: 1.2.0
mlflow_version: 2.11.1
model_size_bytes: 878
model_uuid: 49c54a35c1be4b53809427050e3463d5
run_id: 163415697d22464ba51c716d2eb68407
signature:
  inputs: '[{"type": "double", "name": "fixed acidity", "required": true}, {"type":
    "double", "name": "volatile acidity", "required": true}, {"type": "double", "name":
    "citric acid", "required": true}, {"type": "double", "name": "residual sugar",
    "required": true}, {"type": "double", "name": "chlorides", "required": true},
    {"type": "double", "name": "free sulfur dioxide", "required": true}, {"type":
    "double", "name": "total sulfur dioxide", "required": true}, {"type": "double",
    "name": "density", "required": true}, {"type": "double", "name": "pH", "required":
    true}, {"type": "double", "name": "sulphates", "required": true}, {"type": "double",
    "name": "alcohol", "required": true}]'
  outputs: '[{"type": "tensor", "tensor-spec": {"dtype": "float64", "shape": [-1]}}]'
  params: null
utc_time_created: '2024-03-13 08:15:55.707239'

注冊

MLflow注冊表是一個擴展，有助于：

• 管理每個MLModel的版本
• 記錄每個模型在三個不同階段的發(fā)展進程：歸檔（archive）、模擬環(huán)境(staging)和生產(chǎn)（production）。它非常類似于Git中的版本系統(tǒng)。

注冊模型有四種方式：

1、通過UI
2、作為“MLflow.<flavor>.log_model()”的參數(shù)方式
3、使用“MLflow.register_model()”方法或
4、使用“create_registered_model()”客戶端API。

使用“MLflow.<flavor>.log_model()”方法注冊模型：

with MLflow.start_run():

   model = DecisionTreeModel(max_depth=max_depth)
   model.load_data()
   model.train()
   model.evaluate()

   MLflow.log_param("tree_depth", max_depth)
   MLflow.log_metric("precision", model.precision)
   MLflow.log_metric("recall", model.recall)
   MLflow.log_metric("accuracy", model.accuracy)

   # Register the model 比model 保存多了個registered_model_name參數(shù)
   MLflow.sklearn.log_model(model.tree, "MyModel-dt",      registered_model_name="Decision Tree")

如果是新模型，MLFlow將其初始化為版本1。如果模型已進行版本控制，則將其初始化成版本2（或后續(xù)版本）。

默認情況下，注冊模型時，分配的狀態(tài)為“無”。要將狀態(tài)分配給已注冊模型，可以通過以下方式執(zhí)行

client = MLflowClient()
client.transition_model_version_stage(
    name="Decision Tree",
    version=2,
    stage="Staging"
)

在上面的代碼片段中，版本2的模型被分配給模擬環(huán)境(staging)。

image.png

使用MLflowCLI實現(xiàn)模型服務(wù)。需要服務(wù)器URI、模型名稱和模型狀態(tài)這些信息即可，如下所示：

$ export MLflow_TRACKING_URI=http://10.0.102.50:15000
$ mlflow models serve -m "models:/model-v1/Staging"

Mlflow Recipes

核心概念

Templates:

一個mlflow工作流編排的工程模板目錄，里面包含了 配置文件模板recipes.yaml , profile，執(zhí)行步驟的代碼等數(shù)據(jù)文件。用戶開發(fā)一個mlflow工作流可以參考templates的目錄結(jié)構(gòu)進行修改，官方提供了一個mlflow recipes模板，參考github地址 recipes-regression-template。

模板工程的目錄組成：

recipes-regression-template
|-- LICENSE
|-- notebooks               # 工作流編排文件，支持python和java兩種api
|   |-- databricks.py
|   `-- jupyter.ipynb
|-- profiles
|   |-- databricks.yaml     # 存放profile實例，運行一個工作流時選擇一個profile來填充 recipes.yaml 模板配置文件的參數(shù)
|   `-- local.yaml
|-- README.md
|-- recipe.yaml             # 模板配置文件，定義recipes的基本信息： steps，name等
|-- requirements            
|   |-- lint-requirements.txt
|   `-- test-requirements.txt
|-- requirements.txt        # 運行一個recipes需要的 環(huán)境依賴信息
|-- steps                   # 工作流步驟對應(yīng)的代碼存放處
|   |-- custom_metrics.py
|   |-- ingest.py
|   |-- split.py
|   |-- train.py
|   `-- transform.py
`-- tests                   # 單元測試
    |-- __init__.py
    |-- train_test.py
     `-- transform_test.py

Recipes:

編排工作流的核心，提供了python和java兩種編程語言的SDK。開發(fā)者通過編寫代碼實現(xiàn)一套工作流程，因此十分容易拓展。編排代碼存放到notebooks目錄。

# 準備環(huán)境依賴：requirements.txt
dbutils.library.restartPython()

from mlflow.recipes import Recipe
# 指定profile，填充recipes模板參數(shù)
r = Recipe(profile="databricks")
# 生成dag可視化數(shù)據(jù)供UI解析
r.inspect()

# 執(zhí)行步驟 ingest
r.run("ingest")

# 執(zhí)行步驟 split
r.run("split")

training_data = r.get_artifact("training_data")
training_data.describe()

# 執(zhí)行步驟 transform
r.run("transform")

# 執(zhí)行步驟 train
r.run("train")

trained_model = r.get_artifact("model")
print(trained_model)

# 執(zhí)行步驟，評估模型
r.run("evaluate")

# 執(zhí)行步驟，注冊模型
r.run("register")

step

表示工作流程中的一個步驟，即DAG 中的一個節(jié)點。

Profiles

工作流配置文件 recipes.yaml 是一個模板，yaml文件可以通過占位符的方式定義參數(shù)，參數(shù)的值在運行工作流時通過profile注入，profile通過yaml格式編寫。

from mlflow.recipes import Recipe
# 指定profile，填充recipes模板參數(shù)
r = Recipe(profile="databricks")

可視化

通過調(diào)用函數(shù) Recipe.inspect() 來生成DAG數(shù)據(jù)，供UI解析