All Products
Search

This Product

    Platform For AI:Terapkan layanan inferensi

    Document Center

    Platform For AI:Terapkan layanan inferensi

    Last Updated:Mar 11, 2026

    Terapkan model ke PAI dan buat layanan inferensi menggunakan API tingkat tinggi dari PAI Python SDK.

    Alur penerapan

    SDK menyediakan API tingkat tinggi pai.model.Model dan pai.predictor.Predictor untuk menerapkan model ke EAS serta menguji layanan tersebut.

    Alur dasar pembuatan layanan inferensi:

    • Definisikan konfigurasi layanan inferensi dalam objek pai.model.InferenceSpec, termasuk informasi processor atau runtime image.

    • Buat objek pai.model.Model menggunakan objek InferenceSpec dan file model untuk penerapan.

    • Panggil pai.model.Model.deploy() untuk membuat layanan inferensi di PAI. Tentukan sumber daya, nama layanan, dan konfigurasi lainnya.

    • Metode deploy mengembalikan objek pai.predictor.Predictor. Gunakan metode predict-nya untuk mengirim permintaan inferensi ke layanan tersebut.

    Contoh:

    from pai.model import InferenceSpec, Model, container_serving_spec
from pai.image import retrieve, ImageScope

# 1. Ambil runtime image inferensi PyTorch yang disediakan oleh PAI.
torch_image = retrieve("PyTorch", framework_version="latest",
    image_scope=ImageScope.INFERENCE)


# 2. Definisikan konfigurasi inferensi menggunakan InferenceSpec.
inference_spec = container_serving_spec(
    # Perintah start untuk layanan inferensi.
    command="python app.py",
    source_dir="./src/"
    # Runtime image inferensi.
    image_uri=torch_image.image_uri,
)


# 3. Bangun objek Model untuk penerapan.
model = Model(
    # File model dari OSS Bucket.
    model_data="oss://<YourBucket>/path-to-model-data",
    inference_spec=inference_spec,
)

# 4. Terapkan model ke PAI-EAS untuk membuat layanan inferensi online dan kembalikan objek Predictor.
predictor = model.deploy(
    service_name="example_torch_service",
    instance_type="ecs.c6.xlarge",
)

# 5. Uji layanan inferensi.
res = predictor.predict(data=data)

    Bagian berikut menjelaskan konfigurasi kode untuk menerapkan layanan inferensi.

    Konfigurasikan InferenceSpec

    Layanan inferensi dapat diterapkan menggunakan processor atau runtime image. Objek pai.model.InferenceSpec mendefinisikan konfigurasi layanan, termasuk metode penerapan, pengaturan penyimpanan, pengaturan warm-up, dan RPC batching. Gunakan objek InferenceSpec yang telah dikonfigurasi untuk membuat layanan tersebut.

    Gunakan processor bawaan

    Processor adalah abstraksi PAI untuk paket layanan inferensi yang membangun layanan inferensi langsung dari model yang disediakan pengguna. PAI menyediakan processor bawaan yang mendukung format model pembelajaran mesin umum seperti TensorFlow SavedModel, PyTorch TorchScript, XGBoost, LightGBM, dan PMML. Untuk daftar lengkapnya, lihat Processor bawaan.

    • Untuk menerapkan model menggunakan processor, konfigurasikan InferenceSpec seperti di bawah ini:

      # Gunakan processor TensorFlow bawaan.
tf_infer_spec = InferenceSpec(processor="tensorflow_cpu_2.3")


# Gunakan processor PyTorch bawaan.
tf_infer_spec = InferenceSpec(processor="pytorch_cpu_1.10")

# Gunakan processor XGBoost bawaan.
xgb_infer_spec = InferenceSpec(processor="xgboost")

    • Konfigurasikan fitur tambahan untuk layanan inferensi pada instance InferenceSpec, seperti file data warm-up atau pengaturan RPC. Untuk daftar lengkap parameter layanan, lihat Penerapan berbasis JSON.

      # Konfigurasikan properti InferenceSpec secara langsung.
tf_infer_spec.warm_up_data_path = "oss://<YourOssBucket>/path/to/warmup-data" # Path ke file data warm-up.
tf_infer_spec.metadata.rpc.keepalive = 1000 # Durasi keep-alive untuk koneksi permintaan.

