Use the AI component set to analyze and optimize models - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Pré-requisitos

Verifique se você tem:

Um cluster ACK Pro (Kubernetes 1.20+) com pelo menos um nó acelerado por GPU. Consulte Atualizar um cluster ACK.
Um bucket do OSS com PV e PVC configurados. Consulte Montar um volume ossfs 1.0 provisionado estaticamente.
A versão mais recente do cliente Arena instalada. Consulte Configurar o cliente Arena.

Como funciona

Cientistas de dados focam na precisão; engenheiros priorizam o desempenho da inferência. Execute benchmarks e profiling antes da implantação para assegurar que o modelo atinja as metas de latência e throughput.

O Arena oferece comandos para cada fase do ciclo de vida do modelo:

Model lifecycle

Fase	Finalidade
Treinamento do modelo	Treinar o modelo em um conjunto de dados
Benchmark do modelo	Verificar se latência, throughput e utilização da GPU atendem aos requisitos
Profile do modelo	Identificar gargalos de desempenho
Otimização do modelo	Melhorar o desempenho de inferência na GPU com ferramentas como TensorRT
Servimento do modelo	Implantar o modelo como um serviço online

Caso o modelo ainda não atenda aos requisitos após a otimização, repita o ciclo benchmark → profile → otimização.

Todos os comandos de análise são executados via arena model analyze. Visualize os subcomandos:

arena model analyze --help

Saída:

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

Etapa 1: Preparar um modelo

Converta o modelo ResNet18 para o formato TorchScript e envie-o para o OSS.

Converta e salve o modelo:

Parâmetro	Descrição
`model_name`	Nome do modelo
`model_platform`	Plataforma ou framework, como `TorchScript` ou `ONNX`
`model_path`	Caminho de armazenamento do modelo.
`inputs`	Parâmetros de entrada
`outputs`	Parâmetros de saída

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")

Envie resnet18.pt para oss://bucketname/models/resnet18/resnet18.pt. Consulte Upload objects.

Etapa 2: Executar benchmark do modelo

Execute o benchmark do modelo comparando-o com as metas de latência, throughput e utilização da GPU. Este exemplo usa um PVC chamado oss-pvc no namespace default.

Crie um arquivo de configuração do modelo 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]
    }
  ]
}

Envie config.json para oss://bucketname/models/resnet18/config.json.

Envie o job de benchmark:

Importante

Os parâmetros --requests e --duration são mutuamente exclusivos; --duration tem precedência se ambos forem definidos. Use --requests para definir uma contagem fixa de requisições em vez de um limite de tempo.

Parâmetro	Descrição
`--gpus`	Número de GPUs a usar
`--data`	Nome do PVC e caminho de montagem
`--model-config-file`	Caminho para o arquivo de configuração do modelo
`--report-path`	Caminho de saída para o relatório de benchmark.
`--concurrency`	Número de requisições simultâneas
`--duration`	Duração do benchmark, em segundos.

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

Verifique o status do job:

arena model analyze list -A

Saída esperada:

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

Quando o status for COMPLETE, recupere o arquivo benchmark_result.txt no diretório definido em --report-path:

Métrica	Descrição	Unidade
`p90_latency`	Tempo de resposta do percentil 90	Milissegundos
`p95_latency`	Tempo de resposta do percentil 95	Milissegundos
`p99_latency`	Tempo de resposta do percentil 99	Milissegundos
`min_latency`	Tempo de resposta mais rápido	Milissegundos
`max_latency`	Tempo de resposta mais lento	Milissegundos
`mean_latency`	Tempo médio de resposta	Milissegundos
`median_latency`	Tempo mediano de resposta	Milissegundos
`throughput`	Throughput	Vezes
`gpu_mem_used`	Uso de memória da GPU	GB
`gpu_utilization`	Utilização da GPU	Porcentagem

{
    "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
}

Etapa 3: Executar profile do modelo

Execute arena model analyze profile para identificar onde o modelo consome tempo durante a inferência. O profiler gera um relatório do TensorBoard detalhado por operador.

Envie o job de profile:

Parâmetro	Descrição
`--gpus`	Número de GPUs a usar
`--data`	Nome do PVC e caminho de montagem
`--model-config-file`	Caminho para o arquivo de configuração do modelo
`--report-path`	Caminho de saída para o relatório de profiling.
`--tensorboard`	Habilita o TensorBoard para visualizar o relatório de profiling.
`--tensorboard-image`	Imagem do container do 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

Verifique o status do job:

arena model analyze list -A

Saída esperada:

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

Confirme se o serviço do TensorBoard está em execução:

kubectl get service -n default

Saída esperada:

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

Encaminhe a porta para acesso local ao TensorBoard:

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

Saída esperada:

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

Abra http://localhost:6006 no navegador. No painel de navegação à esquerda, clique em Views para explorar os dados de desempenho e identificar operadores que causam gargalos.

Etapa 4: Otimizar o modelo

Após identificar os gargalos, envie um job de otimização. Por padrão, o Arena usa o TensorRT para otimizar o modelo para inferência em GPU.

Envie o job de otimização:

Parâmetro	Descrição
`--gpus`	Número de GPUs a usar
`--data`	Nome do PVC e caminho de montagem
`--optimizer`	Motor de otimização. Valores válidos: `tensorrt` (padrão), `aiacc-torch`
`--model-config-file`	Caminho para o arquivo de configuração do modelo
`--export-path`	Caminho de saída para o modelo otimizado.

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

Verifique o status do job:

arena model analyze list -A

Saída esperada:

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

Quando o status for COMPLETE, o modelo otimizado opt_resnet18.pt será salvo no diretório definido em --export-path.

Execute novamente o benchmark com o modelo otimizado. Atualize model_path em config.json para opt_resnet18.pt e repita a Etapa 2. A tabela a seguir compara os resultados antes e depois da otimização com TensorRT. Se o modelo ainda não atender aos seus requisitos, repita as Etapas 3 e 4.

Métrica	Antes da otimização	Após a otimização
`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 vezes	198 vezes
`gpu_mem_used`	1,47 GB	1,6 GB
`gpu_utilization`	21,280%	10,912%

Etapa 5: Implantar o modelo

Assim que o modelo atender aos requisitos de desempenho, implante-o com o NVIDIA Triton Inference Server.

Crie o arquivo de configuração do Triton config.pbtxt:

Importante

Não altere o nome do arquivo.

Consulte Model Repository para detalhes sobre a configuração.

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 ]
    }
]

Crie esta estrutura de diretórios no OSS:

O diretório 1/ representa a versão do modelo (convenção do Triton). Um repositório pode armazenar várias versões. Consulte Model Repository .
```
oss://bucketname/triton/model-repository/
    resnet18/
      config.pbtxt
      1/
        opt_resnet18.pt
```
Implante o modelo com o Arena. Escolha o modo de GPU com base na sua carga de trabalho:
- Modo exclusivo de GPU — Um modelo por GPU. Ideal para inferência de alta estabilidade, em que os modelos não devem compartilhar recursos da 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
```
- Modo compartilhado de GPU — Vários modelos compartilham uma única GPU com limites de memória por modelo. Recomendado para inferência econômica ou de cauda longa. Defina --gpumemory como a memória da GPU (GB) por pod com base em gpu_mem_used obtido no benchmark. Se gpu_mem_used for 1,6 GB, defina --gpumemory=2. O valor deve ser um número inteiro positivo.
```
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
```

Verifique a implantação:

arena serve list -A

Saída esperada:

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

O modelo estará pronto quando AVAILABLE for igual a DESIRED.