Présentation des FPGA (Field Programmable Gate Arrays) et de la façon dont ils sont déployésWhat are field-programmable gate arrays (FPGA) and how to deploy

S’APPLIQUE À : ouiÉdition de base ouiÉdition Entreprise                    (Mise à niveau vers l’édition Entreprise)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Cet article présente les FGPA (Field-Programmable Gate Array) et explique comment déployer vos modèles à l’aide d’Azure Machine Learning sur un FPGA Azure.This article provides an introduction to field-programmable gate arrays (FPGA), and shows you how to deploy your models using Azure Machine Learning to an Azure FPGA.

Présentation des FPGAWhat are FPGAs

Les FPGA contiennent un tableau de blocs logiques programmables et une hiérarchie d’interconnexions reconfigurables.FPGAs contain an array of programmable logic blocks, and a hierarchy of reconfigurable interconnects. Les interconnexions permettent la configuration de ces blocs de différentes façons après leur fabrication.The interconnects allow these blocks to be configured in various ways after manufacturing. Par rapport aux autres circuits intégrés, les FPGA offrent une combinaison de programmabilité et de performances.Compared to other chips, FPGAs provide a combination of programmability and performance.

Diagramme de comparaison des FPGA Azure Machine Learning

ProcesseurProcessor AbréviationAbbreviation DescriptionDescription
Application Specific Integrated Circuit (Circuits intégrés spécifiques à une application)Application-specific integrated circuits ASICASICs Les circuits personnalisés, comme les TPU (TensorFlow Processor Units) de Google, offrent la meilleure efficacité.Custom circuits, such as Google's TensorFlow Processor Units (TPU), provide the highest efficiency. Ils ne peuvent pas être reconfigurés selon vos besoins.They can't be reconfigured as your needs change.
Field-Programmable Gate ArrayField-programmable gate arrays FPGAFPGAs Les FPGA, comme ceux disponibles sur Azure, offrent des performances approchant celles des ASIC.FPGAs, such as those available on Azure, provide performance close to ASICs. Ils sont flexibles et reconfigurables, afin de pouvoir implémenter de nouvelles logiques.They are also flexible and reconfigurable over time, to implement new logic.
GPU (Graphics Processing Unit, Unité de traitement graphique)Graphics processing units GPUGPUs Un choix courant pour les calculs en intelligence artificielle.A popular choice for AI computations. Les GPU offrent des fonctionnalités de traitement parallèle qui les rendent plus rapides que les UC pour le rendu des images.GPUs offer parallel processing capabilities, making it faster at image rendering than CPUs.
UC (Unité centrale)Central processing units UCCPUs Processeurs à usage général dont les performances ne sont pas idéales pour le traitement des images et de la vidéo.General-purpose processors, the performance of which isn't ideal for graphics and video processing.

Les FPGA permettent d’obtenir une latence faible pour les requêtes d’inférence en temps réel (ou notation de modèle).FPGAs make it possible to achieve low latency for real-time inference (or model scoring) requests. Les requêtes asynchrones (traitement par lot) ne sont pas nécessaires.Asynchronous requests (batching) aren't needed. Le traitement par lots peut entraîner une latence, car davantage de données doivent être traitées.Batching can cause latency, because more data needs to be processed. Les implémentations des unités de traitement neuronal ne nécessitent pas de traitement par lots. Ainsi, la latence peut être plusieurs fois inférieure à celle des UC et des GPU.Implementations of neural processing units don't require batching; therefore the latency can be many times lower, compared to CPU and GPU processors.

Vous pouvez reconfigurer les FGPA pour différents types de modèles Machine Learning.You can reconfigure FPGAs for different types of machine learning models. Cette souplesse permet d’accélérer les applications basées sur la précision numérique la plus optimale et le modèle de mémoire utilisé.This flexibility makes it easier to accelerate the applications based on the most optimal numerical precision and memory model being used. Étant donné que les FPGA sont reconfigurables, vous pouvez suivre l’évolution des besoins des algorithmes d’intelligence artificielle.Because FPGAs are reconfigurable, you can stay current with the requirements of rapidly changing AI algorithms.

Prise en charge des FPGA dans AzureFPGA support in Azure