print(tf_infer_spec.warm_up_data_path)
print(tf_infer_spec.metadata.rpc.keepalive)

    Gunakan runtime image

    Meskipun penerapan dengan processor bersifat langsung, dukungan terhadap konfigurasi kustom yang fleksibel tidak tersedia. Untuk model atau layanan inferensi dengan dependensi kompleks, PAI mendukung penerapan menggunakan runtime image, memberikan fleksibilitas lebih besar.

    • Paketkan kode layanan model dan dependensinya ke dalam Docker image lalu dorong ke repository image Alibaba Cloud ACR. Kemudian bangun InferenceSpec dari Docker image tersebut untuk penerapan.

      from pai.model import InferenceSpec, container_serving_spec

# Bangun InferenceSpec untuk model yang dilayani oleh runtime image.
container_infer_spec = container_serving_spec(
    # Runtime image untuk menjalankan layanan inferensi.
    image_uri="<CustomImageUri>",
    # Port yang didengarkan oleh layanan inferensi di dalam kontainer. PAI meneruskan permintaan prediksi ke port ini.
    port=8000,
    environment_variables=environment_variables,
    # Perintah start untuk layanan inferensi.
    command=command,
    # Paket Python yang dibutuhkan oleh layanan inferensi.
    requirements=[
        "scikit-learn",
        "fastapi==0.87.0",
    ],
)


print(container_infer_spec.to_dict())

m = Model(
    model_data="oss://<YourOssBucket>/path-to-tensorflow-saved-model",
    inference_spec=custom_container_infer_spec,
)
p = m.deploy(
    instance_type="ecs.c6.xlarge"
)

    • Penerapan dengan custom image biasanya memerlukan persiapan kode inferensi, integrasi ke dalam kontainer, serta pembuatan dan pendorongan image ke repository. PAI SDK menyederhanakan proses ini dengan membangun layanan inferensi dari kode lokal dan base image tanpa perlu membangun image secara manual. Gunakan parameter source_dir dalam pai.model.container_serving_spec() untuk menentukan direktori kode lokal. SDK secara otomatis memaketkan dan mengunggah direktori ini ke OSS Bucket serta memasangnya ke path tertentu di dalam kontainer yang sedang berjalan. Gunakan perintah start yang ditentukan untuk menjalankan layanan.

      from pai.model import InferenceSpec

inference_spec = container_serving_spec(
    # Path ke direktori lokal yang berisi program inferensi Anda. Direktori ini diunggah ke OSS Bucket dan dipasang ke dalam kontainer yang sedang berjalan. Path pemasangan default adalah /ml/usercode/.
    source_dir="./src",
    # Perintah start layanan. Saat source_dir ditentukan, perintah dijalankan dengan /ml/usercode sebagai direktori kerja default.
    command="python run.py",
    image_uri="<ServingImageUri>",
    requirements=[
        "fastapi",
        "uvicorn",
    ]
)
print(inference_spec.to_dict())

    • Untuk mengimpor data, kode, atau model tambahan ke dalam kontainer layanan inferensi, gunakan pai.model.InferenceSpec.mount() untuk memasang direktori lokal atau path data OSS ke kontainer layanan online.

      # Unggah data lokal ke OSS dan pasang ke direktori /ml/tokenizers/ di dalam kontainer.
inference_spec.mount("./bert_tokenizers/", "/ml/tokenizers/")

# Pasang data yang disimpan di OSS ke direktori /ml/data/ di dalam kontainer.
inference_spec.mount("oss://<YourOssBucket>/path/to/data/", "/ml/data/")

    • Ambil gambar publik PAI

      PAI menyediakan runtime image inferensi untuk framework umum seperti TensorFlow, PyTorch, dan XGBoost. Berikan image_scope=ImageScope.INFERENCE ke pai.image.list_images dan pai.image.retrieve untuk mengambil runtime image inferensi yang sesuai untuk penerapan model.

      from pai.image import retrieve, ImageScope, list_images

# Dapatkan semua runtime image inferensi PyTorch yang disediakan oleh PAI.
for image_info in list_images(framework_name="PyTorch", image_scope=ImageScope.INFERENCE):
  	print(image_info)


# Dapatkan runtime image inferensi CPU PyTorch 1.12 yang disediakan oleh PAI.
retrieve(framework_name="PyTorch", framework_version="1.12", image_scope=ImageScope.INFERENCE)

