Model dan platform AI
Menggelar Model Bahasa Besar di Kubernetes: Panduan Lengkap
Tambahkan Unite.AI ke sumber pilihan Anda di Google
Model Bahasa Besar (LLM) dapat memahami dan menghasilkan teks seperti manusia, membuatnya sangat berharga untuk berbagai aplikasi, seperti chatbot, pembuatan konten, dan terjemahan bahasa.
Namun, menggelar LLM dapat menjadi tugas yang menantang karena ukurannya yang besar dan persyaratan komputasi. Kubernetes, sebuah sistem orkestrasi kontainer sumber terbuka, menyediakan solusi yang kuat untuk menggelar dan mengelola LLM secara besar-besaran. Dalam blog teknis ini, kita akan menjelajahi proses menggelar LLM di Kubernetes, mencakup berbagai aspek seperti kontainerisasi, alokasi sumber daya, dan skalabilitas.
Mengenal Model Bahasa Besar
Sebelum memulai proses penggelaran, mari kita memahami apa itu Model Bahasa Besar dan mengapa mereka mendapatkan perhatian banyak.
Model Bahasa Besar (LLM) adalah jenis model jaringan saraf yang dilatih pada jumlah besar data teks. Model ini belajar memahami dan menghasilkan bahasa seperti manusia dengan menganalisis pola dan hubungan dalam data pelatihan. Beberapa contoh populer LLM termasuk GPT (Generative Pre-trained Transformer), BERT (Bidirectional Encoder Representations from Transformers), dan XLNet.
LLM telah mencapai kinerja yang luar biasa dalam berbagai tugas NLP, seperti pembuatan teks, terjemahan bahasa, dan menjawab pertanyaan. Namun, ukuran besar dan persyaratan komputasi mereka menimbulkan tantangan signifikan untuk penggelaran dan inferensi.
Mengapa Kubernetes untuk Penggelaran LLM?
Kubernetes adalah platform orkestrasi kontainer sumber terbuka yang mengotomatisasi penggelaran, penskalaan, dan pengelolaan aplikasi kontainer. Kubernetes menyediakan beberapa keuntungan untuk menggelar LLM, termasuk:
- Skalabilitas: Kubernetes memungkinkan Anda untuk menskalakan penggelaran LLM secara horizontal dengan menambah atau menghapus sumber daya komputasi sesuai kebutuhan, memastikan utilitas sumber daya yang optimal dan kinerja.
- Pengelolaan Sumber Daya: Kubernetes memungkinkan alokasi sumber daya yang efisien dan isolasi, memastikan bahwa penggelaran LLM Anda memiliki akses ke sumber daya komputasi, memori, dan GPU yang diperlukan.
- Ketersediaan Tinggi: Kubernetes menyediakan mekanisme bawaan untuk self-healing, rollout otomatis, dan rollback, memastikan bahwa penggelaran LLM Anda tetap tersedia tinggi dan tahan terhadap kegagalan.
- Portabilitas: Penggelaran LLM kontainer dapat dengan mudah dipindahkan antara lingkungan yang berbeda, seperti pusat data on-premises atau platform cloud, tanpa perlu konfigurasi ulang yang luas.
- Dukungan Ekosistem dan Komunitas: Kubernetes memiliki komunitas besar dan aktif, menyediakan banyak alat, perpustakaan, dan sumber daya untuk menggelar dan mengelola aplikasi kompleks seperti LLM.
Mempersiapkan Penggelaran LLM di Kubernetes:
Sebelum menggelar LLM di Kubernetes, ada beberapa prasyarat yang perlu dipertimbangkan:
- Klaster Kubernetes: Anda memerlukan klaster Kubernetes yang sudah diatur dan berjalan, baik on-premises atau di platform cloud seperti Amazon Elastic Kubernetes Service (EKS) , Google Kubernetes Engine (GKE) , atau Azure Kubernetes Service (AKS).
- Dukungan GPU: LLM memerlukan akselerasi GPU untuk inferensi yang efisien. Pastikan klaster Kubernetes Anda memiliki akses ke sumber daya GPU, baik melalui GPU fisik atau instance GPU cloud.
- Registri Kontainer: Anda memerlukan registri kontainer untuk menyimpan gambar Docker LLM. Opsi populer termasuk Docker Hub, Amazon Elastic Container Registry (ECR), Google Container Registry (GCR), atau Azure Container Registry (ACR).
- Berkas Model LLM: Dapatkan berkas model LLM pra-dilatih (berat, konfigurasi, dan tokenizer) dari sumber yang sesuai atau latih model Anda sendiri.
- Kontainerisasi: Kontainerisasi aplikasi LLM Anda menggunakan Docker atau runtime kontainer lainnya. Ini melibatkan membuat Dockerfile yang mengemas kode LLM, ketergantungan, dan berkas model menjadi gambar Docker.
Menggelar LLM di Kubernetes
Setelah Anda memiliki prasyarat yang diperlukan, Anda dapat melanjutkan dengan menggelar LLM di Kubernetes. Proses penggelaran biasanya melibatkan langkah-langkah berikut:
Membangun Gambar Docker
Bangun gambar Docker untuk aplikasi LLM Anda menggunakan Dockerfile yang disediakan dan dorong gambar tersebut ke registri kontainer Anda.
Membuat Sumber Daya Kubernetes
Tentukan sumber daya Kubernetes yang diperlukan untuk penggelaran LLM Anda, seperti Deployments, Services, ConfigMaps, dan Secrets. Sumber daya ini biasanya didefinisikan menggunakan manifest YAML atau JSON.
Mengonfigurasi Persyaratan Sumber Daya
Tentukan persyaratan sumber daya untuk penggelaran LLM Anda, termasuk CPU, memori, dan sumber daya GPU. Ini memastikan bahwa penggelaran Anda memiliki akses ke sumber daya komputasi yang diperlukan untuk inferensi yang efisien.
Menggelar ke Kubernetes
Gunakan alat baris perintah kubectl atau alat manajemen Kubernetes (misalnya, Kubernetes Dashboard, Rancher, atau Lens) untuk menerapkan manifest Kubernetes dan menggelar aplikasi LLM Anda.
Pemantauan dan Penskalaan
Pantau kinerja dan utilitas sumber daya penggelaran LLM Anda menggunakan alat pemantauan Kubernetes seperti Prometheus dan Grafana. Sesuaikan alokasi sumber daya atau skala penggelaran Anda sesuai kebutuhan untuk memenuhi permintaan.
Contoh Penggelaran
Mari kita lihat contoh penggelaran model bahasa GPT-3 di Kubernetes menggunakan gambar Docker pra-dibangun dari Hugging Face. Kami akan menganggap bahwa Anda memiliki klaster Kubernetes yang sudah diatur dan dikonfigurasi dengan dukungan GPU.
Tarik Gambar Docker:
<p>docker pull huggingface/text-generation-inference:1.1.0</p>
Buat Penggelaran Kubernetes:
Buat file bernama gpt3-deployment.yaml dengan konten berikut:
<p>apiVersion: apps/v1 kind: Deployment metadata: name: gpt3-deployment spec: replicas: 1 selector: matchLabels: app: gpt3 template: metadata: labels: app: gpt3 spec: containers: - name: gpt3 image: huggingface/text-generation-inference:1.1.0 resources: limits: nvidia.com/gpu: 1 env: - name: MODEL_ID value: gpt2 - name: NUM_SHARD value: "1" - name: PORT value: "8080" - name: QUANTIZE value: bitsandbytes-nf4</p>
Penggelaran ini menentukan bahwa kita ingin menjalankan satu replika kontainer gpt3 menggunakan gambar Docker huggingface/text-generation-inference:1.1.0. Penggelaran ini juga menyetel variabel lingkungan yang diperlukan untuk kontainer memuat model GPT-3 dan mengonfigurasi server inferensi.
Buat Layanan Kubernetes:
Buat file bernama gpt3-service.yaml dengan konten berikut:
<p>apiVersion: v1 kind: Service metadata: name: gpt3-service spec: selector: app: gpt3 ports: - port: 80 targetPort: 8080 type: LoadBalancer</p>
Layanan ini mengekspos penggelaran gpt3 pada port 80 dan membuat Layanan LoadBalancer untuk membuat server inferensi dapat diakses dari luar klaster Kubernetes.
Deploy ke Kubernetes:
Terapkan manifest Kubernetes menggunakan perintah kubectl:
<p>kubectl apply -f gpt3-deployment.yaml kubectl apply -f gpt3-service.yaml</p>
Pantau Penggelaran:
Pantau kemajuan penggelaran menggunakan perintah berikut:
<p>kubectl get pods kubectl logs <pod_name></p>
Saat pod berjalan dan log menunjukkan bahwa model telah dimuat dan siap, Anda dapat mendapatkan alamat IP eksternal Layanan LoadBalancer:
kubectl get service gpt3-service
Uji Penggelaran:
Anda sekarang dapat mengirimkan permintaan ke server inferensi menggunakan alamat IP eksternal dan port yang diperoleh dari langkah sebelumnya. Misalnya, menggunakan curl:
<p>curl -X POST \
http://<external_ip>:80/generate \
-H 'Content-Type: application/json' \
-d '{"inputs": "The quick brown fox", "parameters": {"max_new_tokens": 50}}'</p>
Perintah ini mengirimkan permintaan pembuatan teks ke server inferensi GPT-3, meminta untuk melanjutkan prompt “The quick brown fox” hingga 50 token tambahan.
Topik Lanjutan yang Perlu Anda Ketahui
Sementara contoh di atas menunjukkan penggelaran dasar LLM di Kubernetes, ada beberapa topik lanjutan dan pertimbangan yang perlu dijelajahi:
1. Autoscaling
Kubernetes mendukung autoscaling horizontal dan vertikal, yang dapat bermanfaat untuk penggelaran LLM karena permintaan komputasi yang bervariasi. Autoscaling horizontal memungkinkan Anda untuk menskalakan jumlah replika (pod) secara otomatis berdasarkan metrik seperti utilitas CPU atau memori. Autoscaling vertikal, di sisi lain, memungkinkan Anda untuk menyesuaikan permintaan dan batas sumber daya untuk kontainer Anda.
Untuk mengaktifkan autoscaling, Anda dapat menggunakan Kubernetes Horizontal Pod Autoscaler (HPA) dan Vertical Pod Autoscaler (VPA). Komponen ini memantau penggelaran Anda dan menskalakan sumber daya secara otomatis berdasarkan aturan dan ambang batas yang telah ditentukan.
2. Penjadwalan dan Pembagian GPU
Dalam skenario di mana beberapa penggelaran LLM atau beban kerja lain yang intensif GPU berjalan di klaster Kubernetes yang sama, penjadwalan dan pembagian GPU yang efisien menjadi sangat penting. Kubernetes menyediakan beberapa mekanisme untuk memastikan utilitas GPU yang adil dan efisien, seperti plugin perangkat GPU, pemilih node, dan batas sumber daya.
Anda juga dapat menggunakan teknik penjadwalan GPU lanjutan seperti NVIDIA Multi-Instance GPU (MIG) (NVDA ) atau AMD Memory Pool Remapping (MPR) untuk memvirtualisasi GPU dan membaginya di antara beberapa beban kerja.
3. Paralelisme Model dan Pembagian
Beberapa LLM, terutama yang memiliki miliaran atau triliunan parameter, mungkin tidak dapat dimasukkan sepenuhnya ke dalam memori satu GPU atau bahkan satu node. Dalam kasus seperti itu, Anda dapat menggunakan teknik paralelisme model dan pembagian untuk mendistribusikan model di seluruh beberapa GPU atau node.
Paralelisme model melibatkan membagi arsitektur model menjadi komponen yang berbeda (misalnya, encoder, decoder) dan mendistribusikannya di seluruh beberapa perangkat. Pembagian, di sisi lain, melibatkan partisi parameter model dan mendistribusikannya di seluruh beberapa perangkat atau node.
Kubernetes menyediakan mekanisme seperti StatefulSets dan Custom Resource Definitions (CRDs) untuk mengelola dan mengatur penggelaran LLM terdistribusi dengan paralelisme model dan pembagian.
4. Pembaruan Halus dan Pembelajaran Berkelanjutan
Dalam banyak kasus, LLM pra-dilatih mungkin perlu diperbarui atau dilatih secara berkelanjutan pada data domain-spesifik untuk meningkatkan kinerjanya untuk tugas atau domain tertentu. Kubernetes dapat memfasilitasi proses ini dengan menyediakan platform yang skalabel dan tangguh untuk menjalankan beban kerja pembaruan atau pembelajaran berkelanjutan.
Anda dapat menggunakan kerangka pemrosesan batch Kubernetes seperti Apache Spark atau Kubeflow untuk menjalankan pekerjaan pembaruan atau pelatihan terdistribusi pada model LLM Anda. Selain itu, Anda dapat mengintegrasikan model yang diperbarui atau dilatih secara berkelanjutan dengan penggelaran inferensi Anda menggunakan mekanisme Kubernetes seperti pembaruan bergulir atau penggelaran biru/hijau.
5. Pemantauan dan Pengamatan
Pemantauan dan pengamatan adalah aspek penting dari setiap penggelaran produksi, termasuk penggelaran LLM di Kubernetes. Kubernetes menyediakan solusi pemantauan bawaan seperti Prometheus dan integrasi dengan platform pengamatan populer seperti Grafana, Elasticsearch, dan Jaeger.
Anda dapat memantau berbagai metrik yang terkait dengan penggelaran LLM Anda, seperti utilitas CPU dan memori, utilitas GPU, latensi inferensi, dan throughput. Selain itu, Anda dapat mengumpulkan dan menganalisis log dan jejak aplikasi untuk memperoleh wawasan tentang perilaku dan kinerja model LLM Anda.
6. Keamanan dan Kepatuhan
Bergantung pada kasus penggunaan dan sensitivitas data yang terlibat, Anda mungkin perlu mempertimbangkan aspek keamanan dan kepatuhan saat menggelar LLM di Kubernetes. Kubernetes menyediakan beberapa fitur dan integrasi untuk meningkatkan keamanan, seperti kebijakan jaringan, kontrol akses berbasis peran (RBAC), pengelolaan rahasia, dan integrasi dengan solusi keamanan eksternal seperti HashiCorp Vault (HCP ) atau AWS Secrets Manager.
Selain itu, jika Anda menggelar LLM di industri yang diatur atau menangani data sensitif, Anda mungkin perlu memastikan kepatuhan dengan standar dan regulasi yang relevan, seperti GDPR, HIPAA, atau PCI-DSS.
7. Penggelaran Multi-Awan dan Hibrida
Sementara posting blog ini berfokus pada penggelaran LLM di satu klaster Kubernetes, Anda mungkin perlu mempertimbangkan penggelaran multi-awan atau hibrida dalam beberapa skenario. Kubernetes menyediakan platform yang konsisten untuk menggelar dan mengelola aplikasi di seluruh penyedia cloud yang berbeda dan pusat data on-premises.
Anda dapat menggunakan alat manajemen klaster Kubernetes seperti KubeFed atau GKE Hub untuk mengelola dan mengatur penggelaran LLM di seluruh beberapa klaster Kubernetes yang melintasi penyedia cloud yang berbeda atau lingkungan hibrida.
Topik lanjutan ini menyoroti fleksibilitas dan skalabilitas Kubernetes untuk menggelar dan mengelola LLM.
Kesimpulan
Menggelar Model Bahasa Besar (LLM) di Kubernetes menawarkan banyak keuntungan, termasuk skalabilitas, pengelolaan sumber daya, ketersediaan tinggi, dan portabilitas. Dengan mengikuti langkah-langkah yang diuraikan dalam blog teknis ini, Anda dapat mengkontainerisasi aplikasi LLM Anda, mendefinisikan sumber daya Kubernetes yang diperlukan, dan menggelarnya ke klaster Kubernetes.
Namun, menggelar LLM di Kubernetes hanya merupakan langkah pertama. Saat aplikasi Anda tumbuh dan kebutuhan Anda berkembang, Anda mungkin perlu menjelajahi topik lanjutan seperti autoscaling, penjadwalan GPU, paralelisme model, pembaruan, pemantauan, keamanan, dan penggelaran multi-awan.
Kubernetes menyediakan platform yang kuat dan dapat diperluas untuk menggelar dan mengelola LLM, memungkinkan Anda untuk membangun aplikasi yang dapat diandalkan, skalabel, dan aman.
