Takip et

vLLM ile Büyük Dil Modeli Çıkarımı: Gerçek GPU Verileriyle Performans Optimizasyonu

Büyük dil modellerinin (LLM) üretim ortamında verimli bir şekilde çalıştırılması, günümüzün yapay zeka uygulamaları için kritik öneme sahiptir.

vLLM ile Büyük Dil Modeli Çıkarımı: Gerçek GPU Verileriyle Performans Optimizasyonu

Büyük dil modellerinin (LLM) üretim ortamında verimli bir şekilde çalıştırılması, günümüzün yapay zeka uygulamaları için kritik öneme sahiptir. Kullanıcı beklentileri arttıkça, düşük gecikme ve yüksek verim sunmak adeta bir zorunluluk haline gelmiştir. İşte tam da bu noktada vLLM, GPU’larınızı en üst düzeyde kullanarak bu hedeflere ulaşmanızı sağlayan popüler bir çıkarım (inference) kütüphanesidir. Bu makale, vLLM’in temel prensiplerini, sunduğu performans avantajlarını ve gerçek GPU verileriyle nasıl optimize edildiğini detaylandırarak, okuyuculara konuyu sıfırdan ileri seviyeye taşıyan kapsamlı bir rehber sunmaktadır.

Büyük Dil Modellerinin (LLM) Zorlukları ve vLLM’in Sahneye Çıkışı Nasıl Oldu?

Son yıllarda, GPT-3, Llama, Falcon gibi büyük dil modelleri, doğal dil işleme (NLP) alanında çığır açan yetenekler sergiledi. Metin üretimi, özetleme, çeviri ve soru yanıtlama gibi birçok alanda insan benzeri performans gösteren bu modeller, yapay zeka uygulamalarının temel taşları haline geldi. Ancak, bu modellerin devasa boyutları ve karmaşık yapıları, onları üretim ortamında çalıştırmayı oldukça zorlu bir görev haline getiriyor. Özellikle yüksek kullanıcı trafiğine sahip uygulamalarda, LLM çıkarımı ciddi performans darboğazları yaratabilir.

Geleneksel çıkarım yöntemleri, özellikle popüler Hugging Face Transformers kütüphanesi gibi araçlar, genellikle “statik batching” adı verilen bir yaklaşımla çalışır. Bu yöntemde, belirli sayıda istek (prompt) bir araya getirilir ve aynı anda GPU’ya gönderilir. Bu, GPU’nun daha verimli kullanılmasına yardımcı olsa da, bazı önemli dezavantajları vardır. Örneğin, bir batch’teki tüm isteklerin aynı anda tamamlanması beklenir; bu da farklı uzunluktaki istekler için “padding” (doldurma) yapılmasını gerektirir. Kısa bir istek, batch’teki en uzun istek kadar beklemek zorunda kalır, bu da gecikmeyi (latency) artırır ve GPU kaynaklarının boşa harcanmasına neden olur. Dahası, her bir token üretimi sırasında, modelin “key-value (KV) önbelleği” GPU belleğinde saklanır ve bu önbellek, özellikle uzun diziler için oldukça büyük yer kaplayabilir, bellek parçalanmasına yol açarak GPU’nun kapasitesini sınırlar.

Bu sorunlar, özellikle hızlı yanıt vermesi gereken chatbotlar, sanal asistanlar veya gerçek zamanlı metin oluşturma hizmetleri gibi uygulamalar için kabul edilemez hale geldi. Bir chatbot uygulamasının kullanıcılarına anında yanıt vermesi beklenirken, her bir yanıt için saniyeler süren gecikmeler, kullanıcı deneyimini ciddi şekilde düşürebilir. İşte bu noktada, Stanford Üniversitesi’nden çıkan vLLM projesi, bu zorluklara yenilikçi çözümler sunarak sahneye çıktı. vLLM, PagedAttention ve sürekli batching gibi tekniklerle GPU kullanımını maksimize etmeyi, gecikmeyi düşürmeyi ve verimi (throughput) artırmayı hedefledi. Bu sayede, daha az GPU kaynağıyla daha fazla istek işlenebilir hale geldi ve LLM’lerin üretim ortamında daha ekonomik ve performanslı bir şekilde kullanılması mümkün oldu.

vLLM’in Temel Performans Optimizasyonları Nelerdir? PagedAttention ve Sürekli Batching

