Collecter des données de production à partir de modèles déployés pour l’inférence en temps réel

S’APPLIQUE À :Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)

Dans cet article, vous allez apprendre à utiliser le collecteur de données Azure Machine Learning pour collecter des données d’inférence de production à partir d’un modèle déployé sur un point de terminaison en ligne managé Azure Machine Learning ou un point de terminaison en ligne Kubernetes.

Vous pouvez activer la collecte de données pour les déploiements de points de terminaison en ligne nouveaux ou existants. Le collecteur de données Azure Machine Learning journalise les données d’inférence dans Stockage Blob Azure. Les données collectées avec le Kit de développement logiciel (SDK) Python sont automatiquement inscrites en tant que ressource de données dans votre espace de travail Azure Machine Learning. Cette ressource de données peut être utilisée pour l’analyse des modèles.

Si vous souhaitez collecter des données d’inférence de production pour un modèle MLflow déployé sur un point de terminaison en temps réel, consultez Collecte de données pour les modèles MLflow.

Prérequis

• Disposez d’un modèle inscrit que vous pouvez utiliser pour le déploiement. Si vous n’avez pas de modèle inscrit, consultez Inscrire votre modèle en tant que ressource dans Machine Learning.

• Créez un point de terminaison en ligne Azure Machine Learning. Si vous n’avez pas de point de terminaison en ligne existant, consultez Déployer et évaluer un modèle Machine Learning à l’aide d’un point de terminaison en ligne.

Effectuer une journalisation personnalisée pour l’analyse des modèles

La collecte de données avec la journalisation personnalisée vous permet de journaliser les DataFrames pandas directement à partir de votre script de scoring avant, pendant et après toute transformation de données. Avec la journalisation personnalisée, les données tabulaires sont connectées en temps réel à votre Stockage Blob d’espace de travail ou à un conteneur de stockage d’objets blob personnalisé. Vos moniteurs de modèle peuvent consommer les données à partir du stockage.

Mettre à jour votre script de scoring avec du code de journalisation personnalisée

Pour commencer, ajoutez du code de journalisation personnalisée à votre script de scoring (score.py). Pour la journalisation personnalisée, vous avez besoin du package azureml-ai-monitoring. Pour plus d’informations sur ce package, consultez la page PyPI complète du Kit de développement logiciel (SDK) du collecteur de données.

1. Importez le package azureml-ai-monitoring en ajoutant la ligne suivante en haut du script de scoring :

   from azureml.ai.monitoring import Collector
   

2. Déclarez vos variables de collecte de données (jusqu’à cinq d’entre elles) dans votre fonction init() :

   Remarque

   Si vous utilisez les noms model_inputs et model_outputs pour vos objets Collector, le système de surveillance des modèles reconnaît automatiquement les ressources de données inscrites automatiquement, afin d’offrir une expérience de surveillance des modèles plus transparente.

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

   Par défaut, Azure Machine Learning déclenche une exception en cas d’échec lors de la collecte de données. Si vous le souhaitez, vous pouvez utiliser le paramètre on_error pour spécifier une fonction à exécuter en cas d’échec de la journalisation. Par exemple, à l’aide du paramètre on_error dans le code suivant, Azure Machine Learning journalise l’erreur au lieu de lever une exception :

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

3. Dans votre fonction run(), utilisez la fonction collect() pour journaliser les DataFrames avant et après le scoring. Le context est retourné à partir du premier appel à collect(), et il contient des informations pour mettre en corrélation les entrées de modèle et les sorties de modèle ultérieurement.

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

   Remarque

   Actuellement, l’API collect() journalise uniquement les DataFrames Pandas. Si les données ne se trouvent pas dans un DataFrame lorsqu’elles sont transmises à collect(), elles ne sont pas journalisées dans le stockage et une erreur est signalée.

Le code suivant est un exemple de script de scoring complet (score.py) qui utilise le Kit de développement logiciel (SDK) Python de journalisation personnalisée.

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

Mettre à jour votre script de scoring pour enregistrer des ID uniques personnalisés

En plus d’enregistrer les DataFrames pandas directement dans votre script de scoring, vous pouvez enregistrer des données à l’aide d’ID uniques de votre choix. Ces ID peuvent provenir de votre application, d’un système externe ou être générés par vos soins. Si vous ne fournissez pas d’ID personnalisé, comme indiqué dans cette section, le collecteur de données générera automatiquement un correlationid unique pour vous aider à corréler les entrées et les sorties de votre modèle ultérieurement. Si vous fournissez un ID personnalisé, le champ correlationid des données enregistrées contiendra la valeur de l’ID personnalisé que vous avez fourni.

1. Effectuez d’abord les étapes de la section précédente, puis importez le package azureml.ai.monitoring.context en ajoutant la ligne suivante à votre script de scoring :

   from azureml.ai.monitoring.context import BasicCorrelationContext
   

2. Dans votre script de scoring, instanciez un objet BasicCorrelationContext et transmettez le id que vous souhaitez enregistrer pour cette ligne. Nous vous recommandons de définir id comme étant un ID unique de votre système, afin que vous puissiez clairement identifier chaque ligne enregistrée à partir de votre Stockage Blob. Transmettez cet objet à votre appel d’API collect() en tant que paramètre :

     # 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. Assurez-vous de transmettre le contexte dans votre outputs_collector afin que les entrées et sorties de votre modèle aient le même ID unique associé, et puissent être facilement corrélées ultérieurement :

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

Le code suivant est un exemple de script de scoring complet (score.py) qui enregistre des ID uniques personnalisés.

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

Collecter des données pour le monitoring des performances du modèle

Si vous souhaitez utiliser les données collectées pour le monitoring des performances du modèle, il est important que chaque ligne enregistrée dispose d’un correlationid unique qui puisse être utilisé pour corréler ces données avec les données réelles, lorsque ces dernières seront disponibles. Le collecteur de données génère automatiquement un correlationid unique pour chaque ligne enregistrée et inclut cet ID généré automatiquement dans le champ correlationid de l’objet JSON. Pour plus d’informations sur le schéma JSON, consultez la rubrique Stocker les données collectées dans le stockage blob.

Si vous souhaitez utiliser votre propre ID unique pour l’enregistrement de vos données de production, nous vous recommandons d’enregistrer cet ID dans une colonne distincte au sein de votre DataFrame pandas, dans la mesure où le collecteur de données regroupe les demandesétroitement liées entre elles. En enregistrant correlationid dans une colonne séparée, il sera facilement disponible en aval pour l’intégration avec les données réelles.

Mettre à jour vos dépendances

Avant de pouvoir créer votre déploiement avec le script de scoring mis à jour, vous devez créer votre environnement avec l’image de base mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 et les dépendances conda appropriées. Par la suite, vous pouvez générer l’environnement à l’aide de la spécification dans le YAML suivant.

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

Mettre à jour votre déploiement YAML

Ensuite, vous allez créer le YAML de déploiement. Pour créer le YAML de déploiement, incluez l’attribut data_collector et activez la collecte de données pour les objets Collector, model_inputs et model_outputs, que vous avez instancié précédemment via le SDK Python de journalisation personnalisée :

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

Le code suivant est un exemple de YAML de déploiement complet pour un déploiement de point de terminaison en ligne managé. Vous devez mettre à jour le YAML de déploiement en fonction de votre scénario. Pour plus d’exemples sur la mise en forme de votre déploiement YAML pour la journalisation des données d’inférence, consultez Exemples de collecteur de données de modèle 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'

Si vous le souhaitez, vous pouvez ajuster les paramètres supplémentaires suivants pour votre data_collector :

• data_collector.rolling_rate : fréquence de partitionnement des données dans le stockage. Choisissez parmi les valeurs Minute, Hour, Day, Month ou Year.
• data_collector.sampling_rate : pourcentage des données à collecter, représenté sous forme de taux décimal. Par exemple, la valeur 1.0 représente la collecte de 100 % des données.
• data_collector.collections.<collection_name>.data.name : nom de la ressource de données à inscrire avec les données collectées.
• data_collector.collections.<collection_name>.data.path : chemin d’accès complet du magasin de données Azure Machine Learning dans lequel les données collectées doivent être inscrites comme ressource de données.
• data_collector.collections.<collection_name>.data.version : version de la ressource de données à inscrire avec les données collectées dans le stockage Blob.

