MLflow modellerini çevrimiçi uç noktalara dağıtma

Makale
02/01/2024

ŞUNUN IÇIN GEÇERLIDIR: Azure CLI ml uzantısı v2 (geçerli)

Bu makalede, gerçek zamanlı çıkarım için MLflow modelinizi çevrimiçi bir uç noktaya dağıtmayı öğrenin. MLflow modelinizi çevrimiçi bir uç noktaya dağıtırken puanlama betiği veya ortam belirtmeniz gerekmez; bu işlev kod içermeyen dağıtım olarak bilinir.

Kod içermeyen dağıtım için Azure Machine Learning:

Dosyada conda.yaml sağlanan Python paketlerini dinamik olarak yükler. Bu nedenle, bağımlılıklar kapsayıcı çalışma zamanı sırasında yüklenir.
Aşağıdaki öğeleri içeren bir MLflow temel görüntüsü/seçilmiş ortam sağlar:
- azureml-inference-server-http
- mlflow-skinny
- Çıkarım için puanlama betiği.

İpucu

Genel ağ erişimi olmayan çalışma alanları: Çıkış bağlantısı olmadan MLflow modellerini çevrimiçi uç noktalara dağıtabilmeniz için önce modelleri paketlemeniz (önizleme) gerekir. Model paketlemeyi kullanarak, Azure Machine Learning'in MLflow modelleri için gerekli Python paketlerini dinamik olarak yüklemesini gerektireceği bir İnternet bağlantısı gereksiniminden kaçınabilirsiniz.

Örnek hakkında

Örnek, tahmin gerçekleştirmek için bir MLflow modelini çevrimiçi uç noktaya nasıl dağıtabileceğinizi gösterir. Örnek, Diabetes veri kümesini temel alan bir MLflow modeli kullanır. Bu veri kümesi 10 temel değişken içerir: yaş, cinsiyet, vücut kitle dizini, ortalama kan basıncı ve 442 diyabet hastasından elde edilen altı kan serumu ölçümü. Ayrıca, temelden bir yıl sonra hastalığın ilerlemesinin nicel bir ölçüsü olan ilginin yanıtını içerir.

Model bir scikit-learn regresör kullanılarak eğitildi ve gerekli tüm ön işleme bir işlem hattı olarak paketlendi ve bu modeli ham verilerden tahminlere giden uçtan uca bir işlem hattı haline getirdi.

Bu makaledeki bilgiler, azureml-examples deposunda yer alan kod örneklerini temel alır. YAML ve diğer dosyaları kopyalamak/yapıştırmak zorunda kalmadan komutları yerel olarak çalıştırmak için depoyu kopyalayın ve ardından Azure CLI kullanıyorsanız dizinleri olarak clideğiştirin. Python için Azure Machine Learning SDK'sını kullanıyorsanız dizinleri olarak sdk/python/endpoints/online/mlflowdeğiştirin.

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Jupyter Notebook'ta takip edin

Kopyalanan depoda MLflow modelini çevrimiçi uç noktalara dağıtma not defterini açarak Azure Machine Learning Python SDK'sını kullanma adımlarını izleyebilirsiniz.

Önkoşullar

Bu makaledeki adımları takip etmeden önce aşağıdaki önkoşullara sahip olduğunuzdan emin olun:

Azure aboneliği. Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun. Azure Machine Learning'in ücretsiz veya ücretli sürümünü deneyin.
Azure Machine Learning’deki işlemlere erişim vermek için Azure rol tabanlı erişim denetimleri (Azure RBAC) kullanılır. Bu makaledeki adımları gerçekleştirmek için kullanıcı hesabınıza Azure Machine Learning çalışma alanı için sahip veya katkıda bulunan rolü ya da izin veren Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*özel bir rol atanmalıdır. Roller hakkında daha fazla bilgi için bkz . Azure Machine Learning çalışma alanına erişimi yönetme.
Çalışma alanınızda kayıtlı bir MLflow modeli olmalıdır. Bu makalede, çalışma alanındaki Diabetes veri kümesi için eğitilmiş bir model kaydedilir.
Ayrıca şunları yapmanız gerekir:
- Azure CLI'yi ve ml Azure CLI uzantısını yükleyin. CLI'yı yükleme hakkında daha fazla bilgi için bkz . CLI'yi (v2) yükleme ve ayarlama.
- Python için Azure Machine Learning SDK'sını yükleyin.
```
pip install azure-ai-ml azure-identity
```
- MLflow SDK paketini mlflow ve MLflow azureml-mlflowiçin Azure Machine Learning eklentisini yükleyin.
```
pip install mlflow azureml-mlflow
```
- Azure Machine Learning işlemde kod çalıştırmıyorsanız, MLflow izleme URI'sini veya MLflow'un kayıt defteri URI'sini üzerinde çalıştığınız Azure Machine Learning çalışma alanını işaret eden şekilde yapılandırın. MLflow'u çalışma alanına bağlama hakkında daha fazla bilgi için bkz . Azure Machine Learning için MLflow'u yapılandırma.
Azure Machine Learning stüdyosu çalışırken ek önkoşul yoktur.

Çalışma alanınıza bağlanma

İlk olarak, çalışacağınız Azure Machine Learning çalışma alanına bağlanın.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Çalışma alanı Azure Machine Learning'in en üst düzey kaynağıdır. Azure Machine Learning'i kullanırken oluşturduğunuz tüm yapıtlarla çalışmak için merkezi bir konum sağlar. Bu bölümde, dağıtım görevlerini gerçekleştirebileceğiniz çalışma alanına bağlanın.

Gerekli kitaplıkları içeri aktarın:

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
CodeConfiguration,
)
from azure.identity import DefaultAzureCredential
from azure.ai.ml.constants import AssetTypes

Çalışma alanı ayrıntılarını yapılandırın ve çalışma alanına bir tanıtıcı alın:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Gerekli kitaplıkları içeri aktarma

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client
from mlflow.tracking import MlflowClient

MLflow istemcisini başlatma
```
mlflow_client = MlflowClient()
```

Dağıtım istemcisini yapılandırma

deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Modeli kaydedin

Yalnızca kayıtlı modelleri çevrimiçi uç noktalara dağıtabilirsiniz. Bu durumda, depoda modelin yerel bir kopyası zaten vardır, bu nedenle modeli yalnızca çalışma alanında kayıt defterinde yayımlamanız gerekir. Dağıtmaya çalıştığınız model zaten kayıtlıysa bu adımı atlayabilirsiniz.

MODEL_NAME='sklearn-diabetes'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "endpoints/online/ncd/sklearn-diabetes/model"

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"
model = ml_client.models.create_or_update(
        Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Modeliniz çalıştırmanın içinde günlüğe kaydedildiyse ne olur?

Modeliniz bir çalıştırmanın içinde günlüğe kaydedildiyse doğrudan kaydedebilirsiniz.

Modeli kaydetmek için depolandığı konumu bilmeniz gerekir. MLflow'un autolog özelliğini kullanıyorsanız modelin yolu model türüne ve çerçevesine bağlıdır. Modelin klasörünün adını belirlemek için işlerin çıkışını denetlemeniz gerekir. Bu klasör adlı MLModelbir dosya içerir.

Modellerinizi el ile günlüğe kaydetmek için yöntemini kullanıyorsanız log_model , yöntemin bağımsız değişkeni olarak modelin yolunu geçirin. Örneğin, kullanarak modeli günlüğe kaydederseniz, mlflow.sklearn.log_model(my_model, "classifier")modelin depolandığı yol olarak adlandırılır classifier.

Eğitim işi çıkışından model oluşturmak için Azure Machine Learning CLI v2'yi kullanın. Aşağıdaki örnekte, adlı $MODEL_NAME model kimliğine $RUN_IDsahip bir işin yapıtları kullanılarak kaydedilir. Modelin depolandığı yol şeklindedir $MODEL_PATH.

az ml model create --name $MODEL_NAME --path azureml://jobs/$RUN_ID/outputs/artifacts/$MODEL_PATH

Not

Yol $MODEL_PATH , modelin çalıştırmada depolandığı konumdur.

model_name = 'sklearn-diabetes'

ml_client.models.create_or_update(
    Model(
        path=f"azureml://jobs/{RUN_ID}/outputs/artifacts/{MODEL_PATH}"
        name=model_name,
        type=AssetTypes.MLFLOW_MODEL
    )
)

Not

Yol MODEL_PATH , modelin çalıştırmada depolandığı konumdur.

model_name = 'sklearn-diabetes'

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"runs://{RUN_ID}/{MODEL_PATH}"
)
version = registered_model.version

Not

Yol MODEL_PATH , modelin çalıştırmada depolandığı konumdur.

Çevrimiçi uç noktaya MLflow modeli dağıtma

Modelin dağıtılacağı uç noktayı yapılandırın. Aşağıdaki örnekte uç noktanın adı ve kimlik doğrulama modu yapılandırılır:

Aşağıdaki komutu çalıştırarak bir uç nokta adı ayarlayın (değerini benzersiz bir adla değiştirin YOUR_ENDPOINT_NAME ):

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Uç noktayı yapılandırın:

create-endpoint.yaml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An online endpoint to generate predictions for the diabetes dataset",
    auth_mode="key",
    tags={"foo": "bar"},
)

Bir yapılandırma dosyası kullanarak bu uç noktanın özelliklerini yapılandırabilirsiniz. Bu durumda, uç noktanın kimlik doğrulama modunu "anahtar" olacak şekilde yapılandırıyorsunuz.


# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Bu yapılandırmayı bir JSON dosyaya yazın:

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Uç noktayı oluşturun:

az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/ncd/create-endpoint.yaml

ml_client.begin_create_or_update(endpoint)

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Dağıtımı yapılandırın. Dağıtım, gerçek çıkarım yapan modeli barındırmak için gereken bir kaynak kümesidir.
sklearn-deployment.yaml
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-deployment
endpoint_name: my-endpoint
model:
  name: mir-sample-sklearn-ncd-model
  version: 1
  path: sklearn-diabetes/model
  type: mlflow_model
instance_type: Standard_DS3_v2
instance_count: 1
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1
)
```
Alternatif olarak, uç noktanızın çıkış bağlantısı yoksa, bağımsız değişkenini with_package=Trueekleyerek model paketlemeyi (önizleme) kullanın:
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
    with_package=True,
)
```
```
blue_deployment_name = "blue"
```
Dağıtımınızın donanım gereksinimlerini yapılandırmak için istenen yapılandırmaya sahip bir JSON dosyası oluşturun:
```
deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}
```
Not

Bu yapılandırmanın tam belirtimi hakkında ayrıntılı bilgi için bkz . Yönetilen çevrimiçi dağıtım şeması (v2).

Yapılandırmayı bir dosyaya yazın:
```
deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))
```
Bu adımı dağıtım aşamasında gerçekleştireceksiniz.
Not

ve environment öğesinin otomatik olarak yenilenmesi scoring_script yalnızca model aroması için pyfunc desteklenir. Farklı bir model türü kullanmak için bkz . MLflow modeli dağıtımlarını özelleştirme.
Dağıtımı oluşturun:
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
Uç noktanızın çıkış bağlantısı yoksa, bayrağını --with-packageekleyerek model paketlemeyi (önizleme) kullanın:
```
az ml online-deployment create --with-package --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
ml_client.online_deployments.begin_create_or_update(blue_deployment)
```
```
blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)    
```
1. Uç Noktalar sayfasında Gerçek zamanlı uç noktalar sekmesinde Oluştur'useçin.
2. Daha önce kaydettiğiniz MLflow modelini ve ardından Seç düğmesini seçin.
  
  Not
  
  Yapılandırma sayfası, puanlama betiğinin ve ortamın seçtiğiniz MLflow modeli için otomatik olarak oluşturulduğunu bildiren bir not içerir.
3. Yeni bir uç noktaya dağıtmak için Yeni'yi seçin.
4. Uç nokta ve dağıtım için bir ad sağlayın veya varsayılan adları koruyun.
5. Modeli uç noktaya dağıtmak için Dağıt'ı seçin.
Tüm trafiği dağıtıma atayın. Şu ana kadar uç noktanın tek bir dağıtımı var, ancak trafiğinden hiçbiri bu dağıtıma atanmadı.
Oluşturma sırasında bayrağını kullandığınızdan --all-traffic , içinde bu adım Azure CLI'da gerekli değildir. Trafiği değiştirmeniz gerekiyorsa komutunu az ml online-endpoint update --traffickullanabilirsiniz. Trafiği güncelleştirme hakkında daha fazla bilgi için bkz . Trafiği aşamalı olarak güncelleştirme.
```
endpoint.traffic = {"blue": 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Yapılandırmayı bir dosyaya yazın:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
içindeki bu adım, stüdyoda gerekli değildir.
Uç nokta yapılandırmasını güncelleştirin:
Oluşturma sırasında bayrağını kullandığınızdan --all-traffic , içinde bu adım Azure CLI'da gerekli değildir. Trafiği değiştirmeniz gerekiyorsa komutunu az ml online-endpoint update --traffickullanabilirsiniz. Trafiği güncelleştirme hakkında daha fazla bilgi için bkz . Trafiği aşamalı olarak güncelleştirme.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```
içindeki bu adım, stüdyoda gerekli değildir.

Uç noktayı çağırma

Dağıtımınız hazır olduktan sonra isteği sunmak için bunu kullanabilirsiniz. Dağıtımı test etmenin bir yolu, kullandığınız dağıtım istemcisindeki yerleşik çağırma özelliğini kullanmaktır. Aşağıdaki JSON, dağıtım için örnek bir istektir.

sample-request-sklearn.json

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Not

input_data , MLflow sunmada bunun yerine inputs bu örnekte kullanılır. Bunun nedeni, Azure Machine Learning'in uç noktalar için swagger sözleşmelerini otomatik olarak oluşturabilmesi için farklı bir giriş biçimi gerektirmesidir. Beklenen giriş biçimleri hakkında daha fazla bilgi için bkz . Azure Machine Learning'de dağıtılan modeller ile MLflow yerleşik sunucusu arasındaki farklar.

Uç noktaya aşağıdaki gibi bir istek gönderin:

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample-request-sklearn.json",
)

# Read the sample request that's in the json file to construct a pandas data frame
with open("sample-request-sklearn.json", "r") as f:
    sample_request = json.loads(f.read())
    samples = pd.DataFrame(**sample_request["input_data"])

deployment_client.predict(endpoint=endpoint_name, df=samples)

Yanıt aşağıdaki metne benzer olacaktır:

[ 
  11633.100167144921,
  8522.117402884991
]

Önemli

MLflow no-code dağıtımı için yerel uç noktalar üzerinden test şu anda desteklenmemektedir.

MLflow modeli dağıtımlarını özelleştirme

MLflow modelinin dağıtım tanımında çevrimiçi uç noktaya puanlama betiği belirtmeniz gerekmez. Ancak bunu yapmayı tercih edebilir ve çıkarımların nasıl yürütüleceğini özelleştirebilirsiniz.

Genellikle aşağıdaki durumlarda MLflow modeli dağıtımınızı özelleştirmek istersiniz:

Modelin üzerinde bir PyFunc çeşit yoktur.
Örneğin, kullanarak modeli yüklemek için belirli bir çeşit kullanmak için modelin mlflow.<flavor>.load_model()çalışma şeklini özelleştirmeniz gerekir.
Modelin kendisi tarafından yapılmadığında puanlama yordamınızda ön/son işlem yapmanız gerekir.
Modelin çıkışı tablosal verilerde düzgün bir şekilde temsil edilemiyor. Örneğin, bir görüntüyü temsil eden bir tensor.

Önemli

MLflow modeli dağıtımı için puanlama betiği belirtmeyi seçerseniz, dağıtımın çalıştırılacağı ortamı da belirtmeniz gerekir.

Adımlar

Özel puanlama betiğiyle bir MLflow modeli dağıtmak için:

MLflow modelinizin bulunduğu klasörü tanımlayın.

a. Azure Machine Learning stüdyosu gidin.

b. Modeller bölümüne gidin.

c. Dağıtmaya çalıştığınız modeli seçin ve Yapıtlar sekmesine gidin.

d. Görüntülenen klasörü not alın. Model kaydedildiğinde bu klasör belirtildi.

Puanlama betiği oluşturun. Daha önce tanımladığınız klasör adının model işleve init() nasıl dahil olduğuna dikkat edin.

İpucu

Aşağıdaki puanlama betiği, MLflow modeliyle çıkarım gerçekleştirme hakkında bir örnek olarak verilmiştir. Bu betiği ihtiyaçlarınıza uyarlayabilir veya senaryonuzu yansıtacak şekilde bölümlerini değiştirebilirsiniz.

score.py

import logging
import os
import json
import mlflow
from io import StringIO
from mlflow.pyfunc.scoring_server import infer_and_parse_json_input, predictions_to_json


def init():
    global model
    global input_schema
    # "model" is the path of the mlflow artifacts when the model was registered. For automl
    # models, this is generally "mlflow-model".
    model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model")
    model = mlflow.pyfunc.load_model(model_path)
    input_schema = model.metadata.get_input_schema()


def run(raw_data):
    json_data = json.loads(raw_data)
    if "input_data" not in json_data.keys():
        raise Exception("Request must contain a top level key named 'input_data'")

    serving_input = json.dumps(json_data["input_data"])
    data = infer_and_parse_json_input(serving_input, input_schema)
    predictions = model.predict(data)

    result = StringIO()
    predictions_to_json(predictions, result)
    return result.getvalue()

Uyarı

MLflow 2.0 önerisi: Sağlanan puanlama betiği hem MLflow 1.X hem de MLflow 2.X ile çalışır. Ancak, bu sürümlerde beklenen giriş/çıkış biçimlerinin farklılık gösterebileceğini unutmayın. Beklenen MLflow sürümünü kullandığınızdan emin olmak için kullanılan ortam tanımını denetleyin. MLflow 2.0'ın yalnızca Python 3.8+'da desteklendiğine dikkat edin.

Puanlama betiğinin yürütülebileceği bir ortam oluşturun. Model bir MLflow modeli olduğundan, conda gereksinimleri de model paketinde belirtilir. MLflow modelinde yer alan dosyalar hakkında daha fazla ayrıntı için bkz . MLmodel biçimi. Ardından, dosyadaki conda bağımlılıklarını kullanarak ortamı oluşturacaksınız. Ancak, Azure Machine Learning'deki çevrimiçi dağıtımlar için gerekli olan paketini azureml-inference-server-httpde eklemeniz gerekir.

Conda tanım dosyası aşağıdaki gibidir:

conda.yml
```
channels:
- conda-forge
dependencies:
- python=3.9
- pip
- pip:
  - mlflow
  - scikit-learn==1.2.2
  - cloudpickle==2.2.1
  - psutil==5.9.4
  - pandas==2.0.0
  - azureml-inference-server-http
name: mlflow-env
```
Not

Paket azureml-inference-server-http özgün conda bağımlılıkları dosyasına eklendi.