Microsoft Azure constitue le plus important investissement cloud au monde en matière de FPGA.Microsoft Azure is the world's largest cloud investment in FPGAs. Microsoft utilise des FPGA pour l’évaluation des réseaux neuronaux profonds, le classement des recherches Bing et l’accélération réseau définie par logiciel pour réduire la latence, tout en libérant les UC pour d’autres tâches.Microsoft uses FPGAs for DNN evaluation, Bing search ranking, and software defined networking (SDN) acceleration to reduce latency, while freeing CPUs for other tasks.

Les FPGA sur Azure sont basés sur les FPGA d’Intel, que les scientifiques des données et les développeurs utilisent pour accélérer les calculs d’intelligence artificielle en temps réel.FPGAs on Azure are based on Intel's FPGA devices, which data scientists and developers use to accelerate real-time AI calculations. Cette architecture compatible avec les FPGA offre performances, flexibilité et scalabilité, et est disponible sur Azure.This FPGA-enabled architecture offers performance, flexibility, and scale, and is available on Azure.

Les FPGA Azure ne sont pas intégrés à Azure Machine Learning.Azure FPGAs are integrated with Azure Machine Learning. Azure peut mettre en parallèle des réseaux neuronaux profonds préentraînés sur des FPGA pour effectuer un scale-out de votre service.Azure can parallelize pre-trained deep neural networks (DNN) across FPGAs to scale out your service. Les réseaux neuronaux profonds peuvent être préentraînés, en tant que caractériseurs profonds pour l’apprentissage du transfert, ou optimisés avec des pondérations mises à jour.The DNNs can be pre-trained, as a deep featurizer for transfer learning, or fine-tuned with updated weights.

Les FPGA sur Azure prennent en charge :FPGAs on Azure supports:

  • Les scénarios de classification et de reconnaissance d’imagesImage classification and recognition scenarios
  • Déploiement de TensorFlow (requiert Tensorflow 1.x)TensorFlow deployment (requires Tensorflow 1.x)
  • Le matériel FPGA d’IntelIntel FPGA hardware

Ces modèles DNN sont actuellement disponibles :These DNN models are currently available:

  • ResNet 50ResNet 50
  • ResNet 152ResNet 152
  • DenseNet-121DenseNet-121
  • VGG-16VGG-16
  • SSD-VGGSSD-VGG

Les FGPA sont disponibles dans ces régions Azure :FPGAs are available in these Azure regions:

  • USA EstEast US
  • Asie Sud-EstSoutheast Asia
  • Europe OuestWest Europe
  • USA Ouest 2West US 2

Pour optimiser la latence et le débit, votre client qui envoie des données au modèle FGPA doit se trouver dans une des régions ci-dessus (celle dans laquelle vous avez déployé le modèle).To optimize latency and throughput, your client sending data to the FPGA model should be in one of the regions above (the one you deployed the model to).

La gamme de machines virtuelles Azure PBS contient des FPGA Intel Arria 10.The PBS Family of Azure VMs contains Intel Arria 10 FPGAs. Elle apparaît comme « Processeurs virtuels de gamme PBS Standard » lorsque vous vérifiez votre allocation de quota Azure.It will show as "Standard PBS Family vCPUs" when you check your Azure quota allocation. La machine virtuelle PB6 dispose de six processeurs virtuels et d’un FPGA, et elle est automatiquement approvisionnée par Azure Machine Learning dans le cadre du déploiement d’un modèle dans un FPGA.The PB6 VM has six vCPUs and one FPGA, and it will automatically be provisioned by Azure ML as part of deploying a model to an FPGA. Elle est uniquement utilisée avec Azure Machine Learning, et ne peut exécuter de flux binaires arbitraires.It is only used with Azure ML, and it cannot run arbitrary bitstreams. Par exemple, vous ne pouvez pas flasher le FPGA avec des flux binaires pour effectuer du chiffrement, de l’encodage, etc.For example, you will not be able to flash the FPGA with bitstreams to do encryption, encoding, etc.

Déployer des modèles sur des FPGADeploy models on FPGAs

Vous pouvez déployer un modèle en tant que service web sur FGPA avec des Modèles accélérés matériellement Azure Machine Learning.You can deploy a model as a web service on FPGAs with Azure Machine Learning Hardware Accelerated Models. L’utilisation de FGPA assure une inférence à très faible latence, même avec une taille de lot unique.Using FPGAs provides ultra-low latency inference, even with a single batch size. L’inférence, ou notation du modèle, est la phase où le modèle déployé est utilisé pour la prédiction, généralement sur des données de production.Inference, or model scoring, is the phase where the deployed model is used for prediction, most commonly on production data.

