NVIDIA NIM İş Akışı ile LLM Dağıtımını ve AI Çıkarımını Kolaylaştırma

Büyük dil modellerinin (LLM) üretim ortamlarına entegrasyonu, gerçek kullanıcıların bu modellerle büyük ölçeklerde etkileşim kurduğu en kritik süreçtir. Bu sadece modelleri çalıştırmakla kalmaz; aynı zamanda onları hızlandırmak, yönetimini kolaylaştırmak ve farklı kullanım durumları ile üretim gereksinimlerini destekleyecek kadar esnek hale getirmekle ilgilidir.

Artan sayıda LLM’in kendine özgü mimarileri, kuantizasyon formatları ve tercih edilen dağıtım çerçeveleri ile geldiğinden, çıkarma arka uçlarını yönetmek zorlu bir hale gelebilir. NVIDIA TensorRT-LLM, vLLM ve SGLang gibi çıkarma arka uçları, artırılmış verimlilik, azalan gecikme süresi ya da model desteği gibi spesifik ihtiyaçlara yönelik benzersiz özellikler sunar. Her çıkarma arka ucu kendi alanında başarılı olsa da, bir modele hangi arka ucun kullanılacağını belirlemek veya farklı arka uçlar arasında geçiş yapmak karmaşık ve zaman alıcı olabilir.

NVIDIA NIM, model yükleme, arka uç seçimi, sunum ve optimizasyonun karmaşasını azaltarak LLM dağıtımını kolaylaştırır; böylece geliştirmeye odaklanmanıza imkan tanır. Bir dizi modeli tek bir konteyner aracılığıyla hızlıca dağıtmanın basit ve birleşik bir yolunu sunar, bu da yalnızca birkaç basit komutla her yere hızlıca dağıtılabilir.

Bu yazıda, NIM kullanarak LLM’lerin nasıl kolayca dağıtılabileceğini göstereceğiz: ister Hugging Face’de barındıran, ister vLLM veya SGLang gibi önde gelen ekosistem arka uçları tarafından desteklenen, ister TensorRT-LLM kontrol noktaları ve motorları olarak mevcut olan modeller olsun. Minimum yapılandırma ile basit ve tutarlı bir iş akışı kullanarak birden fazla modeli nasıl dağıtıp geçiş yapacağınızı öğreneceksiniz.

**NIM Model Dağıtım Yetkinliklerini Anlamak**

NIM, geniş bir LLM yelpazesini sunabilen tek bir Docker konteyneri sağlar. Aşağıda gösterildiği gibi konteynerin içine bir model girdiğinizde, NIM şu adımları gerçekleştirir:

1. Model formatını analiz eder ve modelinizin Hugging Face formatında, TensorRT-LLM kontrol noktası formatında veya TensorRT-LLM motor formatında olup olmadığını tespit eder.
2. Mimariyi belirler; model konfigürasyonunu inceleyerek mimarisini (örneğin Llama veya Mistral) saptar.
3. Kuantizasyon formatını tespit eder ve model ağırlıklarının hassasiyetini (FP16, FP8, INT4 gibi) belirler.
4. Belirtilen bilgilere göre optimum arka ucu (vLLM, SGLang veya TensorRT-LLM) seçer.
5. Belirtilen modeller için optimize edilmiş ayarları uygular ve çıkarım sunucusunu başlatır.

NIM, üç ana ağırlık formatını destekler:

1. Hugging Face kontrol noktaları: .safetensors veya .gguf dosyalarına sahip standart Hugging Face model depotları.
2. TensorRT-LLM kontrol noktaları: Konfigürasyon ve ağırlık dosyalarını içeren trtllm_ckpt dizini bulunan modeller.
3. TensorRT-LLM motorları: trtllm_engine dizininde bulunan önceden derlenmiş TensorRT-LLM motorları.

NIM, optimum arka ucu seçerken belli kriterler kullanır. Tam hassasiyet için, Hugging Face modelleri, TensorRT-LLM, vLLM ya da SGLang kullanılabilirken, kuantize edilmiş Hugging Face modellerinin genellikle vLLM veya SGLang ile en iyi çalıştığı görülmektedir. FP8 kuantizasyonlu birleşik Hugging Face kontrol noktaları, tercihen TensorRT-LLM ile çalıştırılmakta; TensorRT-LLM kontrol noktaları veya motorları ise doğal olarak TensorRT-LLM arka ucunu kullanır.

Bu seçim, her arka ucun model mimarisi uyumluluğunu, kuantizasyon formatını ve performans özelliklerini dikkate alarak en iyi deneyimi sağlamayı amaçlar.