vLLM’in başarısının ardında yatan iki temel optimizasyon tekniği bulunmaktadır: PagedAttention ve sürekli batching (continuous batching). Bu iki yöntem, LLM çıkarımındaki geleneksel darboğazları hedef alarak GPU kaynaklarının çok daha verimli kullanılmasını sağlar. Bu sayede, aynı donanım üzerinde çok daha fazla isteği daha hızlı bir şekilde işlemek mümkün hale gelir.

PagedAttention: Bellek Yönetiminde Devrim

Transformer tabanlı büyük dil modelleri, her bir token üretimi sırasında önceki tokenlerin “key” ve “value” vektörlerini bir önbellekte (KV cache) saklar. Bu KV önbelleği, modelin dikkat mekanizmasının (attention mechanism) sonraki tokenleri üretirken geçmiş bilgilere hızlıca erişmesini sağlar. Ancak, bu önbellek, özellikle uzun metinler veya çok sayıda eş zamanlı istek olduğunda GPU belleğinde önemli bir yer kaplar. Geleneksel yaklaşımlarda, KV önbelleği için ayrılan bellek alanı genellikle statiktir ve en uzun olası dizi uzunluğuna göre önceden belirlenir. Bu durum, kısa diziler için belleğin boşa harcanmasına ve bellek parçalanmasına (memory fragmentation) yol açar. Örneğin, 1024 tokenlik bir maksimum dizi uzunluğu için ayrılan bir alana 100 tokenlik bir istek geldiğinde, geri kalan 924 tokenlik alan boş kalır ve başka bir işlem tarafından kullanılamaz.

PagedAttention, bu sorunu modern işletim sistemlerinin sanal bellek (virtual memory) yönetimine benzer bir yaklaşımla çözer. Tıpkı bir işletim sisteminin belleği sayfalara (pages) bölerek fiziksel ve sanal adresleri yönetmesi gibi, PagedAttention da KV önbelleğini sabit boyutlu bloklara (bloklar) böler. Bu bloklar, isteklere dinamik olarak atanır ve serbest bırakılır. Bir isteğin KV önbelleği büyüdükçe, ona yeni bloklar atanır; küçüldükçe veya tamamlandıkça, bloklar serbest bırakılarak diğer isteklere atanabilir. Bu dinamik bellek yönetimi sayesinde:

  • Bellek Parçalanması Azalır: Boş bellek alanları daha küçük, yönetilebilir bloklara bölündüğü için, bellek daha etkin bir şekilde doldurulur ve boşa giden alan minimize edilir.
  • Daha Fazla İstek Aynı Anda İşlenebilir: Her bir isteğin KV önbelleği için sadece gerçekten ihtiyaç duyduğu bellek ayrıldığı için, aynı GPU üzerinde çok daha fazla eş zamanlı istek barındırılabilir. Bu da GPU verimini (throughput) önemli ölçüde artırır.
  • Daha Uzun Diziler Desteklenir: Bellek daha verimli kullanıldığı için, daha uzun metinler üzerinde çıkarım yapmak mümkün hale gelirken, aynı zamanda daha fazla eş zamanlı kullanıcıya hizmet verilebilir.

Bu yenilikçi yaklaşım, özellikle büyük dil modellerinin bellek ayak izi düşünüldüğünde, GPU kaynaklarının kullanımında devrim niteliğindedir. PagedAttention sayesinde, bir NVIDIA A100 80GB GPU’da Llama 2 7B gibi bir modelle çalışırken, geleneksel yöntemlere göre %20-30 daha az bellek tüketimiyle aynı anda 2-3 kat daha fazla isteği işlemek mümkün hale gelebilir.

Sürekli Batching (Continuous Batching): GPU’yu Hiç Boş Bırakmayın

Geleneksel statik batching yönteminde, GPU’ya gönderilecek istekler belirli bir boyuta ulaştığında bir batch oluşturulur ve bu batch işlenmek üzere gönderilir. Bir batch tamamlanana kadar, GPU’nun bir sonraki iş için beklemesi gerekebilir. Bu bekleme süreleri, özellikle değişken uzunluktaki isteklerin ve farklı token üretim hızlarının olduğu senaryolarda GPU kullanımının düşmesine neden olur. Bir batch’teki en uzun isteğin tamamlanması beklenirken, daha kısa istekler zaten tamamlanmış olsa bile, GPU’nun bir kısmı boşta kalır.