# Dapatkan runtime image inferensi GPU PyTorch 1.12 yang disediakan oleh PAI.
retrieve(framework_name="PyTorch", framework_version="1.12", accelerator_type="GPU", image_scope=ImageScope.INFERENCE)

# Dapatkan runtime image inferensi GPU PyTorch versi terbaru yang disediakan oleh PAI.
retrieve(framework_name="PyTorch", framework_version="latest", accelerator_type="GPU", image_scope=ImageScope.INFERENCE)

    Terapkan dan panggil layanan inferensi online

    Terapkan layanan inferensi

    Bangun objek pai.model.Model menggunakan objek pai.model.InferenceSpec dan alamat data model yang ditentukan oleh model_data. Terapkan model dengan memanggil .deploy. Parameter model_data menerima URI OSS atau path lokal. Jika path lokal ditentukan, file model diunggah ke OSS Bucket dan disiapkan di layanan inferensi untuk dimuat dan digunakan.

    Saat memanggil .deploy untuk menerapkan model, tentukan parameter layanan seperti konfigurasi sumber daya yang diperlukan, jumlah instans layanan, dan nama layanan. Untuk parameter lanjutan, lihat penerapan berbasis JSON.

    from pai.model import Model, InferenceSpec
from pai.predictor import Predictor

model = Model(
    # Path ke model_data. Bisa berupa URI OSS atau path lokal. Untuk path lokal, file diunggah ke OSS Bucket secara default.
    model_data="oss://<YourBucket>/path-to-model-data",
    inference_spec=inference_spec,
)

# Terapkan ke EAS.
predictor = m.deploy(
    # Nama layanan inferensi.
    service_name="example_xgb_service",
    # Jenis mesin yang digunakan oleh layanan.
    instance_type="ecs.c6.xlarge",
    # Jumlah instans mesin/layanan.
    instance_count=2,
    # Kelompok sumber daya spesifikasi khusus. Ini opsional. Kelompok sumber daya publik digunakan secara default.
    # resource_id="<YOUR_EAS_RESOURCE_GROUP_ID>",
    options={
        "metadata.rpc.batching": True,
        "metadata.rpc.keepalive": 50000,
        "metadata.rpc.max_batch_size": 16,
        "warm_up_data_path": "oss://<YourOssBucketName>/path-to-warmup-data",
    },
)

    Untuk mengonfigurasi layanan berdasarkan kebutuhan sumber daya spesifik seperti CPU dan memori, gunakan resource_config untuk mengalokasikan sumber daya ke setiap instans layanan:

    from pai.model import ResourceConfig

predictor = m.deploy(
    service_name="dedicated_rg_service",
    # Tentukan sumber daya CPU dan memori yang digunakan oleh satu instans layanan.
    # Pada contoh ini, setiap layanan menggunakan 2 core CPU dan 4000 MB memori.
    resource_config=ResourceConfig(
        cpu=2,
        memory=4000,
    ),
)

    Panggil layanan inferensi

    Metode pai.model.Model.deploy memanggil API EAS untuk membuat layanan inferensi baru dan mengembalikan objek pai.predictor.Predictor yang mengarah ke layanan yang baru dibuat. Objek Predictor menyediakan metode predict dan raw_predict untuk mengirim permintaan prediksi ke layanan tersebut.

    Catatan

    Input dan output dari pai.predictor.Predictor.raw_predict tidak memerlukan pemrosesan oleh Serializer.

    from pai.predictor import Predictor, EndpointType

# Buat layanan inferensi baru.
predictor = model.deploy(
    instance_type="ecs.c6.xlarge",
    service_name="example_xgb_service",
)

# Gunakan layanan inferensi yang sudah ada.
predictor = Predictor(
    service_name="example_xgb_service",
    # Secara default, layanan diakses melalui Internet. Konfigurasikan akses melalui jaringan VPC. Kode klien harus dijalankan di lingkungan VPC.
    # endpoint_type=EndpointType.INTRANET
)

# .predict mengirim permintaan data ke layanan yang sesuai dan mendapatkan respons. Data input dan respons diproses oleh serializer.
res = predictor.predict(data_in_nested_list)


