Créer des travaux et des données d’entrée pour les points de terminaison de lot

Les points de terminaison par lots peuvent être utilisés pour effectuer de longues opérations de traitement par lots sur de grandes quantités de données. Ces données peuvent être placées à différents endroits. Certains types de points de terminaison par lots peuvent également recevoir des paramètres de littéral en tant qu’entrées. Dans ce tutoriel, nous allons expliquer comment vous pouvez spécifier ces entrées, ainsi que les différents types ou emplacements pris en charge.

Avant d’appeler le point de terminaison

Pour appeler un point de terminaison par lots et créer des tâches avec succès, assurez-vous de disposer des éléments suivants :

• Vous avez des autorisations pour exécuter un déploiement de point de terminaison par lots. Les rôles Scientifique des données, Contributeur et Propriétaire AzureML peuvent être utilisés pour exécuter un déploiement. Pour que les définitions de rôles personnalisés, consultez l’Autorisation sur les points de terminaison de traitement par lots pour connaître les autorisations spécifiques nécessaires.

• Vous avez un jeton Microsoft Entra ID valide représentant un principal de sécurité pour appeler le point de terminaison. Ce principal peut être un principal d’utilisateur ou un principal de service. Dans tous les cas, une fois qu’un point de terminaison est appelé, un travail de déploiement par lots est créé sous l’identité associée au jeton. À des fins de test, vous pouvez utiliser vos propres informations d’identification pour l’appel, comme indiqué ci-dessous.

  Azure CLI

  Utilisez Azure CLI pour vous connecter à l’aide de l’authentification interactive ou par code d’appareil :

  az login
  

  Python

  Utilisez le kit de développement logiciel (SDK) Azure Machine Learning pour Python pour vous connecter :

  from azure.ai.ml import MLClient
  from azure.identity import DefaultAzureCredential
  
  ml_client = MLClient.from_config(DefaultAzureCredential())
  

  Si vous exécutez en dehors du calcul Azure Machine Learning, vous devez spécifier l’espace de travail où le point de terminaison est déployé :

  from azure.ai.ml import MLClient
  from azure.identity import DefaultAzureCredential
  
  subscription_id = "<subscription>"
  resource_group = "<resource-group>"
  workspace = "<workspace>"
  
  ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
  

  REST

  Le moyen le plus simple d’obtenir un jeton valide pour votre compte utilisateur consiste à utiliser Azure CLI. Dans une console, entrez la commande suivante :

  az account get-access-token --resource https://ml.azure.com --query "accessToken" --output tsv
  

  Conseil

  Lorsque vous utilisez REST, nous vous recommandons d’appeler des points de terminaison par lot au moyen d’un principal de service. Consultez Exécution de tâches à l’aide d’un principal de service (REST) pour savoir comment obtenir un jeton pour un principal de service à l’aide de REST.

  Pour en savoir plus sur l’authentification avec plusieurs types d’informations d’identification, lisez Autorisation relative aux points de terminaison par lots.

• Le cluster de calcul où le point de terminaison est déployé a accès pour lire les données d’entrée.

  Conseil

  Si vous utilisez un magasin de données sans informations d’identification ou un compte de stockage Azure externe comme entrée de données, veillez à configurer des clusters de calcul pour l’accès aux données. L’identité managée du cluster de calcul est utilisée pour le montage du compte de stockage. L’identité de la tâche (demandeur) est encore utilisée afin de lire les données sous-jacentes, ce qui vous permet d’obtenir un contrôle d’accès granulaire.

Principes de base pour créer des travaux

Pour créer un travail à partir d’un point de terminaison de lot, vous devez l’appeler. L’appel peut être effectué avec Azure CLI, le SDK Azure Machine Learning pour Python ou un appel d’API REST. Les exemples suivants montrent les principes de base d’un appel de point de terminaison de lot qui reçoit un seul dossier de données d’entrée à traiter. Consultez Présentation des entrées et sorties pour obtenir des exemples avec différentes entrées et sorties.

Azure CLI

Utilisez l’opération invoke sous des points de terminaison de lot :

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Python

Utilisez la méthode MLClient.batch_endpoints.invoke() pour spécifier le nom de l’expérience :

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