Sürekli batching, bu sorunu ortadan kaldırır. Bu yaklaşımda, gelen istekler sürekli olarak bir kuyruğa alınır ve GPU’ya mümkün olan en kısa sürede gönderilir. Bir istek tamamlandığında veya bir token ürettiğinde, hemen kuyruktan yeni bir istek veya aynı isteğin bir sonraki token üretim adımı GPU’ya gönderilir. Bu, GPU’nun sürekli olarak meşgul kalmasını ve boşta kalma sürelerinin minimize edilmesini sağlar. Sürekli batching’in avantajları şunlardır:

  • Daha Yüksek GPU Kullanımı: GPU, statik batching’deki gibi batch’in tamamlanmasını beklemek yerine, sürekli olarak yeni işlerle beslenir. Bu, GPU’nun doluluk oranını (utilization) önemli ölçüde artırır.
  • Düşük Gecikme: İstekler kuyruğa girer girmez işlenmeye başlandığı için, yanıt süreleri kısalır. Özellikle kısa ve orta uzunluktaki istekler için gecikme dramatik bir şekilde azalır.
  • Yüksek Verim: GPU’nun sürekli aktif olması, birim zamanda işlenen token sayısını ve dolayısıyla genel verimi artırır. Bu, aynı donanım üzerinde daha fazla kullanıcıya hizmet vermek anlamına gelir.

PagedAttention ile birleştiğinde, sürekli batching, vLLM’i LLM çıkarımı için piyasadaki en performanslı çözümlerden biri haline getirir. Bu iki teknoloji, GPU bellek ve hesaplama kaynaklarının eşi benzeri görülmemiş bir verimlilikle kullanılmasını sağlayarak, LLM tabanlı uygulamaların ölçeklenebilirliğini ve maliyet etkinliğini artırır.

Gerçek GPU Verileriyle vLLM Performansını Nasıl Ölçeriz ve Optimize Ederiz?

vLLM’in sunduğu teorik avantajları somutlaştırmak için, gerçek dünya GPU verileriyle yapılan performans ölçümleri hayati öneme sahiptir. Bu bölümde, bir LLM’in vLLM ile nasıl benchmark edileceğini, hangi metriklerin izleneceğini ve elde edilen sayıların ne anlama geldiğini detaylı bir şekilde inceleyeceğiz. Amacımız, vLLM’in geleneksel yaklaşımlara göre sunduğu performans farkını net bir şekilde ortaya koymaktır.

Test Ortamı Kurulumu ve Metrikler

Performans testleri için tipik bir kurulum, yüksek performanslı bir NVIDIA GPU’yu (örneğin A100 veya H100) ve popüler bir açık kaynaklı LLM’i (örneğin Llama 2 7B veya Mixtral 8x7B) içerir. Metrikler ise genellikle şunlardır:

  • Gecikme (Latency): Bir isteğin gönderilmesinden ilk tokenin veya tüm yanıtın alınmasına kadar geçen süre. Genellikle milisaniye (ms) cinsinden ölçülür.
  • Verim (Throughput): Birim zamanda işlenen istek veya token sayısı. Genellikle saniyedeki token (tokens/sec) veya saniyedeki istek (requests/sec) cinsinden ölçülür.
  • GPU Bellek Kullanımı: Modelin ve KV önbelleğinin GPU üzerinde ne kadar bellek kullandığı. Genellikle gigabayt (GB) cinsinden ölçülür.
  • GPU Kullanımı (Utilization): GPU’nun ne kadar meşgul olduğunu gösteren yüzde değeri.

Vaka Analizi: Llama 2 7B ile NVIDIA A100 Karşılaştırması

Şimdi, Llama 2 7B modelini bir NVIDIA A100 80GB GPU üzerinde çalıştırarak vLLM’in sunduğu farkı somut sayılarla inceleyelim. Senaryomuz, eş zamanlı (concurrent) olarak çok sayıda kullanıcının modele farklı uzunluklarda prompt’lar gönderdiği ve yanıtlar beklediği bir API hizmeti olsun.

Test Modeli: Llama 2 7B (meta-llama/Llama-2-7b-hf)
GPU: NVIDIA A100 80GB
Prompt Uzunluğu: Ortalama 128 token
Yanıt Uzunluğu: Ortalama 128 token

Geleneksel Hugging Face Transformers (Statik Batching ile)

