Deploy layanan inference LLM dengan runtime kustom menggunakan ModelMesh - Alibaba Cloud Service Mesh

Model bahasa besar (LLM) adalah model jaringan saraf dengan ratusan juta parameter, seperti Generative Pre-Trained Transformer 3 (GPT-3), GPT-4, Pathways Language Model (PaLM), dan PaLM 2. Saat memproses sejumlah besar data bahasa alami atau membangun sistem pemahaman bahasa yang kompleks, Anda dapat menggunakan LLM sebagai layanan inferensi dan memanggil API untuk mengintegrasikan kemampuan pemrosesan bahasa alami (NLP) tingkat lanjut, seperti klasifikasi teks, analisis sentimen, dan penerjemahan mesin, ke dalam aplikasi Anda. Dengan pendekatan LLM-sebagai-layanan, Anda tidak perlu membayar biaya infrastruktur yang tinggi dan dapat merespons perubahan pasar dengan cepat. Selain itu, Anda dapat memperluas layanan kapan saja untuk menangani lonjakan permintaan pengguna serta meningkatkan efisiensi operasional karena LLM berjalan di cloud.

Prasyarat

Fitur Model Service Mesh (selanjutnya disebut ModelMesh) harus diaktifkan di instance Service Mesh (ASM) Anda, dan lingkungan ASM harus dikonfigurasi. Untuk informasi lebih lanjut, lihat Langkah 1 dan Langkah 2 di Gunakan ModelMesh untuk Meluncurkan Layanan Inferensi Multi-Model.
Anda telah mempelajari cara menggunakan ModelMesh untuk membuat runtime penyajian model kustom. Untuk informasi lebih lanjut, lihat Gunakan ModelMesh untuk Membuat Runtime Penyajian Model Kustom.

Langkah 1: Bangun runtime kustom

Bangun runtime kustom untuk menyajikan Hugging Face LLM dengan konfigurasi pengaturan prompt. Dalam contoh ini, nilai default diatur ke gambar runtime kustom pra-dibangun dan konfigurasi pengaturan prompt pra-dibangun.

Implementasikan kelas yang mewarisi dari kelas MLModel MLServer.

File peft_model_server.py berisi semua kode tentang cara menyajikan Hugging Face LLM dengan konfigurasi pengaturan prompt. Fungsi _load_model dalam file digunakan untuk memilih model LLM pra-latih dengan konfigurasi pengaturan prompt PEFT yang dilatih. Fungsi _load_model juga mendefinisikan tokenizer yang dapat mengkodekan dan mendekodekan input string mentah dari permintaan inferensi tanpa meminta pengguna untuk memproses input mereka menjadi byte tensor.

Tampilkan File peft_model_server.py

from typing import List

from mlserver import MLModel, types
from mlserver.codecs import decode_args

from peft import PeftModel, PeftConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import os

class PeftModelServer(MLModel):
    async def load(self) -> bool:
        self._load_model()
        self.ready = True
        return self.ready

    @decode_args
    async def predict(self, content: List[str]) -> List[str]:
        return self._predict_outputs(content)

    def _load_model(self):
        model_name_or_path = os.environ.get("PRETRAINED_MODEL_PATH", "bigscience/bloomz-560m")
        peft_model_id = os.environ.get("PEFT_MODEL_ID", "aipipeline/bloomz-560m_PROMPT_TUNING_CAUSAL_LM")
        self.tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, local_files_only=True)
        config = PeftConfig.from_pretrained(peft_model_id)
        self.model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
        self.model = PeftModel.from_pretrained(self.model, peft_model_id)
        self.text_column = os.environ.get("DATASET_TEXT_COLUMN_NAME", "Tweet text")
        return

    def _predict_outputs(self, content: List[str]) -> List[str]:
        output_list = []
        for input in content:
            inputs = self.tokenizer(
                f'{self.text_column} : {input} Label : ',
                return_tensors="pt",
            )
            with torch.no_grad():
                inputs = {k: v for k, v in inputs.items()}
                outputs = self.model.generate(
                    input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], max_new_tokens=10, eos_token_id=3
                )
                outputs = self.tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True)
            output_list.append(outputs[0])
        return output_list

Bangun Gambar Docker.

Setelah kelas model diimplementasikan, Anda perlu mengemas dependensinya, termasuk MLServer, ke dalam gambar yang didukung sebagai sumber daya ServingRuntime. Anda dapat merujuk pada Dockerfile berikut untuk membangun gambar:

Tampilkan Dockerfile

# TODO: pilih gambar dasar yang sesuai, instal Python, MLServer, dan
# dependensi dari implementasi MLModel Anda
FROM python:3.8-slim-buster
RUN pip install mlserver peft transformers datasets
# ...

# Implementasi `MLModel` kustom harus ada di jalur pencarian Python
# daripada bergantung pada direktori kerja gambar. Jika menggunakan modul
# satu file, ini dapat dicapai dengan:
COPY --chown=${USER} ./peft_model_server.py /opt/peft_model_server.py
ENV PYTHONPATH=/opt/

# variabel lingkungan agar kompatibel dengan ModelMesh Serving
# ini juga dapat diatur dalam ServingRuntime, tetapi ini direkomendasikan untuk
# konsistensi saat membangun dan menguji
ENV MLSERVER_MODELS_DIR=/models/_mlserver_models \
    MLSERVER_GRPC_PORT=8001 \
    MLSERVER_HTTP_PORT=8002 \
    MLSERVER_LOAD_MODELS_AT_STARTUP=false \
    MLSERVER_MODEL_NAME=peft-model

# Dengan pengaturan ini, bidang implementasi tidak diperlukan dalam pengaturan model
# yang mempermudah integrasi dengan memungkinkan adaptor bawaan menghasilkan
# file pengaturan model dasar
ENV MLSERVER_MODEL_IMPLEMENTATION=peft_model_server.PeftModelServer

CMD mlserver start ${MLSERVER_MODELS_DIR}

Buat Sumber Daya ServingRuntime Baru.

Buat sumber daya ServingRuntime baru dengan menggunakan konten berikut dan arahkan ke gambar yang Anda buat.

Tampilkan File YAML

apiVersion: serving.kserve.io/v1alpha1
kind: ServingRuntime
metadata:
  name: peft-model-server
  namespace: modelmesh-serving
spec:
  supportedModelFormats:
    - name: peft-model
      version: "1"
      autoSelect: true
  multiModel: true
  grpcDataEndpoint: port:8001
  grpcEndpoint: port:8085
  containers:
    - name: mlserver
      image:  registry.cn-beijing.aliyuncs.com/test/peft-model-server:latest
      env:
        - name: MLSERVER_MODELS_DIR
          value: "/models/_mlserver_models/"
        - name: MLSERVER_GRPC_PORT
          value: "8001"
        - name: MLSERVER_HTTP_PORT
          value: "8002"
        - name: MLSERVER_LOAD_MODELS_AT_STARTUP
          value: "true"
        - name: MLSERVER_MODEL_NAME
          value: peft-model
        - name: MLSERVER_HOST
          value: "127.0.0.1"
        - name: MLSERVER_GRPC_MAX_MESSAGE_LENGTH
          value: "-1"
        - name: PRETRAINED_MODEL_PATH
          value: "bigscience/bloomz-560m"
        - name: PEFT_MODEL_ID
          value: "aipipeline/bloomz-560m_PROMPT_TUNING_CAUSAL_LM"
        # - name: "TRANSFORMERS_OFFLINE"
        #   value: "1"  
        # - name: "HF_DATASETS_OFFLINE"
        #   value: "1"    
      resources:
        requests:
          cpu: 500m
          memory: 4Gi
        limits:
          cpu: "5"
          memory: 5Gi
  builtInAdapter:
    serverType: mlserver
    runtimeManagementPort: 8001
    memBufferBytes: 134217728
    modelLoadingTimeoutMillis: 90000

Jalankan perintah berikut untuk menyebarkan sumber daya ServingRuntime:
```
kubectl apply -f sample-runtime.yaml
```
Setelah membuat sumber daya ServingRuntime, Anda dapat melihat runtime kustom baru di penyebaran ModelMesh Anda.

Langkah 2: Sebarkan layanan LLM

Untuk menyebarkan model menggunakan runtime yang baru dibuat, Anda harus membuat sumber daya InferenceService untuk menyajikan model. Sumber daya ini merupakan antarmuka utama yang digunakan oleh KServe dan ModelMesh untuk mengelola model. Ini mewakili titik akhir logis model untuk menyajikan inferensi.

Buat sumber daya InferenceService untuk menyajikan model dengan menggunakan konten berikut:
Tampilkan File YAML
```
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: peft-demo
  namespace: modelmesh-serving
  annotations:
    serving.kserve.io/deploymentMode: ModelMesh
spec:
  predictor:
    model:
      modelFormat:
        name: peft-model
      runtime: peft-model-server
      storage:
        key: localMinIO
        path: sklearn/mnist-svm.joblib
```
Dalam file YAML, sumber daya InferenceService diberi nama peft-demo dan format modelnya dinyatakan sebagai peft-model, yang merupakan format yang sama dengan runtime kustom contoh yang dibuat pada langkah sebelumnya. Bidang opsional runtime juga dilewatkan, secara eksplisit memerintahkan ModelMesh untuk menggunakan runtime peft-model-server untuk menyebarkan model ini.
Jalankan perintah berikut untuk menyebarkan sumber daya InferenceService:
```
kubectl apply -f ${Nama file YAML}.yaml
```

Langkah 3: Lakukan inferensi

Jalankan perintah curl untuk mengirim permintaan inferensi ke layanan LLM yang disebarkan pada langkah sebelumnya.

MODEL_NAME="peft-demo"
ASM_GW_IP="Alamat IP gateway ingress"
curl -X POST -k http://${ASM_GW_IP}:8008/v2/models/${MODEL_NAME}/infer -d @./input.json

input.json dalam perintah curl menunjukkan data permintaan:

{
    "inputs": [
        {
          "name": "content",
          "shape": [1],
          "datatype": "BYTES",
          "contents": {"bytes_contents": ["RXZlcnkgZGF5IGlzIGEgbmV3IGJpbm5pbmcsIGZpbGxlZCB3aXRoIG9wdGlvbnBpZW5pbmcgYW5kIGhvcGU="]}
        }
    ]
}

Nilai dari bytes_contents adalah konten yang dienkripsi Base64 dari string "Every day is a new beginning, filled with opportunities and hope".

Blok kode berikut menunjukkan respons JSON:

{
 "modelName": "peft-demo__isvc-5c5315c302",
 "outputs": [
  {
   "name": "output-0",
   "datatype": "BYTES",
   "shape": [
    "1",
    "1"
   ],
   "parameters": {
    "content_type": {
     "stringParam": "str"
    }
   },
   "contents": {
    "bytesContents": [
     "VHdlZXQgdGV4dCA6IEV2ZXJ5IGRheSBpcyBhIG5ldyBiaW5uaW5nLCBmaWxsZWQgd2l0aCBvcHRpb25waWVuaW5nIGFuZCBob3BlIExhYmVsIDogbm8gY29tcGxhaW50"
    ]
   }
  }
 ]
}

Blok kode berikut menunjukkan konten yang didekode Base64 dari bytesContents. Ini menunjukkan bahwa permintaan inferensi dilakukan pada layanan LLM sesuai harapan.

Tweet text : Every day is a new binning, filled with optionpiening and hope Label : no complaint