REST

Exécutez une requête POST sur l’URL d’appel du point de terminaison. Vous pouvez obtenir l’URL d’appel à partir du portail Azure Machine Learning, dans la page de détails du point de terminaison.

Corps

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Requête

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Appeler un déploiement spécifique

Les points de terminaison par lots peuvent héberger plusieurs déploiements sous le même point de terminaison. Le point de terminaison par défaut est utilisé, sauf si l’utilisateur le spécifiez autrement. Vous pouvez modifier le déploiement utilisé comme suit :

Azure CLI

Utilisez l’argument --deployment-name ou -d pour spécifier le nom du déploiement :

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --deployment-name $DEPLOYMENT_NAME \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Python

Utilisez le paramètre deployment_name pour spécifier le nom du déploiement :

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    deployment_name=deployment.name,
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data")
    }
)

REST

Ajoutez l’en-tête azureml-model-deployment à votre requête, y compris le nom du déploiement que vous souhaitez appeler.

Corps

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        }
    }
}

Requête

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
azureml-model-deployment: DEPLOYMENT_NAME

Configurer les propriétés du travail

Vous pouvez configurer certaines propriétés du travail créé au moment de l’appel.

Remarque

Pour le moment, la configuration des propriétés de la tâche n'est disponible que dans les points de terminaison par lots avec les déploiements de composants Pipeline.

Configurer le nom de l’expérience

Azure CLI

Utilisez l’argument --experiment-name pour spécifier le nom de l’expérience :

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
                            --experiment-name "my-batch-job-experiment" \
                            --input https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data

Python

Utilisez le paramètre experiment_name pour spécifier le nom de l’expérience :

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name,
    experiment_name="my-batch-job-experiment",
    inputs={
        "heart_dataset": Input("https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"),
    }
)

REST

Utilisez la clé experimentName dans la section properties pour indiquer le nom de l’expérience :

Corps

{
    "properties": {
        "InputData": {
           "heart_dataset": {
               "JobInputType" : "UriFolder",
               "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
           }
        },
        "properties":
        {
            "experimentName": "my-batch-job-experiment"
        }
    }
}

Requête

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Présentation des entrées et des sorties

Les points de terminaison par lots fournissent une API durable que les consommateurs peuvent utiliser pour créer des programmes de traitement par lots. La même interface peut être utilisée pour spécifier les entrées et les sorties attendues par votre déploiement. Utilisez des entrées pour transmettre les informations dont votre point de terminaison a besoin pour effectuer le travail.

Les points de terminaison par lots prennent en charge deux types d’entrées :

• Les entrées de données, qui sont des pointeurs vers un emplacement de stockage spécifique ou une ressource Azure Machine Learning.
• Les entrées littérales, qui sont des valeurs littérales (comme des nombres ou des chaînes) que vous souhaitez transmettre à la tâche.

Le nombre et le type d’entrées et de sorties dépendent du type de déploiement par lots. Les modèles de déploiement nécessitent toujours une entrée de données et produisent une sortie de données. Les entrées littérales ne sont pas prises en charge. Toutefois, les déploiements de composants de pipeline fournissent une construction plus générale pour générer des points de terminaison et vous permettent de spécifier n’importe quel nombre d’entrées (données et littérales) et de sorties.

Le tableau suivant récapitule les entrées et sorties pour les déploiements par lots :

Type de déploiement	Nombre d’entrées	Types d’entrée pris en charge	Nombre de sorties	Types de sortie pris en charge
Déploiement de modèle	1	Entrées de données	1	Sorties de données
Déploiement de composant de pipeline	[0..N]	Entrées de données et entrées de littéral	[0..N]	Sorties de données

Conseil

Les entrées et sorties sont toujours nommées. Ces noms servent de clés pour les identifier et transmettre la valeur réelle lors de l’appel. Pour les modèles de déploiement, étant donné qu’ils nécessitent toujours une entrée et une sortie, le nom est ignoré lors de l’appel. Vous pouvez attribuer le nom qui correspond au mieux votre cas d’usage, par exemple « estimation_ventes ».

Entrées de données