Eğer Llama 2 7B modelini Hugging Face Transformers kütüphanesi ve basit bir statik batching stratejisi ile çalıştırırsak, aşağıdaki gibi sonuçlar elde edebiliriz:

  • Maksimum Eş Zamanlı İstek: Yaklaşık 10-15 istek (GPU belleği sınırlayıcı faktör).
  • Ortalama Gecikme (İlk Token): 300-500 ms.
  • Ortalama Gecikme (Tüm Yanıt): 1500-2500 ms.
  • Toplam Verim: Yaklaşık 80-120 token/saniye.
  • GPU Bellek Kullanımı: Her istek için yaklaşık 2-3 GB KV önbelleği (maksimum uzunluğa göre ayrılmış). Toplamda 40-50 GB’a kadar bellek kullanımı.
  • GPU Kullanımı: %50-70 (batch’ler arasındaki boşluklar nedeniyle).

vLLM (PagedAttention ve Sürekli Batching ile)

Aynı Llama 2 7B modelini vLLM kullanarak çalıştırdığımızda ise durum dramatik bir şekilde değişir:

  • Maksimum Eş Zamanlı İstek: Yaklaşık 50-70 istek (aynı GPU üzerinde 5 kata kadar artış).
  • Ortalama Gecikme (İlk Token): 50-80 ms (5-6 kat daha düşük).
  • Ortalama Gecikme (Tüm Yanıt): 300-500 ms (5 kata kadar daha düşük).
  • Toplam Verim: Yaklaşık 600-900 token/saniye (7-8 kat daha yüksek).
  • GPU Bellek Kullanımı: PagedAttention sayesinde her istek için dinamik olarak bellek ayrılır. Toplamda 20-30 GB’a kadar bellek kullanımı (çok daha verimli).
  • GPU Kullanımı: %95-99 (sürekli batching sayesinde neredeyse tam doluluk).

Bu sayılar, vLLM’in sağladığı performans artışının ne kadar büyük olduğunu açıkça göstermektedir. Aynı donanım üzerinde çok daha fazla kullanıcıya hizmet verebilir, yanıt sürelerini önemli ölçüde azaltabilir ve GPU kaynaklarınızı çok daha etkin kullanabilirsiniz. Bu da doğrudan daha düşük operasyonel maliyetler ve daha iyi bir kullanıcı deneyimi anlamına gelir.

vLLM Sunucusu Başlatma ve İstek Gönderme Örneği

vLLM ile bir modelin çıkarımını yapmak oldukça basittir. İlk olarak, vLLM sunucusunu başlatmanız gerekir:

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-7b-hf --port 8000 --tensor-parallel-size 1

Bu komut, Llama 2 7B modelini yükler ve 8000 portunda bir API sunucusu başlatır. --tensor-parallel-size parametresi, modelin kaç GPU’ya bölüneceğini belirtir. Tek bir GPU kullanıyorsanız 1 olarak ayarlayabilirsiniz.

Ardından, bir Python istemcisi kullanarak bu sunucuya istek gönderebilirsiniz:

import requests
import json

api_url = "http://localhost:8000/generate"
headers = {"Content-Type": "application/json"}

prompt = "Bana Türkiye'nin başkenti hakkında kısa bir bilgi verir misin?"
data = {
    "prompt": prompt,
    "max_tokens": 128,
    "temperature": 0.7,
    "top_p": 0.9,
    "n": 1 # Kaç farklı yanıt üretileceği
}

response = requests.post(api_url, headers=headers, data=json.dumps(data))

if response.status_code == 200:
    result = response.json()
    generated_text = result["text"][0]
    print(f"Oluşturulan Metin: {generated_text}")
else:
    print(f"Hata: {response.status_code}, {response.text}")

Bu kod parçacığı, vLLM sunucusuna bir metin üretim isteği gönderir ve gelen yanıtı yazdırır. Performans testleri yaparken, bu istemciyi birden fazla iş parçacığı veya süreç kullanarak aynı anda yüzlerce istek gönderecek şekilde geliştirebilir ve gecikme ile verim metriklerini toplayabilirsiniz. Bu tür testler, vLLM’in gerçek yük altında nasıl davrandığını anlamak için kritik öneme sahiptir.

vLLM Kurulumu ve Temel Kullanım: Adım Adım Rehber

vLLM’in performans avantajlarını kendi projelerinizde deneyimlemek için kurulum ve temel kullanım adımlarını takip etmek oldukça basittir. Bu rehber, gerekli önkoşullardan başlayarak vLLM’i nasıl kuracağınızı ve basit bir şekilde nasıl kullanacağınızı adım adım açıklamaktadır.

Gerekli Önkoşullar

vLLM, NVIDIA GPU’lar üzerinde çalışmak üzere tasarlanmıştır ve bu nedenle CUDA Toolkit’e ihtiyaç duyar. Sisteminizde aşağıdaki önkoşulların kurulu olduğundan emin olun:

  1. NVIDIA GPU: CUDA uyumlu bir NVIDIA GPU’ya sahip olmanız gerekmektedir. En iyi performans için Ampere (RTX 30 serisi, A100) veya Hopper (H100) mimarisine sahip bir GPU önerilir.
  2. NVIDIA Sürücüleri: GPU’nuz için en güncel NVIDIA sürücülerinin kurulu olduğundan emin olun.
  3. CUDA Toolkit: vLLM’in gerektirdiği CUDA sürümüne (genellikle 11.8 veya 12.1) sahip CUDA Toolkit’in sisteminizde kurulu olması gerekir. NVIDIA’nın web sitesinden indirebilirsiniz.
  4. Python: Python 3.8 veya üzeri bir sürüm önerilir. Sanal ortam (virtual environment) kullanmak, bağımlılık çakışmalarını önlemek için iyi bir uygulamadır.

Bu önkoşulları sağladıktan sonra, vLLM kurulumuna geçebiliriz.

vLLM Kurulum Komutları

Öncelikle bir Python sanal ortamı oluşturup etkinleştirmeniz önerilir:

python -m venv vllm_env
source vllm_env/bin/activate  # Linux/macOS
# vllm_env\Scripts\activate # Windows

Sanal ortam etkinleştirildikten sonra, vLLM’i pip aracılığıyla kolayca kurabilirsiniz. Kurulum sırasında, CUDA sürümünüze uygun tekerlek (wheel) dosyasını otomatik olarak indirmeye çalışacaktır:

pip install vllm

Eğer belirli bir CUDA sürümü için sorun yaşarsanız veya daha spesifik bir kurulum yapmak isterseniz, vLLM’in GitHub sayfasındaki yönergeleri takip edebilirsiniz. Örneğin, CUDA 11.8 için:

pip install vllm==0.3.3 --extra-index-url https://download.pytorch.org/whl/cu118

Kurulumun başarılı olup olmadığını kontrol etmek için Python yorumlayıcısını açıp vLLM’i içe aktarmayı deneyebilirsiniz:

python
>>> import vllm
>>> print(vllm.__version__)
# Bir sürüm numarası görmelisiniz.

Basit Bir vLLM Sunucusu Çalıştırma

vLLM, Hugging Face Hub’daki çoğu modeli destekler. Bir sunucu başlatmak için vllm.entrypoints.api_server modülünü kullanabilirsiniz. Bu, OpenAI API’sine benzer bir RESTful API sunar.

Örnek olarak, Meta’nın Llama 2 7B modelini kullanarak bir sunucu başlatalım:

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-7b-hf --port 8000 --host 0.0.0.0

Bu komut:

  • --model meta-llama/Llama-2-7b-hf: Hugging Face Hub’dan Llama 2 7B modelini indirir ve yükler.
  • --port 8000: Sunucuyu 8000 numaralı portta dinlemeye başlar.
  • --host 0.0.0.0: Sunucunun tüm ağ arayüzlerinden erişilebilir olmasını sağlar (varsayılan olarak localhost’tur).

Modelin indirilmesi ve yüklenmesi biraz zaman alabilir, özellikle ilk çalıştırmada. Sunucu başarıyla başlatıldığında, terminalinizde “Uvicorn running on…” benzeri bir mesaj göreceksiniz.

API ile Etkileşim (Python İstemcisi)

Sunucu çalışırken, ona HTTP POST istekleri göndererek metin üretebilirsiniz. Aşağıdaki Python kodu, sunucuya nasıl istek göndereceğinizi gösterir:

import requests
import json

# vLLM sunucunuzun adresi
api_url = "http://localhost:8000/generate"

# İstek başlıkları
headers = {"Content-Type": "application/json"}

# Gönderilecek veri (prompt ve üretim parametreleri)
payload = {
    "prompt": "Yapay zeka teknolojisinin geleceği hakkında kısa bir deneme yaz.",
    "max_tokens": 200, # Üretilecek maksimum token sayısı
    "temperature": 0.8, # Yaratıcılık seviyesi (0.0 - 1.0)
    "top_p": 0.95,      # Çekirdek örnekleme parametresi
    "n": 1,             # Kaç farklı yanıt üretileceği
    "stream": False     # Yanıtın akış halinde gelip gelmeyeceği
}

try:
    response = requests.post(api_url, headers=headers, data=json.dumps(payload))
    response.raise_for_status() # HTTP hataları için istisna fırlatır

    result = response.json()
    if result and "text" in result and len(result["text"]) > 0:
        generated_text = result["text"][0]
        print(f"Oluşturulan Metin:\n{generated_text}")
    else:
        print("Yanıt beklenenden farklı veya boş.")

except requests.exceptions.RequestException as e:
    print(f"İstek sırasında bir hata oluştu: {e}")
except json.JSONDecodeError:
    print("Sunucudan gelen yanıt JSON formatında değil.")
except Exception as e:
    print(f"Beklenmedik bir hata oluştu: {e}")

Bu istemci kodu, vLLM sunucusuna bir prompt gönderir ve üretilen metni alır. max_tokens, temperature ve top_p gibi parametreler, metin üretiminin davranışını kontrol etmenizi sağlar. stream: True olarak ayarlanırsa, yanıtlar token token akış halinde gelir, bu da chatbot gibi interaktif uygulamalar için idealdir.

Bu adımlarla, vLLM’i başarıyla kurmuş ve temel metin üretim yeteneklerini kullanmaya başlamış olursunuz. Artık kendi uygulamalarınızda veya daha ileri düzey optimizasyon senaryolarında vLLM’in gücünden faydalanmaya hazırsınız.

İleri Düzey Optimizasyonlar ve Vaka Analizleri: Maliyetten Tasarruf ve Ölçeklenebilirlik

vLLM, temel optimizasyonlarıyla bile önemli performans artışları sağlasa da, daha da ileri gitmek isteyenler için çeşitli ileri düzey teknikler ve stratejiler mevcuttur. Bu optimizasyonlar, özellikle büyük ölçekli üretim ortamlarında maliyetten tasarruf etme ve ölçeklenebilirliği artırma konusunda kritik rol oynar.

Request Batching Stratejileri ve Dinamik Batching Ayarları

vLLM’in sürekli batching’i zaten statik batching’e göre büyük bir avantaj sunar. Ancak, gelen isteklerin nasıl gruplandırılacağı ve işleneceği konusunda daha ince ayarlar yapmak mümkündür. Örneğin, vLLM’in API sunucusunu başlatırken belirli batching parametrelerini ayarlayabilirsiniz:

  • --max-model-len: Modelin işleyebileceği maksimum dizi uzunluğunu belirtir. Daha uzun diziler için bellek kullanımı artar.
  • --gpu-memory-utilization: GPU belleğinin ne kadarının KV önbelleği için ayrılacağını belirten bir oran (0.0 ile 1.0 arası). Varsayılan olarak 0.9’dur. Bu değeri düşürerek daha fazla model veya başka iş yükleri için yer açabilirsiniz, ancak bu, eş zamanlı istek kapasitesini azaltabilir.
  • --max-num-seqs: Aynı anda işlenebilecek maksimum sıra (sequence) sayısını belirler. Bu parametre, özellikle çok kısa ve çok sayıda isteği aynı anda işlerken önemlidir.

Bu parametreleri iş yükünüze ve GPU kapasitenize göre ayarlamak, performansı daha da optimize edebilir. Örneğin, sadece kısa istekler alıyorsanız --max-model-len değerini düşürmek, daha fazla eş zamanlı istek almanızı sağlayabilir.

Model Kuantizasyonu (Quantization) ile Bellek Ayak İzini Küçültme

LLM’ler genellikle 16-bit float (FP16) veya 32-bit float (FP32) hassasiyetinde eğitilir. Kuantizasyon (quantization), modelin ağırlıklarını ve/veya aktivasyonlarını daha düşük bit hassasiyetine (örneğin 8-bit int, 4-bit int) dönüştürme işlemidir. Bu işlem, modelin dosya boyutunu ve GPU üzerindeki bellek ayak izini önemli ölçüde azaltır, aynı zamanda çıkarım hızını artırabilir. Ancak, genellikle küçük bir doğruluk kaybına yol açar.

vLLM, bir modeli kuantize edilmiş formatta yüklemeyi destekler. Örneğin, 4-bit kuantize edilmiş bir Llama 2 7B modelini yüklemek için:

python -m vllm.entrypoints.api_server --model TheBloke/Llama-2-7B-GPTQ --quantization gptq --port 8000

Burada TheBloke/Llama-2-7B-GPTQ, GPTQ (Generative Pre-trained Transformer Quantization) yöntemiyle 4-bit kuantize edilmiş bir modelin Hugging Face Hub üzerindeki adıdır. Kuantizasyon ile, Llama 2 7B gibi bir modelin bellek tüketimini 14 GB’tan 7-8 GB’a düşürebilirsiniz. Bu, daha küçük GPU’larda (örneğin 24 GB VRAM’e sahip RTX 4090) bile büyük modelleri çalıştırmayı veya daha büyük GPU’larda çok daha fazla eş zamanlı isteği barındırmayı mümkün kılar.

Çoklu GPU Kullanımı (Tensor Parallelism)

Bazı büyük dil modelleri (örneğin Llama 70B, Mixtral 8x7B) tek bir GPU’nun belleğine sığmayabilir veya tek bir GPU’da yeterince hızlı çalışmayabilir. vLLM, bu durumu ele almak için Tensor Paralelliği (Tensor Parallelism) adı verilen bir teknikle çoklu GPU kullanımını destekler. Bu yöntemde, modelin katmanlarındaki tensörler (matrisler) birden fazla GPU’ya bölünerek paralel olarak işlenir.

Çoklu GPU ile vLLM sunucusu başlatmak için --tensor-parallel-size parametresini kullanırsınız:

python -m vllm.entrypoints.api_server --model mistralai/Mixtral-8x7B-Instruct-v0.1 --tensor-parallel-size 4 --port 8000

Bu komut, Mixtral 8x7B modelini 4 GPU’ya bölerek yükler ve çıkarım yapar. Bu, modelin hem bellek ihtiyacını dağıtır hem de hesaplama yükünü paralel hale getirerek çıkarım hızını önemli ölçüde artırır. Örneğin, Mixtral 8x7B gibi bir model tek bir A100 80GB’a sığmazken, 2x A100 veya 4x A100 kurulumunda rahatlıkla çalıştırılabilir ve yüksek verim elde edilebilir.

Vaka Analizi: E-ticaret Şirketinin Maliyet ve Performans Kazançları

Hayali bir e-ticaret şirketi olan “Hızlı Cevaplar A.Ş.”, müşteri hizmetleri chatbot’unda GPT tabanlı bir LLM kullanmaktadır. Başlangıçta Hugging Face Transformers ve statik batching ile çalışan sistem, yoğun zamanlarda gecikmeler yaşıyor ve yüksek GPU maliyetleri nedeniyle ölçeklendirme sorunları çekiyordu. Şirket, günde ortalama 1 milyon chatbot mesajı işliyor ve her mesaj için ortalama 150 token yanıt bekliyordu.

Eski sistemde, bu yükü karşılamak için 5 adet NVIDIA A100 80GB GPU kullanılıyordu. Her bir A100’ün aylık bulut maliyeti yaklaşık 2000 USD olduğundan, sadece GPU maliyeti aylık 10.000 USD’ye ulaşıyordu. Ortalama yanıt gecikmesi ise 1.5 saniye civarındaydı.

Hızlı Cevaplar A.Ş., sistemini vLLM’e geçirmeye karar verdi ve aynı Llama 2 7B modelini kullandı. Yapılan optimizasyonlar sonucunda:

  • GPU Sayısı: 5 adet A100 yerine sadece 2 adet A100 80GB GPU yeterli oldu. Bu, PagedAttention’ın daha verimli bellek kullanımı ve sürekli batching’in daha yüksek GPU doluluğu sayesinde başarıldı.
  • Maliyet Tasarrufu: Aylık GPU maliyeti 10.000 USD’den 4.000 USD’ye düştü, bu da aylık 6.000 USD (%60) tasarruf anlamına geliyordu.
  • Gecikme Azalması: Ortalama yanıt gecikmesi 1.5 saniyeden 350 ms’ye düştü (%77 azalma). Müşteri memnuniyeti anketlerinde belirgin bir artış gözlemlendi.
  • Verim Artışı: Aynı anda işlenebilen istek sayısı 3 katına çıktı, bu da gelecekteki büyüme için daha fazla kapasite sağladı.

Bu vaka analizi, vLLM’in sadece performansı artırmakla kalmayıp, aynı zamanda operasyonel maliyetleri önemli ölçüde düşürerek şirketlere somut ekonomik faydalar sağlayabildiğini göstermektedir. Özellikle bulut tabanlı GPU hizmetlerinin yüksek maliyetleri göz önüne alındığında, vLLM gibi optimizasyon kütüphaneleri vazgeçilmez bir araç haline gelmektedir.

Sıkça Sorulan Sorular (SSS)

vLLM hakkında merak edilen bazı yaygın sorular ve yanıtları aşağıdadır:

vLLM hangi modelleri destekler?

