Büyük Dil Modellerinin Dağıtımı için Optimizasyon: vLLM PagedAttention ve Verimli AI Hizmetinin Geleceği

Büyük Dil Modelleri (LLM’ler), gerçek dünya uygulamalarında benzersiz zorluklar sunar, özellikle hesaplama kaynakları, gecikme ve maliyet etkinliği açısından. Bu kapsamlı rehberde, LLM hizmetinin manzarasını, özellikle vLLM (vektör Dil Modeli) gibi bir çözümü keşfedeceğiz. vLLM, bu güçlü modelleri dağıtmak ve etkileşimde bulunmak şeklimizi yeniden şekillendiren bir çözümdür.

Büyük Dil Modellerini Hizmet Etmenin Zorlukları

Özel çözümlere dalmadan önce, LLM hizmetini karmaşık bir görev yapan ana zorlukları inceleyelim:

Hesaplama Kaynakları

LLM’ler, milyarlarca veya yüz milyarlarca parametre ile ünlüdür. Örneğin, GPT-3 175 milyar parametreye sahiptir, daha yeni modeller gibi GPT-4 ise daha da fazlasına sahiptir. Bu büyüklük, çıkarım için önemli hesaplama gereksinimlerine karşılık gelir.

Örnek:
Bir LLM düşünün, 13 milyar parametre ile (16-bit kesinlik varsayılarak) yaklaşık 26 GB bellek gerektirir, yalnızca model parametrelerini depolamak için. Ek bellek, aktivasyonlar, dikkat mekanizmaları ve ara hesaplamalar için gereklidir. Gerçek zamanlı çıkarım için önemli GPU hesaplama gücü gereklidir.

Gecikme

Çoklu uygulamada, sohbet botları veya gerçek zamanlı içerik oluşturma gibi, düşük gecikme, iyi bir kullanıcı deneyimi için önemlidir. Ancak, LLM’lerin karmaşıklığı, özellikle daha uzun diziler için önemli işlem sürelerine yol açabilir.

Örnek:
Bir müşteri hizmetleri sohbet botunu düşünün, bir LLM tarafından güçlendiriliyor. Her bir yanıtın üretimi birkaç saniye sürerse, sohbet kullanıcılar için doğal ve can sıkıcı olmaz.

Maliyet

LLM’leri ölçekte çalıştırmak için gereken donanım çok pahalı olabilir. Yüksek performanslı GPU’lar veya TPU’lar genellikle gereklidir ve bu sistemlerin enerji tüketimi önemlidir.

Örnek:
Bir NVIDIA A100 GPU kümesinin (çoğunlukla LLM çıkarımı için kullanılır) bulut hesaplama ücretleri günlük olarak binlerce dolar olabilir.

Geleneksel LLM Hizmet Yaklaşımları

Daha gelişmiş çözümleri keşfetmeden önce, geleneksel LLM hizmet yaklaşımlarına kısaca göz atalım:

Basit Dağıtım ile Hugging Transformers

Hugging Face Transformers kütüphanesi, LLM’leri dağıtmak için basit bir yol sağlar, ancak yüksek hacimli hizmet için optimize edilmemiştir.

Örnek kod:

“`python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = “meta-llama/Llama-2-13b-hf”
model = AutoModelForCausalLM.from_pretrained(model_name, device_map=”auto”)
tokenizer = AutoTokenizer.from_pretrained(model_name)

def generate_text(prompt, max_length=100):
inputs = tokenizer(prompt, return_tensors=”pt”).to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.decode(outputs[0], skip_special_tokens=True)

print(generate_text(“AI’nin geleceği…”))
“`

Bu yaklaşım çalışır, ancak yüksek trafikli uygulamalar için kaynakların verimsiz kullanımı ve hizmet için optimizasyon eksikliği nedeniyle uygun değildir.

TorchServe veya Benzer Çerçeveler Kullanma

TorchServe gibi çerçeveler, yük dengeleme ve model sürümü gibi daha güçlü hizmet özellikleri sunar. Ancak, LLM hizmetinin özel zorluklarını, yani büyük modeller için verimli bellek yönetimi gibi konuları ele almazlar.

LLM Hizmetinde Bellek Yönetimi Anlama

Verimli bellek yönetimi, LLM’leri hizmet verirken kritiktir, çünkü önemli hesaplama kaynakları gereklidir. Aşağıdaki görüntüler, LLM performansını optimize etmede integral olan bellek yönetiminin çeşitli yönlerini gösterir.

Parçalanmış vs. Sayfa Belleği

Bellek Yönetimi OS vs. vLLM

 