Collecter des données dans un conteneur de stockage d’objets blob personnalisé

Vous pouvez utiliser le collecteur de données pour collecter vos données d’inférence de production dans un conteneur de stockage d’objets blob personnalisé en effectuant ces étapes :

1. Connectez le conteneur de stockage à un magasin de données Azure Machine Learning. Pour plus d’informations sur la connexion du conteneur de stockage au magasin de données Azure Machine Learning, consultez Créer des magasins de données.

2. Vérifiez que votre point de terminaison Azure Machine Learning dispose des autorisations nécessaires pour écrire dans la destination du magasin de données.

   Le collecteur de données prend en charge les identités managées affectées par le système (SAMI) et les identités managées affectées par l’utilisateur (UAMI). Ajoutez l’identité à votre point de terminaison. Attribuez le rôle Storage Blob Data Contributor à cette identité avec le conteneur de stockage d’objets blob à utiliser comme destination des données. Pour savoir comment utiliser des identités managées dans Azure, consultez Attribuer des rôles Azure à une identité managée.

3. Mettez à jour votre déploiement YAML de façon à inclure la propriété data dans chaque collection.

   • Le paramètre obligatoire, data.name, spécifie le nom de la ressource de données à inscrire auprès des données collectées.
   • Le paramètre obligatoire, data.path, spécifie le chemin d’accès complet au magasin de données Azure Machine Learning, qui est connecté à votre conteneur Stockage Blob Azure.
   • Le paramètre facultatif, data.version, spécifie la version de la ressource de données (valeur par défaut : 1).

   La configuration YAML suivante illustre comment inclure la propriété data dans chaque collection.

   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
   

   Remarque

   Vous pouvez également utiliser le paramètre data.path pour pointer vers des magasins de données dans différents abonnements Azure en fournissant un chemin d’accès qui respecte le format suivant : azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

Créer votre déploiement avec la collecte de données

Déployez le modèle avec la journalisation personnalisée activée :

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

Pour plus d’informations sur la mise en forme de votre YAML de déploiement pour la collecte de données avec des points de terminaison en ligne Kubernetes, consultez le Schéma du YAML de déploiement en ligne Kubernetes avec Azure Arc CLI (v2).

Pour plus d’informations sur la mise en forme de votre YAML de déploiement pour la collecte de données avec des points de terminaison en ligne managés, consultez le Schéma du YAML de déploiement en ligne managé CLI (v2).

Enregistrer les données de la charge utile

En plus de la journalisation personnalisée avec le Kit de développement logiciel (SDK) Python fourni, vous pouvez collecter directement les données de charge utile HTTP de requête et de réponse sans avoir à augmenter votre script de scoring (score.py).

1. Pour activer la journalisation de la charge utile, dans votre YAML de déploiement, utilisez les noms request et 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. Déployez le modèle avec la journalisation de la charge utile activée :

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

Avec la journalisation de la charge utile, il n’est pas garanti que les données collectées soient au format tabulaire. Par conséquent, si vous souhaitez utiliser des données de charge utile collectées avec la surveillance des modèles, vous devez fournir un composant de prétraitement afin de rendre les données tabulaires. Si vous êtes intéressé par une expérience transparente d’analyse des modèles, nous vous recommandons d’utiliser le Kit de développement logiciel (SDK) Python de journalisation personnalisée.

À mesure que votre déploiement est utilisé, les données collectées sont transmises au stockage Blob de votre espace de travail. Le code JSON suivant est un exemple de requête HTTP collectée :

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

Et le code JSON suivant est un autre exemple de réponse HTTP collectée :

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

Stocker les données collectées dans le stockage blob

La collecte de données vous permet d’enregistrer les données d’inférence de production vers une destination de stockage Blob de votre choix. Les paramètres de destination des données sont configurables au niveau collection_name.

Sortie/format du stockage Blob :

• Par défaut, les données collectées sont stockées au niveau du chemin d’accès suivant dans le Stockage Blob de votre espace de travail : azureml://datastores/workspaceblobstore/paths/modelDataCollector.