**NIM ile LLM Dağıtımı Örnekleri**

NIM’in bu yeteneklerini göstermek için birkaç pratik örneğe göz atacağız. Bu örnekleri takip etmeden önce aşağıdaki ön koşulları sağlamanız gerektiğini unutmayın.

**Ön Koşullar**

• Uygun sürücülere sahip NVIDIA GPU’lar (NVIDIA CUDA 12.1+). Aşağıdaki örnekler, en az 80 GB GPU belleğine sahip olduğunuzu varsayıyor. Tek bir GPU’ya sığmayan modeller için, bellek yetersizliği sorunları yaşamamak için tensor paralelliğini etkinleştirin.
• Docker’ın yüklü ve yapılandırılmış olması.
• Bir NGC hesabı ve API anahtarı gereklidir.
• Kimlik doğrulama gerektiren modeller için bir Hugging Face hesabı ve API belirteci olmalıdır.

**Ortam Kurulumu**

Kullanım kolaylığı için, sıkça kullanılan bazı bilgileri ortam değişkenlerinde saklayalım.

# NIM docker imajı tanımı için bir değişken
NIM_IMAGE=llm-nim
# Hugging Face API belirtecini buraya yerleştirin.
HF_TOKEN=<your_huggingface_token>

NIM konteyneri, indirilmiş model kontrol noktaları ve ara sonuçları depolamak için ana makinede bir dizine ihtiyaç duyar. Konteyner içinde bu dizin /opt/nim/.cache konumundadır. Model indirimlerini farklı çalışmalarda kalıcı hale getirmek için, bu konumu ana makinedeki bir dizine yönlendirmek iyi bir fikirdir. Yeni bir dizin oluşturup tüm NIM başlatma komutlarında bunu eşleştireceğiz.

Unix izinleri hakkında not:

Dizinin Unix izinlerinin doğru ayarlandığından emin olun. Docker konteynerini başlatan aynı Unix kullanıcısının dizini sahiplenmesi önerilir; aksi takdirde izin sorunları ile karşılaşabilir ve dağıtım komutları başarısız olabilir. Bu nedenle, gösterilen tüm Docker komutları ana makinedeki kullanıcının kimliğiyle başlatılmaktadır (Docker çalıştırma komutuna -u $(id -u) bayrağını ekleyerek). Bu, NIM konteynerinin kullanıcısının ana makinenin kullanıcısıyla aynı olmasını sağlar.

mkdir $(pwd)/nim_cache

**Örnek 1: Hugging Face’den veya Yerel Dosya Sisteminden Temel Model Dağıtımı**

Bu örnek, güçlü bir kod oluşturma modeli olan Codestral-22B’yi doğrudan Hugging Face’den dağıtmanın yolunu gösterir. Bu modeli kullanmadan önce erişim sözleşmesini kabul etmelisiniz.

# Hugging Face'den doğrudan dağıtım
docker run --rm --gpus all 
  --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -e HF_TOKEN=$HF_TOKEN 
  -e NIM_TENSOR_PARALLEL_SIZE=1 
  -e NIM_MODEL_NAME="hf://mistralai/Codestral-22B-v0.1" 
  $NIM_IMAGE

Bu örnekte, hedef modeli belirtmek için NIM_MODEL_NAME ortam değişkenini kullanarak modeli tanımlıyoruz. hf:// kullanarak modeli dağıtma talimatı veriyoruz; bu, NIM’in modeli Hugging Face’den otomatik olarak indirmesini sağlar.

Modeliniz zaten yerel olarak indirilmişse, NIM_MODEL_NAME‘i hedef modelin dosya sistemindeki konumuna işaret edecek şekilde ayarlayabilirsiniz:

# Yerel dosya sisteminde mevcut bir modeli dağıtma
docker run --rm --gpus all 
 --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -v /path/to/model/dir:/path/to/model/dir 
  -e HF_TOKEN=$HF_TOKEN 
  -e NIM_TENSOR_PARALLEL_SIZE=1 
  -e NIM_MODEL_NAME="/path/to/model/dir/mistralai-Codestral-22B-v0.1" 
  $NIM_IMAGE

Model indirildikten veya yerel dosya sisteminden yüklendikten sonra, NIM bunu tam hassasiyetle bir Mistral modeli olarak tanır, optimum arka ucu seçer (genellikle en iyi performans için TensorRT-LLM kullanılır) ve sunucuyu donanımınıza en uygun şekilde yapılandırır.