Bellek Yönetimi OS vs. vLLM

Bu iki diyagram, işletim sistemlerinde (OS) yaygın olarak kullanılan parçalanmış bellek ve sayfa belleği yönetim tekniklerini karşılaştırır.

• Parçalanmış Bellek: Bu teknik, belleği farklı segmentlere ayırır, her biri farklı bir programa veya işleme karşılık gelir. LLM hizmetinde, farklı segmentler modelin çeşitli bileşenlerine atanabilir, Örneğin, tokenization, embedding ve dikkat mekanizmaları. Her segment bağımsız olarak büyüyebilir veya küçülebilir, esneklik sağlar ancak doğru yönetilmezse parçalanmaya neden olabilir.
• Sayfa Belleği: Burada, bellek sabit boyutlu sayfalar halinde bölünür ve fiziksel belleğe eşlenir. Sayfalar gerektiğinde değiştirilebilir, bu da bellek kaynaklarının verimli kullanılmasını sağlar. LLM hizmetinde, bu, model ağırlıkları ve ara hesaplamalar için gereken büyük miktarda belleği yönetmek için kritiktir.

OS Bellek Yönetimi vs. vLLM

Bu görüntü, geleneksel OS bellek yönetimini vLLM’de kullanılan bellek yönetim yaklaşımıyla karşılaştırır.

• OS Bellek Yönetimi: Geleneksel işletim sistemlerinde, işlemler (örneğin, İşlem A ve İşlem B) fiziksel bellekte sayfalar (Sayfa 0, Sayfa 1, vb.) atanır. Bu atama, zaman içinde parçalanmaya yol açabilir.
• vLLM Bellek Yönetimi: vLLM çerçevesi, belleği daha verimli yönetmek için bir Anahtar-Değer (KV) önbelleği kullanır. İstekler (örneğin, İstek A ve İstek B) KV önbelleğinde bloklara atanır. Bu yaklaşım, parçalanmayı en aza indirir ve bellek kullanımını optimize eder, daha hızlı ve verimli model hizmetini sağlar.

LLM’lerde Dikkat Mekanizması

LLM’lerde Dikkat Mekanizması

Dikkat mekanizması, transformer modellerinin temel bir bileşenidir ve LLM’ler için yaygın olarak kullanılır. Bu diyagram, dikkat formülünü ve bileşenlerini gösterir:

• Sorgu (Q): Bir decoder adımında yeni bir token veya modelin gördüğü son token.
• Anahtar (K): Önceki bağlam, modelin dikkat etmesi gereken.
• Değer (V): Önceki bağlamın ağırlıklı toplamı.

Formül, dikkat puanlarını hesaplar, sorgu ile anahtarların nokta ürününü alarak, anahtar boyutunun karekökünü ölçeklendirerek, softmax fonksiyonu uygulayarak ve sonra değerlerle nokta ürününü alarak. Bu işlem, modelin her token üretimi sırasında girdi dizisinin ilgili kısımlarına odaklanmasını sağlar.

Hizmet Verimliliği Karşılaştırması

vLLM: Kolay, Hızlı ve Ucuz LLM Hizmeti ile PagedAttention

Bu görüntü, farklı çerçeveler (HF, TGI ve vLLM) kullanarak LLaMA modelleriyle hizmet verimliliğini karşılaştırır.

• LLaMA-13B, A100-40GB: vLLM, HuggingFace Transformers’a (HF) göre 14 kat daha yüksek ve HuggingFace Text Generation Inference’a (TGI) göre 2.2 kat daha yüksek verimlilik sağlar.
• LLaMA-7B, A10G: Benzer eğilimler gözlenir, vLLM’nin HF ve TGI’yi önemli ölçüde geride bırakmasıyla.

vLLM: Yeni Bir LLM Hizmet Mimarisi

vLLM, UC Berkeley’deki araştırmacılar tarafından geliştirilen, LLM hizmet teknolojisinde önemli bir adım olan bir çözümdür. vLLM’nin temel özelliklerini ve yeniliklerini keşfedeceğiz:

PagedAttention

vLLM’nin kalbinde, işletim sistemlerinde sanal bellek yönetiminden esinlenen yeni bir dikkat algoritması olan PagedAttention yer alır. İşte nasıl çalışır:

