Platform For AI:Processeurs intégrés

Le processeur PMML dans EAS :

• Charge un fichier de modèle PMML en tant que service.

• Traite les requêtes adressées au service de modèle.

• Calcule et renvoie les résultats de prédiction au client.

Le processeur PMML applique une stratégie par défaut pour gérer les valeurs manquantes. Si aucune politique isMissing n'est spécifiée pour les colonnes de caractéristiques dans le fichier de modèle PMML, le système les remplace par les valeurs par défaut suivantes.

Déployez un modèle PMML en utilisant l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur PMML. Pour plus d'informations, consultez la rubrique Déployer un service de modèle via la console.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez processor sur pmml. Exemple :

  {
    "processor": "pmml",
    "generate_token": "true",
    "model_path": "http://xxxxx/lr.pmml",
    "name": "eas_lr_example",
    "metadata": {
      "instance": 1,
      "cpu": 1 # EAS allocates 4 GB of memory per CPU core (1 Quota).
    }
  }

• Data Science Workshop (DSW)

  De manière similaire à l'utilisation du client EASCMD, créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer un service de modèle avec EASCMD.

Le processeur EAS TensorFlow 1.12 charge les modèles TensorFlow aux formats SavedModel (recommandé) ou SessionBundle. Convertissez les modèles Keras et Checkpoint au format SavedModel avant le déploiement. Pour plus d'informations, consultez la rubrique FAQ TensorFlow.

Déployez un modèle TensorFlow en utilisant l'une des méthodes suivantes :

• Console

  Définissez Processor Type sur TensorFlow1,12. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez processor sur tensorflow_cpu_1,12 ou tensorflow_gpu_1,12. Sélectionnez le code en fonction des ressources de déploiement. Une inadéquation entre processor et le type de ressource entraîne l'échec du déploiement. Exemple :

  {
    "name": "tf_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/savedmodel_example.zip",
    "processor": "tensorflow_cpu_1.12",
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 0,
      "memory": 2000
    }
  }

• DSW

  De manière similaire à l'utilisation du client EASCMD, créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD.

Le processeur EAS TensorFlow 1.14 charge les modèles TensorFlow aux formats SavedModel (recommandé) ou SessionBundle. Convertissez les modèles Keras et Checkpoint au format SavedModel avant le déploiement. Pour plus d'informations, consultez la rubrique FAQ TensorFlow.

Déployez un modèle TensorFlow en utilisant l'une des méthodes suivantes :

• Console

  Définissez Processor Type sur TensorFlow1,14. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez processor sur tensorflow_cpu_1,14 ou tensorflow_gpu_1,14. Sélectionnez le code correspondant à vos ressources de déploiement. Une inadéquation entre processor et le type de ressource entraîne l'échec du déploiement. Exemple :

  {
    "name": "tf_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/savedmodel_example.zip",
    "processor": "tensorflow_cpu_1.14",
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 0,
      "memory": 2000
    }
  }

• DSW

  De manière similaire à l'utilisation du client EASCMD, créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD.

Le processeur EAS TensorFlow 1.15 charge les modèles TensorFlow aux formats SavedModel (recommandé) ou SessionBundle. Convertissez les modèles Keras et Checkpoint au format SavedModel avant le déploiement. Pour plus d'informations, consultez la rubrique FAQ TensorFlow.

Déployez un modèle TensorFlow en utilisant l'une des méthodes suivantes :

• Console

  Définissez Processor Type sur TensorFlow1,15. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• EASCMD

  Dans le fichier de configuration service.json, définissez processor sur tensorflow_cpu_1,15 ou tensorflow_gpu_1,15. Sélectionnez le code correspondant à vos ressources de déploiement. Une inadéquation entre processor et le type de ressource entraîne l'échec du déploiement. Exemple :

  {
    "name": "tf_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/savedmodel_example.zip",
    "processor": "tensorflow_cpu_1.15",
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 0,
      "memory": 2000
    }
  }

• DSW

  De manière similaire à l'utilisation d'EASCMD, créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD. Pour obtenir la description des paramètres, consultez la rubrique Créer un service.

Le processeur EAS TensorFlow 2.3 charge les modèles TensorFlow au format SavedModel (recommandé) ou SessionBundle. Convertissez les modèles Keras et Checkpoint au format SavedModel avant le déploiement. Pour plus d'informations, consultez la rubrique FAQ TensorFlow.

Déployez un modèle TensorFlow en utilisant l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur TensorFlow2,3. Pour plus d'informations, consultez la rubrique Déployer un service via la console.

• EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur tensorflow_cpu_2,3 Exemple :

  {
    "name": "tf_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/savedmodel_example.zip",
    "processor": "tensorflow_cpu_2.3",
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 0,
      "memory": 2000
    }
  }

• DSW

  La procédure est similaire à celle utilisant EASCMD. Créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD.

Le processeur EAS PyTorch 1.6 charge les modèles au format TorchScript. Pour plus d'informations, consultez la documentation officielle TorchScript.

Déployez un modèle TorchScript en utilisant l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur PyTorch 1.6. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur pytorch_cpu_1,6 ou pytorch_gpu_1,6. Sélectionnez la valeur en fonction des ressources de déploiement. Une inadéquation entre le paramètre processor et le type de ressource entraîne l'échec du déploiement. Exemple :

  {
    "name": "pytorch_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/torchscript_model.pt",
    "processor": "pytorch_gpu_1.6",
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 1,
      "cuda": "10.0",
      "memory": 2000
    }
  }

• DSW

  La procédure est similaire à celle utilisant le client EASCMD. Créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD. Pour une description des paramètres, consultez la rubrique Créer un service.

Le processeur EAS Caffe charge les modèles de deep learning entraînés avec Caffe. Spécifiez les noms du modèle et du fichier de poids dans le package de modèle.

Déployez un modèle Caffe en utilisant les méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur Caffe. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur caffe_cpu ou caffe_gpu en fonction du type de ressource. Une inadéquation entre le paramètre processor et le type de ressource entraîne l'échec du déploiement. Exemple :

  {
    "name": "caffe_serving_test",
    "generate_token": "true",
    "model_path": "http://xxxxx/caffe_model.zip",
    "processor": "caffe_cpu",
    "model_config": {
      "model": "deploy.prototxt",
      "weight": "bvlc_reference_caffenet.caffemodel"
    },
    "metadata": {
      "instance": 1,
      "cpu": 1,
      "gpu": 0,
      "memory": 2000
    }
  }

• DSW

  La procédure est similaire à celle utilisant le client EASCMD. Créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec EASCMD.

Déployez un modèle PS et envoyez des requêtes au service.

• Déployez un modèle PS en utilisant l'une des méthodes suivantes :

  • Console

    Définissez le paramètre Processor Type sur PS Algorithm. Pour plus d'informations, consultez la rubrique Déploiement personnalisé.

  • Client EASCMD

    Dans le fichier de configuration service.json, définissez le paramètre processor sur parameter_sever.

    {
      "name":"ps_smart",
      "model_path": "oss://examplebucket/xlab_m_pai_ps_smart_b_1058272_v0.tar.gz",
      "processor": "parameter_sever",
      "metadata": {
        "region": "beijing",
        "cpu": 1,
        "instance": 1,
        "memory": 2048
      }
    }

  • DSW

    La procédure est similaire à celle utilisant le client EASCMD. Créez un fichier de configuration service.json. Pour plus d'informations, consultez la rubrique Déployer des services de modèle avec le client EASCMD.

