Platform For AI：Penerapan layanan Triton Inference Server

Langkah 1: Siapkan repositori model

Triton memerlukan struktur direktori tertentu dalam bucket Object Storage Service (OSS) Anda. Buat direktori Anda dalam format berikut. Untuk informasi lebih lanjut, lihat Kelola direktori dan Unggah file.

oss://your-bucket/models/triton/
└── your_model_name/
    ├── 1/                    # Direktori versi (harus berupa angka)
    │   └── model.pt          # File model
    └── config.pbtxt          # File konfigurasi model

Persyaratan utama:

• Direktori versi model harus diberi nama dengan angka (1, 2, 3, dst.).

• Angka yang lebih besar menunjukkan versi yang lebih baru.

• Setiap model memerlukan file konfigurasi config.pbtxt.

Langkah 2: Buat file konfigurasi model

Buat file config.pbtxt untuk menentukan informasi dasar model Anda. Berikut adalah contohnya:

name: "your_model_name"
platform: "pytorch_libtorch"
max_batch_size: 128

input [
  {
    name: "INPUT__0"
    data_type: TYPE_FP32
    dims: [ 3, -1, -1 ]
  }
]

output [
  {
    name: "OUTPUT__0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]


# Gunakan GPU untuk inferensi
# instance_group [
#   { 
#     kind: KIND_GPU
#   }
# ]

# Kebijakan versi model
# Muat hanya versi terbaru (perilaku default)
# version_policy: { latest: { num_versions: 1 }}

# Muat semua versi
# version_policy: { all { }}

# Muat dua versi terbaru
# version_policy: { latest: { num_versions: 2 }}

# Muat versi tertentu
# version_policy: { specific: { versions: [1, 3] }}

Langkah 3: Terapkan layanan

1. Masuk ke Konsol PAI. Pilih wilayah di bagian atas halaman. Kemudian, pilih ruang kerja yang diinginkan dan klik Elastic Algorithm Service (EAS).

2. Pada tab Inference Service, klik Deploy Service, lalu pada bagian Scenario-based Model Deployment, klik Triton Deployment.

3. Konfigurasikan parameter penerapan:

   • Service Name: Masukkan nama layanan kustom.

   • Model Settings: Untuk Type, pilih OSS. Masukkan path ke repositori model Anda (misalnya, oss://your-bucket/models/triton/).

   • Instance Count dan Resource Group Type: Pilih nilai berdasarkan kebutuhan Anda. Untuk memperkirakan memori GPU yang diperlukan untuk model Anda, lihat Estimasi VRAM yang diperlukan untuk model besar.

4. Klik Deploy dan tunggu hingga layanan mulai.

Langkah 4: Aktifkan gRPC (opsional)

Secara default, Triton menyediakan layanan HTTP pada port 8000. Untuk menggunakan gRPC:

1. Di pojok kanan atas halaman konfigurasi layanan, klik Convert to Custom Deployment.

2. Pada bagian Environment Information, ubah Port Number menjadi 8001.

3. Di bawah Features > Advanced Networking, klik Enable gRPC.

4. Klik Deploy.

Struktur direktori

your_model_name/
├── 1/
│   ├── model.pt          # File model
│   └── model.py          # Logika inferensi kustom
└── config.pbtxt

Implementasikan Python Backend

Buat file model.py dan definisikan kelas TritonPythonModel:

import json
import os
import torch
from torch.utils.dlpack import from_dlpack, to_dlpack

import triton_python_backend_utils as pb_utils


class TritonPythonModel:
    """Nama kelas harus 'TritonPythonModel'."""

    def initialize(self, args):
        """
        Opsional. Dipanggil sekali saat model dimuat. Gunakan fungsi ini untuk menginisialisasi
        properti dan konfigurasi model.
        Parameters
        ----------
        args : Dictionary dengan kunci dan nilai berupa string. Termasuk:
          * model_config: Konfigurasi model dalam format JSON.
          * model_instance_kind: Jenis perangkat.
          * model_instance_device_id: ID perangkat.
          * model_repository: Path ke repositori model.
          * model_version: Versi model.
          * model_name: Nama model.
        """

        # Parsing konfigurasi model dari representasi JSON-nya.
        self.model_config = model_config = json.loads(args["model_config"])

        # Dapatkan properti dari file konfigurasi model.
        output_config = pb_utils.get_output_config_by_name(model_config, "OUTPUT__0")

        # Konversi tipe Triton ke tipe NumPy.
        self.output_dtype = pb_utils.triton_string_to_numpy(output_config["data_type"])

        # Dapatkan path ke repositori model.
        self.model_directory = os.path.dirname(os.path.realpath(__file__))

        # Dapatkan perangkat untuk inferensi model. Contoh ini menggunakan GPU.
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        print("device: ", self.device)

        model_path = os.path.join(self.model_directory, "model.pt")
        if not os.path.exists(model_path):
            raise pb_utils.TritonModelException("Cannot find the pytorch model")
        # Muat model PyTorch ke GPU menggunakan .to(self.device).
        self.model = torch.jit.load(model_path).to(self.device)

        print("Initialized...")

    def execute(self, requests):
        """
        Wajib. Metode ini dipanggil untuk setiap permintaan inferensi. Jika batching diaktifkan,
        Anda harus mengimplementasikan logika pemrosesan batch sendiri.
        Parameters
        ----------
        requests : Daftar objek pb_utils.InferenceRequest.

        Returns
        -------
        Daftar objek pb_utils.InferenceResponse. Daftar harus berisi satu
        respons untuk setiap permintaan.
        """

        output_dtype = self.output_dtype

        responses = []

        # Iterasi melalui daftar permintaan dan buat respons yang sesuai untuk setiap permintaan.
        for request in requests:
            # Dapatkan tensor input.
            input_tensor = pb_utils.get_input_tensor_by_name(request, "INPUT__0")
            # Konversi tensor Triton ke tensor Torch.
            pytorch_tensor = from_dlpack(input_tensor.to_dlpack())

            if pytorch_tensor.shape[2] > 1000 or pytorch_tensor.shape[3] > 1000:
                responses.append(
                    pb_utils.InferenceResponse(
                        output_tensors=[],
                        error=pb_utils.TritonError(
                            "Image shape should not be larger than 1000"
                        ),
                    )
                )
                continue

            # Jalankan inferensi pada perangkat target.
            prediction = self.model(pytorch_tensor.to(self.device))

            # Konversi tensor output Torch ke tensor Triton.
            out_tensor = pb_utils.Tensor.from_dlpack("OUTPUT__0", to_dlpack(prediction))

            inference_response = pb_utils.InferenceResponse(output_tensors=[out_tensor])
            responses.append(inference_response)

        return responses

    def finalize(self):
        """
        Opsional. Dipanggil saat model dilepas. Gunakan ini untuk tugas pembersihan, seperti
        melepaskan sumber daya.
        """
        print("Cleaning up...")

Perbarui file konfigurasi

name: "resnet50_pt"
backend: "python"
max_batch_size: 128
input [
  {
    name: "INPUT__0"
    data_type: TYPE_FP32
    dims: [ 3, -1, -1 ]
  }
]
output [
  {
    name: "OUTPUT__0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

parameters: {
    key: "FORCE_CPU_ONLY_INPUT_TENSORS"
    value: {string_value: "no"}
}

Deskripsi parameter utama sebagai berikut:

• backend: Harus diatur ke python.

• parameters: Saat menggunakan GPU untuk inferensi, Anda dapat secara opsional mengatur parameter FORCE_CPU_ONLY_INPUT_TENSORS ke no untuk menghindari overhead penyalinan tensor input antara CPU dan GPU.

Terapkan layanan

Python backend memerlukan shared memory. Di Custom Model Deployment > JSON On Premises Deployment, masukkan konfigurasi JSON berikut dan klik Deploy.

{
  "metadata": {
    "name": "triton_server_test",
    "instance": 1
  },
  "cloud": {
        "computing": {
            "instance_type": "ml.gu7i.c8m30.1-gu30",
            "instances": null
        }
    },
  "containers": [
    {
      "command": "tritonserver --model-repository=/models",
      "image": "eas-registry-vpc.<region>.cr.aliyuncs.com/pai-eas/tritonserver:25.03-py3",
      "port": 8000,
      "prepare": {
        "pythonRequirements": [
          "torch==2.0.1"
        ]
      }
    }
  ],
  "storage": [
    {
      "mount_path": "/models",
      "oss": {
        "path": "oss://oss-test/models/triton_backend/"
      }
    },
    {
      "empty_dir": {
        "medium": "memory",
        // Konfigurasikan shared memory sebesar 1 GB.
        "size_limit": 1
      },
      "mount_path": "/dev/shm"
    }
  ]
}

Deskripsi konfigurasi JSON utama:

• containers[0].image: Image resmi Triton. Ganti <region> dengan wilayah tempat layanan Anda berada.

• containers[0].prepare.pythonRequirements: Cantumkan dependensi Python Anda di sini. EAS akan menginstalnya secara otomatis sebelum layanan dimulai.

• storage: Berisi dua titik mount.

  • Yang pertama memasang path repositori model OSS Anda ke direktori /models dalam kontainer.

  • Entri storage kedua mengonfigurasi shared memory, yang wajib. Server Triton dan Python backend menggunakan path /dev/shm untuk meneruskan data tensor tanpa copy, sehingga memaksimalkan performa. size_limit dalam satuan GB. Perkirakan ukuran yang diperlukan berdasarkan model dan konkurensi yang diharapkan.

Dapatkan endpoint dan token layanan

1. Pada halaman Elastic Algorithm Service (EAS), klik nama layanan.

2. Pada tab Service Details, klik View Endpoint Information. Salin Internet Endpoint dan Token.

Kirim permintaan HTTP

Saat nomor port diatur ke 8000, layanan mendukung permintaan HTTP.

import numpy as np
# Untuk menginstal paket tritonclient, jalankan: pip install tritonclient
import tritonclient.http as httpclient

# URL endpoint layanan. Jangan sertakan skema `http://`.
url = '1859257******.cn-hangzhou.pai-eas.aliyuncs.com/api/predict/triton_server_test'

triton_client = httpclient.InferenceServerClient(url=url)

image = np.ones((1,3,224,224))
image = image.astype(np.float32)

inputs = []
inputs.append(httpclient.InferInput('INPUT__0', image.shape, "FP32"))
inputs[0].set_data_from_numpy(image, binary_data=False)
outputs = []
outputs.append(httpclient.InferRequestedOutput('OUTPUT__0', binary_data=False))  # Dapatkan vektor berdimensi 1000

# Tentukan nama model, token permintaan, input, dan output.
results = triton_client.infer(
    model_name="<your-model-name>",
    model_version="<version-num>",
    inputs=inputs,
    outputs=outputs,
    headers={"Authorization": "<your-service-token>"},
)
output_data0 = results.as_numpy('OUTPUT__0')
print(output_data0.shape)
print(output_data0)

Kirim permintaan gRPC

Saat nomor port diatur ke 8001 dan pengaturan terkait gRPC dikonfigurasi, layanan mendukung permintaan gRPC.

#!/usr/bin/env python
import grpc
# Untuk menginstal paket tritonclient, jalankan: pip install tritonclient
from tritonclient.grpc import service_pb2, service_pb2_grpc
import numpy as np

if __name__ == "__main__":
    # URL akses (endpoint layanan) yang dihasilkan setelah penerapan layanan.
    # Jangan sertakan skema `http://`. Tambahkan port `:80`.
    # Meskipun Triton mendengarkan pada port 8001 secara internal, PAI-EAS mengekspos gRPC melalui port 80 secara eksternal. Gunakan :80 di klien Anda.
    host = (
        "service_name.115770327099****.cn-beijing.pai-eas.aliyuncs.com:80"
    )
    # Token layanan. Gunakan token aktual Anda dalam aplikasi nyata.
    token = "<your-service-token>"
    # Nama dan versi model.
    model_name = "<your-model-name>"
    model_version = "<version-num>"
    
    # Buat metadata gRPC untuk autentikasi token.
    metadata = (("authorization", token),)

    # Buat channel dan stub gRPC untuk berkomunikasi dengan server.
    channel = grpc.insecure_channel(host)
    grpc_stub = service_pb2_grpc.GRPCInferenceServiceStub(channel)
    
    # Bangun permintaan inferensi.
    request = service_pb2.ModelInferRequest()
    request.model_name = model_name
    request.model_version = model_version

    # Bangun tensor input. Harus sesuai dengan input dalam konfigurasi model.
    input_tensor = service_pb2.ModelInferRequest().InferInputTensor()
    input_tensor.name = "INPUT__0"
    input_tensor.datatype = "FP32"
    input_tensor.shape.extend([1, 3, 224, 224])
    # Bangun tensor output. Harus sesuai dengan output dalam konfigurasi model.
    output_tensor = service_pb2.ModelInferRequest().InferRequestedOutputTensor()
    output_tensor.name = "OUTPUT__0"

    # Tambahkan tensor input dan output ke permintaan.
    request.inputs.extend([input_tensor])
    request.outputs.extend([output_tensor])
    
    # Buat array acak dan serialisasi menjadi urutan byte sebagai data input.
    request.raw_input_contents.append(np.random.rand(1, 3, 224, 224).astype(np.float32).tobytes())
            
    # Kirim permintaan inferensi dan terima respons.
    response, _ = grpc_stub.ModelInfer.with_call(request, metadata=metadata)
    
    # Ekstrak tensor output dari respons.
    output_contents = response.raw_output_contents[0]  # Asumsikan hanya ada satu tensor output.
    output_shape = [1, 1000]  # Asumsikan bentuk tensor output adalah [1, 1000].
    
    # Konversi byte output menjadi array NumPy.
    output_array = np.frombuffer(output_contents, dtype=np.float32)
    output_array = output_array.reshape(output_shape)
    
    # Cetak output model.
    print("Model output:\n", output_array)

Aktifkan log verbose

Atur verbose=True untuk mencetak data JSON untuk permintaan dan respons:

client = httpclient.InferenceServerClient(url=url, verbose=True)

Contoh output:

POST /api/predict/triton_test/v2/models/resnet50_pt/versions/1/infer, headers {'Authorization': '************1ZDY3OTEzNA=='}
b'{"inputs":[{"name":"INPUT__0","shape":[1,3,32,32],"datatype":"FP32","data":[1.0,1.0,1.0,.....,1.0]}],"outputs":[{"name":"OUTPUT__0","parameters":{"binary_data":false}}]}'

Debugging online

Anda dapat menguji langsung menggunakan debugging online di konsol. Lengkapi URL permintaan menjadi /api/predict/triton_test/v2/models/resnet50_pt/versions/1/infer dan gunakan data permintaan JSON dari log verbose sebagai Body.

Q: Mengapa saya mendapatkan error "CUDA error: no kernel image is available for execution on the device"?

Error ini menunjukkan ketidakcocokan kompatibilitas antara versi CUDA dalam image Triton dan arsitektur instans GPU yang dipilih.

Untuk mengatasinya, alihkan ke tipe instans GPU yang berbeda yang kompatibel dengan versi CUDA image Anda. Misalnya, coba gunakan instans A10 atau T4.

Q: Bagaimana cara memperbaiki error "InferenceServerException: url should not include the scheme" untuk permintaan HTTP?

Error ini terjadi karena tritonclient.http.InferenceServerClient memerlukan URL yang diberikan tanpa skema protokol (misalnya, http:// atau https://).

Untuk memperbaikinya, hapus skema dari string URL Anda.

Q: Bagaimana cara mengatasi error "DNS resolution failed" saat melakukan panggilan gRPC?

Error ini terjadi karena host layanan salah. Format endpoint layanan adalah http://we*****.1751930*****.cn-hangzhou.pai-eas.aliyuncs.com/ (perhatikan bahwa ini berbeda dari endpoint HTTP). Hapus awalan http:// dan akhiran /. Kemudian, tambahkan :80 di akhir. Format akhirnya adalah we*****.1751930*****.cn-hangzhou.pai-eas.aliyuncs.com:80.