Elastic Algorithm Service (EAS) dari Platform for AI (PAI) menyediakan layanan Scalable Job untuk pelatihan model dan inferensi. Layanan ini mendukung penggunaan kembali serta penskalaan otomatis. Dalam skenario pelatihan model dengan beberapa pekerjaan yang berjalan bersamaan, layanan Scalable Job membantu mengurangi pemborosan sumber daya akibat pembuatan dan pelepasan instans yang sering. Pada skenario inferensi, layanan ini melacak kemajuan eksekusi setiap permintaan untuk meningkatkan efisiensi penjadwalan tugas. Topik ini menjelaskan cara menggunakan layanan Scalable Job.
Skenario
Pelatihan model
Implementasi
Sistem menggunakan arsitektur yang memisahkan layanan frontend dan backend untuk mendukung layanan frontend tetap serta layanan backend Scalable Job.
Manfaat Arsitektur
Umumnya, layanan frontend memerlukan sedikit sumber daya dan biaya rendah untuk penyebaran. Anda dapat menyebar layanan frontend tetap untuk menghindari pembuatan layanan frontend yang sering dan mengurangi waktu tunggu. Layanan backend Scalable Job memungkinkan Anda menjalankan tugas pelatihan beberapa kali dalam satu instans, mencegah instans dihidupkan dan dilepaskan berulang kali selama beberapa eksekusi, serta meningkatkan throughput layanan. Layanan Scalable Job juga dapat secara otomatis menskalakan berdasarkan panjang antrian untuk memastikan penggunaan sumber daya yang efisien.
Inferensi model
Dalam skenario inferensi model, layanan Scalable Job melacak kemajuan eksekusi setiap permintaan untuk mengimplementasikan penjadwalan tugas secara lebih efisien.
Secara umum, kami merekomendasikan agar Anda menyebar layanan inferensi yang membutuhkan waktu lebih lama untuk merespons sebagai layanan inferensi asinkron di EAS. Namun, layanan asinkron memiliki masalah berikut:
Layanan antrian tidak dapat mengutamakan pengiriman permintaan ke instans yang idle, yang dapat menyebabkan pemanfaatan sumber daya yang tidak optimal.
Selama pengecilan layanan, layanan antrian mungkin menghapus instans yang masih memproses permintaan, menyebabkan permintaan terputus dan dijadwalkan ulang ke instans lain untuk dieksekusi kembali.
Untuk menyelesaikan masalah tersebut, layanan Scalable Job mengimplementasikan optimasi berikut:
Optimasi logika langganan: Memastikan bahwa permintaan dikirimkan dengan prioritas ke instans yang idle. Sebelum instans Scalable Job dihentikan atau dilepaskan, instans tersebut diblokir selama periode waktu tertentu untuk memastikan bahwa eksekusi permintaan pada instans selesai.
Optimasi logika penskalaan: Berbeda dengan mekanisme pelaporan biasa dari layanan pemantauan umum, layanan Scalable Job menggunakan layanan pemantauan bawaan dalam layanan antrian untuk mengimplementasikan tautan pemantauan khusus. Ini memastikan bahwa penambahan dan pengurangan skala dipicu dengan cepat ketika panjang antrian melebihi atau berada di bawah ambang batas. Waktu respons penskalaan dikurangi dari menit menjadi sekitar 10 detik.
Arsitektur
Arsitektur terdiri dari bagian-bagian berikut: layanan antrian, Horizontal Pod Autoscaling (HPA) controller, dan Scalable Job. 
Cara kerjanya:
Layanan antrian digunakan untuk memisahkan pengiriman dan eksekusi permintaan atau tugas, memungkinkan layanan Scalable Job tunggal mengeksekusi beberapa permintaan atau tugas.
Kontroler HPA digunakan untuk terus memantau jumlah tugas pelatihan dan permintaan yang tertunda dalam layanan antrian guna memicu penskalaan otomatis instans Scalable Job. Bagian berikutnya menjelaskan konfigurasi penskalaan otomatis default untuk layanan Scalable Job. Untuk informasi lebih lanjut tentang parameter, lihat Penskalaan Otomatis.
{ "behavior":{ "onZero":{ "scaleDownGracePeriodSeconds":60 # Durasi dari waktu ketika pengecilan skala dipicu hingga semua instans dihapus. Unit: detik. }, "scaleDown":{ "stabilizationWindowSeconds":1 # Durasi dari waktu ketika pengecilan skala dipicu hingga pengecilan skala dimulai. Unit: detik. } }, "max":10, # Jumlah maksimum instans job yang dapat diskalakan. "min":1, # Jumlah minimum instans job yang dapat diskalakan. "strategies":{ "avg_waiting_length":2 # Panjang antrian rata-rata setiap instans job yang dapat diskalakan. } }
Menyebarkan layanan
Menyebarkan layanan inferensi
Prosesnya mirip dengan proses pembuatan layanan inferensi asinkron. Siapkan file konfigurasi layanan berdasarkan contoh berikut:
{
"containers": [
{
"image": "registry-vpc.cn-shanghai.aliyuncs.com/eas/eas-container-deploy-test:202010091755",
"command": "/data/eas/ENV/bin/python /data/eas/app.py"
"port": 8000,
}
],
"metadata": {
"name": "scalablejob",
"type": "ScalableJob",
"rpc.worker_threads": 4,
"instance": 1,
}
}Atur tipe ke ScalableJob untuk menyebarkan layanan inferensi sebagai job yang dapat diskalakan. Untuk informasi tentang parameter lainnya, lihat Parameter untuk Penyebaran JSON. Untuk informasi tentang cara menyebarkan layanan inferensi, lihat Sebarkan Layanan Potret Online sebagai Job yang Dapat Diskalakan.
Setelah Anda menyebarkan layanan, sistem secara otomatis membuat layanan antrian dan job yang dapat diskalakan serta mengaktifkan penskalaan otomatis.
Menyebarkan layanan pelatihan
Metode penyebaran terintegrasi dan penyebaran independen didukung. Bagian berikutnya menjelaskan cara kerja penyebaran dan detail konfigurasi. Untuk informasi lebih lanjut tentang metode penyebaran, lihat Sebarkan Kohya Training Auto-Scaling sebagai Job yang Dapat Diskalakan.
Cara Kerja Penyebaran
Penyebaran Terintegrasi: EAS membuat layanan frontend selain layanan antrian dan layanan Scalable Job. Layanan frontend digunakan untuk menerima permintaan dan meneruskan permintaan ke layanan antrian. Layanan frontend berfungsi sebagai klien layanan Scalable Job. Layanan Scalable Job dikaitkan dengan layanan frontend unik. Dalam hal ini, layanan Scalable Job hanya dapat mengeksekusi tugas pelatihan yang diteruskan oleh layanan frontend terkait.
Penyebaran Independen: Penyebaran independen cocok untuk skenario multi-pengguna. Dalam mode ini, layanan Scalable Job digunakan sebagai layanan backend umum dan dapat dikaitkan dengan beberapa layanan frontend. Setiap pengguna dapat mengirim tugas pelatihan dari layanan frontend mereka. Layanan backend Scalable Job membuat instans Scalable Job yang sesuai untuk mengeksekusi tugas pelatihan, dan setiap instans pekerjaan dapat mengeksekusi beberapa tugas pelatihan berdasarkan urutan pengiriman. Ini memungkinkan berbagi sumber daya di antara beberapa pengguna. Anda tidak perlu membuat tugas pelatihan berkali-kali, yang secara efektif mengurangi biaya.
Konfigurasi
Saat Anda menyebarkan layanan Scalable Job, Anda perlu menyediakan gambar kustom. Perhatikan bahwa jika Anda ingin menyebarkan layanan berbasis Kohya, Anda dapat menggunakan gambar Kohya_ss yang telah ditetapkan sebelumnya di EAS. Gambar harus berisi semua dependensi tugas pelatihan. Gambar digunakan sebagai lingkungan eksekusi tugas pelatihan. Anda tidak perlu mengonfigurasi perintah startup atau nomor port. Jika Anda perlu melakukan tugas inisialisasi sebelum tugas pelatihan, Anda dapat mengonfigurasi perintah inisialisasi. EAS membuat proses terpisah dalam instans Scalable Job untuk melakukan tugas inisialisasi. Untuk informasi tentang cara menyiapkan gambar kustom, lihat Sebarkan Layanan Model Menggunakan Gambar Kustom. Contoh gambar preset di EAS:
"containers": [ { "image": "eas-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai-eas/kohya_ss:2.2" } ]Penyebaran terintegrasi
Siapkan file konfigurasi layanan. Bagian berikutnya memberikan file konfigurasi sampel dengan menggunakan gambar Kohya_ss yang telah ditetapkan sebelumnya di EAS.
{ "containers": [ { "image": "eas-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai-eas/kohya_ss:2.2" } ], "metadata": { "cpu": 4, "enable_webservice": true, "gpu": 1, "instance": 1, "memory": 15000, "name": "kohya_job", "type": "ScalableJobService" }, "front_end": { "image": "eas-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai-eas/kohya_ss:2.2", "port": 8001, "script": "python -u kohya_gui.py --listen 0.0.0.0 --server_port 8001 --data-dir /workspace --headless --just-ui --job-service" } }Bagian berikutnya menjelaskan parameter utama. Untuk informasi tentang cara mengonfigurasi parameter lainnya, lihat Parameter untuk Penyebaran JSON.
Atur tipe ke ScalableJobService.
Secara default, kelompok sumber daya yang digunakan oleh layanan frontend sama dengan kelompok sumber daya yang digunakan oleh layanan Scalable Job. Sistem mengalokasikan 2 vCPU dan 8 GB memori untuk layanan frontend.
Kustomisasi kelompok sumber daya atau sumber daya berdasarkan kode sampel berikut:
{ "front_end": { "resource": "", # Ubah kelompok sumber daya khusus yang digunakan oleh layanan frontend. "cpu": 4, "memory": 8000 } }Kustomisasi jenis instans yang digunakan untuk penyebaran berdasarkan kode sampel berikut:
{ "front_end": { "instance_type": "ecs.c6.large" } }
Penyebaran independen
Siapkan file konfigurasi layanan. Bagian berikutnya memberikan file konfigurasi sampel dengan menggunakan gambar Kohya_ss yang telah ditetapkan sebelumnya di EAS.
{ "containers": [ { "image": "eas-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai-eas/kohya_ss:2.2" } ], "metadata": { "cpu": 4, "enable_webservice": true, "gpu": 1, "instance": 1, "memory": 15000, "name": "kohya_job", "type": "ScalableJob" } }Atur tipe ke ScalableJobService. Untuk informasi tentang cara mengonfigurasi parameter lainnya, lihat Parameter untuk Penyebaran JSON.
Dalam mode ini, Anda perlu menyebarkan layanan frontend dan mengimplementasikan proxy dalam layanan frontend yang meneruskan permintaan yang diterima ke antrian layanan Scalable Job. Dengan cara ini, layanan frontend dan layanan backend Scalable Job dikaitkan. Untuk informasi lebih lanjut, lihat bagian "Kirim Data ke Layanan Antrian" dalam topik Akses Layanan Antrian.
Panggil layanan
Untuk membedakan antara layanan pelatihan dan layanan inferensi, Anda perlu mengonfigurasi bidang taskType:command/query saat Anda memanggil layanan Scalable Job. Parameter:
command: Digunakan untuk mengidentifikasi layanan pelatihan.
query: Digunakan untuk mengidentifikasi layanan inferensi.
Saat Anda memanggil layanan menggunakan HTTP atau SDK, Anda perlu secara eksplisit menentukan taskType. Contoh:
Atur taskType ke query saat Anda mengirim permintaan HTTP:
curl http://166233998075****.cn-shanghai.pai-eas.aliyuncs.com/api/predict/scalablejob?taskType={Wanted_TaskType} -H 'Authorization: xxx' -D 'xxx'Gunakan parameter tags untuk menentukan taskType saat Anda memanggil SDK:
# Buat antrian input untuk mengirim tugas atau permintaan. queue_client = QueueClient('166233998075****.cn-shanghai.pai-eas.aliyuncs.com', 'scalabejob') queue_client.set_token('xxx') queue_client.init() tags = {"taskType": "wanted_task_type"} # Kirim tugas atau permintaan ke antrian input. index, request_id = inputQueue.put(cmd, tags)
Terima Respons:
Layanan Inferensi: Anda dapat menggunakan SDK untuk layanan antrian EAS untuk mendapatkan hasil di antrian output. Untuk informasi lebih lanjut, lihat bagian "Berlangganan ke Layanan Antrian" dalam topik Akses Layanan Antrian.
Layanan Pelatihan: Saat Anda menyebarkan layanan, kami merekomendasikan agar Anda memasang Bucket OSS untuk menyimpan hasil pelatihan di Bucket OSS untuk penyimpanan permanen. Untuk informasi lebih lanjut, lihat Sebarkan Pelatihan Berbasis Kohya sebagai Job yang Dapat Diskalakan.
Konfigurasikan pengumpulan log
Anda dapat mengonfigurasi enable_write_log_to_queue untuk mendapatkan log real-time.
{
"scalable_job": {
"enable_write_log_to_queue": true
}
}Dalam skenario pelatihan, konfigurasi ini diaktifkan secara default. Sistem menulis log real-time kembali ke antrian output. Anda dapat menggunakan SDK layanan antrian EAS untuk mendapatkan log pelatihan secara real-time. Untuk informasi lebih lanjut, lihat Sebarkan Pelatihan Kohya Auto-Scaling sebagai Job yang Dapat Diskalakan.
Dalam skenario inferensi, konfigurasi ini dinonaktifkan secara default. Sistem mengeluarkan log menggunakan stdout.
Referensi
Untuk informasi lebih lanjut tentang skenario layanan Scalable Job, lihat topik-topik berikut: