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 :Aug 11, 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 afin d'effectuer des tests de référence (benchmark), un profilage et une optimisation. Cette rubrique prend pour exemple le modèle PyTorch ResNet18 sur des GPU V100.

    Prerequisites

    Assurez-vous d'avoir :

    How it works

    Les data scientists optimisent la précision, tandis que les ingénieurs privilégient les performances d'inférence. Effectuez des benchmarks et un profilage avant le déploiement pour vous assurer que le modèle respecte 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 Purpose
    Model training Entraîner le modèle sur un jeu de données
    Model benchmark Vérifier si la latence, le débit et l'utilisation du GPU répondent aux exigences
    Model profile Identifier les goulots d'étranglement de performance
    Model optimize Améliorer les performances d'inférence GPU à l'aide d'outils tels que TensorRT
    Model serving Déployer le modèle en tant que service en ligne
    Si le modèle ne satisfait toujours pas aux exigences après optimisation, répétez le cycle benchmark → profile → optimize.

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

    arena model analyze --help

    Sortie :

    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

    Step 1: Prepare a model

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

    1. Convertissez et enregistrez le modèle :

      Parameter 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. Voir Upload objects.

    Step 2: Benchmark the model

    Évaluez le modèle par rapport aux cibles 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 spécifier un nombre fixe de requêtes au lieu d'une limite de temps.

      Parameter 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 concurrentes
      --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

      Sortie attendue :

      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 :

      Metric 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 Fois
      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
}

    Step 3: Profile the model

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

    1. Soumettez la tâche de profilage :

      Parameter 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

      Sortie attendue :

      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

      Sortie attendue :

      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 localement à TensorBoard :

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

      Sortie attendue :

      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 goulot d'étranglement.

      Profiling results

    Step 4: Optimize the model

    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 :

      Parameter 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

      Sortie attendue :

      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 pour pointer vers 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.

      Metric Before optimization After optimization
      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 fois 198 fois
      gpu_mem_used 1.47 Go 1.6 Go
      gpu_utilization 21.280 % 10.912 %

    Step 5: Deploy the model

    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.

      Voir 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. Voir 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 même 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. La valeur 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

      Sortie attendue :

      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.