• Format de requête

  Le processeur prend en charge les prédictions simples et par lots. Le format de requête est identique : un tableau JSON d'objets de caractéristiques.

  • Exemple de requête simple

    curl "http://eas.location/api/predict/ps_smart" -d "[
                {
                    "f0": 1,
                    "f1": 0.2,
                    "f3": 0.5
                }
    ]"

  • Exemple de requête par lot

    curl "http://eas.location/api/predict/ps_smart" -d "[
            {
                "f0": 1,
                "f1": 0.2,
                "f3": 0.5
            },
            {
                "f0": 1,
                "f1": 0.2,
                "f3": 0.5
            }
    ]"

  • Réponse

    Le format de réponse est identique pour les requêtes simples et par lots : un tableau d'objets de réponse. Chaque objet de réponse correspond à l'objet de requête situé à la même position.

    [
      {
        "label":"xxxx",
        "score" : 0.2,
        "details" : [{"k1":0.3}, {"k2":0.5}]
      },
      {
        "label":"xxxx",
        "score" : 0.2,
        "details" : [{"k1":0.3}, {"k2":0.5}]
      }
    ]

Déployez un modèle EasyTransfer en utilisant les méthodes suivantes :

• Console

  Sélectionnez EasyTransfer pour le paramètre Processor Type. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur easytransfer_cpu ou easytransfer_gpu en fonction des ressources de déploiement. Une inadéquation entre le paramètre processor et les ressources entraîne l'échec du déploiement. Dans le paramètre model_config, définissez le paramètre type sur le type de modèle utilisé lors de l'entraînement. L'exemple suivant utilise un modèle de classification de texte. Pour les autres paramètres, consultez la rubrique Créer un service.

  • Configuration pour le déploiement GPU (en utilisant un groupe de ressources public à titre d'exemple)

    {
      "name": "et_app_demo",
      "metadata": {
        "instance": 1
      },
      "cloud": {
        "computing": {
          "instance_type": "ecs.gn6i-c4g1.xlarge"
        }
      },
      "model_path": "http://xxxxx/your_model.zip",
      "processor": "easytransfer_gpu",
      "model_config": {
        "type": "text_classify_bert"
      }
    }

  • Configuration pour le déploiement CPU

    {
      "name": "et_app_demo",
      "model_path": "http://xxxxx/your_model.zip",
      "processor": "easytransfer_cpu",
      "model_config": {
        "type":"text_classify_bert"
      },
      "metadata": {
        "instance": 1,
        "cpu": 1,
        "memory": 4000
      }
    }

  Types de tâches pris en charge :

  Type de tâche	Type
  Correspondance de texte	text_match_bert
  Classification de texte	text_classify_bert
  Étiquetage de séquence	sequence_labeling_bert
  Vectorisation de texte	vectorization_bert

Déployez un modèle EasyNLP en utilisant l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur EasyNLP. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur easynlp. Dans le paramètre model_config, définissez le paramètre type sur le type de tâche d'entraînement. L'exemple suivant utilise un modèle de classification de texte à étiquette unique. Pour les autres paramètres, consultez la rubrique Créer un service.

  {
    "name": "easynlp_app_demo",
    "metadata": {
      "instance": 1
    },
    "cloud": {
      "computing": {
        "instance_type": "ecs.gn6i-c4g1.xlarge"
      }
    },
    "model_config": {
      "app_name": "text_classify",
      "type": "text_classify"
    },
    "model_path": "http://xxxxx/your_model.tar.gz",
    "processor": "easynlp"
  }

  Types de tâches pris en charge :

  Type de tâche	Valeur
  Classification de texte à étiquette unique	text_classify
  Classification de texte multi-étiquettes	text_classify_multi
  Correspondance de texte	text_match
  Étiquetage de séquence	sequence_labeling
  Vectorisation de texte	vectorization
  Résumé de texte chinois (GPU)	sequence_generation_zh
  Résumé de texte anglais (GPU)	sequence_generation_en
  Compréhension de lecture automatique (chinois)	machine_reading_comprehension_zh
  Compréhension de lecture automatique (anglais)	machine_reading_comprehension_en
  WUKONG_CLIP (GPU)	wukong_clip
  CLIP (GPU)	clip

Après le déploiement, sur la page Elastic Algorithm Service (EAS), cliquez sur Invocation Information dans la colonne Service Type du service cible pour afficher l'endpoint et le jeton. Appelez le service en utilisant l'exemple Python suivant.

import requests
# Replace with your service endpoint.
url = '<eas-service-url>'
# Replace with your token.
token = '<eas-service-token>'
# Prepare the request data. The following example is for text classification.
request_body = {
    "first_sequence": "hello"
}
 
headers = {"Authorization": token}
resp = requests.post(url=url, headers=headers, json=request_body)
print(resp.content.decode())

Déployez un modèle EasyCV en utilisant l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur EasyCV. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur easycv. Dans le paramètre model_config, définissez le paramètre type sur le type de modèle utilisé lors de l'entraînement. L'exemple suivant utilise un modèle de classification d'images. Pour les autres paramètres, consultez la rubrique Créer un service.

  {
    "name": "easycv_classification_example",
    "processor": "easycv",
    "model_path": "oss://examplebucket/epoch_10_export.pt",
    "model_config": {"type":"TorchClassifier"},
    "metadata": {
      "instance": 1
    },
    "cloud": {
      "computing": {
        "instance_type": "ecs.gn5i-c4g1.xlarge"
      }
    }
  }

  Types de travaux pris en charge :

  Type de travail	model_config
  Classification d'images	{"type":"TorchClassifier"}
  Détection d'objets	{"type":"DetectionPredictor"}
  Segmentation sémantique	{"type":"SegmentationPredictor"}
  YOLOX	{"type":"YoloXPredictor"}
  Classification vidéo	{"type":"VideoClassificationPredictor"}

Après le déploiement, accédez à la page Elastic Algorithm Service (EAS). Localisez le service, puis dans la colonne Service Type, cliquez sur Invocation Information pour afficher l'endpoint et le jeton. L'exemple Python suivant illustre l'appel du service.

import requests
import base64
import json
resp = requests.get('http://examplebucket.oss-cn-zhangjiakou.aliyuncs.com/images/000000123213.jpg')
ENCODING = 'utf-8'
datas = json.dumps( {
            "image": base64.b64encode(resp.content).decode(ENCODING)
            })
# Replace with your authentication token.
head = {
   "Authorization": "NTFmNDJlM2E4OTRjMzc3OWY0NzI3MTg5MzZmNGQ5Yj***"
}
for x in range(0,10):
  	# Replace with your service endpoint.
    resp = requests.post("http://150231884461***.cn-hangzhou.pai-eas.aliyuncs.com/api/predict/easycv_classification_example", data=datas, headers=head)
    print(resp.text)
                            

Encodez les données d'image ou de vidéo en Base64 pour la transmission. Utilisez la clé image pour les données d'image et la clé video pour les données vidéo.

Déployez un modèle EasyVision selon l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur EasyVision. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur easy_vision_cpu_tf1,12_torch151 ou easy_vision_gpu_tf1,12_torch151. Sélectionnez le code correspondant à vos ressources de déploiement. Une inadéquation entre le paramètre processor et le type de ressource entraîne l'échec du déploiement. Dans la section model_config, définissez le paramètre type sur le type de modèle utilisé lors de l'entraînement. Exemples. Pour les autres paramètres, reportez-vous à la rubrique Créer un service :

  • Configuration pour un déploiement sur GPU

    {
      "name": "ev_app_demo",
      "processor": "easy_vision_gpu_tf1.12_torch151",
      "model_path": "oss://path/to/your/model",
      "model_config": "{\"type\":\"classifier\"}",
      "metadata": {
        "resource": "your_resource_name",
        "cuda": "9.0",
        "instance": 1,
        "memory": 4000,
        "gpu": 1,
        "cpu": 4,
        "rpc.worker_threads" : 5
      }
    }

  • Configuration pour un déploiement sur CPU

    {
      "name": "ev_app_cpu_demo",
      "processor": "easy_vision_cpu_tf1.12_torch151",
      "model_path": "oss://path/to/your/model",
      "model_config": "{\"type\":\"classifier\"}",
      "metadata": {
        "resource": "your_resource_name",
        "instance": 1,
        "memory": 4000,
        "gpu": 0,
        "cpu": 4,
        "rpc.worker_threads" : 5
      }
    }

Déployez un modèle MediaFlow selon l'une des méthodes suivantes :

• Console

  Définissez le paramètre Processor Type sur MediaFlow. Pour plus d'informations, consultez la rubrique Déployer un service d'inférence personnalisé.

• Client EASCMD

  Dans le fichier de configuration service.json, définissez le paramètre processor sur mediaflow. Ce processeur nécessite des champs de configuration supplémentaires. Pour les autres champs, reportez-vous à la rubrique Créer un service :

  • graph_pool_size : nombre de pools de graphes.

  • worker_threads : nombre de threads de travail.

  Exemples :

  • Configuration pour le déploiement d'un modèle de classification vidéo.

    {
      "model_entry": "video_classification/video_classification_ext.js", 
      "name": "video_classification", 
      "model_path": "oss://path/to/your/model", 
      "generate_token": "true", 
      "processor": "mediaflow", 
      "model_config" : {
          "graph_pool_size":8,
          "worker_threads":16
      },
      "metadata": {
        "eas.handlers.disable_failure_handler" :true,
        "resource": "your_resource_name", 
          "rpc.worker_threads": 30,
          "rpc.enable_jemalloc": true,
        "rpc.keepalive": 500000, 
        "cpu": 4, 
        "instance": 1, 
        "cuda": "9.0", 
        "rpc.max_batch_size": 64, 
        "memory": 10000, 
        "gpu": 1 
      }
    }

  • Configuration pour le déploiement d'un modèle de reconnaissance automatique de la parole (ASR).

    {
      "model_entry": "asr/video_asr_ext.js", 
      "name": "video_asr", 
      "model_path": "oss://path/to/your/model", 
      "generate_token": "true", 
      "processor": "mediaflow", 
      "model_config" : {
          "graph_pool_size":8,
          "worker_threads":16
      },
      "metadata": {
        "eas.handlers.disable_failure_handler" :true,
        "resource": "your_resource_name", 
          "rpc.worker_threads": 30,
          "rpc.enable_jemalloc": true,
        "rpc.keepalive": 500000, 
        "cpu": 4, 
        "instance": 1, 
        "cuda": "9.0", 
        "rpc.max_batch_size": 64, 
        "memory": 10000, 
        "gpu": 1 
      }
    }

  Les configurations pour l'ASR et la classification vidéo diffèrent principalement par les paramètres model_entry, name et model_path. Modifiez ces champs en fonction de votre modèle.

Triton Inference Server est un framework de service en ligne développé par NVIDIA. Il fournit une interface pour le déploiement et la gestion de modèles sur GPU et est compatible avec la norme d'API KFServing. Principales fonctionnalités :

• Déploiement de modèles issus de divers frameworks, tels que TensorFlow, PyTorch, ONNX Runtime, TensorRT et des backends personnalisés.

• Exécution simultanée de plusieurs modèles sur un même GPU pour optimiser l'utilisation des ressources.

• Prise en charge des protocoles HTTP/gRPC et de l'extension de format binaire pour réduire la taille des requêtes.

• Prise en charge du Dynamic Batching pour améliorer le débit du service.

Triton Inference Server est disponible sur EAS sous forme de processeur Triton intégré.

Déployez et appelez un service utilisant le processeur Triton.

• Déploiement avec le processeur Triton

  Le déploiement des services de modèles Triton s'effectue exclusivement via EASCMD. Pour plus d'informations, consultez la rubrique Créer un service. Dans le fichier de configuration service.json, définissez le paramètre processor sur triton. Étant donné que Triton récupère les modèles depuis OSS, configurez les paramètres OSS requis. Exemple de fichier service.json :

  {
    "name": "triton_test",                          
    "processor": "triton",
    "processor_params": [
      "--model-repository=oss://triton-model-repo/models", 
      "--allow-http=true", 
    ],
    "metadata": {
      "instance": 1,
      "cpu": 4,
      "gpu": 1,
      "memory": 10000,
      "resource":"<your resource id>"
    }
  }

  Les paramètres spécifiques à Triton sont répertoriés ci-dessous. Pour les autres paramètres, reportez-vous à la rubrique Paramètres dans service.json.

  Paramètre		Description
  processor_params		Paramètres transmis à Triton Server au démarrage. Les paramètres non pris en charge sont automatiquement filtrés. Les paramètres pris en charge sont répertoriés dans l'ensemble de paramètres pouvant être transmis au serveur Triton suivant. Le paramètre model-repository est obligatoire. Pour les paramètres facultatifs, consultez le fichier main.cc.
  oss_endpoint		Endpoint OSS. Si ce paramètre n'est pas spécifié, le système utilise OSS dans la même région que le service EAS. Spécifiez ce paramètre pour un OSS interrégional. Pour les valeurs, consultez la rubrique Régions et endpoints.
  metadata	resource	ID du groupe de ressources exclusif EAS pour le déploiement du service de modèle. Le processeur Triton nécessite un groupe de ressources exclusif EAS. Pour plus d'informations, consultez la rubrique Utiliser des groupes de ressources exclusifs EAS.

  Tableau 1. Paramètres pris en charge pour le serveur Triton

  Paramètre	Obligatoire	Description
  model-repository	Oui	Le chemin doit être spécifié sous la forme d'un chemin OSS. Le système ne prend pas en charge l'utilisation directe du répertoire racine du bucket comme model-repository. Vous devez spécifier un sous-répertoire du bucket. Par exemple, oss://triton-model-repo/models, où triton-model-repo est le nom du bucket et models est un sous-répertoire du bucket.
  log-verbose	Non	Pour plus d'informations, consultez le fichier main.cc.
  log-info	Non
  log-warning	Non
  log-error	Non
  exit-on-error	Non
  strict-model-config	Non
  strict-readiness	Non
  allow-http	Non
  http-thread-count	Non
  pinned-memory-pool-byte-size	Non
  cuda-memory-pool-byte-size	Non
  min-supported-compute-capability	Non
  buffer-manager-thread-count	Non
  backend-config	Non

• Appel du service avec le client Triton natif

  Installez le client Triton officiel de NVIDIA :

  pip3 install nvidia-pyindex
  pip3 install tritonclient[all]

  Téléchargez une image de test :

  wget http://pai-blade.oss-cn-zhangjiakou.aliyuncs.com/doc-assets/cat.png

  Envoyez une requête au format binaire au service du processeur Triton à l'aide du client Python :

  import numpy as np
  import time
  from PIL import Image
  
  import tritonclient.http as httpclient
  from tritonclient.utils import InferenceServerException
  
  URL = "<service url>"  # Replace <service url> with your service endpoint.
  HEADERS = {"Authorization": "<service token>"} # Replace <service token> with your service access token.
  input_img = httpclient.InferInput("input", [1, 299, 299, 3], "FP32")
  img = Image.open('./cat.png').resize((299, 299))
  img = np.asarray(img).astype('float32') / 255.0
  input_img.set_data_from_numpy(img.reshape([1, 299, 299, 3]), binary_data=True)
  
  output = httpclient.InferRequestedOutput(
      "InceptionV3/Predictions/Softmax", binary_data=True
  )
  triton_client = httpclient.InferenceServerClient(url=URL, verbose=False)
  
  start = time.time()
  for i in range(10):
      results = triton_client.infer(
          "inception_graphdef", inputs=[input_img], outputs=[output], headers=HEADERS
      )
      res_body = results.get_response()
      elapsed_ms = (time.time() - start) * 1000
      if i == 0:
          print("model name: ", res_body["model_name"])
          print("model version: ", res_body["model_version"])
          print("output name: ", res_body["outputs"][0]["name"])
          print("output shape: ", res_body["outputs"][0]["shape"])
      print("[{}] Avg rt(ms): {:.2f}".format(i, elapsed_ms))
      start = time.time()