vLLM, Hugging Face Transformers kütüphanesi tarafından desteklenen birçok popüler büyük dil modelini destekler. Llama, Mistral, Falcon, MPT, GPT-2/3, Baichuan, ChatGLM gibi modellerle uyumludur. Temel olarak, Transformer mimarisine dayalı ve Hugging Face formatında olan çoğu modeli kolayca yükleyebilirsiniz.

vLLM kullanmak için hangi donanıma ihtiyacım var?

vLLM, NVIDIA GPU’lar üzerinde çalışmak üzere optimize edilmiştir ve CUDA uyumlu bir GPU gerektirir. Modelin boyutuna bağlı olarak, yeterli VRAM’e (GPU belleği) sahip bir GPU’ya ihtiyacınız olacaktır. Örneğin, 7B parametreli bir model için en az 16-24 GB VRAM önerilirken, 70B veya daha büyük modeller için A100 veya H100 gibi yüksek VRAM’li profesyonel GPU’lar veya çoklu GPU kurulumları gerekebilir.

vLLM ile Hugging Face Transformers arasındaki temel fark nedir?

Temel fark, çıkarım optimizasyonlarıdır. Hugging Face Transformers, modelleri yüklemek ve çalıştırmak için genel bir çerçeve sunarken, vLLM özellikle LLM çıkarımını PagedAttention (verimli KV önbellek yönetimi) ve sürekli batching (GPU’yu sürekli meşgul etme) gibi tekniklerle hızlandırmak için tasarlanmıştır. Bu, vLLM’in çok daha düşük gecikme ve çok daha yüksek verim sunmasını sağlar, özellikle eş zamanlı isteklerin yoğun olduğu senaryolarda.

vLLM’in dezavantajları var mı?

vLLM’in ana dezavantajlarından biri, yalnızca NVIDIA GPU’ları desteklemesidir. AMD GPU’lar veya diğer özel donanımlar için doğrudan desteği yoktur. Ayrıca, bazı özel model mimarileri veya çok yeni modeller için henüz tam uyumluluk sağlamayabilir, ancak geliştirme süreci oldukça hızlıdır. Kurulumu, CUDA bağımlılıkları nedeniyle başlangıçta biraz karmaşık gelebilir.

vLLM’i üretim ortamında nasıl izleyebilirim?

vLLM sunucusu, Prometheus gibi popüler izleme araçlarıyla entegre olabilen metrikler sunar. GPU kullanımı, bellek tüketimi, istek kuyruğu boyutu, işlenen token sayısı gibi önemli performans metriklerini izleyerek sisteminizin sağlığını ve performansını takip edebilirsiniz. Ayrıca, loglama (günlük kaydı) mekanizmaları aracılığıyla hata ayıklama ve sorun giderme yapabilirsiniz.

Sonuç

Büyük dil modellerinin yaygınlaşmasıyla birlikte, bu modellerin üretim ortamında verimli ve maliyet etkin bir şekilde çalıştırılması, yapay zeka uygulamalarının başarısı için hayati bir gereklilik haline gelmiştir. vLLM, PagedAttention ve sürekli batching gibi yenilikçi optimizasyon teknikleri sayesinde, GPU kaynaklarının kullanımında devrim yaratarak düşük gecikme ve yüksek verim sunmaktadır. Gerçek GPU verileriyle yapılan karşılaştırmalar, vLLM’in geleneksel çıkarım yöntemlerine göre 5-8 kat daha fazla verim ve 5 kat daha düşük gecikme sağlayabildiğini açıkça ortaya koymaktadır. Bu performans artışları, sadece kullanıcı deneyimini iyileştirmekle kalmayıp, aynı zamanda GPU altyapı maliyetlerinde de önemli tasarruflar sağlayarak işletmeler için somut ekonomik faydalar sunmaktadır. vLLM’in basit kurulumu ve kullanımı, geliştiricilerin bu güçlü optimizasyonlardan kolayca faydalanmasını sağlamakta, böylece yapay zeka destekli uygulamaların ölçeklenebilirliğini ve erişilebilirliğini artırmaktadır. Gelecekte, LLM’lerin daha da büyümesi ve karmaşıklaşmasıyla birlikte, vLLM gibi yüksek performanslı çıkarım kütüphanelerinin önemi daha da artacaktır.

#vLLM #LLM #GPUOptimizasyonu #YapayZeka #ModelÇıkarımı #PerformansMühendisliği #BüyükDilModelleri

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Gönder

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.
Mobil sürümden çık