– Anahtar-Değer (KV) Önbelleği Bölümü: KV önbelleğini tümüyle sürekli bellekte depolamak yerine, PagedAttention onu sabit boyutlu bloklara ayırır.
– Non-Contiguous Depolama: Bu bloklar, bellekte non-contiguously depolanabilir, daha esnek bellek yönetimi sağlar.
– İhtiyaç Duyulduğunda Atama: Bloklar yalnızca ihtiyaç duyulduğunda atanır, bellek israfını azaltır.
– Verimli Paylaşım: Birden fazla dizi, blokları paylaşabilir, paralel örneklem ve ışın arama gibi teknikler için optimizasyon sağlar.

İllüstrasyon:

“`
Geleneksel KV Önbelleği:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Sürekli bellek ataması)

PagedAttention KV Önbelleği:
[Block 1] -> Fiziksel Adres A
[Block 2] -> Fiziksel Adres C
[Block 3] -> Fiziksel Adres B
…
(Non-contiguous bellek ataması)
“`

Bu yaklaşım, bellek parçalanmasını önemli ölçüde azaltır ve GPU belleğinin daha verimli kullanılmasını sağlar.

Sürekli Toplu İşlem

vLLM, gelen istekleri dinamik olarak işler, sabit boyutlu toplu işlemler oluşturmayı beklemez. Bu, daha düşük gecikme ve daha yüksek verimlilik sağlar.

Örnek:

“`
Zaman 0ms: İstek A gelir
Zaman 10ms: İstek A işleme başlar
Zaman 15ms: İstek B gelir
Zaman 20ms: İstek B (A ile paralel olarak) işleme başlar
Zaman 25ms: İstek C gelir
…
“`

Sürekli toplu işlemle, vLLM her isteği hemen işleyebilir, önceden belirlenmiş toplu işlemler oluşturmayı beklemeksizin.

Verimli Paralel Örnekleme

Birden fazla çıktı örneği gerektiren uygulamalar için (örneğin, yaratıcı yazı asistanları), vLLM’nin bellek paylaşım yetenekleri öne çıkar. Paylaşılan ön ekler için KV önbelleğini yeniden kullanabilir.

Örnek kod:

“`python
from vllm import LLM, SamplingParams

llm = LLM(model=”meta-llama/Llama-2-13b-hf”)
prompts = [“AI’nin geleceği…”]

# 3 örnek üret
sampling_params = SamplingParams(n=3, temperature=0.8, max_tokens=100)
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
print(f”İstek: {output.prompt}”)
for i, out in enumerate(output.outputs):
print(f”Örnek {i + 1}: {out.text}”)
“`

Bu kod, verilen istek için birden fazla örnek üretir, vLLM’nin optimizasyonlarını kullanarak.

vLLM Performansını Test Etme

vLLM’nin etkisini gerçekten takdir etmek için, bazı performans karşılaştırmalarına bakalım:

Verimlilik Karşılaştırması

Tablo dựaında, vLLM diğer hizmet çözümlerini önemli ölçüde geride bırakır:

– Hugging Face Transformers’a göre 24 kata kadar daha yüksek verimlilik
– Hugging Face Text Generation Inference’a (TGI) göre 2.2 ila 3.5 kat daha yüksek verimlilik

İllüstrasyon:

“`
Verimlilik (Token/saniye)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Bellek Verimliliği

vLLM’nin PagedAttention sonucu, neredeyse optimal bellek kullanımı sağlar:

– Sadece yaklaşık %4 bellek israfı, geleneksel sistemlerdekinin %60-80’i
– Bu verimlilik, aynı donanım ile daha büyük modellerin hizmet verilmesini veya daha fazla eş zamanlı isteğin işlenmesini sağlar.

vLLM ile Başlama

Artık vLLM’nin avantajlarını keşfettik, şimdi kurulum ve kullanım sürecini yürüyelim.

6.1 Kurulum

vLLM’yi kurmak pip ile basittir:

“`python
!pip install vllm
“`

6.2 Çevrimdışı Çıkarım için Temel Kullanım

Burada, vLLM’yi basit bir metin üretimi için kullanma örneği verilmiştir:

“`python
from vllm import LLM, SamplingParams

# Modeli başlat
llm = LLM(model=”meta-llama/Llama-2-13b-hf”)

# İstekleri hazırla
prompts = [
“Sanal zekanın kısa bir şiiri yaz…”,
“Kuantum bilgisayarları basit terimlerle açıkla…”
]

# Örnekleme parametrelerini ayarla
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)

# Yanıtları üret
outputs = llm.generate(prompts, sampling_params)

