Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Menyajikan model terbuka menggunakan container premium Hex-LLM di Cloud TPU

Hex-LLM, inferensi model bahasa besar (LLM) berefisiensi tinggi dengan XLA, adalah framework inferensi LLM Gemini Enterprise Agent Platform yang dirancang dan dioptimalkan untuk hardware Cloud TPU. Hex-LLM menggabungkan teknologi inferensi LLM seperti batching berkelanjutan dan PagedAttention dengan pengoptimalan Gemini Enterprise Agent Platform yang disesuaikan untuk XLA dan Cloud TPU. Ini adalah inferensi LLM berefisiensi tinggi dan berbiaya rendah di Cloud TPU untuk model open source.

Hex-LLM tersedia di Model Garden melalui playground 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 menyajikan 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 dikomposisi dengan metode sharding bobot yang sangat dioptimalkan untuk menjalankan LLM secara efisien di beberapa chip Cloud TPU.

Hex-LLM mendukung berbagai LLM dense dan sparse:

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, Phi-4 reasoning, dan Phi-4 reasoning 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 inferensi.

Fitur lanjutan

Hex-LLM mendukung fitur lanjutan berikut:

Penayangan multi-host
Penayangan terpilah [eksperimental]
Caching 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 maksimal delapan core v5e.

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

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 container Hex-LLM dengan topologi TPU multi-host, lihat notebook Agent Platform Model Garden - Llama 3.1 (Deployment).

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

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

Penayangan terpilah [eksperimental]

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

Penyajian terpisah adalah metode yang efektif untuk menyeimbangkan Waktu hingga Token Pertama (TTFT) dan Waktu per Token Output (TPOT) untuk setiap permintaan, serta throughput penyajian secara keseluruhan. Teknik ini memisahkan fase pengisian awal dan fase dekode 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 dalam argumen container Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy container Hex-LLM di TPU v5e-8 yang menyajikan 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 worker prefill dan 1 worker dekode. Setiap worker menggunakan dua core TPU v5e.

Caching awalan

Prefix caching mengurangi Time to First Token (TTFT) untuk perintah yang memiliki konten identik di awal perintah, seperti pembukaan di seluruh perusahaan, petunjuk sistem umum, dan histori percakapan multi-turn. Alih-alih memproses token input yang sama berulang kali, Hex-LLM dapat mempertahankan cache sementara dari komputasi token input yang diproses untuk meningkatkan TTFT.

Untuk mengaktifkan fitur ini, tetapkan --enable_prefix_cache_hbm dalam argumen container Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy container Hex-LLM di TPU v5e-8 yang menyajikan 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 (secara default 512 token, dapat dikonfigurasi menggunakan prefill_len_padding). Cache ditemukan terjadi dalam kelipatan nilai ini, sehingga 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 ditemukan di cache.

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

Pra-pengisian terpotong

Pengisian awal yang dipotong-potong membagi pengisian awal permintaan menjadi potongan-potongan yang lebih kecil, dan menggabungkan pengisian awal dan dekode menjadi satu langkah batch. Hex-LLM menerapkan prefill yang dipotong-potong untuk menyeimbangkan Time to First Token (TTFT) dan Time per Output Token (TPOT) serta meningkatkan throughput.

Untuk mengaktifkan fitur ini, tetapkan --enable_chunked_prefill dalam argumen container Hex-LLM. Berikut adalah contoh yang menunjukkan cara men-deploy container Hex-LLM di TPU v5e-8 yang menyajikan 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 yang biasa.

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

Tidak ada flag tambahan yang diperlukan untuk menyajikan model yang dikuantisasi.

Mulai menggunakan Model Garden

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

Menggunakan playground

Playground Model Garden adalah endpoint Agent Platform yang telah di-deploy dan dapat dijangkau dengan mengirimkan permintaan di kartu model.

Masukkan perintah dan, jika perlu, sertakan argumen untuk permintaan Anda.
Klik SUBMIT untuk mendapatkan respons model dengan cepat.

Coba dengan Gemma.

Menggunakan deployment sekali klik

Anda dapat men-deploy endpoint Agent Platform kustom dengan Hex-LLM menggunakan kartu model.

Buka halaman kartu model dan klik Deploy.
Untuk variasi model yang ingin Anda gunakan, pilih jenis mesin Cloud TPU v5e untuk deployment.
Klik Deploy di bagian bawah untuk memulai proses deployment. Anda akan menerima dua notifikasi email; satu saat model diupload dan satu lagi saat endpoint sudah siap.

