Tous les produits
Search

Ce produit

    Container Service for Kubernetes:Analyze and optimize models

    Centre de documentation

    Container Service for Kubernetes:Analyze and optimize models

    Dernière mise à jour :Sep 21, 2026

    Pour garantir qu'un modèle respecte les critères de mise en production avant son déploiement, utilisez l'outil d'analyse de modèles pour le benchmarker, profiler ses performances et l'optimiser. Cette rubrique utilise le modèle PyTorch ResNet18 sur des GPU V100 comme exemple.

    Prérequis

    Assurez-vous d'avoir :

    Fonctionnement

    Les data scientists optimisent la précision, tandis que les ingénieurs se concentrent sur les performances d'inférence. Effectuez des benchmarks et du profilage avant le déploiement pour vous assurer que le modèle atteint les objectifs de latence et de débit.

    Arena fournit des commandes pour chaque phase du cycle de vie du modèle :

    Model lifecycle

    Phase Objectif
    Entraînement du modèle Entraîner le modèle sur un jeu de données
    Benchmark du modèle Vérifier si la latence, le débit et l'utilisation du GPU répondent aux exigences
    Profilage du modèle Identifier les goulots d'étranglement de performance
    Optimisation du modèle Améliorer les performances d'inférence GPU avec des outils tels que TensorRT
    Service du modèle Déployer le modèle en tant que service en ligne
    Si le modèle ne répond toujours pas aux exigences après optimisation, répétez le cycle benchmark → profilage → optimisation.

    Toutes les commandes d'analyse s'exécutent via arena model analyze. Affichez les sous-commandes :

    arena model analyze --help

    Résultat :

    submit a model analyze job.

Available Commands:
  benchmark   Submit a model benchmark job
  delete      Delete a model job
  evaluate    Submit a model evaluate job
  get         Get a model job
  list        List all the model jobs
  optimize    Submit a model optimize job, this is a experimental feature
  profile     Submit a model profile job

    Étape 1 : Préparer un modèle

    Convertissez le modèle ResNet18 au format TorchScript et téléchargez-le sur OSS.

    1. Convertissez et enregistrez le modèle :

      Paramètre Description
      model_name Nom du modèle
      model_platform Plateforme ou framework, tel que TorchScript ou ONNX
      model_path Chemin de stockage du modèle.
      inputs Paramètres d'entrée
      outputs Paramètres de sortie 
      import torch
import torchvision

model = torchvision.models.resnet18(pretrained=True)

# Switch the model to eval mode
model.eval()

# An example input you would normally provide to your model's forward() method
dummy_input = torch.rand(1, 3, 224, 224)

# Use torch.jit.trace to generate a torch.jit.ScriptModule via tracing
traced_script_module = torch.jit.trace(model, dummy_input)

# Save the TorchScript model
traced_script_module.save("resnet18.pt")

    2. Téléchargez resnet18.pt vers oss://bucketname/models/resnet18/resnet18.pt. Consultez la documentation Upload objects.

    Étape 2 : Benchmarker le modèle

    Évaluez le modèle par rapport aux objectifs de latence, de débit et d'utilisation du GPU. Cet exemple utilise un PVC nommé oss-pvc dans le namespace default.

    1. Créez un fichier de configuration de modèle config.json :

      {
  "model_name": "resnet18",
  "model_platform": "torchscript",
  "model_path": "/data/models/resnet18/resnet18.pt",
  "inputs": [
    {
      "name": "input",
      "data_type": "float32",
      "shape": [1, 3, 224, 224]
    }
  ],
  "outputs": [
    {
      "name": "output",
      "data_type": "float32",
      "shape": [1000]
    }
  ]
}

    2. Téléchargez config.json vers oss://bucketname/models/resnet18/config.json.

    3. Soumettez la tâche de benchmark :

      Important

      Les options --requests et --duration sont mutuellement exclusives ; --duration est prioritaire si les deux sont définies. Utilisez --requests pour un nombre fixe de requêtes plutôt qu'une limite de temps.

      Paramètre Description
      --gpus Nombre de GPU à utiliser
      --data Nom du PVC et chemin de montage
      --model-config-file Chemin vers le fichier de configuration du modèle
      --report-path Chemin de sortie pour le rapport de benchmark.
      --concurrency Nombre de requêtes simultanées
      --duration Durée du benchmark, en secondes. 
      arena model analyze benchmark \
  --name=resnet18-benchmark \
  --namespace=default \
  --image=registry.cn-beijing.aliyuncs.com/kube-ai/easy-inference:1.0.2 \
  --gpus=1 \
  --data=oss-pvc:/data \
  --model-config-file=/data/models/resnet18/config.json \
  --report-path=/data/models/resnet18 \
  --concurrency=5 \
  --duration=60

    4. Vérifiez l'état de la tâche :

      arena model analyze list -A

      Résultat attendu :

      NAMESPACE  NAME                STATUS    TYPE       DURATION  AGE  GPU(Requested)
default    resnet18-benchmark  COMPLETE  Benchmark  0s        2d   1

    5. Lorsque l'état est COMPLETE, récupérez benchmark_result.txt depuis le répertoire --report-path :

      Métrique Description Unité
      p90_latency Temps de réponse au 90e percentile Millisecondes
      p95_latency Temps de réponse au 95e percentile Millisecondes
      p99_latency Temps de réponse au 99e percentile Millisecondes
      min_latency Temps de réponse le plus rapide Millisecondes
      max_latency Temps de réponse le plus lent Millisecondes
      mean_latency Temps de réponse moyen Millisecondes
      median_latency Temps de réponse médian Millisecondes
      throughput Débit Requêtes/seconde
      gpu_mem_used Utilisation de la mémoire GPU Go
      gpu_utilization Utilisation du GPU Pourcentage 
      {
    "p90_latency": 7.511,
    "p95_latency": 7.86,
    "p99_latency": 9.34,
    "min_latency": 7.019,
    "max_latency": 12.269,
    "mean_latency": 7.312,
    "median_latency": 7.206,
    "throughput": 136,
    "gpu_mem_used": 1.47,
    "gpu_utilization": 21.280
}

    Étape 3 : Profiler le modèle

    Exécutez arena model analyze profile pour identifier où le modèle passe du temps lors de l'inférence. Le profileur génère un rapport TensorBoard détaillé par opérateur.

    1. Soumettez la tâche de profilage :

      Paramètre Description
      --gpus Nombre de GPU à utiliser
      --data Nom du PVC et chemin de montage
      --model-config-file Chemin vers le fichier de configuration du modèle
      --report-path Chemin de sortie pour le rapport de profilage.
      --tensorboard Active TensorBoard pour afficher le rapport de profilage.
      --tensorboard-image Image du conteneur TensorBoard. 
      arena model analyze profile \
  --name=resnet18-profile \
  --namespace=default \
  --image=registry.cn-beijing.aliyuncs.com/kube-ai/easy-inference:1.0.2 \
  --gpus=1 \
  --data=oss-pvc:/data \
  --model-config-file=/data/models/resnet18/config.json \
  --report-path=/data/models/resnet18/log/ \
  --tensorboard \
  --tensorboard-image=registry.cn-beijing.aliyuncs.com/kube-ai/easy-inference:1.0.2

    2. Vérifiez l'état de la tâche :

      arena model analyze list -A

      Résultat attendu :

      NAMESPACE  NAME              STATUS    TYPE     DURATION  AGE  GPU(Requested)
default    resnet18-profile  COMPLETE  Profile  13s       2d   1

    3. Vérifiez que le service TensorBoard est en cours d'exécution :

      kubectl get service -n default

      Résultat attendu :

      NAME                           TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
resnet18-profile-tensorboard   NodePort   172.16.158.170   <none>        6006:30582/TCP   2d20h

    4. Redirigez le port pour accéder à TensorBoard localement :

      kubectl port-forward svc/resnet18-profile-tensorboard -n default 6006:6006

      Résultat attendu :

      Forwarding from 127.0.X.X:6006 -> 6006
Forwarding from [::1]:6006 -> 6006

    5. Ouvrez http://localhost:6006 dans un navigateur. Dans le volet de navigation de gauche, cliquez sur Views pour explorer les données de performance et identifier les opérateurs goulots d'étranglement.

      Profiling results

    Étape 4 : Optimiser le modèle

    Après avoir identifié les goulots d'étranglement, soumettez une tâche d'optimisation. Par défaut, Arena utilise TensorRT pour optimiser le modèle pour l'inférence GPU.

    1. Soumettez la tâche d'optimisation :

      Paramètre Description
      --gpus Nombre de GPU à utiliser
      --data Nom du PVC et chemin de montage
      --optimizer Moteur d'optimisation. Valeurs valides : tensorrt (par défaut), aiacc-torch
      --model-config-file Chemin vers le fichier de configuration du modèle
      --export-path Chemin de sortie pour le modèle optimisé. 
      arena model analyze optimize \
  --name=resnet18-optimize \
  --namespace=default \
  --image=registry.cn-beijing.aliyuncs.com/kube-ai/easy-inference:1.0.2 \
  --gpus=1 \
  --data=oss-pvc:/data \
  --optimizer=tensorrt \
  --model-config-file=/data/models/resnet18/config.json \
  --export-path=/data/models/resnet18

    2. Vérifiez l'état de la tâche :

      arena model analyze list -A

      Résultat attendu :

      NAMESPACE  NAME               STATUS    TYPE      DURATION  AGE  GPU(Requested)
default    resnet18-optimize  COMPLETE  Optimize  16s       2d   1

    3. Lorsque l'état est COMPLETE, le modèle optimisé opt_resnet18.pt est enregistré dans le répertoire --export-path.

    4. Relancez le benchmark avec le modèle optimisé. Mettez à jour model_path dans config.json avec opt_resnet18.pt, puis répétez l'étape 2. Le tableau suivant compare les résultats avant et après l'optimisation TensorRT. Si le modèle ne répond toujours pas à vos exigences, répétez les étapes 3 et 4.

      Métrique Avant optimisation Après optimisation
      p90_latency 7,511 ms 5,162 ms
      p95_latency 7,86 ms 5,428 ms
      p99_latency 9,34 ms 6,64 ms
      min_latency 7,019 ms 4,827 ms
      max_latency 12,269 ms 8,426 ms
      mean_latency 7,312 ms 5,046 ms
      median_latency 7,206 ms 4,972 ms
      throughput 136 req/s 198 req/s
      gpu_mem_used 1,47 Go 1,6 Go
      gpu_utilization 21,280 % 10,912 %

    Étape 5 : Déployer le modèle

    Une fois que le modèle répond aux exigences de performance, déployez-le avec NVIDIA Triton Inference Server.

    1. Créez le fichier de configuration Triton config.pbtxt :

      Important

      Ne modifiez pas le nom du fichier.

      Consultez Model Repository pour plus de détails sur la configuration.
      name: "resnet18"
platform: "pytorch_libtorch"
max_batch_size: 1
default_model_filename: "opt_resnet18.pt"
input [
    {
        name: "input__0"
        format: FORMAT_NCHW
        data_type: TYPE_FP32
        dims: [ 3, 224, 224 ]
    }
]
output [
    {
        name: "output__0",
        data_type: TYPE_FP32,
        dims: [ 1000 ]
    }
]

    2. Créez cette structure de répertoires dans OSS :

      Le répertoire 1/ représente la version du modèle (convention Triton). Un référentiel peut stocker plusieurs versions. Consultez Model Repository .
      oss://bucketname/triton/model-repository/
    resnet18/
      config.pbtxt
      1/
        opt_resnet18.pt

    3. Déployez le modèle avec Arena. Choisissez le mode GPU en fonction de votre charge de travail :

      • Mode exclusif GPU — Un modèle par GPU. À utiliser pour une inférence haute stabilité où les modèles ne doivent pas partager les ressources GPU.

        arena serve triton \
  --name=resnet18-serving \
  --gpus=1 \
  --replicas=1 \
  --image=nvcr.io/nvidia/tritonserver:21.05-py3 \
  --data=oss-pvc:/data \
  --model-repository=/data/triton/model-repository \
  --allow-metrics=true

      • Mode partagé GPU — Plusieurs modèles partagent un GPU avec des limites de mémoire par modèle. À utiliser pour une inférence rentable ou de longue traîne. Définissez --gpumemory sur la mémoire GPU (Go) par pod en fonction de gpu_mem_used issu du benchmark — si gpu_mem_used est de 1,6 Go, définissez --gpumemory=2. Doit être un entier positif.

        arena serve triton \
  --name=resnet18 \
  --gpumemory=2 \
  --replicas=1 \
  --image=nvcr.io/nvidia/tritonserver:21.12-py3 \
  --data=oss-pvc:/data \
  --model-repository=/data/triton/model-repository \
  --allow-metrics=true

    4. Vérifiez le déploiement :

      arena serve list -A

      Résultat attendu :

      NAMESPACE  NAME              TYPE    VERSION       DESIRED  AVAILABLE  ADDRESS         PORTS                   GPU
default    resnet18-serving  Triton  202202141817  1        1          172.16.147.248  RESTFUL:8000,GRPC:8001  1

      Le modèle est prêt lorsque AVAILABLE est égal à DESIRED.