# Sonuçları yaz
for output in outputs:
print(f”İstek: {output.prompt}”)
print(f”Üretilen metin: {output.outputs[0].text}\n”)
“`

Bu betik, modeli yüklemeyi, örneklem parametrelerini ayarlamayı ve birden fazla istek için metin üretmeyi gösterir.

6.3 vLLM Sunucusunu Ayarlama

Çevrimiçi hizmet için, vLLM OpenAI uyumlu bir API sunucusu sağlar. İşte nasıl kurulur:

1. Sunucuyu başlat:

“`bash
python -m vllm.entrypoints.openai.api_server –model meta-llama/Llama-2-13b-hf
“`

2. Sunucuyu curl ile sorgula:

“`bash
curl http://localhost:8000/v1/completions \
-H “Content-Type: application/json” \
-d ‘{
“model”: “meta-llama/Llama-2-13b-hf”,
“prompt”: “Sanal zekanın faydaları…”,
“max_tokens”: 100,
“temperature”: 0.7
}’
“`

Bu kurulum, LLM’nizi OpenAI API’si ile uyumlu bir arayüzle hizmet vermenizi sağlar, bu da mevcut uygulamalara entegre etmeyi kolaylaştırır.

İleri Konular

vLLM, LLM hizmetinde önemli iyileştirmeler sunar, ancak daha fazla dikkate alınması gereken gelişmiş konular vardır:

7.1 Model Kuantizasyonu

Daha verimli hizmet için, özellikle sınırlı bellekli donanımda, kuantizasyon teknikleri kullanılabilir. vLLM kendisi kuantizasyonu desteklemez, ancak kuantize edilmiş modellerle birlikte kullanılabilir:

“`python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Kuantize edilmiş modeli yükle
model_name = “meta-llama/Llama-2-13b-hf”
model = AutoModelForCausalLM.from_pretrained(model_name, device_map=”auto”, load_in_8bit=True)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Kuantize edilmiş modeli vLLM ile kullan
from vllm import LLM

llm = LLM(model=model, tokenizer=tokenizer)
“`

7.2 Dağıtılmış Çıkarım

Çok büyük modeller veya yüksek trafikli uygulamalar için, birden fazla GPU veya makine arasında dağıtılmış çıkarım gerekli olabilir. vLLM bunu yerli olarak desteklemez, ancak Ray gibi çerçevelerle entegre edilebilir:

“`python
import ray
from vllm import LLM

@ray.remote(num_gpus=1)
class DistributedLLM:
def __init__(self, model_name):
self.llm = LLM(model=model_name)

def generate(self, prompt, params):
return self.llm.generate(prompt, params)

# Dağıtılmış LLM’leri başlat
llm1 = DistributedLLM.remote(“meta-llama/Llama-2-13b-hf”)
llm2 = DistributedLLM.remote(“meta-llama/Llama-2-13b-hf”)

# Onları paralel olarak kullan
result1 = llm1.generate.remote(“İstek 1”, sampling_params)
result2 = llm2.generate.remote(“İstek 2”, sampling_params)

# Sonuçları al
print(ray.get([result1, result2]))
“`

7.3 İzleme ve Gözlemlenebilirlik

LLM’leri üretim ortamında hizmet verirken, izleme çok önemlidir. vLLM yerli olarak izleme sağlamaz, ancak Prometheus ve Grafana gibi araçlarla entegre edilebilir:

“`python
from prometheus_client import start_http_server, Summary
from vllm import LLM

# Metric tanımla
REQUEST_TIME = Summary(‘request_processing_seconds’, ‘İstek işleme süresi’)

# vLLM’i başlat
llm = LLM(model=”meta-llama/Llama-2-13b-hf”)

# Metricleri aç
start_http_server(8000)

# Modeli izleme ile kullan
@REQUEST_TIME.time()
def process_request(prompt):
return llm.generate(prompt)

# Hizmet döngünüz burada
“`

Bu kurulum, istek işleme süresi gibi metricleri izlemenizi sağlar, bunlar Grafana panellerinde görselleştirilebilir.

Sonuç

Büyük Dil Modellerini verimli bir şekilde hizmet vermek, AI çağındaki karmaşık ancak kritik bir görevdir. vLLM, yenilikçi PagedAttention algoritması ve optimize edilmiş uygulamasıyla, LLM dağıtımı daha erişilebilir ve maliyet etkin hale getirir.

Verimliliği önemli ölçüde artırarak, bellek israfını azaltarak ve daha esnek hizmet seçenekleri sunarak, vLLM geniş bir uygulama yelpazesine güçlü dil modellerini entegre etme olanağı sağlar. Bir sohbet botu, içerik oluşturma sistemi veya herhangi bir NLP güçlendirilmiş uygulama inşa ediyorsanız, vLLM gibi araçları anlama ve kullanma, başarının anahtarı olacaktır.