Les entrées de données désignent les entrées qui pointent vers un emplacement où les données sont placées. Étant donné que les points de terminaison par lots consomment généralement de grandes quantités de données, vous ne pouvez pas transmettre les données d’entrée dans le cadre de la demande d’appel. Au lieu de cela, vous devez spécifiez l’emplacement où le point de terminaison par lots doit se rendre pour rechercher les données. Les données d’entrée sont montées et diffusées en continu sur le calcul cible pour améliorer les performances.

Les points de terminaison par lots prennent en charge la lecture de fichiers situés dans les emplacements de stockage suivants :

• Ressources de données Azure Machine Learning, y compris le dossier (uri_folder) et le fichier (uri_file).
• Magasins de données Azure Machine Learning, y compris Stockage Blob Azure, Azure Data Lake Storage Gen1 et Azure Data Lake Storage Gen2.
• Comptes Stockage Azure, y compris Azure Data Lake Storage Gen1, Azure Data Lake Storage Gen2 et Stockage Blob Azure.
• Fichiers/dossiers de données locales (CLI Azure Machine Learning ou kit de développement logiciel (SDK) Azure Machine Learning pour Python). Toutefois, cette opération entraîne le chargement des données locales dans la banque de données Azure Machine Learning par défaut de l’espace de travail sur lequel vous travaillez.

Important

Note relative à la suppression de fonctionnalités : les jeux de données de type FileDataset (V1) sont déconseillés et seront mis hors service à l’avenir. Les points de terminaison par lots existants qui s’appuient sur cette fonctionnalité continueront de fonctionner, mais les points de terminaison par lots créés avec GA CLIv2 (2.4.0 et versions ultérieures) ou l’API REST GA (2022-05-01 et versions ultérieures) ne prendront pas en charge le jeu de données V1.

Entrées littérales

Les entrées de littéral font référence aux entrées qui peuvent être représentées et résolues au moment de l’appel, telles que les chaînes, les nombres et les valeurs booléennes. Vous utilisez généralement des entrées de littéral pour transmettre des paramètres à votre point de terminaison dans le cadre d’un déploiement de composants de pipeline. Les points de terminaison par lots prennent en charge les types de littéral suivants :

• string
• boolean
• float
• integer

Les entrées littérales ne sont prises en charge que dans les déploiements de composants de pipeline. Consultez Créer des tâches avec des entrées littérales pour savoir comment les spécifier.

Sorties de données

Les sorties de données font référence à l’emplacement où les résultats d’un programme de traitement par lots doivent être placés. Les sorties sont identifiées par leur nom et Azure Machine Learning attribue automatiquement un chemin d’accès unique à chaque sortie nommée. Toutefois, vous pouvez spécifier un autre chemin si nécessaire.

Important

Les points de terminaison Batch prennent uniquement en charge l’écriture de sorties dans les magasins de données du Stockage Blob Azure. Si vous devez écrire dans un compte de stockage avec des espaces de noms hiérarchiques activés (également appelé Azure Datalake Gen2 ou ADLS Gen2), notez que ce service de stockage peut être inscrit comme magasin de données de Stockage Blob Azure, car les services sont entièrement compatibles. De cette façon, vous pouvez écrire des sorties de points de terminaison de lot vers ADLS Gen2.

Créer des tâches avec des entrées de données

Les exemples suivants montrent comment créer des tâches et utiliser des entrées de données à partir de ressources de données, magasins de données et comptes de Stockage Azure.

Saisie de données à partir d’une ressource de données

Les ressources de données Azure Machine Learning (anciennement appelées jeux de données) sont prises en charge comme entrées pour les travaux. Procédez comme suit pour exécuter un travail de point de terminaison par lots à l’aide de données stockées dans une ressource de données inscrite dans Azure Machine Learning :

Avertissement

Les ressources de données de type Table (MLTable) ne sont actuellement pas prises en charge.

