Gunakan kumpulan komponen AI untuk menganalisis dan mengoptimalkan model - Container Service for Kubernetes

Untuk memastikan model memenuhi standar go-live sebelum penerapan, gunakan alat analisis model guna melakukan benchmark, profiling, dan optimasi. Topik ini menggunakan model PyTorch ResNet18 pada GPU V100 sebagai contoh.

Prasyarat

Pastikan Anda telah memiliki:

Kluster ACK Pro (Kubernetes 1.20+) dengan setidaknya satu node yang dipercepat GPU. Lihat Perbarui kluster ACK.
Bucket OSS dengan PV dan PVC yang telah dikonfigurasi. Lihat Pasang volume ossfs 1.0 yang disediakan secara statis.
Klien Arena versi terbaru yang telah diinstal. Lihat Konfigurasikan klien Arena.

Cara kerja

Data scientist mengoptimalkan akurasi; insinyur mengoptimalkan performa inferensi. Lakukan benchmark dan profiling sebelum penerapan untuk memastikan model memenuhi target latensi dan throughput.

Arena menyediakan perintah untuk setiap fase siklus hidup model:

Fase	Tujuan
Model training	Latih model pada suatu dataset
Model benchmark	Periksa apakah latensi, throughput, dan pemanfaatan GPU memenuhi persyaratan
Model profile	Identifikasi bottleneck performa
Model optimize	Tingkatkan performa inferensi GPU dengan tool seperti TensorRT
Model serving	Terapkan model sebagai layanan online

Jika model masih belum memenuhi persyaratan setelah optimasi, ulangi siklus benchmark → profile → optimize.

Semua perintah analisis dijalankan di bawah arena model analyze. Lihat subperintah:

arena model analyze --help

Output:

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

Langkah 1: Siapkan model

Konversi model ResNet18 ke format TorchScript dan unggah ke OSS.

Konversi dan simpan model:

Parameter	Deskripsi
`model_name`	Nama model
`model_platform`	Platform atau framework, seperti `TorchScript` atau `ONNX`
`model_path`	Path penyimpanan model.
`inputs`	Parameter input
`outputs`	Parameter output

import torch
import torchvision

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

# Alihkan model ke mode eval
model.eval()

# Input contoh yang biasanya Anda berikan ke metode forward() model
dummy_input = torch.rand(1, 3, 224, 224)

# Gunakan torch.jit.trace untuk menghasilkan torch.jit.ScriptModule melalui tracing
traced_script_module = torch.jit.trace(model, dummy_input)

# Simpan model TorchScript
traced_script_module.save("resnet18.pt")

Unggah resnet18.pt ke oss://bucketname/models/resnet18/resnet18.pt. Lihat Upload objects.

Langkah 2: Benchmark model

Lakukan benchmark model terhadap target latensi, throughput, dan pemanfaatan GPU. Contoh ini menggunakan PVC bernama oss-pvc di namespace default.

Buat file konfigurasi model 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]
    }
  ]
}

Unggah config.json ke oss://bucketname/models/resnet18/config.json.

Kirim pekerjaan benchmark:

Penting

--requests dan --duration saling eksklusif; --duration didahulukan jika keduanya ditetapkan. Gunakan --requests untuk jumlah permintaan tetap alih-alih batas waktu.

Parameter	Deskripsi
`--gpus`	Jumlah GPU yang digunakan
`--data`	Nama PVC dan path mount
`--model-config-file`	Path ke file konfigurasi model
`--report-path`	Path output untuk laporan benchmark.
`--concurrency`	Jumlah permintaan konkuren
`--duration`	Durasi benchmark, dalam detik.

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

Periksa status pekerjaan:

arena model analyze list -A

Output yang diharapkan:

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

Saat statusnya COMPLETE, ambil benchmark_result.txt dari direktori --report-path:

Metrik	Deskripsi	Unit
`p90_latency`	Waktu respons persentil ke-90	Milidetik
`p95_latency`	Waktu respons persentil ke-95	Milidetik
`p99_latency`	Waktu respons persentil ke-99	Milidetik
`min_latency`	Waktu respons tercepat	Milidetik
`max_latency`	Waktu respons paling lambat	Milidetik
`mean_latency`	Waktu respons rata-rata	Milidetik
`median_latency`	Waktu respons median	Milidetik
`throughput`	Throughput	Kali
`gpu_mem_used`	Penggunaan memori GPU	GB
`gpu_utilization`	Pemanfaatan GPU	Persentase

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