• {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl sera ajouté au chemin d’accès final dans l’objet blob.

• Chaque ligne du fichier est un objet JSON représentant une seule requête/réponse d’inférence journalisée.

Les données collectées respectent le schéma JSON suivant. Les données collectées sont disponibles à partir de la clé data et des métadonnées supplémentaires sont fournies.

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

Stocker des charges utiles volumineuses

Si la charge utile de vos données est supérieure à 4 Mo, un événement du fichier {instance_id}.jsonl contenu dans le chemin d’accès {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl pointera vers un chemin d’accès au fichier brut, qui devrait se présenter comme suit : blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. Les données collectées existent au niveau de ce chemin d’accès.

Stocker des données binaires

Avec les données binaires collectées, nous affichons le fichier brut directement, avec instance_id comme nom de fichier. Les données binaires sont placées dans le même dossier que le chemin d’accès du groupe source de la requête, en fonction du rolling_rate. L’exemple suivant reflète le chemin d’accès dans le champ de données. Le format est json et les sauts de ligne sont affichés uniquement à des fins de lisibilité :

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

Traitement par lot du collecteur de données

Lorsque les requêtes sont envoyées à intervalles rapprochés, le collecteur de données les regroupe dans le même objet JSON. Par exemple, si vous exécutez un script pour envoyer des données d’échantillonnage à votre point de terminaison et que la collecte de données est activée dans le cadre du déploiement, certaines requêtes peuvent être regroupées, en fonction de l’intervalle de temps qui les sépare. Si vous utilisez la collecte de données avec la surveillance des modèles Azure Machine Learning, le service de surveillance des modèles gère chaque requête indépendamment. Cependant, si vous souhaitez que chaque ligne de données enregistrée ait sa propre valeur correlationid, vous pouvez inclure correlationid en tant que colonne dans le DataFrame pandas utilisé pour l’enregistrement avec le collecteur de données. Pour plus d’informations sur la manière dont vous pouvez inclure votre correlationid unique en tant que colonne dans le DataFrame pandas, consultez la rubrique Collecter des données pour le monitoring des performances du modèle.

Voici un exemple de deux requêtes enregistrées et regroupées par lots :

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

Afficher les données dans l’interface utilisateur du studio

Pour afficher les données collectées dans Stockage Blob à partir de l’interface utilisateur du studio :

1. Accédez à l’onglet Données de votre espace de travail Azure Machine Learning :

   

2. Accédez à Magasins de données et sélectionnez votre espace de travail blobstore (par défaut) :

   

3. Utilisez le menu Parcourir pour afficher les données de production collectées :

   

Collecter des données pour les modèles MLflow

Si vous déployez un modèle MLflow sur un point de terminaison en ligne Azure Machine Learning, vous pouvez activer la collecte de données d’inférence de production avec un bouton bascule unique dans l’interface utilisateur du studio. Si la collecte de données est activée, Azure Machine Learning instrumente automatiquement votre script de scoring avec du code de journalisation personnalisée afin de s’assurer que les données de production sont journalisées dans le Stockage Blob de votre espace de travail. Vos moniteurs de modèle peuvent ensuite utiliser les données pour surveiller les performances de votre modèle MLflow en production.

Pendant que vous configurez le déploiement de votre modèle, vous pouvez activer la collecte de données de production. Sous l’onglet Déploiement, sélectionnez Activé pour Collecte de données.

Une fois que vous avez activé la collecte de données, les données d’inférence de production sont journalisées dans le Stockage Blob de votre espace de travail Azure Machine Learning et deux ressources de données sont créées avec les noms <endpoint_name>-<deployment_name>-model_inputs et <endpoint_name>-<deployment_name>-model_outputs. Ces ressources de données sont mises à jour en temps réel à mesure que vous utilisez votre déploiement en production. Vos moniteurs de modèle peuvent ensuite utiliser les ressources de données pour surveiller les performances de votre modèle en production.

Contenu connexe

• Qu’est-ce que la supervision des modèles Azure Machine Learning ?
• Superviser les performances des modèles déployés en production
• Que sont les points de terminaison Azure Machine Learning ?