Samla in produktionsdata från modeller som distribuerats för inferens i realtid

  • Artikel

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

I den här artikeln får du lära dig hur du använder Azure Mašinsko učenje Data-insamlare för att samla in produktionsinferensdata från en modell som distribueras till en Azure-Mašinsko učenje hanterad onlineslutpunkt eller en Kubernetes-slutpunkt online.

Du kan aktivera datainsamling för nya eller befintliga distributioner av onlineslutpunkter. Azure Mašinsko učenje datainsamlare loggar slutsatsdragningsdata i Azure Blob Storage. Data som samlas in med Python SDK registreras automatiskt som en datatillgång i din Azure Mašinsko učenje-arbetsyta. Den här datatillgången kan användas för modellövervakning.

Om du är intresserad av att samla in produktionsinferensdata för en MLflow-modell som distribueras till en realtidsslutpunkt kan du läsa Datainsamling för MLflow-modeller.

Förutsättningar

Innan du följer stegen i den här artikeln kontrollerar du att du har följande förutsättningar:

  • Rollbaserade åtkomstkontroller i Azure (Azure RBAC) används för att bevilja åtkomst till åtgärder i Azure Machine Learning. Om du vill utföra stegen i den här artikeln måste ditt användarkonto tilldelas rollen ägare eller deltagare för Azure Mašinsko učenje-arbetsytan eller en anpassad roll som tillåter Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Mer information finns i Hantera åtkomst till en Azure Mašinsko učenje-arbetsyta.

Utföra anpassad loggning för modellövervakning

Med datainsamling med anpassad loggning kan du logga Pandas DataFrames direkt från ditt bedömningsskript före, under och efter eventuella datatransformeringar. Med anpassad loggning loggas tabelldata i realtid till din arbetsyta Blob Storage eller en anpassad bloblagringscontainer. Dina modellövervakare kan använda data från lagringen.

Uppdatera ditt bedömningsskript med anpassad loggningskod

Börja med att lägga till anpassad loggningskod i bedömningsskriptet (score.py). För anpassad loggning behöver azureml-ai-monitoring du paketet. Mer information om det här paketet finns på den omfattande PyPI-sidan för datainsamlarens SDK.

  1. azureml-ai-monitoring Importera paketet genom att lägga till följande rad överst i bedömningsskriptet:

    from azureml.ai.monitoring import Collector

  2. Deklarera dina datainsamlingsvariabler (upp till fem av dem) i din init() funktion:

    Kommentar

    Om du använder namnen model_inputs och model_outputs för dina Collector objekt identifierar modellövervakningssystemet automatiskt de automatiskt registrerade datatillgångarna för att ge en smidigare modellövervakning.

    global inputs_collector, outputs_collector
inputs_collector = Collector(name='model_inputs')          
outputs_collector = Collector(name='model_outputs')

    Som standard genererar Azure Mašinsko učenje ett undantag om det uppstår ett fel under datainsamlingen. Du kan också använda parametern on_error för att ange en funktion som ska köras om loggningsfel inträffar. Om du till exempel använder parametern on_error i följande kod loggar Azure Mašinsko učenje felet i stället för att utlösa ett undantag:

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

  3. I din run() funktion använder du collect() funktionen för att logga DataFrames före och efter bedömning. context Returneras från det första anropet till collect()och innehåller information som korrelerar modellindata och modellutdata senare.

    context = inputs_collector.collect(data) 
result = model.predict(data)
outputs_collector.collect(result, context)

    Kommentar

    API:et collect() loggar för närvarande endast Pandas DataFrames. Om data inte finns i en DataFrame när de skickas till collect()loggas de inte till lagringen och ett fel rapporteras.

Följande kod är ett exempel på ett fullständigt bedömningsskript (score.py) som använder den anpassade python-SDK:t för loggning.

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

Uppdatera bedömningsskriptet för att logga anpassade unika ID:er

Förutom att logga Pandas DataFrames direkt i ditt bedömningsskript kan du logga data med unika ID:er som du väljer. Dessa ID:er kan komma från ditt program, ett externt system eller så kan du generera dem. Om du inte anger ett anpassat ID, enligt beskrivningen i det här avsnittet, skapar datainsamlaren automatiskt ett unikt correlationid för att hjälpa dig att korrelera modellens indata och utdata senare. Om du anger ett anpassat ID correlationid innehåller fältet i de loggade data värdet för ditt angivna anpassade ID.

  1. Slutför först stegen i föregående avsnitt och importera azureml.ai.monitoring.context sedan paketet genom att lägga till följande rad i bedömningsskriptet:

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. I bedömningsskriptet instansierar du ett BasicCorrelationContext objekt och skickar det du vill logga för den id raden. Vi rekommenderar att detta id är ett unikt ID från systemet, så att du unikt kan identifiera varje loggad rad från bloblagringen. Skicka det här objektet till API-anropet collect() som en parameter:

      # 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. Se till att du skickar in kontexten i din outputs_collector så att dina modellindata och utdata har samma unika ID loggat med dem, och de kan enkelt korreleras senare:

      # collect outputs data, pass in context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)