1. Tout d’abord, créez la ressource de données. Cette ressource de données se compose d’un dossier contenant plusieurs fichiers CSV que vous allez traiter en parallèle à l’aide de points de terminaison par lots. Vous pouvez ignorer cette étape si vos données sont déjà inscrites en tant que ressource de données.

   Azure CLI

   Créez une définition de ressource de données dans YAML :

   heart-dataset-unlabeled.yml

   $schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
   name: heart-dataset-unlabeled
   description: An unlabeled dataset for heart classification.
   type: uri_folder
   path: heart-classifier-mlflow/data
   

   Ensuite, créez la ressource de données :

   az ml data create -f heart-dataset-unlabeled.yml
   

   Python

   data_path = "heart-classifier-mlflow/data"
   dataset_name = "heart-dataset-unlabeled"
   
   heart_dataset_unlabeled = Data(
       path=data_path,
       type=AssetTypes.URI_FOLDER,
       description="An unlabeled dataset for heart classification",
       name=dataset_name,
   )
   

   Créez la ressource de données :

   ml_client.data.create_or_update(heart_dataset_unlabeled)
   

   Pour obtenir la ressource de données nouvellement créée, utilisez :

   heart_dataset_unlabeled = ml_client.data.get(name=dataset_name, label="latest")
   

   REST

   Utilisez l’interface CLI Azure Machine Learning, le Kit de développement logiciel (SDK) Azure Machine Learning pour Python ou Azure Machine Learning studio pour obtenir l’emplacement (région), l’espace de travail, et le nom et la version de la ressource de données. Vous en aurez besoin ultérieurement.

2. Créez l’entrée ou la requête :

   Azure CLI

   DATASET_ID=$(az ml data show -n heart-dataset-unlabeled --label latest | jq -r .id)
   

   Python

   input = Input(path=heart_dataset_unlabeled.id)
   

   REST

   Corps

   {
       "properties": {
           "InputData": {
               "heart_dataset": {
                   "JobInputType" : "UriFolder",
                   "Uri": "azureml://locations/<location>/workspaces/<workspace>/data/<dataset_name>/versions/labels/latest"
               }
           }
       }
   }
   

   Notes

   L’ID des ressources de données doit ressembler à /subscriptions/<subscription>/resourcegroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/data/<data-asset>/versions/<version>. Vous pouvez également utiliser azureml:/<datasset_name>@latest pour spécifier l'entrée.

3. Exécutez le point de terminaison :

   Azure CLI

   Utilisez l’argument --set pour spécifier l’entrée :

   az ml batch-endpoint invoke --name $ENDPOINT_NAME \
       --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$DATASET_ID
   

   Pour un point de terminaison qui sert un modèle de déploiement, vous pouvez utiliser l’argument --input pour spécifier l’entrée de données, car un modèle de déploiement nécessite toujours une seule entrée de données.

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $DATASET_ID
   

   L’argument --set a tendance à produire de longues commandes lorsque plusieurs entrées sont spécifiées. Dans ce cas, placez vos entrées dans un fichier YAML et utilisez --file pour spécifier les entrées dont vous avez besoin pour l’appel de votre point de terminaison.

   inputs.yml

   inputs:
     heart_dataset: azureml:/<datasset_name>@latest
   

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
   

   Python

   Conseil

   Quelle est la différence entre inputs et input lorsque vous appelez un point de terminaison ?

   En général, vous pouvez utiliser un dictionnaire inputs = {} avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison par lots contenant un modèle de déploiement ou un déploiement de pipelines.

   Pour un modèle de déploiement, vous pouvez utiliser input comme moyen plus court de spécifier l’emplacement des données d’entrée pour le déploiement, car un modèle de déploiement ne prend toujours qu’une seule entrée de données.

   Appelez la méthode invoke, en utilisant inputs pour spécifier les entrées requises :

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       inputs={
           "heart_dataset": input,
       }
   )
   

   Simplifiez davantage l’appel invoke d’un modèle de déploiement en utilisant input pour spécifier l’emplacement des données d’entrée :

   job = ml_client.batch_endpoints.invoke(
      endpoint_name=endpoint.name,
      input=input,
   )
   

   REST

   Requête

   POST jobs HTTP/1.1
   Host: <ENDPOINT_URI>
   Authorization: Bearer <TOKEN>
   Content-Type: application/json
   

Saisie de données à partir de magasins de données

Les données des magasins de données inscrits auprès d’Azure Machine Learning peuvent être référencées directement par les travaux de déploiement par lots. Dans cet exemple, vous allez d’abord devoir charger des données dans le magasin de données par défaut dans l’espace de travail Azure Machine Learning, puis exécuter un déploiement par lots dessus. Procédez comme suit pour exécuter un travail de point de terminaison par lots à l’aide de données stockées dans une banque de données.

1. Accédez à la banque de données par défaut dans l’espace de travail Azure Machine Learning. Si vos données se trouvent dans une autre banque, vous pouvez l’utiliser à la place. Il n’est pas nécessaire d’utiliser le magasin de données par défaut.

   Azure CLI

   DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
   

   Notes

   L’ID des banques de données ressemblerait à /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.

   Python

   default_ds = ml_client.datastores.get_default()
   

   REST

   Utilisez l’interface CLI Azure Machine Learning, le Kit de développement logiciel (SDK) Azure Machine Learning pour Python ou Studio pour obtenir les informations de magasin de données.

   Conseil

   Le magasin de données blob par défaut dans un espace de travail est appelé workspaceblobstore. Vous pouvez ignorer cette étape si vous connaissez déjà l’ID de ressource du magasin de données par défaut dans votre espace de travail.

2. Vous devez charger des exemples de données dans le magasin de données. Cet exemple suppose que vous avez déjà chargé les exemples de données inclus dans le référentiel dans le dossier sdk/python/endpoints/batch/deploy-models/heart-classifier-mlflow/data du dossier heart-disease-uci-unlabeled du compte de stockage d’objets blob. Veillez à effectuer cette étape avant de continuer.

3. Créez l’entrée ou la requête :

   Azure CLI

   Insérez le chemin du fichier dans la variable suivante :

   DATA_PATH="heart-disease-uci-unlabeled"
   INPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
   

   Python

   data_path = "heart-disease-uci-unlabeled"
   input = Input(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})
   

   Si vos données sont un fichier, modifiez type=AssetTypes.URI_FILE.

   REST

   Corps

   {
       "properties": {
           "InputData": {
               "heart_dataset": {
                   "JobInputType" : "UriFolder",
                   "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
               }
           }
       }
   }
   

   Si vos données sont un fichier, utilisez plutôt UriFile comme type.

   Notes

   Observez l’ajout du chemin paths à l’ID de ressource du magasin de données pour indiquer que la chaîne qui suit est un chemin dans celui-ci.

   Conseil

   Vous pouvez également utiliser azureml://datastores/<data-store>/paths/<data-path> pour spécifier l'entrée.

4. Exécutez le point de terminaison :

   Azure CLI

   Utilisez l’argument --set pour spécifier l’entrée :

   az ml batch-endpoint invoke --name $ENDPOINT_NAME \
       --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_PATH
   

   Pour un point de terminaison qui sert un modèle de déploiement, vous pouvez utiliser l’argument --input pour spécifier l’entrée de données, car un modèle de déploiement nécessite toujours une seule entrée de données.

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_PATH --input-type uri_folder
   

   L’argument --set a tendance à produire de longues commandes lorsque plusieurs entrées sont spécifiées. Dans ce cas, placez vos entrées dans un fichier YAML et utilisez --file pour spécifier les entrées dont vous avez besoin pour l’appel de votre point de terminaison.

   inputs.yml

   inputs:
     heart_dataset:
       type: uri_folder
       path: azureml://datastores/<data-store>/paths/<data-path>
   

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
   

   Si vos données sont un fichier, utilisez plutôt uri_file comme type.

   Python

   Conseil

   Quelle est la différence entre inputs et input lorsque vous appelez un point de terminaison ?

   En général, vous pouvez utiliser un dictionnaire inputs = {} avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison par lots contenant un modèle de déploiement ou un déploiement de pipelines.

   Pour un modèle de déploiement, vous pouvez utiliser input comme moyen plus court de spécifier l’emplacement des données d’entrée pour le déploiement, car un modèle de déploiement ne prend toujours qu’une seule entrée de données.

   Appelez la méthode invoke, en utilisant inputs pour spécifier les entrées requises :

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       inputs={
           "heart_dataset": input,
       }
   )
   

   Simplifiez davantage l’appel invoke d’un modèle de déploiement en utilisant input pour spécifier l’emplacement des données d’entrée :

   job = ml_client.batch_endpoints.invoke(
      endpoint_name=endpoint.name,
      input=input,
   )
   

   REST

   Requête

   POST jobs HTTP/1.1
   Host: <ENDPOINT_URI>
   Authorization: Bearer <TOKEN>
   Content-Type: application/json
   

Saisie de données à partir de comptes de stockage Azure

Les points de terminaison par lots Azure Machine Learning peuvent lire des données à partir d’emplacements cloud dans les comptes de stockage Azure publics et privés. Procédez comme suit pour exécuter un travail de point de terminaison par lots à l’aide de données stockées dans un compte de stockage :

Remarque

Consultez la section Configurer des clusters de calcul pour l’accès aux données pour en savoir plus sur la configuration supplémentaire requise pour lire correctement les données à partir de comptes de stockage.

1. Créez l’entrée ou la requête :

   Azure CLI

   INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
   

   Si vos données sont un fichier :

   INPUT_DATA = "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
   

   Python

   input = Input(
       type=AssetTypes.URI_FOLDER, 
       path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
   )
   

   Si vos données sont un fichier, modifiez type=AssetTypes.URI_FILE :

   input = Input(
       type=AssetTypes.URI_FILE,
       path="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
   )
   

   REST

   Corps

   {
       "properties": {
           "InputData": {
               "heart_dataset": {
                   "JobInputType" : "UriFolder",
                   "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
               }
           }
       }
   }
   

   Si vos données sont un fichier, modifiez JobInputType :

   Corps

   {
       "properties": {
           "InputData": {
               "heart_dataset": {
                   "JobInputType" : "UriFile",
                   "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data/heart.csv"
               }
           }
       }
   }
   

2. Exécutez le point de terminaison :

   Azure CLI

   Utilisez l’argument --set pour spécifier l’entrée :

   az ml batch-endpoint invoke --name $ENDPOINT_NAME \
       --set inputs.heart_dataset.type="uri_folder" inputs.heart_dataset.path=$INPUT_DATA
   

   Pour un point de terminaison qui sert un modèle de déploiement, vous pouvez utiliser l’argument --input pour spécifier l’entrée de données, car un modèle de déploiement nécessite toujours une seule entrée de données.

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $INPUT_DATA --input-type uri_folder
   

   L’argument --set a tendance à produire de longues commandes lorsque plusieurs entrées sont spécifiées. Dans ce cas, placez vos entrées dans un fichier YAML et utilisez --file pour spécifier les entrées dont vous avez besoin pour l’appel de votre point de terminaison.

   inputs.yml

   inputs:
     heart_dataset:
       type: uri_folder
       path: https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data
   

   az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml
   

   Si vos données sont un fichier, utilisez plutôt uri_file comme type.

   Python

   Conseil

   Quelle est la différence entre inputs et input lorsque vous appelez un point de terminaison ?

   En général, vous pouvez utiliser un dictionnaire inputs = {} avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison par lots contenant un modèle de déploiement ou un déploiement de pipelines.

   Pour un modèle de déploiement, vous pouvez utiliser input comme moyen plus court de spécifier l’emplacement des données d’entrée pour le déploiement, car un modèle de déploiement ne prend toujours qu’une seule entrée de données.

   Appelez la méthode invoke, en utilisant inputs pour spécifier les entrées requises :

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       inputs={
           "heart_dataset": input,
       }
   )
   

   Simplifiez davantage l’appel invoke d’un modèle de déploiement en utilisant input pour spécifier l’emplacement des données d’entrée :

   job = ml_client.batch_endpoints.invoke(
      endpoint_name=endpoint.name,
      input=input,
   )
   

   REST

   Requête

   POST jobs HTTP/1.1
   Host: <ENDPOINT_URI>
   Authorization: Bearer <TOKEN>
   Content-Type: application/json
   

Créer des tâches avec des entrées littérales

Les déploiements de composants de pipeline prennent en charge les entrées littérales. L’exemple suivant montre comment spécifier une entrée nommée score_mode, de type string, avec la valeur append :

Azure CLI

Placez vos entrées dans un fichier YAML et utilisez --file pour spécifier les entrées dont vous avez besoin pour l’appel de votre point de terminaison.

inputs.yml

inputs:
  score_mode:
    type: string
    default: append

az ml batch-endpoint invoke --name $ENDPOINT_NAME --file inputs.yml

Vous pouvez également utiliser l’argument --set pour spécifier la valeur. Il a toutefois tendance à produire de longues commandes quand plusieurs entrées sont spécifiées :

az ml batch-endpoint invoke --name $ENDPOINT_NAME \
    --set inputs.score_mode.type="string" inputs.score_mode.default="append"

Python

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint.name, 
    inputs = { 
        'score_mode': Input(type="string", default="append")
        }
)

REST

Corps

{
    "properties": {
        "InputData": {
            "score_mode": {
                "JobInputType" : "Literal",
                "Value": "append"
            }
        }
    }
}

Requête

POST jobs HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

Créer des tâches avec des sorties de données

L’exemple suivant montre comment modifier l’emplacement où une sortie nommée score est placée. À des fins d’exhaustivité, ces exemples configurent également une entrée nommée heart_dataset.

1. Utilisez le magasin de données par défaut dans l’espace de travail Azure Machine Learning pour enregistrer les sorties. Vous pouvez utiliser n’importe quel autre magasin de données dans votre espace de travail, tant qu’il s’agit d’un compte de stockage d’objets blob.

   Azure CLI

   DATASTORE_ID=$(az ml datastore show -n workspaceblobstore | jq -r '.id')
   

   Notes

   L’ID des banques de données ressemblerait à /subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>.

   Python

   default_ds = ml_client.datastores.get_default()
   

   REST

   Utilisez l’interface CLI Azure Machine Learning, le Kit de développement logiciel (SDK) Azure Machine Learning pour Python ou Studio pour obtenir les informations de magasin de données.

2. Créez une sortie de données :

   Azure CLI

   DATA_PATH="batch-jobs/my-unique-path"
   OUTPUT_PATH="$DATASTORE_ID/paths/$DATA_PATH"
   

   À des fins d’exhaustivité, créez également une entrée de données :

   INPUT_PATH="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
   

   Python

   data_path = "batch-jobs/my-unique-path"
   output = Output(type=AssetTypes.URI_FOLDER, path=f"{default_ds.id}/paths/{data_path})
   

   À des fins d’exhaustivité, nous allons également créer une entrée de données :

   input="https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
   

   REST

   Corps

   {
       "properties": {
           "InputData": {
              "heart_dataset": {
                  "JobInputType" : "UriFolder",
                  "Uri": "https://azuremlexampledata.blob.core.windows.net/data/heart-disease-uci/data"
              }
           },
           "OutputData": {
               "score": {
                   "JobOutputType" : "UriFile",
                   "Uri": "azureml:/subscriptions/<subscription>/resourceGroups/<resource-group/providers/Microsoft.MachineLearningServices/workspaces/<workspace>/datastores/<data-store>/paths/<data-path>"
               }
           }
       }
   }
   

   Notes

   Observez l’ajout du chemin paths à l’ID de ressource du magasin de données pour indiquer que la chaîne qui suit est un chemin dans celui-ci.

3. Exécutez le déploiement :

   Azure CLI

   Utilisez l’argument --set pour spécifier l’entrée :

   az ml batch-endpoint invoke --name $ENDPOINT_NAME \
       --set inputs.heart_dataset.path=$INPUT_PATH \
       --set outputs.score.path=$OUTPUT_PATH
   

   Python

   job = ml_client.batch_endpoints.invoke(
      endpoint_name=endpoint.name,
      inputs={ "heart_dataset": input },
      outputs={ "score": output }
   )
   

   REST

   Requête

   POST jobs HTTP/1.1
   Host: <ENDPOINT_URI>
   Authorization: Bearer <TOKEN>
   Content-Type: application/json
   

Étapes suivantes

• Résolution des problèmes de points de terminaison de traitement par lots.
• Personnaliser les sorties dans les déploiements par lots des modèles de déploiement.
• Créer un pipeline de scoring personnalisé avec des entrées et des sorties.
• Appel de points de terminaison par lots à partir d’Azure Data Factory.