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

Hex-LLM, model bahasa besar (LLM) berperforma tinggi yang di-deploy dengan XLA, adalah framework deployment LLM Vertex AI yang dirancang dan dioptimalkan untuk hardware Cloud TPU. Hex-LLM menggabungkan teknologi penayangan LLM seperti batch berkelanjutan dan PagedAttention dengan pengoptimalan Vertex AI yang disesuaikan untuk XLA dan Cloud TPU. Ini adalah penayangan LLM berbiaya rendah dan berefisiensi tinggi di Cloud TPU untuk model open source.

Hex-LLM tersedia di Model Garden melalui 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 memanfaatkan hardware sepenuhnya dengan sejumlah besar permintaan serentak.
  • Penulisan ulang lengkap kernel perhatian yang dioptimalkan untuk XLA.
  • Strategi paralelisme data dan paralelisme tensor yang fleksibel dan dapat disusun dengan metode pemartisian 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-3.3 70B
  • Llama-Guard-3 1B dan 8B
  • Llama-4 Scout-17B-16E
  • Mistral 7B
  • Mixtral 8x7B dan 8x22B
  • Phi-3 mini dan medium
  • Phi-4, penalaran Phi-4, dan penalaran plus
  • Qwen-2 0,5B, 1,5B, dan 7B
  • Qwen-2.5 0,5B, 1,5B, 7B, 14B, dan 32B

Hex-LLM juga menyediakan berbagai fitur, seperti berikut:

  • Hex-LLM disertakan dalam satu container. Hex-LLM mengemas 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.
  • Kuantisasi 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 diuraikan [eksperimental]
  • Penyimpanan dalam cache awalan
  • Dukungan kuantisasi 4-bit

Penayangan multi-host

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

Untuk mengaktifkan fitur ini, tetapkan --num_hosts di argumen container Hex-LLM dan tetapkan --tpu_topology di permintaan upload model Vertex AI SDK. Contoh berikut menunjukkan cara men-deploy container Hex-LLM dengan topologi TPU 4x4 v5e yang menyajikan 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 men-deploy container 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 Vertex AI SDK model upload API.

Penayangan yang diuraikan [eksperimental]

Hex-LLM kini mendukung penayangan yang dipisah-pisahkan sebagai fitur eksperimental. Fitur ini hanya dapat diaktifkan pada penyiapan host tunggal dan performanya sedang dalam penyesuaian.

Penayangan yang tidak digabungkan adalah metode efektif untuk menyeimbangkan Time to First Token (TTFT) dan Time Per Output Token (TPOT) untuk setiap permintaan, serta throughput penayangan secara keseluruhan. Hal ini memisahkan fase pengisian otomatis dan fase decoding menjadi 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 di argumen penampung Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy container 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 pengisian otomatis dan 1 pekerja dekode. Setiap pekerja menggunakan dua core TPU v5e.

Penyimpanan dalam cache awalan

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

Untuk mengaktifkan fitur ini, tetapkan --enable_prefix_cache_hbm di argumen penampung Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy container Hex-LLM di TPU v5e-8 yang melayani 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=4",
    "--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 caching awalan untuk mengoptimalkan performa perintah yang melebihi panjang tertentu (512 token secara default, dapat dikonfigurasi menggunakan prefill_len_padding). Cache yang cocok terjadi dalam inkrement nilai ini, sehingga 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
  }
}

Pengisian otomatis yang dibagi-bagi

Pengisian awal yang di-chunk membagi pengisian awal permintaan menjadi chunk yang lebih kecil, dan menggabungkan pengisian awal dan dekode menjadi satu langkah batch. Hex-LLM menerapkan pengisian awal yang di-chunk untuk menyeimbangkan Waktu hingga Token Pertama (TTFT) dan Waktu per Token Output (TPOT) serta meningkatkan throughput.

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

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

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

Dukungan kuantisasi 4-bit

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

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 rangkaian model Mistral, Mixtral, dan Llama.

Tidak ada tanda tambahan yang diperlukan untuk menayangkan model terkuantisasi.

Mulai menggunakan Model Garden

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