Le déploiement d’un modèle sur un FPGA implique les étapes suivantes :Deploying a model to an FPGA involves the following steps:

  1. Définir le modèle TensorFlowDefine the TensorFlow model
  2. Convertir le modèle au format ONNXConvert the model to ONNX
  3. Déployer le modèle sur le cloud ou un périphériqueDeploy the model to the cloud or an edge device
  4. Utiliser le modèle déployéConsume the deployed model

Dans cet exemple, vous créez un graph TensorFlow pour prétraiter l’image en entrée, en faire un caractériseur à l’aide de ResNet 50 sur un FPGA, et exécuter les fonctionnalités via un classificateur formé sur le jeu de données ImageNet.In this sample, you create a TensorFlow graph to preprocess the input image, make it a featurizer using ResNet 50 on an FPGA, and then run the features through a classifier trained on the ImageNet data set. Ensuite, le modèle est déployé sur un cluster AKS.Then, the model is deployed to an AKS cluster.

PrérequisPrerequisites

  • Un abonnement Azure.An Azure subscription. Le cas échéant, vous devrez créer un compte avec option de paiement à l’utilisation (les comptes Azure gratuits ne sont pas éligibles pour le quota de FPGA).If you do not have one, you will need to create a pay-as-you-go account (free Azure accounts are not eligible for FPGA quota).

  • Azure CLIAzure CLI

  • Quota FPGA.FPGA quota. Utilisez Azure CLI pour vérifier si vous disposez de quota :Use the Azure CLI to check whether you have quota:

    az vm list-usage --location "eastus" -o table --query "[?localName=='Standard PBS Family vCPUs']"
    

    La commande retourne du texte semblable au suivant :The command returns text similar to the following:

    CurrentValue    Limit    LocalName
    --------------  -------  -------------------------
    0               6        Standard PBS Family vCPUs
    

    Vérifiez que vous avez au moins six processeurs virtuels sous CurrentValue.Make sure you have at least 6 vCPUs under CurrentValue.

    Si vous n’avez pas de quota, envoyez une demande à https://aka.ms/accelerateAI.If you do not have quota, then submit a request at https://aka.ms/accelerateAI.

  • Un espace de travail Azure Machine Learning et le SDK Azure Machine Learning pour Python installé.An Azure Machine Learning workspace and the Azure Machine Learning SDK for Python installed. Pour plus d’informations, consultez Créer un espace de travail.For more information, see Create a workspace.

  • Le kit de développement logiciel (SDK) Python pour modèles accélérés matériellement :The Python SDK for hardware-accelerated models:

    pip install --upgrade azureml-accel-models[cpu]
    

1. Définir le modèle TensorFlow1. Define the TensorFlow model

Utilisez le SDK Azure Machine Learning pour Python pour créer une définition de service.Use the Azure Machine Learning SDK for Python to create a service definition. Une définition de service est un fichier décrivant un pipeline de graphes (entrée, caractériseur et classifieur) basé sur TensorFlow.A service definition is a file describing a pipeline of graphs (input, featurizer, and classifier) based on TensorFlow. La commande de déploiement compresse automatiquement la définition et les graphes dans un fichier ZIP, puis charge ce fichier dans Stockage Blob Azure.The deployment command automatically compresses the definition and graphs into a ZIP file, and uploads the ZIP to Azure Blob storage. Le réseau neuronal profond est déjà déployé pour s’exécuter sur le FPGA.The DNN is already deployed to run on the FPGA.

  1. Charger un espace de travail Azure Machine LearningLoad Azure Machine Learning workspace

    import os
    import tensorflow as tf
    
    from azureml.core import Workspace
    
    ws = Workspace.from_config()
    print(ws.name, ws.resource_group, ws.location, ws.subscription_id, sep='\n')
    
  2. Prétraitez l’image.Preprocess image. L’entrée du service web est une image JPEG.The input to the web service is a JPEG image. La première étape consiste à décoder l’image JPEG et la prétraiter.The first step is to decode the JPEG image and preprocess it. Les images JPEG sont traitées comme des chaînes, ce qui donne des tenseurs qui constituent l’entrée du modèle ResNet 50.The JPEG images are treated as strings and the result are tensors that will be the input to the ResNet 50 model.

    # Input images as a two-dimensional tensor containing an arbitrary number of images represented a strings
    import azureml.accel.models.utils as utils
    tf.reset_default_graph()
    
    in_images = tf.placeholder(tf.string)
    image_tensors = utils.preprocess_array(in_images)
    print(image_tensors.shape)
    
  3. Chargez un caractériseur.Load featurizer. Initialisez le modèle et téléchargez un point de contrôle TensorFlow de la version quantifiée de ResNet50 à utiliser comme caractériseur.Initialize the model and download a TensorFlow checkpoint of the quantized version of ResNet50 to be used as a featurizer. Vous pouvez remplacer « QuantizedResnet50 » dans l’extrait de code ci-dessous en important des autres réseaux neuronaux profonds :You may replace "QuantizedResnet50" in the code snippet below with by importing other deep neural networks:

    • QuantizedResnet152QuantizedResnet152
    • QuantizedVgg16QuantizedVgg16
    • Densenet121Densenet121
    from azureml.accel.models import QuantizedResnet50
    save_path = os.path.expanduser('~/models')
    model_graph = QuantizedResnet50(save_path, is_frozen=True)
    feature_tensor = model_graph.import_graph_def(image_tensors)
    print(model_graph.version)
    print(feature_tensor.name)
    print(feature_tensor.shape)
    
  4. Ajoutez un classifieur.Add a classifier. Ce classifieur a été entraîné sur le jeu de données ImageNet.This classifier has been trained on the ImageNet data set. Des exemples de transfert d’apprentissage et de formation de vos poids personnalisés sont disponibles dans l’ensemble d’exemples de blocs-notes.Examples for transfer learning and training your customized weights are available in the set of sample notebooks.

    classifier_output = model_graph.get_default_classifier(feature_tensor)
    print(classifier_output)
    
  5. Enregistrez le modèle.Save the model. Maintenant le préprocesseur, le caractériseur ResNet 50 et le classifieur ont été chargés, enregistrez le graph et les variables associées en tant que modèle.Now that the preprocessor, ResNet 50 featurizer, and the classifier have been loaded, save the graph and associated variables as a model.

    model_name = "resnet50"
    model_save_path = os.path.join(save_path, model_name)
    print("Saving model in {}".format(model_save_path))
    
    with tf.Session() as sess:
        model_graph.restore_weights(sess)
        tf.saved_model.simple_save(sess, model_save_path,
                                   inputs={'images': in_images},
                                   outputs={'output_alias': classifier_output})
    
  6. Enregistrez les tenseurs d’entrée et de sortie.Save input and output tensors. Les tenseurs d’entrée et de sortie qui ont été créés lors des étapes de prétraitement et du classifieur sont nécessaires pour l’inférence et la conversion de modèle.The input and output tensors that were created during the preprocessing and classifier steps will be needed for model conversion and inference.

    input_tensors = in_images.name
    output_tensors = classifier_output.name
    
    print(input_tensors)
    print(output_tensors)
    

    Important

    Enregistrez les tenseurs d’entrée et de sortie, vous en aurez besoin pour toute demande d’inférence ou de conversion de modèle.Save the input and output tensors because you will need them for model conversion and inference requests.

    Les modèles disponibles et les tenseurs de sortie du classifieur par défaut correspondants se trouvent ci-dessous. Il s’agit de ce que vous utilisez pour l’inférence si vous employez le classifieur par défaut.The available models and the corresponding default classifier output tensors are below, which is what you would use for inference if you used the default classifier.

    • Resnet50, QuantizedResnet50Resnet50, QuantizedResnet50
      output_tensors = "classifier_1/resnet_v1_50/predictions/Softmax:0"
      
    • Resnet152, QuantizedResnet152Resnet152, QuantizedResnet152
      output_tensors = "classifier/resnet_v1_152/predictions/Softmax:0"
      
    • Densenet121, QuantizedDensenet121Densenet121, QuantizedDensenet121
      output_tensors = "classifier/densenet121/predictions/Softmax:0"
      
    • Vgg16, QuantizedVgg16Vgg16, QuantizedVgg16
      output_tensors = "classifier/vgg_16/fc8/squeezed:0"
      
    • SsdVgg, QuantizedSsdVggSsdVgg, QuantizedSsdVgg
      output_tensors = ['ssd_300_vgg/block4_box/Reshape_1:0', 'ssd_300_vgg/block7_box/Reshape_1:0', 'ssd_300_vgg/block8_box/Reshape_1:0', 'ssd_300_vgg/block9_box/Reshape_1:0', 'ssd_300_vgg/block10_box/Reshape_1:0', 'ssd_300_vgg/block11_box/Reshape_1:0', 'ssd_300_vgg/block4_box/Reshape:0', 'ssd_300_vgg/block7_box/Reshape:0', 'ssd_300_vgg/block8_box/Reshape:0', 'ssd_300_vgg/block9_box/Reshape:0', 'ssd_300_vgg/block10_box/Reshape:0', 'ssd_300_vgg/block11_box/Reshape:0']
      

2. Convertir le modèle2. Convert the model

Avant de déployer le modèle sur des FPGA, vous devez le convertir au format ONNX.Before deploying the model to FPGAs, you have to convert it to ONNX format.

  1. Inscrivez le modèle en utilisant le SDK avec le fichier ZIP dans Stockage Blob Azure.Register the model by using the SDK with the ZIP file in Azure Blob storage. L’ajout de balises et autres modèles vous aide à suivre vos modèles formés.Adding tags and other metadata about the model helps you keep track of your trained models.

    from azureml.core.model import Model
    
    registered_model = Model.register(workspace=ws,
                                      model_path=model_save_path,
                                      model_name=model_name)
    
    print("Successfully registered: ", registered_model.name,
          registered_model.description, registered_model.version, sep='\t')
    

    Si vous avez déjà inscrit un modèle et que vous souhaitez le charger, vous pouvez le récupérer.If you've already registered a model and want to load it, you may retrieve it.

    from azureml.core.model import Model
    model_name = "resnet50"
    # By default, the latest version is retrieved. You can specify the version, i.e. version=1
    registered_model = Model(ws, name="resnet50")
    print(registered_model.name, registered_model.description,
          registered_model.version, sep='\t')
    
  2. Convertissez le graph TensorFlow au format ONNX (Open Neural Network Exchange).Convert the TensorFlow graph to the Open Neural Network Exchange format (ONNX). Vous devez renseigner les noms des tenseurs d’entrée et de sortie, et ces noms sont utilisés par votre client lorsque vous utilisez le service web.You will need to provide the names of the input and output tensors, and these names will be used by your client when you consume the web service.

    from azureml.accel import AccelOnnxConverter
    
    convert_request = AccelOnnxConverter.convert_tf_model(
        ws, registered_model, input_tensors, output_tensors)
    
    # If it fails, you can run wait_for_completion again with show_output=True.
    convert_request.wait_for_completion(show_output=False)
    
    # If the above call succeeded, get the converted model
    converted_model = convert_request.result
    print("\nSuccessfully converted: ", converted_model.name, converted_model.url, converted_model.version,
          converted_model.id, converted_model.created_time, '\n')
    

3. Conteneuriser et déployer le modèle3. Containerize and deploy the model

Créez l’image Docker à partir du modèle converti et de toutes les dépendances.Create Docker image from the converted model and all dependencies. Cette image Docker peut ensuite être déployée et instanciée.This Docker image can then be deployed and instantiated. Les cibles de déploiement prises en charge comprennent AKS dans le cloud ou un appareil edge tel qu’Azure Data Box Edge.Supported deployment targets include AKS in the cloud or an edge device such as Azure Data Box Edge. Vous pouvez aussi ajouter des balises et des descriptions à votre image Docker inscrite.You can also add tags and descriptions for your registered Docker image.

from azureml.core.image import Image
from azureml.accel import AccelContainerImage

image_config = AccelContainerImage.image_configuration()
# Image name must be lowercase
image_name = "{}-image".format(model_name)

image = Image.create(name=image_name,
                     models=[converted_model],
                     image_config=image_config,
                     workspace=ws)
image.wait_for_creation(show_output=False)

Répertoriez les images par balise et obtenez des journaux détaillés en cas de débogage.List the images by tag and get the detailed logs for any debugging.

for i in Image.list(workspace=ws):
    print('{}(v.{} [{}]) stored at {} with build log {}'.format(
        i.name, i.version, i.creation_state, i.image_location, i.image_build_log_uri))