Langkah 3: Profil model

Jalankan arena model analyze profile untuk mengidentifikasi bagian mana model menghabiskan waktu selama inferensi. Profiler menghasilkan laporan TensorBoard yang dipecah berdasarkan operator.

Kirim pekerjaan profil:

Parameter	Deskripsi
`--gpus`	Jumlah GPU yang digunakan
`--data`	Nama PVC dan path mount
`--model-config-file`	Path ke file konfigurasi model
`--report-path`	Path output untuk laporan profiling.
`--tensorboard`	Mengaktifkan TensorBoard untuk melihat laporan profiling.
`--tensorboard-image`	Gambar kontainer 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

Periksa status pekerjaan:

arena model analyze list -A

Output yang diharapkan:

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

Verifikasi layanan TensorBoard sedang berjalan:

kubectl get service -n default

Output yang diharapkan:

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

Teruskan port untuk akses TensorBoard lokal:

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

Output yang diharapkan:

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

Buka http://localhost:6006 di browser. Di panel navigasi kiri, klik Views untuk menjelajahi data performa dan mengidentifikasi operator bottleneck.

Langkah 4: Optimalkan model

Setelah mengidentifikasi bottleneck, kirim pekerjaan optimasi. Secara default, Arena menggunakan TensorRT untuk mengoptimalkan model guna inferensi GPU.

Kirim pekerjaan optimasi:

Parameter	Deskripsi
`--gpus`	Jumlah GPU yang digunakan
`--data`	Nama PVC dan path mount
`--optimizer`	Mesin optimasi. Nilai yang valid: `tensorrt` (default), `aiacc-torch`
`--model-config-file`	Path ke file konfigurasi model
`--export-path`	Path output untuk model yang dioptimalkan.

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

Periksa status pekerjaan:

arena model analyze list -A

Output yang diharapkan:

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

Saat statusnya COMPLETE, model yang dioptimalkan opt_resnet18.pt disimpan di direktori --export-path.

Jalankan ulang benchmark dengan model yang dioptimalkan. Perbarui model_path di config.json menjadi opt_resnet18.pt, lalu ulangi Langkah 2. Tabel berikut membandingkan hasil sebelum dan sesudah optimasi TensorRT. Jika model masih belum memenuhi persyaratan Anda, ulangi Langkah 3 dan 4.

Metrik	Sebelum optimasi	Sesudah optimasi
`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 kali	198 kali
`gpu_mem_used`	1.47 GB	1.6 GB
`gpu_utilization`	21.280%	10.912%

Langkah 5: Terapkan model

Setelah model memenuhi persyaratan performa, terapkan dengan NVIDIA Triton Inference Server.

Buat file konfigurasi Triton config.pbtxt:

Penting

Jangan ubah nama file.

Lihat Model Repository untuk detail konfigurasi.

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

Buat struktur direktori berikut di OSS:

Direktori 1/ merepresentasikan versi model (konvensi Triton). Repositori dapat menyimpan beberapa versi. Lihat Model Repository.
```
oss://bucketname/triton/model-repository/
    resnet18/
      config.pbtxt
      1/
        opt_resnet18.pt
```
Terapkan model dengan Arena. Pilih mode GPU berdasarkan beban kerja Anda:
- Mode eksklusif GPU — Satu model per GPU. Gunakan untuk inferensi berstabilitas tinggi di mana model tidak boleh berbagi sumber daya 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 berbagi GPU — Beberapa model berbagi satu GPU dengan batas memori per model. Gunakan untuk inferensi hemat biaya atau long-tail. Tetapkan --gpumemory ke memori GPU (GB) per pod berdasarkan gpu_mem_used dari benchmark — jika gpu_mem_used adalah 1,6 GB, tetapkan --gpumemory=2. Harus berupa bilangan bulat 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
```

Verifikasi penerapan:

arena serve list -A

Output yang diharapkan:

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

Model siap digunakan saat AVAILABLE sama dengan DESIRED.