Menggunakan taman bermain

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 SUBMIT 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 Open notebook.

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

  3. Jalankan notebook untuk men-deploy model menggunakan Hex-LLM dan mengirim 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 memungkinkan pengalaman deployment yang paling mudah. Untuk menyesuaikan argumen, Anda dapat membuat contoh notebook sebagai 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 terkuantisasi BitsAndBytes int8 dan AWQ didukung untuk Llama, Gemma 2, dan Mistral/Mixtral.
  • --tokenizer: Tokenizer 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, nilai defaultnya adalah 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. Tokenizer lambat ditulis dalam Python dan disediakan di library Transformers, sedangkan tokenizer 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 titik pemeriksaan model yang akan dimuat. Kemungkinan pilihannya adalah ["auto", "dummy"]. Nilai defaultnya adalah "auto". Jika disetel ke "auto", bobot model dimuat dalam format safetensors. Jika disetel 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) yang akan ditayangkan untuk 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 disetel, argumen ini akan menggantikan ukuran periode 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 ditujukan untuk penggunaan eksperimental. Dalam kasus penggunaan umum, sebaiknya gunakan ukuran jendela asli model.
  • --seed: Seed untuk menginisialisasi semua generator angka acak. Mengubah argumen ini dapat memengaruhi output yang dihasilkan untuk perintah yang sama dengan mengubah 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 pengisian otomatis dan pekerja decoding dengan penayangan yang dipisah-pisahkan untuk fitur eksperimental. 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 nilai ini ke N dari 1 akan meningkatkan throughput sekitar 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) atau tidak. Nilai defaultnya adalah True. Menyetel --no-enable_jit akan menonaktifkannya. Mengaktifkan mode JIT meningkatkan performa inferensi dengan mengorbankan waktu tambahan yang diperlukan untuk kompilasi awal. Secara umum, manfaat performa inferensi lebih besar daripada overhead.
  • --warmup: Apakah akan memanaskan server dengan contoh permintaan selama inisialisasi. Nilai defaultnya adalah True. Menyetel --no-warmup akan menonaktifkannya. Pemanasan direkomendasikan, karena permintaan awal memicu kompilasi yang lebih berat dan oleh karena itu akan lebih lambat.
  • --max_prefill_seqs: Jumlah maksimum urutan yang dapat dijadwalkan untuk pengisian otomatis 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 mengisi ukuran batch pengisian otomatis hingga kelipatan nilai ini. Nilai defaultnya adalah 8. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan komputasi yang terbuang dan overhead inferensi. Setelan optimal bergantung pada traffic permintaan.
  • --prefill_len_padding: Server mengisi panjang urutan hingga kelipatan nilai ini. Nilai defaultnya adalah 512. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead komputasi dan inferensi yang terbuang. Setelan yang optimal bergantung pada distribusi data permintaan.
  • --max_decode_seqs/--max_running_seqs: Jumlah maksimum urutan yang dapat dijadwalkan untuk decoding 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 mengisi ukuran batch dekode 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.
  • --decode_blocks_padding: Server mengisi jumlah blok memori yang digunakan untuk cache Key-Value (KV cache) urutan ke kelipatan nilai ini selama decoding. Nilai defaultnya adalah 128. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan overhead komputasi dan inferensi yang terbuang. Setelan yang optimal bergantung pada distribusi data permintaan.
  • --enable_prefix_cache_hbm: Apakah akan mengaktifkan penyimpanan dalam cache awalan di HBM. Nilai defaultnya adalah False. Menetapkan argumen ini dapat meningkatkan performa dengan menggunakan kembali komputasi awalan bersama dari permintaan sebelumnya.
  • --enable_chunked_prefill: Apakah akan mengaktifkan pengisian awal yang di-chunk. Nilai defaultnya adalah False. Menetapkan argumen ini dapat mendukung panjang konteks yang lebih panjang dan meningkatkan performa.

Pengelolaan memori

  • --hbm_utilization_factor: Persentase Memori Bandwidth Tinggi (HBM) Cloud TPU gratis 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 juga meningkatkan risiko kehabisan HBM Cloud TPU 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 disetel, server akan memprofilkan 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 juga 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 biaya 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. Fitur ini didukung untuk rangkaian 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. Caching meningkatkan performa karena tidak perlu mendownload ulang file adaptor LoRA yang sebelumnya digunakan.
  • --max_num_mem_cached_lora: Jumlah maksimum adaptor LoRA yang disimpan dalam cache memori TPU.Nilai defaultnya 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 ini ke salah satu tingkat 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 akan menyebabkan penggunaan memori TPU yang lebih tinggi, sehingga memerlukan alokasi memori yang lebih besar dan batching yang lebih sedikit. Selain itu, beberapa argumen ditentukan oleh kasus penggunaan, sementara yang lain dapat disesuaikan. Berikut adalah alur kerja untuk mengonfigurasi server Hex-LLM.

  1. Tentukan keluarga model dan varian model yang diinginkan. Misalnya, Llama 3.1 8B Instruct.
  2. Perkirakan 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. Perkirakan 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 dimaksud. Misalnya, 4096. Selanjutnya, Anda dapat menetapkan --max_model_len=4096.
  5. Sesuaikan jumlah memori TPU kosong yang dialokasikan untuk cache KV ke nilai maksimum yang dapat dicapai berdasarkan model, hardware, dan konfigurasi 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 pemanfaatan yang sesuai.

Contoh kumpulan argumen untuk men-deploy Llama 3.1 8B Instruct 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 Llama 3.1 70B Instruct AWQ 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 32 chip Cloud TPU v5e di region us-west1. Kuota ini berlaku untuk deployment sekali klik dan deployment notebook Colab Enterprise. Untuk meminta nilai kuota yang lebih tinggi, lihat Meminta penyesuaian kuota.