Shromažďování produkčních dat z modelů pro odvozování v reálném čase

PLATÍ PRO:Rozšíření Azure CLI ml v2 (aktuální)Python SDK azure-ai-ml v2 (aktuální)

V tomto článku se dozvíte, jak pomocí kolektoru dat Azure Machine Learning protokolovat produkční odvozování dat z modelu nasazeného do spravovaného online koncového bodu nebo online koncového bodu Kubernetes. Shromažďování dat můžete povolit pro nová nebo existující nasazení.

Návod

Pokud nasazujete model MLflow, přečtěte si téma Shromažďování dat pro modely MLflow pro zjednodušené nastavení jedním kliknutím.

Rozhraní příkazového řádku Azure a rozšíření ml pro Azure CLI, nainstalované a nakonfigurované. Další informace najdete v tématu Instalace a nastavení rozhraní příkazového řádku (v2).
Prostředí Bash nebo kompatibilní prostředí, například prostředí v systému Linux nebo subsystému Windows pro Linux. Příklady Azure CLI v tomto článku předpokládají, že používáte tento typ shellu.
Pracovní prostor služby Azure Machine Learning. Pokyny k vytvoření pracovního prostoru najdete v tématu Nastavení.

Jedna z následujících rolí Azure RBAC pro pracovní prostor Azure Machine Learning:
- Owner
- Contributor
- Vlastní role, která umožňuje Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
Další informace najdete v tématu Správa přístupu k pracovnímu prostoru Azure Machine Learning.

Pracovní prostor služby Azure Machine Learning. Postup vytvoření pracovního prostoru najdete v tématu Vytvoření pracovního prostoru.
Sada nástrojů Azure Machine Learning SDK pro Python, verze 2 K instalaci sady SDK použijte následující příkaz:
```
pip install azure-ai-ml azure-identity
```
Pokud chcete aktualizovat existující instalaci sady SDK na nejnovější verzi, použijte následující příkaz:
```
pip install --upgrade azure-ai-ml azure-identity
```
Další informace najdete v klientské knihovně balíčku Azure Machine Learning pro Python.

Jedna z následujících rolí Azure RBAC pro pracovní prostor Azure Machine Learning:
- Owner
- Contributor
- Vlastní role, která umožňuje Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
Další informace najdete v tématu Správa přístupu k pracovnímu prostoru Azure Machine Learning.

Registrovaný model, který můžete použít pro nasazení. Pokud nemáte zaregistrovaný model, přečtěte si téma Registrace modelu jako prostředku ve službě Machine Learning.
Online koncový bod služby Azure Machine Learning Pokud nemáte existující online koncový bod, přečtěte si téma Nasazení a hodnocení modelu strojového učení pomocí online koncového bodu.

Nastavení vlastního protokolování pro monitorování modelů

Vlastní protokolování umožňuje protokolovat datové rámce pandas přímo ze skriptu vyhodnocování před, během a po všech transformacích dat. Tabulková data se protokolují v reálném čase do služby Blob Storage pracovního prostoru nebo do vlastního kontejneru Blob Storage pro účely monitorování modelů.

Aktualizace hodnoticího skriptu vlastním kódem protokolování

Přidejte vlastní kód protokolování do hodnoticího skriptu (score.py). Nainstalujte balíček azureml-ai-monitoring. Další informace o konceptech shromažďování dat najdete v tématu Shromažďování dat z modelů v produkčním prostředí.

azureml-ai-monitoring Naimportujte balíček přidáním následujícího řádku do horní části hodnoticího skriptu:
```
from azureml.ai.monitoring import Collector
```
Deklarujte proměnné shromažďování dat (až pět z nich) ve vaší init() funkci:

Poznámka:

Pokud používáte názvy model_inputs a model_outputs pro své Collector objekty, systém monitorování modelů automaticky rozpozná automaticky registrované datové prostředky, aby poskytoval plynulejší zážitek z monitorování modelu.
```
global inputs_collector, outputs_collector
inputs_collector = Collector(name='model_inputs')          
outputs_collector = Collector(name='model_outputs')
```
Azure Machine Learning ve výchozím nastavení vyvolá výjimku, pokud během shromažďování dat dojde k chybě. Volitelně můžete pomocí parametru on_error určit funkci, která se má spustit, pokud dojde k selhání protokolování. Následující kód například pomocí parametru on_error určí, že azure Machine Learning by měl chybu protokolovat místo vyvolání výjimky:
```
inputs_collector = Collector(name='model_inputs', on_error=lambda e: logging.info("ex:{}".format(e)))
```
Ve své run() funkci použijte collect() funkci k protokolování datových rámců před a po vyhodnocení. Vrátí se context z prvního volání collect()a obsahuje informace, které korelují vstupy modelu a výstupy modelu později.
```
context = inputs_collector.collect(data) 
result = model.predict(data)
outputs_collector.collect(result, context)
```
Poznámka:

collect() V současné době rozhraní API protokoluje pouze datové rámce pandas. Pokud data nejsou ve formátu DataFrame, když jsou předána collect(), neuloží se do úložiště a zobrazí se chyba.

Následující kód je příkladem úplného hodnoticího skriptu (score.py), který používá vlastní protokolování sady Python SDK.

import pandas as pd
import json
from azureml.ai.monitoring import Collector

def init():
  global inputs_collector, outputs_collector, inputs_outputs_collector

  # instantiate collectors with appropriate names, make sure align with the deployment spec.
  inputs_collector = Collector(name='model_inputs')                    
  outputs_collector = Collector(name='model_outputs')

def run(data): 
  # json data: { "data" : {  "col1": [1,2,3], "col2": [2,3,4] } }
  pdf_data = preprocess(json.loads(data))
  
  # tabular data: {  "col1": [1,2,3], "col2": [2,3,4] }
  input_df = pd.DataFrame(pdf_data)

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df)

  # Perform scoring with a pandas Dataframe. Return value is also a pandas Dataframe.
  output_df = predict(input_df) 

  # collect outputs data, pass in correlation_context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)
  
  return output_df.to_dict()
  
def preprocess(json_data):
  # preprocess the payload to ensure it can be converted to pandas DataFrame
  return json_data["data"]

def predict(input_df):
  # process input and return with outputs
  ...
  
  return output_df

Když koncový bod přijme požadavky, protokolují se DataFramy model_inputs a model_outputs do úložiště objektů blob vašeho pracovního prostoru. Data se automaticky zaregistrují jako datový prostředek pro monitorování modelu.

Referenční informace:Shromažďování dat z modelů v produkčním prostředí

Aktualizace hodnoticího skriptu pro protokolování vlastních jedinečných ID

Kromě protokolování datových rámců pandas přímo v bodovacím skriptu můžete data protokolovat s jedinečnými ID podle vašeho výběru. Tato ID můžou pocházet z vaší aplikace nebo z externího systému nebo je můžete vygenerovat. Pokud nezadáte vlastní ID, jak je popsáno v této části, kolektor dat automaticky vygeneruje jedinečnou vlastnost correlationid , která vám pomůže korelovat vstupy a výstupy modelu později. Pokud zadáte vlastní ID, correlationid bude pole v protokolovaných datech obsahovat hodnotu zadaného vlastního ID.

Nejprve proveďte kroky v předchozí části. Potom balíček naimportujte azureml.ai.monitoring.context přidáním následujícího řádku do hodnoticího skriptu:
```
from azureml.ai.monitoring.context import BasicCorrelationContext
```
Ve skriptu bodování instanciujte objekt BasicCorrelationContext a zadejte id pro tento řádek, který chcete protokolovat. Doporučujeme, aby se jedná id o jedinečné ID z vašeho systému, abyste mohli jednoznačně identifikovat každý zaprotokolovaný řádek ze služby Blob Storage. Předejte tento objekt do collect() volání rozhraní API jako parametr:
```
  # create a context with a custom unique ID
  artificial_context = BasicCorrelationContext(id='test')

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df, artificial_context)
```
Ujistěte se, že kontext předáte do svého outputs_collector modelu tak, aby vstupy a výstupy modelu měly stejné jedinečné ID, které se s nimi zaprotokoluje, a je možné je později snadno korelovat:
```
  # collect outputs data, pass in context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)
```

Následující kód je příkladem úplného hodnoticího skriptu (score.py), který protokoluje vlastní jedinečná ID.

import pandas as pd
import json
from azureml.ai.monitoring import Collector
from azureml.ai.monitoring.context import BasicCorrelationContext

def init():
  global inputs_collector, outputs_collector, inputs_outputs_collector

  # instantiate collectors with appropriate names, make sure align with deployment spec
  inputs_collector = Collector(name='model_inputs')                    
  outputs_collector = Collector(name='model_outputs')

def run(data): 
  # json data: { "data" : {  "col1": [1,2,3], "col2": [2,3,4] } }
  pdf_data = preprocess(json.loads(data))
  
  # tabular data: {  "col1": [1,2,3], "col2": [2,3,4] }
  input_df = pd.DataFrame(pdf_data)

  # create a context with a custom unique ID
  artificial_context = BasicCorrelationContext(id='test')

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df, artificial_context)

  # Perform scoring with a pandas Dataframe. Return value is also a pandas Dataframe.
  output_df = predict(input_df) 

  # collect outputs data, pass in context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)
  
  return output_df.to_dict()
  
def preprocess(json_data):
  # preprocess the payload to ensure it can be converted to pandas DataFrame
  return json_data["data"]

def predict(input_df):
  # process input and return with outputs
  ...
  
  return output_df

Shromažďování dat pro monitorování výkonu modelu

Pokud chcete použít shromážděná data pro monitorování výkonu modelu, je důležité, aby každý protokolovaný řádek byl jedinečný correlationid , který se dá použít ke korelaci dat s podkladovými pravdivými daty, pokud jsou tato data k dispozici. Kolektor dat automaticky vygeneruje jedinečný correlationid pro každý protokolovaný řádek a zahrne toto automaticky generované ID do correlationid pole v objektu JSON. Další informace o schématu JSON najdete v tématu Ukládání shromážděných dat ve službě Blob Storage.

Pokud chcete pro protokolování s produkčními daty použít vlastní jedinečné ID, doporučujeme toto ID protokolovat jako samostatný sloupec v rámci pandas, protože kolektor dat zpracovává dávkové požadavky, které jsou blízko sebe. Pokud protokolujete correlationid jako samostatný sloupec, bude snadno dostupný v další fázi pro integraci s ověřenými referenčními daty.

Aktualizace závislostí

Než budete moct vytvořit nasazení pomocí aktualizovaného bodovacího skriptu, musíte vytvořit prostředí se základní imagí mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04 a odpovídajícími závislostmi conda. Potom můžete prostředí sestavit pomocí specifikace v následujícím JAZYCE YAML.

channels:
  - conda-forge
dependencies:
  - python=3.10
  - pip
  - pip:
      - azureml-defaults
      - azureml-ai-monitoring
name: model-env

Aktualizace YAML nasazení

Dále vytvoříte YAML nasazení. Pokud chcete vytvořit YAML nasazení, zahrňte data_collector atribut a povolte shromažďování dat pro Collector objekty model_inputs a model_outputs, které jste vytvořili dříve prostřednictvím vlastního protokolování sady Python SDK:

data_collector:
  collections:
    model_inputs:
      enabled: 'True'
    model_outputs:
      enabled: 'True'

Následující kód je příkladem komplexního nasazení YAML pro spravované nasazení online koncového bodu. Podle vašeho scénáře byste měli aktualizovat YAML nasazení. Další příklady formátování souborů YAML pro nasazení a protokolování inference dat najdete v příkladech kolektoru dat modelu Azure.

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my_endpoint
model: azureml:iris_mlflow_model@latest
environment:
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
  conda_file: model/conda.yaml
code_configuration:
  code: scripts
  scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1
data_collector:
  collections:
    model_inputs:
      enabled: 'True'
    model_outputs:
      enabled: 'True'

Volitelně můžete upravit následující dodatečné parametry:data_collector

data_collector.rolling_rate: Rychlost rozdělení dat do úložiště. Vyberte z hodnot Minute, , HourDay, Montha Year.
data_collector.sampling_rate: Procento, reprezentované jako desetinná sazba dat, která se mají shromáždit. Například hodnota 1.0 představuje shromažďování 100% dat.
data_collector.collections.<collection_name>.data.name: Název datového prostředku pro registraci se shromážděnými daty.
data_collector.collections.<collection_name>.data.path: Úplná cesta úložiště dat ve službě Azure Machine Learning, kde by se shromážděná data měla zaregistrovat jako datový prostředek.
data_collector.collections.<collection_name>.data.version: Verze datového prostředku, který se má zaregistrovat se shromážděnými daty ve službě Blob Storage.

Shromažďování dat do vlastního kontejneru Blob Storage

Kolektor dat můžete použít ke shromažďování produkčních inferenčních dat do vlastního kontejneru služby Blob Storage podle těchto kroků:

Připojte kontejner úložiště k úložišti dat služby Azure Machine Learning. Další informace o připojení kontejneru úložiště k úložišti dat služby Azure Machine Learning najdete v tématu vytváření úložišť dat.
Zkontrolujte, že koncový bod služby Azure Machine Learning má potřebná oprávnění k zápisu do cíle úložiště dat.

Kolektor dat podporuje spravované identity přiřazené systémem i spravované identity přiřazené uživatelem. Přidejte identitu do koncového bodu. Storage Blob Data Contributor Přiřaďte k této identitě roli s kontejnerem Blob Storage, který se má použít jako cíl dat. Informace o používání spravovaných identit v Azure najdete v tématu Přiřazení rolí Azure ke spravované identitě.
Aktualizujte YAML nasazení tak, aby zahrnovala data vlastnost v každé kolekci.
- Požadovaný parametr data.name určuje název datového assetu, který se má zaregistrovat se shromážděnými daty.
- Požadovaný parametr data.path určuje cestu k plně vytvořenému úložišti dat Azure Machine Learning, která je připojená k vašemu kontejneru Blob Storage.
- Volitelný parametr data.version určuje verzi datového assetu. (Výchozí hodnota je 1.)
Následující konfigurace YAML ukazuje příklad zahrnutí data vlastnosti do každé kolekce.
```
data_collector:
  collections:
    model_inputs:
      enabled: 'True'
      data: 
        name: my_model_inputs_data_asset
        path: azureml://datastores/workspaceblobstore/paths/modelDataCollector/my_endpoint/blue/model_inputs
        version: 1
    model_outputs:
      enabled: 'True'
      data: 
        name: my_model_outputs_data_asset
        path: azureml://datastores/workspaceblobstore/paths/modelDataCollector/my_endpoint/blue/model_outputs 
        version: 1
```
Poznámka:

Pomocí parametru data.path můžete také odkazovat na úložiště dat v různých předplatných Azure zadáním cesty, která následuje za formátem. azureml://subscriptions/<subscription_id>/resourcegroups/<resource_group_name>/workspaces/<workspace_name>/datastores/<datastore_name>/paths/<path>

Vytvoření nasazení pomocí shromažďování dat

Azure CLI
Python SDK

Nasazení modelu s povoleným vlastním protokolováním:

az ml online-deployment create -f deployment.YAML

Po dokončení nasazení ověřte, že shromažďování dat funguje vyvoláním koncového bodu:

az ml online-endpoint invoke --name my_endpoint --deployment-name blue --request-file sample-request.json

Shromážděná data proudí do vašeho pracovního úložiště Blob na adrese azureml://datastores/workspaceblobstore/paths/modelDataCollector/{endpoint_name}/{deployment_name}/.

Další informace o tom, jak formátovat YAML nasazení pro shromažďování dat pomocí online koncových bodů Kubernetes, najdete v schématu YAML pro online nasazení Kubernetes s podporou Azure Arc (v2).

Další informace o tom, jak formátovat YAML nasazení pro shromažďování dat se spravovanými online koncovými body, najdete ve schématu YAML spravovaného online nasazení CLI (v2).

Ke konfiguraci shromažďování dat při vytváření nasazení použijte tyto DataCollectorDeploymentCollection třídy:

from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
    DataCollector,
    DeploymentCollection,
)
from azure.identity import DefaultAzureCredential

# Get a handle to the workspace
ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="<subscription-id>",
    resource_group_name="<resource-group>",
    workspace_name="<workspace-name>",
)

# Define data collector with collections for model inputs and outputs
data_collector = DataCollector(
    collections={
        "model_inputs": DeploymentCollection(enabled="true"),
        "model_outputs": DeploymentCollection(enabled="true"),
    }
)

# Define the deployment with data collection enabled
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name="my_endpoint",
    model=Model(path="model/"),
    environment=Environment(
        conda_file="model/conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
    ),
    code_configuration=CodeConfiguration(
        code="scripts", scoring_script="score.py"
    ),
    instance_type="Standard_F2s_v2",
    instance_count=1,
    data_collector=data_collector,
)

# Create the deployment
ml_client.online_deployments.begin_create_or_update(blue_deployment).result()

Referenční informace:

Povolení protokolování datové části

Data datové části HTTP požadavku a odpovědi můžete shromažďovat přímo bez rozšíření hodnoticího skriptu (score.py).

Pokud chcete povolit protokolování datové části, použijte ve svém nasazení YAML názvy request a response:

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json

endpoint_name: my_endpoint 
name: blue 
model: azureml:my-model-m1:1 
environment: azureml:env-m1:1 
data_collector:
   collections:
       request:
           enabled: 'True'
       response:
           enabled: 'True'

Nasazení modelu s povoleným protokolováním datové části:
```
az ml online-deployment create -f deployment.YAML
```

Při zaznamenávání zátěže není zaručeno, že shromážděná data budou v tabulkovém formátu. Proto, pokud chcete použít shromážděná užitečná data s monitorováním modelu, musíte poskytnout modul předzpracování, aby data byla ve formátu tabulky. Pokud vás zajímá bezproblémové prostředí pro monitorování modelů, doporučujeme použít vlastní protokolování sady Python SDK.

Při použití vašeho nasazení proudí shromážděná data do úložiště objektů Blob pracovního prostoru. Následující kód JSON je příkladem shromážděného požadavku HTTP:

{"specversion":"1.0",
"id":"aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
"source":"/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterenvws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.request",
"datacontenttype":"application/json",
"time":"2022-05-25T08:59:48Z",
"data":{"data": [  [1,2,3,4,5,6,7,8,9,10], [10,9,8,7,6,5,4,3,2,1]]},
"path":"/score",
"method":"POST",
"contentrange":"bytes 0-59/*",
"correlationid":"aaaa0000-bb11-2222-33cc-444444dddddd","xrequestid":"aaaa0000-bb11-2222-33cc-444444dddddd"}

Následující kód JSON je příkladem shromážděné odpovědi HTTP:

{"specversion":"1.0",
"id":"bbbbbbbb-1111-2222-3333-cccccccccccc",
"source":"/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterenvws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.response",
"datacontenttype":"application/json",
"time":"2022-05-25T08:59:48Z",
"data":[11055.977245525679, 4503.079536107787],
"contentrange":"bytes 0-38/39",
"correlationid":"aaaa0000-bb11-2222-33cc-444444dddddd","xrequestid":"aaaa0000-bb11-2222-33cc-444444dddddd"}

Podrobnosti o cestách úložiště a formátech dat najdete v tématu Ukládání shromážděných dat ve službě Blob Storage.

Ukládání shromážděných dat ve službě Blob Storage

Shromažďování dat umožňuje protokolovat inferenční data z produkce do cílového umístění služby Blob Storage dle vašeho výběru. Nastavení cíle dat je možné konfigurovat na collection_name úrovni.

Výstup/formát služby Blob Storage:

Ve výchozím nastavení jsou shromážděná data uložena na následující cestě ve službě Blob Storage pracovního prostoru: azureml://datastores/workspaceblobstore/paths/modelDataCollector.
Konečná cesta v objektu blob bude připojena pomocí {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl.
Každý řádek v souboru je objekt JSON představující jeden zaprotokolovaný požadavek na odvozování nebo odpověď.

Poznámka:

collection_name odkazuje na název shromažďování dat (například model_inputsmodel_outputs). instance_id je jedinečné ID, které identifikuje seskupení zaprotokolovaných dat.

Shromážděná data se řídí následujícím schématem JSON. Shromážděná data jsou k dispozici z data klíče a jsou k dispozici další metadata.

{"specversion":"1.0",
"id":"aaaaaaaa-0b0b-1c1c-2d2d-333333333333",
"source":"/subscriptions/bbbb1b1b-cc2c-dd3d-ee4e-ffffff5f5f5f/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.inputs",
"datacontenttype":"application/json",
"time":"2022-12-01T08:51:30Z",
"data":[{"label":"DRUG","pattern":"aspirin"},{"label":"DRUG","pattern":"trazodone"},{"label":"DRUG","pattern":"citalopram"}],
"correlationid":"bbbb1111-cc22-3333-44dd-555555eeeeee","xrequestid":"bbbb1111-cc22-3333-44dd-555555eeeeee",
"modelversion":"default",
"collectdatatype":"pandas.core.frame.DataFrame",
"agent":"monitoring-sdk/0.1.2",
"contentrange":"bytes 0-116/117"}

Návod

Konce řádků se zobrazují jenom pro čitelnost. Ve shromážděných souborech .jsonl nebudou žádné konce řádků.

Ukládání velkých datových částí

Pokud je datová část vašich dat větší než 4 MB, v souboru {instance_id}.jsonl bude událost, která odkazuje na surovou cestu k souboru {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl, což by měla být následující cesta: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. Shromážděná data budou na této cestě.

Ukládání binárních dat

Při shromáždění binárních dat se nezpracovaný soubor zobrazí přímo s názvem souboru instance_id. Binární data jsou umístěna ve stejné složce jako cesta zdrojové skupiny požadavku na rolling_ratezákladě . Následující příklad odráží cestu v datovém poli. Formát je JSON a konce řádků se zobrazují jenom pro čitelnost:

{
"specversion":"1.0",
"id":"cccccccc-2222-3333-4444-dddddddddddd",
"source":"/subscriptions//resourceGroups//providers/Microsoft.MachineLearningServices/workspaces/ws/onlineEndpoints/ep/deployments/dp",
"type":"azureml.inference.request",
"datacontenttype":"text/plain",
"time":"2022-02-28T08:41:07Z",
"data":"https://masterws0373607518.blob.core.windows.net/modeldata/mdc/%5Byear%5D%5Bmonth%5D%5Bday%5D-%5Bhour%5D_%5Bminute%5D/cccccccc-2222-3333-4444-dddddddddddd",
"path":"/score?size=1",
"method":"POST",
"contentrange":"bytes 0-80770/80771",
"datainblob":"true"
}

Dávkování kolektoru dat

Pokud se požadavky posílají do krátkých časových intervalů mezi sebou, kolekce dat je zasáhne do stejného objektu JSON. Pokud například spustíte skript pro odesílání ukázkových dat do koncového bodu a nasazení má povolené shromažďování dat, některé požadavky se můžou dávkovat společně v závislosti na časovém intervalu mezi nimi. Pokud používáte shromažďování dat s monitorováním modelu Azure Machine Learning, služba monitorování modelů zpracovává jednotlivé požadavky nezávisle. Pokud ale očekáváte, že každý protokolovaný řádek dat bude mít svůj vlastní jedinečný correlationid, můžete do correlationid datového rámce pandas zahrnout sloupec, který protokolujete pomocí kolektoru dat. Další informace o tom, jak do datového rámce pandas zahrnout jedinečný correlationid sloupec, najdete v tématu Shromažďování dat pro monitorování výkonu modelu.

Tady je příklad dvou zalogovaných požadavků, které jsou společně dávkovány:

{"specversion":"1.0",
"id":"dddddddd-3333-4444-5555-eeeeeeeeeeee",
"source":"/subscriptions/cccc2c2c-dd3d-ee4e-ff5f-aaaaaa6a6a6a/resourceGroups/rg-bozhlinmomoignite/providers/Microsoft.MachineLearningServices/workspaces/momo-demo-ws/onlineEndpoints/credit-default-mdc-testing-4/deployments/main2",
"type":"azureml.inference.model_inputs",
"datacontenttype":"application/json",
"time":"2024-03-05T18:16:25Z",
"data":[{"LIMIT_BAL":502970,"AGE":54,"BILL_AMT1":308068,"BILL_AMT2":381402,"BILL_AMT3":442625,"BILL_AMT4":320399,"BILL_AMT5":322616,"BILL_AMT6":397534,"PAY_AMT1":17987,"PAY_AMT2":78764,"PAY_AMT3":26067,"PAY_AMT4":24102,"PAY_AMT5":-1155,"PAY_AMT6":2154,"SEX":2,"EDUCATION":2,"MARRIAGE":2,"PAY_0":0,"PAY_2":0,"PAY_3":0,"PAY_4":0,"PAY_5":0,"PAY_6":0},{"LIMIT_BAL":293458,"AGE":35,"BILL_AMT1":74131,"BILL_AMT2":-71014,"BILL_AMT3":59284,"BILL_AMT4":98926,"BILL_AMT5":110,"BILL_AMT6":1033,"PAY_AMT1":-3926,"PAY_AMT2":-12729,"PAY_AMT3":17405,"PAY_AMT4":25110,"PAY_AMT5":7051,"PAY_AMT6":1623,"SEX":1,"EDUCATION":3,"MARRIAGE":2,"PAY_0":-2,"PAY_2":-2,"PAY_3":-2,"PAY_4":-2,"PAY_5":-1,"PAY_6":-1}],
"contentrange":"bytes 0-6794/6795",
"correlationid":"test",
"xrequestid":"test",
"modelversion":"default",
"collectdatatype":"pandas.core.frame.DataFrame",
"agent":"azureml-ai-monitoring/0.1.0b4"}

Ověření shromážděných dat v uživatelském rozhraní studia

Zobrazení shromážděných dat ve službě Blob Storage z uživatelského rozhraní studia:

V pracovním prostoru Azure Machine Learning přejděte na kartu Data :
Na kartě Úložiště dat vyberte workspaceblobstore (Výchozí):
Zobrazení shromážděných produkčních dat na kartě Procházet :

Shromažďování dat pro modely MLflow

Pokud nasazujete model MLflow do online koncového bodu Služby Azure Machine Learning, můžete shromažďování dat odvozování v produkčním prostředí povolit jediným kliknutím v uživatelském rozhraní studia. Pokud je shromažďování dat zapnuté, Azure Machine Learning automaticky přidává do vašeho bodovacího skriptu vlastní protokolovací kód, aby se zajistilo, že se produkční data zaznamenají do služby Blob Storage vašeho pracovního prostoru. Monitorování modelů pak můžou pomocí dat monitorovat výkon modelu MLflow v produkčním prostředí.

Při konfiguraci nasazení modelu můžete povolit shromažďování produkčních dat. Na kartě Nasazení vyberte Povoleno pro shromažďování dat.

Po povolení shromažďování dat se produkční inferenční data uloží do vašeho úložiště Azure Machine Learning Blob Storage a vytvoří se dva datové prostředky s názvy <endpoint_name>-<deployment_name>-model_inputs a <endpoint_name>-<deployment_name>-model_outputs. Tyto datové prostředky se aktualizují v reálném čase při použití nasazení v produkčním prostředí. Monitorování modelů pak můžou pomocí datových prostředků monitorovat výkon modelu v produkčním prostředí.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-01-22