Déployer sur un cluster AKSDeploy to AKS Cluster

  1. Pour déployer votre modèle en tant que service web de production à grande échelle, utilisez Azure Kubernetes Service (AKS).To deploy your model as a high-scale production web service, use Azure Kubernetes Service (AKS). Vous pouvez en créer un en utilisant le Kit de développement logiciel (SDK) Azure Machine Learning, l’interface CLI ou Azure Machine Learning Studio.You can create a new one using the Azure Machine Learning SDK, CLI, or Azure Machine Learning studio.

    from azureml.core.compute import AksCompute, ComputeTarget
    
    # Specify the Standard_PB6s Azure VM and location. Values for location may be "eastus", "southeastasia", "westeurope", or "westus2". If no value is specified, the default is "eastus".
    prov_config = AksCompute.provisioning_configuration(vm_size = "Standard_PB6s",
                                                        agent_count = 1,
                                                        location = "eastus")
    
    aks_name = 'my-aks-cluster'
    # Create the cluster
    aks_target = ComputeTarget.create(workspace=ws,
                                      name=aks_name,
                                      provisioning_configuration=prov_config)
    

    Le déploiement AKS peut prendre environ 15 minutes.The AKS deployment may take around 15 minutes. Vérifiez que le déploiement a réussi.Check to see if the deployment succeeded.

    aks_target.wait_for_completion(show_output=True)
    print(aks_target.provisioning_state)
    print(aks_target.provisioning_errors)
    
  2. Déployez le conteneur dans le cluster AKS.Deploy the container to the AKS cluster.

    from azureml.core.webservice import Webservice, AksWebservice
    
    # For this deployment, set the web service configuration without enabling auto-scaling or authentication for testing
    aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False,
                                                    num_replicas=1,
                                                    auth_enabled=False)
    
    aks_service_name = 'my-aks-service'
    
    aks_service = Webservice.deploy_from_image(workspace=ws,
                                               name=aks_service_name,
                                               image=image,
                                               deployment_config=aks_config,
                                               deployment_target=aks_target)
    aks_service.wait_for_deployment(show_output=True)
    

Déployer dans un serveur edge localDeploy to a local edge server

Tous les appareils Azure Data Box Edge contiennent un FPGA pour l’exécution du modèle.All Azure Data Box Edge devices contain an FPGA for running the model. Un seul modèle peut être exécuté à la fois sur le FGPA.Only one model can be running on the FPGA at one time. Pour exécuter un modèle différent, déployez simplement un nouveau conteneur.To run a different model, just deploy a new container. Vous trouverez des instructions et des exemples de code dans cet exemple Azure.Instructions and sample code can be found in this Azure Sample.

4. Utiliser le modèle déployé4. Consume the deployed model

L’image Docker prend en charge gRPC et l’API de prédiction TensorFlow Serving.The Docker image supports gRPC and the TensorFlow Serving "predict" API. Utilisez l’exemple de client pour appeler une image Docker pour obtenir des prédictions du modèle.Use the sample client to call into the Docker image to get predictions from the model. L’exemple de code client est disponible :Sample client code is available:

Si vous voulez utiliser TensorFlow Serving, vous pouvez télécharger un exemple du client.If you want to use TensorFlow Serving, you can download a sample client.

# Using the grpc client in Azure ML Accelerated Models SDK package
from azureml.accel import PredictionClient

address = aks_service.scoring_uri
ssl_enabled = address.startswith("https")
address = address[address.find('/')+2:].strip('/')
port = 443 if ssl_enabled else 80

# Initialize Azure ML Accelerated Models client
client = PredictionClient(address=address,
                          port=port,
                          use_ssl=ssl_enabled,
                          service_name=aks_service.name)

Comme ce classifieur a été formé sur un ensemble de données ImageNet, mappez les classes à des étiquettes pouvant être lues par des humains.Since this classifier was trained on the ImageNet data set, map the classes to human-readable labels.

import requests
classes_entries = requests.get(
    "https://raw.githubusercontent.com/Lasagne/Recipes/master/examples/resnet50/imagenet_classes.txt").text.splitlines()

# Score image with input and output tensor names
results = client.score_file(path="./snowleopardgaze.jpg",
                            input_name=input_tensors,
                            outputs=output_tensors)

# map results [class_id] => [confidence]
results = enumerate(results)
# sort results by confidence
sorted_results = sorted(results, key=lambda x: x[1], reverse=True)
# print top 5 results
for top in sorted_results[:5]:
    print(classes_entries[top[0]], 'confidence:', top[1])

Nettoyer les ressourcesClean up resources

Supprimez votre service web, votre image et votre modèle (en suivant cet ordre, car il s’agit de dépendances).Delete your web service, image, and model (must be done in this order since there are dependencies).

aks_service.delete()
aks_target.delete()
image.delete()
registered_model.delete()
converted_model.delete()

Étapes suivantesNext steps

Consultez ces notebooks, vidéos et ces blogs :Check out these notebooks, videos, and blogs: