Menayangkan model terbuka menggunakan penampung premium Hex-LLM di Cloud TPU

Hex-LLM, penayangan model bahasa besar (LLM) efisiensi tinggi dengan XLA, adalah framework penayangan LLM Vertex AI yang dirancang dan dioptimalkan untuk hardware Cloud TPU. Hex-LLM menggabungkan teknologi penayangan LLM seperti batching berkelanjutan dan PagedAttention dengan pengoptimalan Vertex AI yang disesuaikan untuk XLA dan Cloud TPU. Ini adalah LLM yang hemat biaya dan berbiaya rendah yang ditayangkan di Cloud TPU untuk model open source.

Hex-LLM tersedia di Model Garden melalui area uji coba model, deployment sekali klik, dan notebook.

Fitur

Hex-LLM didasarkan pada project open source dengan pengoptimalan Google sendiri untuk XLA dan Cloud TPU. Hex-LLM mencapai throughput tinggi dan latensi rendah saat menayangkan LLM yang sering digunakan.

Hex-LLM mencakup pengoptimalan berikut:

  • Algoritma pengelompokan berkelanjutan berbasis token untuk membantu memastikan model sepenuhnya menggunakan hardware dengan sejumlah besar permintaan serentak.
  • Penulisan ulang lengkap kernel perhatian yang dioptimalkan untuk XLA.
  • Strategi paralelisme data dan paralelisme tensor yang fleksibel dan composable dengan metode sharding bobot yang sangat dioptimalkan untuk menjalankan LLM secara efisien di beberapa chip Cloud TPU.

Hex-LLM mendukung berbagai LLM padat dan jarang:

  • Gemma 2B dan 7B
  • Gemma 2 9B dan 27B
  • Llama 2 7B, 13B, dan 70B
  • Llama 3 8B dan 70B
  • Llama 3.1 8B dan 70B
  • Llama 3.2 1B dan 3B
  • Llama Guard 3 1B dan 8B
  • Mistral 7B
  • Mixtral 8x7B dan 8x22B
  • Phi-3 mini dan sedang
  • Qwen2 0,5B, 1,5B, dan 7B
  • Qwen2.5 0,5B, 1,5B, 7B, 14B, dan 32B AWQ

Hex-LLM juga menyediakan berbagai fitur, seperti berikut:

  • Hex-LLM disertakan dalam satu penampung. Hex-LLM memaketkan server API, mesin inferensi, dan model yang didukung ke dalam satu image Docker untuk di-deploy.
  • Kompatibel dengan format model Hugging Face. Hex-LLM dapat memuat model Hugging Face dari disk lokal, Hugging Face Hub, dan bucket Cloud Storage.
  • Kuantifikasi menggunakan bitsandbytes dan AWQ.
  • Pemuatan LoRA dinamis. Hex-LLM dapat memuat bobot LoRA dengan membaca argumen permintaan selama penayangan.

Fitur Lanjutan

Hex-LLM mendukung fitur lanjutan berikut:

  • Penayangan multi-host
  • Penayangan yang terdiferensiasi [eksperimental]
  • Penyimpanan cache awalan
  • Dukungan kuantisasi 4-bit

Penayangan multi-host

Hex-LLM kini mendukung model penayangan dengan slice TPU multi-host. Fitur ini memungkinkan Anda menayangkan model besar yang tidak dapat dimuat ke dalam satu VM TPU host, yang berisi maksimal delapan core v5e.

Untuk mengaktifkan fitur ini, tetapkan --num_hosts dalam argumen penampung Hex-LLM dan tetapkan --tpu_topology dalam permintaan upload model Vertex AI SDK. Contoh berikut menunjukkan cara men-deploy penampung Hex-LLM dengan topologi TPU 4x4 v5e yang menayangkan model bfloat16 Llama 3.1 70B:

hexllm_args = [
    "--host=0.0.0.0",
    "--port=7080",
    "--model=meta-llama/Meta-Llama-3.1-70B",
    "--data_parallel_size=1",
    "--tensor_parallel_size=16",
    "--num_hosts=4",
    "--hbm_utilization_factor=0.9",
]

model = aiplatform.Model.upload(
    display_name=model_name,
    serving_container_image_uri=HEXLLM_DOCKER_URI,
    serving_container_command=["python", "-m", "hex_llm.server.api_server"],
    serving_container_args=hexllm_args,
    serving_container_ports=[7080],
    serving_container_predict_route="/generate",
    serving_container_health_route="/ping",
    serving_container_environment_variables=env_vars,
    serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
    serving_container_deployment_timeout=7200,
    location=TPU_DEPLOYMENT_REGION,
)

model.deploy(
    endpoint=endpoint,
    machine_type=machine_type,
    tpu_topology="4x4",
    deploy_request_timeout=1800,
    service_account=service_account,
    min_replica_count=min_replica_count,
    max_replica_count=max_replica_count,
)

Untuk tutorial menyeluruh tentang cara men-deploy penampung Hex-LLM dengan topologi TPU multi-host, lihat notebook Vertex AI Model Garden - Llama 3.1 (Deployment).

Secara umum, satu-satunya perubahan yang diperlukan untuk mengaktifkan penayangan multi-host adalah:

  1. Tetapkan argumen --tensor_parallel_size ke jumlah total core dalam topologi TPU.
  2. Tetapkan argumen --num_hosts ke jumlah host dalam topologi TPU.
  3. Tetapkan --tpu_topology dengan API upload model Vertex AI SDK.

Penayangan yang terdiferensiasi [eksperimental]

Hex-LLM kini mendukung penayangan yang terdisagregasi sebagai fitur eksperimental. Fitur ini hanya dapat diaktifkan pada penyiapan host tunggal dan performanya sedang disesuaikan.

Penayangan yang terdisagregasi adalah metode yang efektif untuk menyeimbangkan Time to First Token (TTFT) dan Time Per Output Token (TPOT) untuk setiap permintaan, dan throughput penayangan secara keseluruhan. Hal ini memisahkan fase pra-pengisian dan fase dekode ke dalam workload yang berbeda sehingga tidak saling mengganggu. Metode ini sangat berguna untuk skenario yang menetapkan persyaratan latensi yang ketat.

Untuk mengaktifkan fitur ini, tetapkan --disagg_topo dalam argumen penampung Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy penampung Hex-LLM di TPU v5e-8 yang menayangkan model Llama 3.1 8B bfloat16:

hexllm_args = [
    "--host=0.0.0.0",
    "--port=7080",
    "--model=meta-llama/Llama-3.1-8B",
    "--data_parallel_size=1",
    "--tensor_parallel_size=2",
    "--disagg_topo=3,1",
    "--hbm_utilization_factor=0.9",
]

model = aiplatform.Model.upload(
    display_name=model_name,
    serving_container_image_uri=HEXLLM_DOCKER_URI,
    serving_container_command=["python", "-m", "hex_llm.server.api_server"],
    serving_container_args=hexllm_args,
    serving_container_ports=[7080],
    serving_container_predict_route="/generate",
    serving_container_health_route="/ping",
    serving_container_environment_variables=env_vars,
    serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
    serving_container_deployment_timeout=7200,
    location=TPU_DEPLOYMENT_REGION,
)

model.deploy(
    endpoint=endpoint,
    machine_type=machine_type,
    deploy_request_timeout=1800,
    service_account=service_account,
    min_replica_count=min_replica_count,
    max_replica_count=max_replica_count,
)

Argumen --disagg_topo menerima string dalam format "number_of_prefill_workers,number_of_decode_workers". Dalam contoh sebelumnya, nilai ini ditetapkan ke "3,1" untuk mengonfigurasi tiga pekerja pra-isi dan 1 pekerja dekode. Setiap pekerja menggunakan dua core TPU v5e.

Penyimpanan cache awalan

Cache awalan mengurangi Waktu hingga Token Pertama (TTFT) untuk perintah yang memiliki konten identik di awal perintah, seperti pengantar untuk seluruh perusahaan, petunjuk sistem umum, dan histori percakapan multi-giliran. Daripada memproses token input yang sama berulang kali, Hex-LLM dapat mempertahankan cache sementara komputasi token input yang diproses untuk meningkatkan TTFT.

Untuk mengaktifkan fitur ini, tetapkan --enable_prefix_cache_hbm dalam argumen penampung Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy penampung Hex-LLM di TPU v5e-8 yang menayangkan model Llama 3.1 8B bfloat16:

hexllm_args = [
    "--host=0.0.0.0",
    "--port=7080",
    "--model=meta-llama/Llama-3.1-8B",
    "--data_parallel_size=1",
    "--tensor_parallel_size=2",
    "--hbm_utilization_factor=0.9",
    "--enable_prefix_cache_hbm",
]

model = aiplatform.Model.upload(
    display_name=model_name,
    serving_container_image_uri=HEXLLM_DOCKER_URI,
    serving_container_command=["python", "-m", "hex_llm.server.api_server"],
    serving_container_args=hexllm_args,
    serving_container_ports=[7080],
    serving_container_predict_route="/generate",
    serving_container_health_route="/ping",
    serving_container_environment_variables=env_vars,
    serving_container_shared_memory_size_mb=(16 * 1024),  # 16 GB
    serving_container_deployment_timeout=7200,
    location=TPU_DEPLOYMENT_REGION,
)

model.deploy(
    endpoint=endpoint,
    machine_type=machine_type,
    deploy_request_timeout=1800,
    service_account=service_account,
    min_replica_count=min_replica_count,
    max_replica_count=max_replica_count,
)

Hex-LLM menggunakan cache awalan untuk mengoptimalkan performa untuk perintah yang melebihi panjang tertentu (512 token secara default, dapat dikonfigurasi menggunakan prefill_len_padding). Hit cache terjadi dalam penambahan nilai ini, yang memastikan jumlah token yang di-cache selalu merupakan kelipatan prefill_len_padding. Kolom cached_tokens dari usage.prompt_tokens_details dalam respons API penyelesaian chat menunjukkan berapa banyak token perintah yang merupakan hit cache.

"usage": {
  "prompt_tokens": 643,
  "total_tokens": 743,
  "completion_tokens": 100,
  "prompt_tokens_details": {
    "cached_tokens": 512
  }
}

Dukungan kuantisasi 4-bit

Kuantisasi adalah teknik untuk mengurangi biaya komputasi dan memori saat menjalankan inferensi dengan merepresentasikan bobot atau aktivasi dengan jenis data presisi rendah seperti INT8 atau INT4, bukan BF16 atau FP32 biasa.

Hex-LLM mendukung kuantisasi khusus bobot INT8. Dukungan yang diperluas mencakup model dengan bobot INT4 yang dikuantisasi menggunakan kuantisasi titik nol AWQ. Hex-LLM mendukung varian INT4 dari keluarga model Mistral, Mixtral, dan Llama.

Tidak ada tanda tambahan yang diperlukan untuk menayangkan model yang dikuantisasi.

Memulai di Model Garden

Penampung penayangan Hex-LLM Cloud TPU terintegrasi ke dalam Model Garden. Anda dapat mengakses teknologi penayangan ini melalui contoh notebook Colab Enterprise, deployment sekali klik, dan playground untuk berbagai model.

Menggunakan simulator

Playground Model Garden adalah endpoint Vertex AI yang telah di-deploy sebelumnya dan dapat dijangkau dengan mengirim permintaan di kartu model.

  1. Masukkan perintah dan, secara opsional, sertakan argumen untuk permintaan Anda.

  2. Klik KIRIM untuk mendapatkan respons model dengan cepat.

Coba dengan Gemma.

Menggunakan deployment sekali klik

Anda dapat men-deploy endpoint Vertex AI kustom dengan Hex-LLM menggunakan kartu model.

  1. Buka halaman kartu model, lalu klik Deploy.

  2. Untuk variasi model yang ingin Anda gunakan, pilih jenis mesin Cloud TPU v5e untuk deployment.

  3. Klik Deploy di bagian bawah untuk memulai proses deployment. Anda akan menerima dua notifikasi email; satu saat model diupload dan satu lagi saat endpoint siap.

Menggunakan notebook Colab Enterprise

Untuk fleksibilitas dan penyesuaian, Anda dapat menggunakan contoh notebook Colab Enterprise untuk men-deploy endpoint Vertex AI dengan Hex-LLM menggunakan Vertex AI SDK untuk Python.

  1. Buka halaman kartu model, lalu klik Buka notebook.

  2. Pilih notebook Vertex Serving. Notebook akan terbuka di Colab Enterprise.

  3. Jalankan notebook untuk men-deploy model menggunakan Hex-LLM dan kirim permintaan prediksi ke endpoint. Cuplikan kode untuk deployment adalah sebagai berikut:

hexllm_args = [
    f"--model=google/gemma-2-9b-it",
    f"--tensor_parallel_size=4",
    f"--hbm_utilization_factor=0.8",
    f"--max_running_seqs=512",
]
hexllm_envs = {
    "PJRT_DEVICE": "TPU",
    "MODEL_ID": "google/gemma-2-9b-it",
    "DEPLOY_SOURCE": "notebook",
}
model = aiplatform.Model.upload(
    display_name="gemma-2-9b-it",
    serving_container_image_uri=HEXLLM_DOCKER_URI,
    serving_container_command=[
        "python", "-m", "hex_llm.server.api_server"
    ],
    serving_container_args=hexllm_args,
    serving_container_ports=[7080],
    serving_container_predict_route="/generate",
    serving_container_health_route="/ping",
    serving_container_environment_variables=hexllm_envs,
    serving_container_shared_memory_size_mb=(16 * 1024),
    serving_container_deployment_timeout=7200,
)

endpoint = aiplatform.Endpoint.create(display_name="gemma-2-9b-it-endpoint")
model.deploy(
    endpoint=endpoint,
    machine_type="ct5lp-hightpu-4t",
    deploy_request_timeout=1800,
    service_account="<your-service-account>",
    min_replica_count=1,
    max_replica_count=1,
)

Contoh notebook Colab Enterprise mencakup:

Mengonfigurasi argumen server dan variabel lingkungan

Anda dapat menetapkan argumen berikut untuk meluncurkan server Hex-LLM. Anda dapat menyesuaikan argumen agar paling sesuai dengan kasus penggunaan dan persyaratan yang diinginkan. Perhatikan bahwa argumen telah ditentukan sebelumnya untuk deployment sekali klik guna mengaktifkan pengalaman deployment yang paling mudah. Untuk menyesuaikan argumen, Anda dapat membuat dari contoh notebook untuk referensi dan menetapkan argumen yang sesuai.

Model

  • --model: Model yang akan dimuat. Anda dapat menentukan ID model Hugging Face, jalur bucket Cloud Storage (gs://my-bucket/my-model), atau jalur lokal. Artefak model diharapkan mengikuti format Hugging Face dan menggunakan file safetensors untuk bobot model. Artefak model kuantisasi BitsAndBytes int8 dan AWQ didukung untuk Llama, Gemma 2, dan Mistral/Mixtral.
  • --tokenizer: Pembuat token yang akan dimuat. Ini dapat berupa ID model Hugging Face, jalur bucket Cloud Storage (gs://my-bucket/my-model), atau jalur lokal. Jika argumen ini tidak ditetapkan, argumen ini akan ditetapkan secara default ke nilai untuk --model.
  • --tokenizer_mode: Mode tokenizer. Kemungkinan pilihannya adalah ["auto", "slow"]. Nilai defaultnya adalah "auto". Jika disetel ke "auto", tokenizer cepat akan digunakan jika tersedia. Pemisah kata lambat ditulis dalam Python dan disediakan di library Transformers, sedangkan pemisah kata cepat yang menawarkan peningkatan performa ditulis dalam Rust dan disediakan di library Tokenizers. Untuk mengetahui informasi selengkapnya, lihat dokumentasi Hugging Face.
  • --trust_remote_code: Apakah akan mengizinkan file kode jarak jauh yang ditentukan di repositori model Hugging Face. Nilai defaultnya adalah False.
  • --load_format: Format checkpoint model yang akan dimuat. Kemungkinan pilihannya adalah ["auto", "dummy"]. Nilai defaultnya adalah "auto". Jika ditetapkan ke "auto", bobot model akan dimuat dalam format safetensors. Jika ditetapkan ke "dummy", bobot model akan diinisialisasi secara acak. Menyetelnya ke "dummy" berguna untuk eksperimen.
  • --max_model_len: Panjang konteks maksimum (panjang input ditambah panjang output) untuk ditayangkan bagi model. Nilai default dibaca dari file konfigurasi model dalam format Hugging Face: config.json. Panjang konteks maksimum yang lebih besar memerlukan lebih banyak memori TPU.
  • --sliding_window: Jika ditetapkan, argumen ini akan mengganti ukuran jendela model untuk perhatian jendela geser. Menetapkan argumen ini ke nilai yang lebih besar akan membuat mekanisme perhatian menyertakan lebih banyak token dan mendekati efek perhatian mandiri standar. Argumen ini hanya dimaksudkan untuk penggunaan eksperimental. Dalam kasus penggunaan umum, sebaiknya gunakan ukuran jendela asli model.
  • --seed: Seed untuk melakukan inisialisasi semua generator angka acak. Mengubah argumen ini dapat memengaruhi output yang dihasilkan untuk perintah yang sama melalui perubahan token yang diambil sampelnya sebagai token berikutnya. Nilai defaultnya adalah 0.

Mesin inferensi

  • --num_hosts: Jumlah host yang akan dijalankan. Nilai defaultnya adalah 1. Untuk mengetahui detail selengkapnya, lihat dokumentasi tentang konfigurasi TPU v5e.
  • --disagg_topo: Menentukan jumlah pekerja pra-isi dan pekerja dekode dengan penayangan fitur eksperimental yang dikelompokkan. Nilai defaultnya adalah None. Argumen mengikuti format: "number_of_prefill_workers,number_of_decode_workers".
  • --data_parallel_size: Jumlah replika paralel data. Nilai defaultnya adalah 1. Menetapkan setelan ini ke N dari 1 akan meningkatkan throughput sebesar N, sekaligus mempertahankan latensi yang sama.
  • --tensor_parallel_size: Jumlah replika paralel tensor. Nilai defaultnya adalah 1. Meningkatkan jumlah replika paralel tensor umumnya meningkatkan latensi, karena mempercepat perkalian matriks dengan mengurangi ukuran matriks.
  • --worker_distributed_method: Metode terdistribusi untuk meluncurkan pekerja. Gunakan mp untuk modul multiprocessing atau ray untuk library Ray. Nilai default-nya adalah mp.
  • --enable_jit: Apakah akan mengaktifkan mode JIT (Kompilasi Tepat Waktu). Nilai defaultnya adalah True. Menyetel --no-enable_jit akan menonaktifkannya. Mengaktifkan mode JIT akan meningkatkan performa inferensi dengan mengorbankan waktu tambahan yang dihabiskan untuk kompilasi awal. Secara umum, manfaat performa inferensi lebih besar daripada overhead.
  • --warmup: Apakah akan melakukan pemanasan server dengan permintaan sampel selama inisialisasi. Nilai defaultnya adalah True. Menetapkan --no-warmup akan menonaktifkannya. Pemanasan direkomendasikan, karena permintaan awal memicu kompilasi yang lebih berat sehingga akan lebih lambat.
  • --max_prefill_seqs: Jumlah maksimum urutan yang dapat dijadwalkan untuk pra-pengisian per iterasi. Nilai defaultnya adalah 1. Makin besar nilai ini, makin tinggi throughput yang dapat dicapai server, tetapi dengan potensi efek buruk pada latensi.
  • --prefill_seqs_padding: Server menambahkan ukuran batch pra-isi ke kelipatan nilai ini. Nilai defaultnya adalah 8. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead inferensi dan komputasi yang terbuang. Setelan optimal bergantung pada traffic permintaan.
  • --prefill_len_padding: Server menambahkan panjang urutan ke kelipatan nilai ini. Nilai defaultnya adalah 512. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead inferensi dan komputasi yang terbuang. Setelan yang optimal bergantung pada distribusi data permintaan.
  • --max_decode_seqs/--max_running_seqs: Jumlah maksimum urutan yang dapat dijadwalkan untuk dekode per iterasi. Nilai defaultnya adalah 256. Makin besar nilai ini, makin tinggi throughput yang dapat dicapai server, tetapi dengan potensi efek buruk pada latensi.
  • --decode_seqs_padding: Server menambahkan ukuran batch dekode ke kelipatan nilai ini. Nilai defaultnya adalah 8. Menaikkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead komputasi dan inferensi yang terbuang. Setelan optimal bergantung pada traffic permintaan.
  • --decode_blocks_padding: Server menambahkan jumlah blok memori yang digunakan untuk cache Nilai Kunci (cache KV) urutan ke kelipatan nilai ini selama decoding. Nilai defaultnya adalah 128. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead inferensi dan komputasi yang terbuang. Setelan yang optimal bergantung pada distribusi data permintaan.
  • --enable_prefix_cache_hbm: Apakah akan mengaktifkan cache awalan di HBM. Nilai defaultnya adalah False. Menetapkan argumen ini dapat meningkatkan performa dengan menggunakan kembali komputasi awalan bersama dari permintaan sebelumnya.

Pengelolaan memori

  • --hbm_utilization_factor: Persentase Memori Bandwidth Tinggi (HBM) Cloud TPU kosong yang dapat dialokasikan untuk cache KV setelah bobot model dimuat. Nilai defaultnya adalah 0.9. Menetapkan argumen ini ke nilai yang lebih tinggi akan meningkatkan ukuran cache KV dan dapat meningkatkan throughput, tetapi meningkatkan risiko kehabisan Cloud TPU HBM selama inisialisasi dan saat runtime.
  • --num_blocks: Jumlah blok perangkat yang akan dialokasikan untuk cache KV. Jika argumen ini ditetapkan, server akan mengabaikan --hbm_utilization_factor. Jika argumen ini tidak ditetapkan, server akan membuat profil penggunaan HBM dan menghitung jumlah blok perangkat yang akan dialokasikan berdasarkan --hbm_utilization_factor. Menetapkan argumen ini ke nilai yang lebih tinggi akan meningkatkan ukuran cache KV dan dapat meningkatkan throughput, tetapi meningkatkan risiko kehabisan HBM Cloud TPU selama inisialisasi dan saat runtime.
  • --block_size: Jumlah token yang disimpan dalam blok. Kemungkinan pilihannya adalah [8, 16, 32, 2048, 8192]. Nilai defaultnya adalah 32. Menetapkan argumen ini ke nilai yang lebih besar akan mengurangi overhead dalam pengelolaan blok, dengan mengorbankan lebih banyak pemborosan memori. Dampak performa yang tepat perlu ditentukan secara empiris.

LoRA Dinamis

  • --enable_lora: Apakah akan mengaktifkan pemuatan adaptor LoRA dinamis dari Cloud Storage. Nilai defaultnya adalah False. Hal ini didukung untuk keluarga model Llama.
  • --max_lora_rank: Peringkat LoRA maksimum yang didukung untuk adaptor LoRA yang ditentukan dalam permintaan. Nilai defaultnya adalah 16. Menetapkan argumen ini ke nilai yang lebih tinggi memungkinkan fleksibilitas yang lebih besar dalam adaptor LoRA yang dapat digunakan dengan server, tetapi meningkatkan jumlah HBM Cloud TPU yang dialokasikan untuk bobot LoRA dan mengurangi throughput.
  • --enable_lora_cache: Apakah akan mengaktifkan caching adaptor LoRA dinamis. Nilai defaultnya adalah True. Menyetel --no-enable_lora_cache akan menonaktifkannya. Cache meningkatkan performa karena tidak perlu mendownload ulang file adaptor LoRA yang sebelumnya digunakan.
  • --max_num_mem_cached_lora: Jumlah maksimum adaptor LoRA yang disimpan di cache memori TPU.Nilai default-nya adalah 16. Menetapkan argumen ini ke nilai yang lebih besar akan meningkatkan peluang hit cache, tetapi akan meningkatkan jumlah penggunaan HBM Cloud TPU.

Anda juga dapat mengonfigurasi server menggunakan variabel lingkungan berikut:

  • HEX_LLM_LOG_LEVEL: Mengontrol jumlah informasi logging yang dihasilkan. Nilai defaultnya adalah INFO. Tetapkan ke salah satu level logging Python standar yang ditentukan dalam modul logging.
  • HEX_LLM_VERBOSE_LOG: Apakah akan mengaktifkan output logging mendetail. Nilai yang diizinkan adalah true atau false. Nilai defaultnya adalah false.

Menyesuaikan argumen server

Argumen server saling terkait dan memiliki efek kolektif pada performa penayangan. Misalnya, setelan --max_model_len=4096 yang lebih besar menyebabkan penggunaan memori TPU yang lebih tinggi, sehingga memerlukan alokasi memori yang lebih besar dan lebih sedikit pengelompokan. Selain itu, beberapa argumen ditentukan oleh kasus penggunaan, sementara yang lain dapat disesuaikan. Berikut adalah alur kerja untuk mengonfigurasi server Hex-LLM.

  1. Tentukan grup model dan varian model yang diinginkan. Misalnya, Llama 3.1 8B Instruct.
  2. Estimasi batas bawah memori TPU yang diperlukan berdasarkan ukuran dan presisi model: model_size * (num_bits / 8). Untuk model 8B dan presisi bfloat16, batas bawah memori TPU yang diperlukan adalah 8 * (16 / 8) = 16 GB.
  3. Estimasi jumlah chip TPU v5e yang diperlukan, dengan setiap chip v5e menawarkan 16 GB: tpu_memory / 16. Untuk model 8B dan presisi bfloat16, Anda memerlukan lebih dari 1 chip. Di antara konfigurasi 1 chip, 4 chip, dan 8 chip, konfigurasi terkecil yang menawarkan lebih dari 1 chip adalah konfigurasi 4 chip: ct5lp-hightpu-4t. Selanjutnya, Anda dapat menetapkan --tensor_parallel_size=4.
  4. Tentukan panjang konteks maksimum (panjang input + panjang output) untuk kasus penggunaan yang diinginkan. Misalnya, 4096. Selanjutnya, Anda dapat menetapkan --max_model_len=4096.
  5. Sesuaikan jumlah memori TPU gratis yang dialokasikan untuk cache KV ke nilai maksimum yang dapat dicapai dengan mempertimbangkan konfigurasi model, hardware, dan server (--hbm_utilization_factor). Mulai dengan 0.95. Deploy server Hex-LLM dan uji server dengan perintah panjang dan konkurensi tinggi. Jika server kehabisan memori, kurangi faktor penggunaan sebagaimana mestinya.

Contoh kumpulan argumen untuk men-deploy Instruksi Llama 3.1 8B adalah:

python -m hex_llm.server.api_server \
    --model=meta-llama/Llama-3.1-8B-Instruct \
    --tensor_parallel_size=4 \
    --max_model_len=4096
    --hbm_utilization_factor=0.95

Contoh kumpulan argumen untuk men-deploy Instruct AWQ Llama 3.1 70B di ct5lp-hightpu-4t adalah:

python -m hex_llm.server.api_server \
    --model=hugging-quants/Meta-Llama-3.1-70B-Instruct-AWQ-INT4 \
    --tensor_parallel_size=4 \
    --max_model_len=4096
    --hbm_utilization_factor=0.45

Meminta kuota Cloud TPU

Di Model Garden, kuota default Anda adalah 4 chip Cloud TPU v5e di region us-west1. Kuota ini berlaku untuk deployment sekali klik dan deployment notebook Colab Enterprise. Untuk meminta kuota tambahan, lihat Meminta kuota yang lebih tinggi.