Följande kod är ett exempel på ett fullständigt bedömningsskript (score.py) som loggar anpassade unika ID:er.

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

Samla in data för övervakning av modellprestanda

Om du vill använda dina insamlade data för övervakning av modellprestanda är det viktigt att varje loggad rad har en unik correlationid som kan användas för att korrelera data med mark sanningsdata när sådana data blir tillgängliga. Datainsamlaren skapar automatiskt ett unikt correlationid för varje loggad rad och inkluderar detta automatiskt genererade ID i correlationid fältet i JSON-objektet. Mer information om JSON-schemat finns i Lagra insamlade data i Blob Storage.

Om du vill använda ditt eget unika ID för loggning med dina produktionsdata rekommenderar vi att du loggar detta ID som en separat kolumn i din Pandas DataFrame, eftersom datainsamlaren batchar begäranden som ligger nära varandra. Genom att logga correlationid som en separat kolumn är den lätt tillgänglig nedströms för integrering med grund sanningsdata.

Uppdatera dina beroenden

Innan du kan skapa distributionen med det uppdaterade bedömningsskriptet måste du skapa din miljö med basavbildningen mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 och lämpliga conda-beroenden. Därefter kan du skapa miljön med hjälp av specifikationen i följande 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

Uppdatera din distributions-YAML

Därefter skapar du distributions-YAML. Om du vill skapa distributionens YAML tar du med data_collector attributet och aktiverar datainsamling för objekten Collector och model_inputs model_outputs, som du instansierade tidigare via den anpassade loggnings-Python SDK:t:

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

Följande kod är ett exempel på en omfattande distributions-YAML för en hanterad onlineslutpunktsdistribution. Du bör uppdatera distributionens YAML enligt ditt scenario. Fler exempel på hur du formaterar din distributions YAML för inferensdataloggning finns i Azure-modelldatainsamlarexempel.

$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'

Du kan också justera följande extra parametrar för :data_collector

  • data_collector.rolling_rate: Hastigheten för att partitioneras data i lagringen. Välj mellan värdena: Minute, Hour, Day, Montheller Year.
  • data_collector.sampling_rate: Procentandelen, som representeras som ett decimaltal, för data som ska samlas in. Till exempel representerar värdet 1.0 för att samla in 100 % av data.
  • data_collector.collections.<collection_name>.data.name: Namnet på den datatillgång som ska registreras med de insamlade data.
  • data_collector.collections.<collection_name>.data.path: Den fullständiga Azure Mašinsko učenje datalagersökväg där insamlade data ska registreras som en datatillgång.
  • data_collector.collections.<collection_name>.data.version: Den version av datatillgången som ska registreras med insamlade data i Blob Storage.

Samla in data till en anpassad bloblagringscontainer

Du kan använda datainsamlaren för att samla in dina produktionsinferensdata till en anpassad bloblagringscontainer genom att följa dessa steg:

  1. Anslut lagringscontainern till ett Azure Mašinsko učenje-datalager. Mer information om hur du ansluter lagringscontainern till Azure Mašinsko učenje datalager finns i skapa datalager.

  2. Kontrollera att din Azure Mašinsko učenje-slutpunkt har de behörigheter som krävs för att skriva till datalagringsmålet.

    Datainsamlaren stöder både systemtilldelade hanterade identiteter (SAMIs) och användartilldelade hanterade identiteter (UAMIs). Lägg till identiteten i slutpunkten. Tilldela rollen till den Storage Blob Data Contributor här identiteten med bloblagringscontainern som ska användas som datamål. Information om hur du använder hanterade identiteter i Azure finns i tilldela Azure-roller till en hanterad identitet.

  3. Uppdatera din distributions-YAML så att den data inkluderar egenskapen i varje samling.

    • Den obligatoriska parametern, data.name, anger namnet på den datatillgång som ska registreras med de insamlade data.
    • Den obligatoriska parametern, data.path, anger den fullständigt bildade Azure Mašinsko učenje datalagersökväg som är ansluten till din Azure Blob Storage-container.
    • Den valfria parametern, data.version, anger versionen av datatillgången (standardvärdet är 1).

    Följande YAML-konfiguration visar ett exempel på hur du data inkluderar egenskapen i varje samling.

    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

    Kommentar

    Du kan också använda parametern data.path för att peka på datalager i olika Azure-prenumerationer genom att ange en sökväg som följer formatet: azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

Skapa din distribution med datainsamling

Distribuera modellen med anpassad loggning aktiverad:

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

Mer information om hur du formaterar din distributions YAML för datainsamling med Kubernetes onlineslutpunkter finns i CLI (v2) Azure Arc-aktiverat YAML-schema för kubernetes-onlinedistribution.

Mer information om hur du formaterar din distributions YAML för datainsamling med hanterade onlineslutpunkter finns i YAML-schema för cli-hanterad onlinedistribution (v2).

Utföra nyttolastloggning

Förutom anpassad loggning med den angivna Python SDK:t kan du samla in http-nyttolastdata för begäran och svar direkt utan att behöva utöka ditt bedömningsskript (score.py).

  1. Om du vill aktivera nyttolastloggning använder du namnen request och response: i din distributions-YAML

    $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. Distribuera modellen med nyttolastloggning aktiverad:

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