Ortamı oluşturmak için bu conda bağımlılıkları dosyasını kullanacaksınız:
Ortam, dağıtım yapılandırmasında satır içinde oluşturulur.
```
environment = Environment(
    conda_file="sklearn-diabetes/environment/conda.yml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
)
```
Bu işlem MLflow SDK'sında desteklenmez
1. Yan menüde Ortamlar sekmesine gidin.
2. Özel ortamlar>Oluştur sekmesini seçin.
3. Bu örnekte sklearn-mlflow-online-py37ortamın adını girin.
4. Ortam kaynağı seç için Mevcut docker görüntüsünü isteğe bağlı conda dosyasıyla kullan'ı seçin.
5. Kapsayıcı kayıt defteri görüntü yolu için girinmcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04.
6. Özelleştir bölümüne gitmek için İleri'yi seçin.
7. Dosyanın içeriğini sklearn-diabetes/environment/conda.yml kopyalayın ve metin kutusuna yapıştırın.
8. İleri'yi seçerek Etiketler sayfasına gidin ve sonra yeniden İleri'yi seçin.
9. Gözden Geçir sayfasında Oluştur'u seçin. Ortam kullanıma hazırdır.
Dağıtımı oluşturun:
Deployment.yml bir dağıtım yapılandırma dosyası oluşturun:
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-diabetes-custom
endpoint_name: my-endpoint
model: azureml:sklearn-diabetes@latest
environment: 
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
  conda_file: sklearn-diabetes/environment/conda.yml
code_configuration:
  code: sklearn-diabetes/src
  scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1
```
Dağıtımı oluşturun:
```
az ml online-deployment create -f deployment.yml
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    environment=environment,
    code_configuration=CodeConfiguration(
        code="sklearn-diabetes/src",
        scoring_script="score.py"
    ),
    instance_type="Standard_F4s_v2",
    instance_count=1,
)
```
Bu işlem MLflow SDK'sında desteklenmez
1. Uç Noktalar sayfasında +Oluştur'u seçin.
2. Daha önce kaydettiğiniz MLflow modelini seçin.
3. Gelişmiş seçenekleri açmak için uç nokta oluşturma sihirbazında Diğer seçenekler'i seçin.
4. Uç nokta için bir ad ve kimlik doğrulama türü sağlayın ve ardından seçtiğiniz modelin dağıtımınız için kullanıldığını görmek için İleri'yi seçin.
5. _Deployment sayfasına devam etmek için İleri'yi seçin.
6. Kod + ortam sayfasına gitmek için İleri'yi seçin. MLflow biçiminde kayıtlı bir modeli seçtiğinizde, bu sayfada bir puanlama betiği veya ortam belirtmeniz gerekmez. Ancak, bu bölümde bir tane belirtmek istiyorsunuz
7. Ortamı özelleştir ve puanlama betiğinin yanındaki kaydırıcıyı seçin.
8. Daha önce oluşturduğunuz puanlama betiğini seçmek için göz atın.
9. Ortam türü için Özel ortamlar'ı seçin.
10. Daha önce oluşturduğunuz özel ortamı seçin ve İleri'yi seçin.
11. Modeli uç noktaya dağıtmak için sihirbazı tamamlayın.
Dağıtımınız tamamlandıktan sonra isteklere hizmet etmeye hazır olur. Dağıtımı test etmenin bir yolu, yöntemiyle birlikte örnek bir istek dosyası kullanmaktır invoke .

sample-request-sklearn.json
```
{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}
```
Uç noktaya aşağıdaki gibi bir istek gönderin:
```
az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json
```
```
ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    request_file="sample-request-sklearn.json",
)
```
Bu işlem MLflow SDK'sında desteklenmez
1. Uç Noktalar sekmesine gidin ve oluşturulan yeni uç noktayı seçin.
2. Test sekmesine gidin.
3. Test uç noktası kutusuna sample-request-sklearn.json dosyanın içeriğini Giriş verileri kutusuna yapıştırın.
4. Test'i seçin.
5. Tahminler, kutunun sağ tarafındaki "Test sonuçları" altında gösterilir.
Yanıt aşağıdaki metne benzer olacaktır:
```
{
  "predictions": [ 
    11633.100167144921,
    8522.117402884991
  ]
}
```
Uyarı

MLflow 2.0 önerisi: MLflow 1.X'te predictions anahtar eksik olacaktır.

Kaynakları temizleme

Uç noktayı kullanmayı bitirdikten sonra ilişkili kaynaklarını silin:

az ml online-endpoint delete --name $ENDPOINT_NAME --yes

ml_client.online_endpoints.begin_delete(endpoint_name)

deployment_client.delete_endpoint(endpoint_name)