Modeli dağıtırken, NIM’in dağıtım sırasında yaptığı seçimleri görmek için çıktı günlüklerini incelemekte özgürsünüz. Dağıtılan model, kullanım için http://localhost:8000 adresinde erişilebilir olacaktır. Mevcut uç noktaları http://localhost:8000/docs adresinde görüntüleyebilirsiniz.

Alt motor tarafından sağlanan ek argümanlar vardır. Bu argümanların tam listesini görmek için konteyner içinde nim-run --help komutunu çalıştırabilirsiniz.

docker run --rm --gpus all 
  --network=host 
  -u $(id -u) 
  $NIM_IMAGE nim-run --help

**Tensor Paralelliği ve Çoklu GPU Dağıtımı Üzerine Not**

Tek bir GPU’ya sığmayan modeller için, modeli birden fazla GPU arasında dağıtmak adına tensor paralelliğini kullanabilirsiniz. Bu, Docker komutuna NIM_TENSOR_PARALLEL_SIZE ortam değişkenini geçirerek ve dağıtım için kullanılan GPU sayısını belirterek yapılabilir. Örneklerde tensor paralelliği 1 olarak belirtilmiştir.

Paralelliği 1’den büyük bir değere getirirken, --shm-size=<paylaşılan bellek boyutu> bayrağını Docker başlatma komutuna eklemeniz gerekir. Bu, çoklu GPU iletişimi için ana makine belleği tahsis eder. Bu bayrağı sağlamamak, genellikle NCCL hatalarına yol açar.

Tek GPU’lu modeller veya NVIDIA NVLink ile etkinleştirilmiş GPU’lar için bu bayrak gerekli değildir. Gerekli paylaşımlı bellek boyutu, dağıtılan modele bağlıdır. Hata alırsanız, bu değeri artırmayı deneyin.

**Model Dağıtırken Arka Ucu Belirlemek**

NIM, bir modeli dağıtırken uygun bir arka uç seçer. İsterseniz, varsayılan davranışı geçersiz kılmak için NIM’e belirli bir arka ucu kullanması talimatını verebilirsiniz.

Dağıtımdan önce, modelinizle uyumlu hangi arka uçların bulunduğunu kontrol edin. list-model-profiles giriş noktası, belirli bir model ve donanımınıza uyumlu tüm mevcut dağıtım profillerinin listesini gösterecektir. Aşağıdaki komut, bu CLI’yi kullanarak bir model için mevcut dağıtım profillerini incelemeyi gösterir (bu örnekte meta-llama/Llama-3.1-8B-Instruct kullanılmaktadır):

docker run --rm --gpus all 
  --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -e HF_TOKEN=$HF_TOKEN 
  $NIM_IMAGE list-model-profiles --model "hf://meta-llama/Llama-3.1-8B-Instruct"

Aşağıda, yukarıdaki komuttan gelen örnek bir çıktı bulunmaktadır:

MODEL PROFILES
- Sisteme uyumlu ve çalıştırılabilir:
  - 668b575f1701fa70a97cfeeae998b5d70b048a9b917682291bb82b67f308f80c (tensorrt_llm)
  - e2f00b2cbfb168f907c8d6d4d40406f7261111fbab8b3417a485dcd19d10cc98 (vllm)
  - 50e138f94d85b97117e484660d13b6b54234e60c20584b1de6ed55d109ca4f21 (sglang)
  - LoRA desteği ile:
    - cdcd22d151713c8b91fcd279a4b5e021153e72ff5cf6ad5498aac96974f5b7d7 (tensorrt_llm-lora)
    - 93c5e281d6616f45e2ef801abf4ed82fc65e38ec5f46e0664f340bad4f92d551 (vllm-lora)
    - 0d08589f2f7cd931cf3a03357d3aa901c132ac97c11073c607c20ae105c87c64 (sglang-lora)
- TRT-LLM'ye just-in-time derleme ile derlenebilir HF modelleri: <Yok>

Bu çıktı, tüm çıkarım arka uçlarının (TensorRT-LLM, vLLM ve SGLang) bu özel model için mevcut olduğunu göstermektedir; ayrıca LoRA adaptörlerini destekleyenleri de içerir. Bu modeli belirli bir arka uç kullanarak dağıtmak için Docker komutuna NIM_MODEL_PROFILE ortam değişkenini ekleyerek yukarıda listelenen profillerden birine ayarlamanız gerekir. Aşağıdaki örnekte, LLaMa modelini vLLM arka ucu kullanarak dağıtıyoruz:

# LLaMa modelini vLLM arka ucu ile dağıtma
docker run --rm --gpus all 
  --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -e HF_TOKEN=$HF_TOKEN 
  -e NIM_TENSOR_PARALLEL_SIZE=1 
  -e NIM_MODEL_NAME="hf://meta-llama/Llama-3.1-8B-Instruct" 
  -e NIM_MODEL_PROFILE="e2f00b2cbfb168f907c8d6d4d40406f7261111fbab8b3417a485dcd19d10cc98" 
  $NIM_IMAGE

Şimdi, yalnızca bir arka uçla desteklenen bir model örneğine göz atalım. Bu yazının yazıldığı tarihte lmms-lab/llama3-llava-next-8b modeli, yalnızca SGLang arka ucu aracılığıyla kullanılabilmektedir. Bu model için desteklenen profilleri incelemek üzere şu komutu çalıştırın:

docker run --rm --gpus all 
  --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -e HF_TOKEN=$HF_TOKEN 
  $NIM_IMAGE list-model-profiles --model "hf://lmms-lab/llama3-llava-next-8b"

Bu komut, modelin yalnızca SGLang arka ucu aracılığıyla dağıtılabileceğini belirten bir çıkış verecektir:

MODEL PROFILES
- Sisteme uyumlu ve çalıştırılabilir:
  - 50e138f94d85b97117e484660d13b6b54234e60c20584b1de6ed55d109ca4f21 (sglang)
  - LoRA desteği ile:
    - 0d08589f2f7cd931cf3a03357d3aa901c132ac97c11073c607c20ae105c87c64 (sglang-lora)
- TRT-LLM'ye just-in-time derleme ile derlenebilir HF modelleri: <Yok>

**Kuantize Edilen Modellerin Dağıtımı**

NIM, çeşitli kuantizasyon formatlarında modellerin dağıtımını destekler. Bu modeller, yukarıda gösterilen komutlarla aynı şekilde, değişiklik yapmadan dağıtılabilir. Aşağıdaki örnek, GGUF kuantizasyonuna sahip bir model ve AWQ kuantizasyonuna sahip bir modelin yüklenmesini göstermektedir:

# Kuantize bir model seçin ve MODEL değişkenini doldurun:
# MODEL="hf://modularai/Llama-3.1-8B-Instruct-GGUF"
# veya
# MODEL="hf://Qwen/Qwen2.5-14B-Instruct-AWQ"

docker run --rm --gpus all 
  --shm-size=16GB 
  --network=host 
  -u $(id -u) 
  -v $(pwd)/nim_cache:/opt/nim/.cache 
  -v $(pwd):$(pwd) 
  -e HF_TOKEN=$HF_TOKEN 
  -e NIM_TENSOR_PARALLEL_SIZE=1 
  -e NIM_MODEL_NAME=$MODEL 
  $NIM_IMAGE

Bu örnekte, NIM kuantizasyon formatını otomatik olarak algılar ve bu kuantizasyon yöntemini destekleyen uygun bir arka ucu seçecektir.

**Dağıtımı Özelleştirmek**

NIM’in otomatik seçimleri çoğu durumda iyi çalışsa da, dağıtımın çeşitli yönlerini özel ortam değişkenleri geçerek kişiselleştirebilirsiniz. Örneğin, NIM_MODEL_PROFILE ile bir arka ucu seçebilir, NIM_TENSOR_PARALLEL_SIZE ile tensor paralelliğini kontrol edebilir veya NIM_MAX_MODEL_LEN ile bağlam uzunluğunu ayarlayabilirsiniz.

Tüm NIM yapılandırma seçenekleri için belgelere göz atın. İleri düzey kullanıcılar ayrıca nim-run komutunu uygun bayraklarla çalıştırarak alt inferans motoruna ek parametreler geçebilirler. Bu bayrakların tam listesini görüntülemek için, konteyner içinde nim-run --help komutunu çalıştırabilirsiniz.

Daha fazla bilgi için, lütfen desteklenen model mimarileri‘ni inceleyin.

**LLM Dağıtımına Başlayın**

NIM, çok çeşitli modelleri otomatik optimizasyon ile çalıştırabilen tek bir konteyner sunarak LLM dağıtımını basitleştirir. Bu, birden fazla çıkarım çerçevesi ve konteynerle çalışmayı ortadan kaldırarak, farklı modelleri test etme ve dağıtma sürecini hızlandırır.

Akıllı arka uç seçimi, belirli model ve donanım konfigürasyonlarınız için en iyi performansı sağlamaktadır; ayrıca tutarlı kullanıcı deneyimi sayesinde, yeni araçlar veya süreçler öğrenmeye gerek kalmadan farklı modellerle deney yapmak kolaylaşır.