Med nyttolastloggning är de insamlade data inte garanterade att de är i tabellformat. Om du vill använda insamlade nyttolastdata med modellövervakning måste du därför ange en förbearbetningskomponent för att göra datafliken. Om du är intresserad av en sömlös modellövervakning rekommenderar vi att du använder den anpassade python-SDK:t för loggning.

När distributionen används flödar de insamlade data till din arbetsytas Blob Storage. Följande JSON-kod är ett exempel på en HTTP-begäran som samlas in:

{"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"}

Och följande JSON-kod är ett annat exempel på ett HTTP-svar som samlats in:

{"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"}

Lagra insamlade data i bloblagring

Med datainsamling kan du logga produktionsinferensdata till valfri bloblagringsmål. Inställningarna för datamål kan konfigureras på collection_name nivån.

Utdata/format för Blob Storage:

  • Som standard lagras insamlade data på följande sökväg i din arbetsytas Blob Storage: azureml://datastores/workspaceblobstore/paths/modelDataCollector.

  • Den sista sökvägen i bloben läggs till med {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl.

  • Varje rad i filen är ett JSON-objekt som representerar en enda slutsatsdragningsbegäran/svar som loggades.

Kommentar

collection_name refererar till namnet på datainsamlingen (t.ex. model_inputs eller model_outputs). instance_id är ett unikt ID som identifierar gruppering av data som loggades.

Insamlade data följer följande JSON-schema. Insamlade data är tillgängliga från data nyckeln och ytterligare metadata tillhandahålls.

{"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"}

Dricks

Radbrytningar visas endast för läsbarhet. I dina insamlade .jsonl-filer kommer det inte att finnas några radbrytningar.

Lagra stora nyttolaster

Om nyttolasten för dina data är större än 4 MB, kommer det att finnas en händelse i filen som finns i {instance_id}.jsonl {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl sökvägen som pekar på en rådatafilsökväg, som bör ha följande sökväg: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. De insamlade data kommer att finnas på den här sökvägen.

Lagra binära data

Med insamlade binära data visar vi rådatafilen direkt, med instance_id som filnamn. Binära data placeras i samma mapp som sökvägen för källgruppen för begäran, baserat på rolling_rate. I följande exempel visas sökvägen i datafältet. Formatet är json och radbrytningar visas endast för läsbarhet:

{
"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"
}

Batchbearbetning av datainsamlare

Om begäranden skickas inom korta tidsintervall för varandra, batchar datainsamlaren dem tillsammans till samma JSON-objekt. Om du till exempel kör ett skript för att skicka exempeldata till slutpunkten och distributionen har datainsamling aktiverad, kan vissa begäranden batchas ihop, beroende på tidsintervallet mellan dem. Om du använder datainsamling med Azure Mašinsko učenje modellövervakning hanterar modellövervakningstjänsten varje begäran oberoende av varandra. Men om du förväntar dig att varje loggad rad med data ska ha sin egen unika correlationidkan du inkludera correlationid som en kolumn i pandas-dataramen som du loggar med datainsamlaren. Mer information om hur du kan inkludera ditt unika correlationid som en kolumn i Pandas DataFrame finns i Samla in data för övervakning av modellprestanda.

Här är ett exempel på två loggade begäranden som batchats tillsammans:

{"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"}

Visa data i studiogränssnittet

Så här visar du insamlade data i Blob Storage från studiogränssnittet:

  1. Gå till fliken Data på din Azure Mašinsko učenje-arbetsyta:

    Skärmbild som visar datasidan i Azure Mašinsko učenje-arbetsytan

  2. Gå till Datalager och välj ditt arbetsyteblobarkiv (standard):

    Skärmbild som visar sidan Datalager i AzureML-arbetsytan

  3. Använd menyn Bläddra för att visa insamlade produktionsdata:

    Skärmbild som visar trädstrukturen för data i Datastore

Samla in data för MLflow-modeller

Om du distribuerar en MLflow-modell till en Azure Mašinsko učenje onlineslutpunkt kan du aktivera datainsamling för produktionsinferens med enkel växling i studiogränssnittet. Om datainsamlingen är aktiverad Mašinsko učenje Azure automatiskt instrumentera ditt bedömningsskript med anpassad loggningskod för att säkerställa att produktionsdata loggas till din arbetsytas Blob Storage. Dina modellövervakare kan sedan använda data för att övervaka prestanda för din MLflow-modell i produktion.

När du konfigurerar distributionen av din modell kan du aktivera insamling av produktionsdata. Under fliken Distribution väljer du Aktiverad för datainsamling.

När du har aktiverat datainsamling loggas data för produktionsinferens till Azure Mašinsko učenje-arbetsytan Blob Storage och två datatillgångar skapas med namn <endpoint_name>-<deployment_name>-model_inputs och <endpoint_name>-<deployment_name>-model_outputs. Dessa datatillgångar uppdateras i realtid när du använder distributionen i produktion. Dina modellövervakare kan sedan använda datatillgångarna för att övervaka modellens prestanda i produktion.

Relaterat innehåll