# .raw_predict menyediakan cara yang lebih fleksibel untuk mengirim permintaan ke layanan inferensi.
response: RawResponse = predictor.raw_predict(
  	# Jika data input berupa bytes atau objek mirip file, data permintaan langsung dilewatkan dalam badan permintaan HTTP.
  	# Jika tidak, data terlebih dahulu diserialisasi ke dalam JSON lalu dilewatkan dalam badan permintaan HTTP.
  	data=data_in_nested_list
  	# path="predict"            # Path permintaan HTTP kustom. Secara default, permintaan dikirim ke path "/".
  	# headers=dict(),						# Header permintaan kustom.
  	# method="POST"							# Metode HTTP kustom.
  	# timeout=30,								# Timeout permintaan kustom.
)

# Dapatkan badan dan header yang dikembalikan.
print(response.content, response.headers)
# Deserialisasi hasil yang dikembalikan dari JSON ke objek Python.
print(response.json())


# Hentikan layanan inferensi.
predictor.stop_service()
# Mulai layanan inferensi.
predictor.start_service()
# Hapus layanan inferensi.
predictor.delete_service()

    Proses input dan output dengan Serializer

    Saat memanggil layanan inferensi menggunakan metode pai.predictor.Predictor.predict dari SDK, struktur data Python input harus diserialisasi ke format yang dapat diproses oleh layanan. Demikian pula, data respons dari layanan harus dideserialisasi ke objek Python yang dapat dibaca. Predictor menggunakan parameter serializer untuk menserialisasi data prediksi dan mendeserialisasi respons prediksi.

    • Saat memanggil predict(data=<PredictionData>), parameter data diserialisasi oleh serializer.serialize. Ini menghasilkan objek bytes, yang kemudian dilewatkan ke layanan inferensi dalam badan permintaan HTTP.

    • Setelah layanan inferensi mengembalikan respons HTTP, objek Predictor mendeserialisasi badan respons HTTP menggunakan serializer.deserialize. Hasilnya kemudian dikembalikan oleh predict.

    SDK menyediakan serializer bawaan yang mendukung tipe data umum dan menangani data input/output untuk processor pembelajaran mendalam bawaan PAI.

    • JsonSerializer

      Objek JsonSerializer mendukung serialisasi dan deserialisasi data dalam format JSON. data yang dilewatkan ke predict dapat berupa numpy.ndarray atau List. JsonSerializer.serialize menserialisasi array tersebut menjadi string JSON. JsonSerializer.deserialize mendeserialisasi string JSON yang diterima menjadi objek Python.

      Processor bawaan PAI seperti XGBoost dan PMML menerima dan mengembalikan data dalam format JSON. Untuk layanan yang dibuat menggunakan processor ini, Predictor secara default menggunakan JsonSerializer.

      • from pai.serializers import JsonSerializer

# Tentukan serializer untuk predictor yang dikembalikan dalam metode ".deploy".
p = Model(
    inference_spec=InferenceSpec(processor="xgboost"),
    model_data="oss://<YourOssBucket>/path-to-xgboost-model"
).deploy(
    instance_type="ecs.c6.xlarge",
    # Opsional: Layanan yang menggunakan processor XGBoost secara default menggunakan JsonSerializer.
    serializer=JsonSerializer()
)

# Atau, tentukan serializer langsung saat membuat Predictor.
p = Predictor(
    service_name="example_xgb_service"
    serializer=JsonSerializer(),
)

# Hasil prediksi juga berupa list.
res = p.predict([[2,3,4], [4,5,6]])

    • TensorFlowSerializer

      Gunakan processor TensorFlow bawaan PAI untuk menerapkan TensorFlow SavedModel ke PAI dan membuat layanan inferensi. Format pesan input dan output untuk layanan ini adalah Protocol Buffers. Untuk informasi lebih lanjut tentang format file tersebut, lihat tf_predict.proto.

      SDK menyediakan TensorFlowSerializer bawaan untuk mengirim permintaan dengan data bertipe numpy.ndarray. Serializer ini mengonversi data numpy.ndarray menjadi pesan Protocol Buffers yang sesuai dan mendeserialisasi pesan Protocol Buffers yang diterima kembali menjadi tipe data numpy.ndarray.

      • # Buat layanan processor TensorFlow.
tf_predictor = Model(
    inference_spec=InferenceSpec(processor="tensorflow_cpu_2.7"),
    model_data="oss://<YourOssBucket>/path-to-tensorflow-saved-model"
).deploy(
    instance_type="ecs.c6.xlarge",
    # Opsional: Layanan yang menggunakan processor TensorFlow secara default menggunakan TensorFlowSerializer.
    # serializer=TensorFlowSerializer(),
)

# Layanan yang dimulai dengan processor TensorFlow memungkinkan mendapatkan signature layanan model melalui API.
print(tf_predictor.inspect_signature_def())

# Input untuk processor TensorFlow memerlukan Dict. Kunci adalah nama signature input model, dan nilai adalah data input spesifik.
tf_result = tf_predictor.predict(data={
    "flatten_input": numpy.zeros(28*28*2).reshape((-1, 28, 28))
})

assert result["dense_1"].shape == (2, 10)

    • PyTorchSerializer

      Gunakan processor PyTorch bawaan PAI untuk menerapkan model dalam format TorchScript sebagai layanan inferensi. Format data input dan output untuk layanan ini adalah Protocol Buffers. Untuk informasi lebih lanjut tentang format file tersebut, lihat pytorch_predict_proto.

      SDK menyediakan PyTorchSerializer bawaan untuk mengirim permintaan dengan data bertipe numpy.ndarray dan mengonversi hasil prediksi menjadi numpy.ndarray. PyTorchSerializer menangani konversi antara pesan Protocol Buffers dan numpy.ndarray.

      • # Buat layanan yang menggunakan processor PyTorch.
torch_predictor = Model(
    inference_spec=InferenceSpec(processor="pytorch_cpu_1.10"),
    model_data="oss://<YourOssBucket>/path-to-torch_script-model"
).deploy(
    instance_type="ecs.c6.xlarge",
    # Opsional: Layanan yang menggunakan processor PyTorch secara default menggunakan PyTorchSerializer.
    # serializer=PyTorchSerializer(),
)

# 1. Ubah bentuk data input ke bentuk yang didukung model.
# 2. Jika terdapat beberapa input, lewatkan sebagai List/Tuple. Setiap item dalam list berupa numpy.ndarray.
torch_result = torch_predictor.predict(data=numpy.zeros(28 * 28 * 2).reshape((-1, 28, 28)))
assert torch_result.shape == (2, 10)

    • Serializer Kustom

      Kustomisasi kelas Serializer berdasarkan format data yang didukung oleh layanan inferensi. Kelas Serializer kustom harus mewarisi pai.serializers.SerializerBase dan mengimplementasikan metode serialize dan deserialize.

      Contoh berikut menunjukkan NumpySerializer kustom. Saat predict dipanggil, alur keseluruhan adalah:

      1. Klien meneruskan numpy.ndarray atau pandas.DataFrame sebagai input ke metode predict. Selanjutnya, NumpySerializer.serializer mengserialisasi input tersebut ke dalam npy format dan mengirimkannya ke server.

      2. Server menerima data dalam format npy, mendeserialisasinya, lalu menghasilkan hasil inferensi. Layanan kemudian menserialisasi hasil tersebut ke dalam format npy dan mengembalikannya.

      3. Klien menerima data yang dikembalikan dalam format npy. Metode NumpySerializer.deserialize kemudian mendeserialisasi data tersebut menjadi numpy.ndarray.

    Terapkan dan panggil layanan secara lokal

    Untuk penerapan custom image, SDK menyediakan mode eksekusi lokal. Mode ini tidak berlaku untuk layanan yang diterapkan menggunakan processor. Jalankan layanan inferensi secara lokal dengan memberikan instance_type="local" ke metode model.deploy. SDK menggunakan docker untuk menjalankan layanan model secara lokal dan secara otomatis mengunduh data model yang diperlukan dari OSS serta memasangnya ke kontainer lokal.

    from pai.predictor import LocalPredictor

p: LocalPredictor = model.deploy(
    # Tentukan untuk menjalankan secara lokal.
    instance_type="local",
    serializer=JsonSerializer()
)

p.predict(data)

# Hapus kontainer docker yang sesuai.
p.delete_service()

    Informasi terkait

    Untuk proses lengkap pelatihan dan penerapan model PyTorch menggunakan PAI Python SDK, lihat Latih dan terapkan model PyTorch menggunakan PAI Python SDK.