Menggunakan notebook Colab Enterprise

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

Buka halaman kartu model, lalu klik Open notebook.
Pilih notebook Vertex Serving. Notebook akan dibuka di Colab Enterprise.
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 meliputi:

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 Anda inginkan. Perhatikan bahwa argumen telah ditentukan sebelumnya untuk deployment sekali klik guna memberikan pengalaman deployment yang paling mudah. Untuk menyesuaikan argumen, Anda dapat menggunakan 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, argumen ini akan ditetapkan secara default ke nilai untuk --model.
--tokenizer_mode: Mode tokenizer. Pilihan yang memungkinkan 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 checkpoint model yang akan dimuat. Pilihan yang memungkinkan adalah ["auto", "dummy"]. Nilai defaultnya adalah "auto". Jika disetel ke "auto", bobot model akan dimuat dalam format safetensors. Jika ini 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) yang akan disajikan untuk model. Nilai default dibaca dari file konfigurasi model dalam format Hugging Face: config.json. Jendela konteks maksimum yang lebih besar memerlukan lebih banyak memori TPU.
--sliding_window: Jika ditetapkan, argumen ini akan mengganti ukuran jendela model untuk sliding window attention. Menetapkan argumen ini ke nilai yang lebih besar akan membuat mekanisme atensi menyertakan lebih banyak token dan mendekati efek self-attention 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 dengan mengubah token yang dijadikan sampel 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 worker prefill dan worker dekode dengan fitur eksperimental penyaluran terpisah. 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. Menyetel 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 worker. Gunakan mp untuk modul multiprocessing atau ray untuk library Ray. Nilai defaultnya adalah mp.
--enable_jit: Apakah akan mengaktifkan mode JIT (Just-in-Time Compilation). Nilai defaultnya adalah True. Menyetel --no-enable_jit akan menonaktifkannya. Mengaktifkan mode JIT akan meningkatkan performa inferensi dengan konsekuensi memerlukan waktu tambahan yang dihabiskan untuk kompilasi awal. Secara umum, manfaat performa inferensi lebih besar daripada overhead.
--warmup: Apakah akan melakukan pemanasan server dengan contoh permintaan 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 akan menambahkan padding pada ukuran batch prefill ke 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 yang optimal bergantung pada traffic permintaan.
--prefill_len_padding: Server menambahkan padding pada panjang urutan ke kelipatan nilai ini. Nilai defaultnya adalah 512. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan komputasi yang terbuang dan overhead inferensi. 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 akan menambahkan padding pada ukuran batch dekode ke 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 yang optimal bergantung pada traffic permintaan.
--decode_blocks_padding: Server mengisi jumlah blok memori yang digunakan untuk cache Nilai Kunci (cache KV) urutan menjadi kelipatan nilai ini selama decoding. Nilai defaultnya adalah 128. Meningkatkan nilai ini akan mengurangi waktu kompilasi ulang model, tetapi meningkatkan komputasi yang terbuang dan overhead inferensi. Setelan yang optimal bergantung pada distribusi data permintaan.
--enable_prefix_cache_hbm: Apakah akan mengaktifkan caching 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 chunked prefill. Nilai defaultnya adalah False. Menetapkan argumen ini dapat mendukung jendela konteks yang lebih panjang dan meningkatkan performa.

Manajemen 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 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 juga meningkatkan risiko kehabisan HBM Cloud TPU selama inisialisasi dan saat runtime.
--block_size: Jumlah token yang disimpan dalam blok. Pilihan yang memungkinkan 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 konsekuensi 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 kelompok 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 menghilangkan kebutuhan untuk mendownload ulang file adaptor LoRA yang digunakan sebelumnya.
--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 cache ditemukan, 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 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 inferensi. 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 pengelompokan yang lebih sedikit. Selain itu, beberapa argumen ditentukan oleh kasus penggunaan, sementara argumen lainnya dapat disesuaikan. Berikut adalah alur kerja untuk mengonfigurasi server Hex-LLM.

Tentukan kelompok model dan varian model yang diinginkan. Misalnya, Llama 3.1 8B Instruct.
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.
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.
Tentukan panjang konteks maksimum (panjang input + panjang output) untuk kasus penggunaan yang diinginkan. Misalnya, 4096. Selanjutnya, Anda dapat menetapkan --max_model_len=4096.
Sesuaikan jumlah memori TPU kosong yang dialokasikan untuk cache KV ke nilai maksimum yang dapat dicapai berdasarkan 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 pemanfaatan sebagaimana mestinya.

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.