Gunakan layanan Scalable Job EAS dalam skenario pelatihan dan inferensi model - Platform For AI

Layanan Scalable Job Elastic Algorithm Service (EAS) mendukung skenario pelatihan dan inferensi model. Dalam skenario pelatihan, layanan ini memungkinkan eksekusi tugas berulang dalam satu instans (Job) dan menyediakan skalabilitas otomatis berdasarkan panjang antrian. Dalam skenario inferensi, layanan ini melacak progres eksekusi setiap permintaan untuk mengaktifkan penjadwalan tugas yang lebih adil. Topik ini menjelaskan cara menggunakan layanan Scalable Job.

Scenarios

Training scenarios

Anda dapat menggunakan layanan Scalable Job dalam skenario pelatihan:

Implementasi: Menggunakan arsitektur antarmuka depan dan backend terpisah yang mendukung penerapan layanan antarmuka depan resident serta layanan Scalable Job.
Manfaat arsitektur: Layanan antarmuka depan biasanya memerlukan sedikit sumber daya dan berbiaya rendah. Menerapkan layanan antarmuka depan resident menghindari pembuatan layanan yang sering dan mengurangi waktu tunggu. Layanan Scalable Job backend memungkinkan eksekusi tugas pelatihan berulang dalam satu instans (Job), sehingga mencegah instans dinyalakan dan dilepas berulang kali serta meningkatkan throughput. Selain itu, layanan Scalable Job backend secara otomatis melakukan scale-out atau scale-in berdasarkan panjang antrian—baik saat terlalu panjang maupun terlalu pendek—untuk memastikan penggunaan sumber daya yang efisien.

Inference scenarios

Dalam skenario inferensi model, layanan Scalable Job dapat melacak progres eksekusi setiap permintaan untuk mengimplementasikan penjadwalan tugas yang lebih adil.

Untuk layanan inferensi dengan waktu respons lama, gunakan layanan inferensi asinkron EAS. Namun, layanan asinkron memiliki isu berikut:

Layanan antrian tidak dapat menjamin bahwa permintaan didorong secara prioritas ke instans yang idle, sehingga menyebabkan pemanfaatan sumber daya yang tidak optimal.
Saat terjadi scale-in layanan, sistem tidak dapat menjamin bahwa permintaan dalam suatu instans selesai diproses sebelum instans tersebut dimatikan, yang dapat menyebabkan permintaan terputus dan dijadwalkan ulang.

Untuk mengatasi isu-isu tersebut, layanan Scalable Job menyediakan optimasi berikut:

Logika subscription yang dioptimalkan: Secara prioritas mendorong permintaan ke instans yang idle. Sebelum instans dimatikan, sistem memblokir dan menunggu hingga permintaan saat ini selesai diproses.
Efisiensi penskalaan yang ditingkatkan: Berbeda dengan mekanisme pelaporan periodik, layanan antrian dilengkapi layanan pemantauan bawaan yang secara cepat memicu penskalaan, mengurangi waktu respons penskalaan dari hitungan menit menjadi sekitar 10 detik.

Basic architecture

Arsitektur terdiri dari tiga komponen: layanan antrian (queue service), pengontrol Horizontal Pod Autoscaler (HPA), dan layanan Scalable Job, seperti ditunjukkan pada gambar berikut.

Cara kerjanya:

Layanan antrian memisahkan pengiriman dan eksekusi permintaan atau tugas, memungkinkan satu layanan Scalable Job memproses beberapa permintaan atau tugas yang berbeda.

Pengontrol HPA memantau jumlah tugas pelatihan dan permintaan yang tertunda dalam layanan antrian untuk mengimplementasikan skalabilitas elastis bagi instans layanan Scalable Job. Konfigurasi penskalaan otomatis default untuk layanan Scalable Job adalah sebagai berikut. Untuk informasi lebih lanjut tentang parameter, lihat Horizontal auto-scaling.

{
    "behavior":{
        "onZero":{
            "scaleDownGracePeriodSeconds":60    # Periode tenggang dalam detik untuk scaling down ke nol.
        },
        "scaleDown":{
            "stabilizationWindowSeconds":1    # Jendela stabilisasi dalam detik untuk scale-in.
        }
    },
    "max":10,    # Jumlah maksimum instans (Jobs).
    "min":1,     # Jumlah minimum instans (Jobs).
    "strategies":{
        "avg_waiting_length":2    # Ambang batas beban rata-rata untuk setiap instans (Job).
    }
}

Service deployment

Deploy an inference service

Prosesnya mirip dengan membuat 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 type menjadi ScalableJob untuk menerapkan layanan inferensi sebagai layanan Scalable Job. Untuk informasi lebih lanjut tentang pengaturan parameter lainnya, lihat JSON deployment. Untuk informasi lebih lanjut tentang cara menerapkan layanan inferensi, lihat Deploy an online photo generation inference service.

Setelah layanan diterapkan, layanan antrian dan layanan Scalable Job akan dibuat secara otomatis. Fitur Autoscaler (horizontal auto-scaling) juga diaktifkan secara default.

Deploy a training service

Dua metode penerapan didukung: integrated deployment dan independent deployment. Logika implementasi dan detail konfigurasi dijelaskan di bawah ini. Untuk instruksi penerapan spesifik, lihat Deploy an auto-scaling Kohya training service.

Logika implementasi
- Integrated deployment: Selain layanan antrian dan layanan Scalable Job, EAS membuat layanan antarmuka depan. Layanan antarmuka depan menerima permintaan pengguna dan meneruskannya ke layanan antrian. Anda dapat menganggap layanan antarmuka depan sebagai klien dari layanan Scalable Job. Dalam mode ini, layanan Scalable Job terikat ke satu layanan antarmuka depan unik dan hanya dapat menjalankan tugas pelatihan yang dikirim dari layanan antarmuka depan tersebut.
- Independent deployment: Metode ini cocok untuk skenario multi-pengguna. Dalam mode ini, layanan Scalable Job bertindak sebagai layanan backend bersama dan dapat diikat ke beberapa layanan antarmuka depan. Setiap pengguna dapat mengirim tugas pelatihan dari layanan antarmuka depan mereka sendiri. Layanan Job backend membuat instans Job yang sesuai untuk menjalankan tugas pelatihan tersebut. Setiap instans Job dapat menjalankan tugas pelatihan yang berbeda secara berurutan, memungkinkan beberapa pengguna berbagi sumber daya pelatihan. Hal ini menghindari pembuatan tugas pelatihan berulang kali dan secara efektif mengurangi biaya.
Detail konfigurasi

Saat menerapkan layanan Scalable Job, sediakan lingkungan custom image. Untuk skenario Kohya, Anda dapat langsung menggunakan preset image `kohya_ss` yang tersedia di EAS. Image tersebut harus berisi semua dependensi yang diperlukan untuk menjalankan tugas pelatihan. Karena hanya berfungsi sebagai lingkungan eksekusi tugas pelatihan, Anda tidak perlu mengonfigurasi perintah start atau nomor port. Untuk melakukan tugas inisialisasi sebelum tugas pelatihan dimulai, Anda dapat mengonfigurasi perintah inisialisasi. EAS membuat proses terpisah di dalam instans (Job) untuk menjalankan tugas-tugas tersebut. Untuk informasi tentang cara menyiapkan custom image, lihat Custom images. Alamat image preset di EAS adalah: eas-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai-eas/kohya_ss:2.2.
Integrated deployment

Siapkan file konfigurasi layanan berdasarkan contoh berikut, yang menggunakan image preset `kohya_ss` yang disediakan oleh 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"
    }
}
```
Pengaturan parameter utama dijelaskan di bawah ini. Untuk informasi tentang pengaturan parameter lainnya, lihat JSON deployment.
- Atur type menjadi ScalableJobService.
- Secara default, layanan antarmuka depan menggunakan kelompok sumber daya yang sama dengan layanan Scalable Job. Sistem mengalokasikan 2 vCPU dan memori 8 GB secara default.
  - Untuk menyesuaikan kelompok sumber daya atau sumber daya, lihat contoh berikut:
    { "front_end": { "resource": "", # Kelompok sumber daya khusus untuk layanan antarmuka depan. "cpu": 4, "memory": 8000 } }
  - Untuk menyesuaikan tipe instans untuk penerapan, lihat contoh berikut:
    { "front_end": { "instance_type": "ecs.c6.large" } }
Independent deployment

Siapkan file konfigurasi layanan berdasarkan contoh berikut, yang menggunakan image preset `kohya_ss` yang disediakan oleh 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 type menjadi ScalableJob. Untuk informasi tentang pengaturan parameter lainnya, lihat JSON deployment.

Dalam mode ini, Anda harus menerapkan layanan antarmuka depan secara manual dan mengimplementasikan proxy permintaan di dalamnya. Proxy tersebut meneruskan permintaan yang diterima ke antrian layanan Scalable Job, sehingga mengikat layanan antarmuka depan ke layanan Job backend. Untuk informasi lebih lanjut, lihat Send data to the queue service.

Service invocation

Untuk membedakan antara skenario pelatihan dan inferensi saat memanggil layanan Scalable Job, atur bidang taskType menjadi command atau query.

command: Mengidentifikasi layanan pelatihan.
query: Mengidentifikasi layanan inferensi.

Anda harus secara eksplisit menentukan `taskType` saat memanggil layanan. Berikut adalah contohnya:

Panggilan HTTP: Untuk layanan inferensi, ganti `{Wanted_TaskType}` dengan `query`.

curl http://166233998075****.cn-shanghai.pai-eas.aliyuncs.com/api/predict/scalablejob?taskType={Wanted_TaskType} -H 'Authorization: xxx' -D 'xxx'

Saat menggunakan SDK, tentukan `taskType` menggunakan parameter `tags`. Pada contoh berikut, jika merupakan layanan inferensi, ganti `wanted_task_type` dengan `query`.

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

Mendapatkan hasil:

Layanan inferensi: Gunakan SDK layanan antrian EAS untuk mendapatkan hasil dari antrian output. Untuk informasi lebih lanjut, lihat Subscribe to the queue service.
Layanan pelatihan: Konfigurasikan mount OSS saat menerapkan layanan. Hal ini menyimpan hasil pelatihan langsung ke path OSS untuk penyimpanan persisten. Untuk informasi lebih lanjut, lihat Deploy an auto-scaling Kohya training service.

Configure log collection

Layanan Scalable Job EAS menyediakan pengaturan enable_write_log_to_queue. Gunakan pengaturan ini untuk menulis log waktu nyata ke antrian.

{
  "scalable_job": {
    "enable_write_log_to_queue": true
  }
}

Skenario pelatihan: Pengaturan ini diaktifkan secara default. Log waktu nyata ditulis kembali ke antrian output. Anda dapat menggunakan SDK layanan antrian EAS untuk mendapatkan log pelatihan secara waktu nyata. Untuk informasi lebih lanjut, lihat Use a custom frontend service image to call a Scalable Job service.
Skenario inferensi: Pengaturan ini dinonaktifkan secara default. Log hanya dapat dikeluarkan menggunakan stdout.

References

Untuk skenario layanan Scalable Job EAS yang lebih detail, lihat topik-topik berikut: