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

  • Článek

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 služby Azure Machine Learning shromažďovat produkční data odvozování z modelu nasazeného do online koncového bodu spravovaného službou Azure Machine Learning nebo z online koncového bodu Kubernetes.

Shromažďování dat můžete povolit pro nová nebo existující nasazení online koncových bodů. Protokoly kolektoru dat služby Azure Machine Learning odvozuje data ve službě Azure Blob Storage. Data shromážděná pomocí sady Python SDK se automaticky zaregistrují jako datový prostředek v pracovním prostoru Služby Azure Machine Learning. Tento datový asset lze použít k monitorování modelu.

Pokud vás zajímá shromažďování produkčních dat odvozování pro model MLflow nasazený do koncového bodu v reálném čase, přečtěte si téma Shromažďování dat pro modely MLflow.

Požadavky

Než budete postupovat podle kroků v tomto článku, ujistěte se, že máte následující požadavky:

  • Řízení přístupu na základě role v Azure (Azure RBAC) slouží k udělení přístupu k operacím ve službě Azure Machine Learning. Pokud chcete provést kroky v tomto článku, musí mít váš uživatelský účet přiřazenou roli vlastníka nebo přispěvatele pro pracovní prostor Služby Azure Machine Learning nebo vlastní roli, která povoluje Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Další informace najdete v tématu Správa přístupu k pracovnímu prostoru Azure Machine Learning.

Provádění vlastního protokolování pro monitorování modelů

Shromažďování dat pomocí vlastního 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. Pomocí vlastního protokolování se tabulková data protokolují v reálném čase do služby Blob Storage pracovního prostoru nebo do vlastního kontejneru úložiště objektů blob. Monitorování modelů může využívat data z úložiště.

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

Začněte přidáním vlastního kódu protokolování do hodnoticího skriptu (score.py). Pro vlastní protokolování potřebujete azureml-ai-monitoring balíček. Další informace o tomto balíčku najdete na komplexní stránce PyPI pro sadu SDK kolektoru dat.

  1. 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

  2. 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 Collector objekty, systém monitorování modelů automaticky rozpozná automaticky registrované datové prostředky, aby poskytoval plynulejší prostředí 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í. Například pomocí parametru on_error v následujícím kódu azure Machine Learning zaznamená chybu místo vyvolání výjimky:

    inputs_collector = Collector(name='model_inputs', on_error=lambda e: logging.info("ex:{}".format(e)))

  3. 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 v datovém rámci při předání collect(), nebudou se protokolovat 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 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 pandas Dataframe, return value is also 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

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, z externího systému nebo je můžete vygenerovat. Pokud nezadáte vlastní ID, jak je podrobně popsáno v této části, kolektor dat automaticky vygeneruje jedinečnou funkci correlationid , která vám pomůže později korelovat vstupy a výstupy modelu. Pokud zadáte vlastní ID, correlationid bude pole v protokolovaných datech obsahovat hodnotu zadaného vlastního ID.

  1. Nejprve proveďte kroky v předchozí části a pak balíček naimportujte azureml.ai.monitoring.context přidáním následujícího řádku do skriptu pro bodování:

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. V bodovacím skriptu vytvořte instanci objektu BasicCorrelationContext a předejte id objekt, který chcete pro tento řádek protokolovat. Doporučujeme, aby se jedná id o jedinečné ID z vašeho systému, abyste mohli jednoznačně identifikovat každý protokolovaný řá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)

  3. Ujistěte se, že do kontextu předáte outputs_collector svůj kontext, aby vstupy a výstupy modelu měly stejné jedinečné ID, které jsou zaprotokolovány s nimi, 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 pandas Dataframe, return value is also 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 vygenerované 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 v úložišti objektů blob.

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 datovém rámci pandas, protože požadavky kolektoru dat, které jsou blízko sebe. Když ho correlationid zapíšete jako samostatný sloupec, bude snadno dostupný pro integraci s podkladovými pravdivý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-ubuntu20.04 a odpovídajícími závislostmi conda. Potom můžete vytvořit prostředí pomocí specifikace v následujícím JAZYCE YAML.

channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=22.3.1
  - pip:
      - azureml-defaults==1.38.0
      - azureml-ai-monitoring~=0.1.0b1
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í YAML nasazení pro protokolování dat odvozování 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-ubuntu20.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 si z hodnot: Minute, Hour, Day, Monthnebo 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 u shromážděných dat v úložišti objektů blob.

Shromažďování dat do vlastního kontejneru úložiště objektů blob

Kolektor dat můžete použít ke shromažďování produkčních dat odvozování do vlastního kontejneru úložiště objektů blob pomocí následujícího postupu:

  1. 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.

  2. 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 (SAMI) i spravované identity přiřazené uživatelem (UAMI). Přidejte identitu do koncového bodu. Storage Blob Data Contributor Přiřaďte k této identitě roli s kontejnerem úložiště objektů blob, 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ě.

  3. Aktualizujte YAML nasazení tak, aby zahrnovala data vlastnost v každé kolekci.

    • Povinný parametr data.name, určuje název datového assetu, který se má zaregistrovat se shromážděnými daty.
    • Povinný parametr data.path, určuje plně vytvořený cestu úložiště dat Azure Machine Learning, která je připojena k vašemu kontejneru Azure 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á se řídí formátem: azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

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

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

$ az ml online-deployment create -f deployment.YAML

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ím cli (v2).

Protokolování datové části

Kromě vlastního protokolování pomocí poskytnuté sady Python SDK můžete shromažďovat data datové části HTTP požadavku a odpovědi přímo bez nutnosti rozšířit bodovací skript (score.py).

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

    $schema: http://azureml/sdk-2-0/OnlineDeployment.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'

  2. Nasazení modelu s povoleným protokolováním datové části:

    $ az ml online-deployment create -f deployment.YAML

U protokolování datové části není zaručeno, že shromážděná data budou v tabulkovém formátu. Proto pokud chcete použít shromážděná data datové části s monitorováním modelu, budete muset poskytnout komponentu předběžného zpracování, aby byla data tabulková. Pokud vás zajímá bezproblémové prostředí pro monitorování modelů, doporučujeme použít vlastní protokolování sady Python SDK.

Jak se používá vaše nasazení, shromážděná data proudí 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":"19790b87-a63c-4295-9a67-febb2d8fbce0",
"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 dalším příkladem shromážděné odpovědi HTTP:

{"specversion":"1.0",
"id":"bbd80e51-8855-455f-a719-970023f41e7d",
"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"}

Ukládání shromážděných dat v úložišti objektů blob

Shromažďování dat umožňuje protokolovat produkční data odvozování do cílového úložiště objektů blob podle vašeho výběru. Nastavení cíle dat je možné konfigurovat na collection_name úrovni.

Výstup/formát úložiště objektů blob:

  • 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ř model_inputs model_outputs. instance_id je jedinečné ID identifikující seskupení dat, která byla zaznamenána.

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":"725aa8af-0834-415c-aaf5-c76d0c08f694",
"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"}

Tip

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, bude v {instance_id}.jsonl souboru obsažena {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl událost, která odkazuje na nezpracovanou cestu k souboru, která by měla mít následující cestu: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. Shromážděná data budou existovat v této cestě.

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

S shromážděnými binárními daty zobrazíme nezpracovaný soubor přímo s instance_id názvem souboru. 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":"ba993308-f630-4fe2-833f-481b2e4d169a",
"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/ba993308-f630-4fe2-833f-481b2e4d169a",
"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 protokolovaných požadavků, které jsou dávkové:

{"specversion":"1.0",
"id":"720b8867-54a2-4876-80eb-1fd6a8975770",
"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"}

Zobrazení dat v uživatelském rozhraní studia

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

  1. V pracovním prostoru Azure Machine Learning přejděte na kartu Data :

    Snímek obrazovky se zvýrazněnou stránkou Data v pracovním prostoru Azure Machine Learning

  2. Přejděte do úložišť dat a vyberte váš pracovní prostorblobstore (výchozí):

    Snímek obrazovky se zvýrazněnou stránkou Úložiště dat v pracovním prostoru AzureML

  3. Pomocí nabídky Procházet zobrazíte shromážděná produkční data:

    Snímek obrazovky se zvýrazněnou stromovou strukturou dat v úložišti dat

Shromažďování dat pro modely MLflow

Pokud nasazujete model MLflow do online koncového bodu Služby Azure Machine Learning, můžete povolit shromažďování dat pro odvozování v produkčním prostředí jediným přepínačem v uživatelském rozhraní studia. Pokud je zapnuté shromažďování dat, Azure Machine Learning automaticky provede bodovací skript vlastním kódem protokolování, aby se zajistilo, že se produkční data zaprotokolují 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í data odvozování zaprotokolují do služby Azure Machine Learning Workspace 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í.

Související obsah