GLM-4.7’yi Yerelde llama.cpp ile Çalıştırma: Yüksek Performanslı Rehber

GLM-4.7, gerçek geliştirme iş akışlarında daha iyi performans göstermesi için tasarlanmış yeni kodlama ortağınızdır. GLM-4.6 ile karşılaştırıldığında, çok dilli ve ajan tabanlı kodlama, terminal tabanlı görevler ve araç kullanımı alanlarında belirgin kazanımlar gösterir; SWE-bench, SWE-bench Multilingual ve Terminal Bench 2.0’da güçlü sonuçlar verir. Ayrıca harekete geçmeden önce düşünmeyi destekler; bu da modern ajan çerçevelerinde karmaşık görevler için daha güvenilir olmasını sağlar.

Bu eğitimde, Runpod ortamını kurmaya, gerekli tüm bağımlılıkları yüklemeye ve tam CUDA desteğiyle llama.cpp’yi klonlamaya doğrudan başlıyoruz. Ardından Hugging Face’ten GLM-4.7 2-bit modelini indiriyor, hem CLI hem de sunucu modlarında çalıştırıyor ve son olarak OpenAI SDK ile çalışan sunucuyu test ediyoruz.

Ayrıca GLM 4.7 Flash’ı yerelde çalıştırma rehberimize de göz atabilirsiniz.

GLM-4.7 Sistem Gereksinimleri ve Donanım Önkoşulları

GLM-4.7’yi yerelde çalıştırmadan önce, sisteminizin aşağıdaki gereksinimleri karşıladığından emin olun.

NVIDIA GPU ve sürücüler

Kullanılabilir performans için NVIDIA GPU gereklidir.

En güncel NVIDIA sürücülerini yükleyin ve kurulumu şu komutla doğrulayın:

nvidia-smiAltyapı:

Bu komut çalışıyor ve GPU’nuzu gösteriyorsa, sürücü kurulumu doğrudur.

CUDA desteği

GLM-4.7’yi çalıştırırken GPU hızlandırması için CUDA gereklidir. llama.cpp’yi kaynaktan derliyorsanız, CUDA’nın derleme sırasında doğru şekilde algılanması gerekir. 

Hazır derlenmiş CUDA etkin ikili dosyaları kullanırken, sistemde hali hazırda çalışan bir CUDA çalışma zamanı kurulu olmalıdır. CUDA desteği olmadan GLM-4.7 CPU üzerinde çalışmaya geri döner; bu da gerçek kullanım için pratik olmayan derecede yavaştır.

Bellek gereksinimleri (çok önemli)

GLM-4.7, kuantize edilmiş olsa bile son derece büyüktür. Modelin çalışıp çalışmayacağı ve ne kadar hızlı çalışacağı, yalnızca GPU VRAM’ına değil, birleşik belleğinize bağlıdır.

Şu şekilde düşünün: GPU VRAM + sistem RAM birlikte.

2-bit Dinamik Kuant (UD-Q2_K_XL)

• Yaklaşık 135 GB disk alanı kullanır
• Yaklaşık 128 GB sistem RAM ile tek bir 24 GB GPU üzerinde çalışabilir
• MoE katmanlarının RAM’e offload edilmesine dayanır
• Kalite ve uygulanabilirlik arasında iyi denge

1-bit Kuant (UD-TQ1)

• 2-bit’ten daha küçük ve hızlı
• Ollama ile yerel olarak çalışır
• En düşük bellek ayak izi
• Fark edilir kalite düşüşü

4-bit Kuantizasyonlar

• En az bir 40 GB GPU gerektirir
• MoE katmanları yine RAM’e offload edilmelidir
• Yaklaşık 165 GB sistem RAM ile kabaca saniyede 5 token bekleyin
• Kararlı performans ve daha uzun bağlamlar için toplam VRAM + RAM’in 205 GB olması önerilir

Önemli Çıkarım

GLM-4.7 için yalnızca H100 GPU boyutu yeterli değildir. Kararlı ve hızlı çıkarım, GPU VRAM’ı ile sistem RAM’ını birlikte toplayan toplam mevcut belleğe bağlıdır.

RunPod Üzerinde GPU Ortamı Kurulumu

Bu eğitimde, kurulumu hızlı olduğu ve talep üzerine geniş bir GPU yelpazesi sunduğu için RunPod kullanacağız.

Önce yeni bir pod oluşturun. En son PyTorch imajını seçin, ardından şablon ayarlarında Düzenle’ye tıklayın. GLM-4.7 modeli 2-bit kuantize biçimde bile çok büyük olduğundan, birim disk boyutunu 200 GB’a çıkarın.

Ardından gerekli portları açın. JupyterLab için varsayılan 8080 portunu koruyun ve daha sonra llama.cpp sunucusu tarafından kullanılacak ek bir port ekleyin.

Yapılandırma tamamlandığında, fiyatlandırma özeti ve pod özeti, varsayılan şablonun daha büyük birim boyutuyla geçersiz kılındığını açıkça göstermelidir.

Pod başladıktan sonra, JupyterLab’i başlatmak için Jupyter Notebook bağlantısına tıklayın. Yeni bir defter (notebook) oluşturun ve aşağıdaki kurulum kodunu çalıştırın.

import os

WORKDIR = "/workspace"
LLAMA_DIR = f"{WORKDIR}/llama.cpp"
MODEL_DIR = f"{WORKDIR}/models/unsloth/GLM-4.7-GGUF"

os.makedirs(MODEL_DIR, exist_ok=True)

# Put Hugging Face cache on /workspace (big speed win on RunPod)
os.environ["HF_HOME"] = f"{WORKDIR}/.cache/huggingface"
os.environ["HUGGINGFACE_HUB_CACHE"] = f"{WORKDIR}/.cache/huggingface/hub"
os.environ["HF_HUB_CACHE"] = f"{WORKDIR}/.cache/huggingface/hub"
os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"

# Enable HF Xet high performance (Xet backend)
os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"

print("WORKDIR:", WORKDIR)
print("LLAMA_DIR:", LLAMA_DIR)
print("MODEL_DIR:", MODEL_DIR)
print("HF_HOME:", os.environ["HF_HOME"])
print("HF_HUB_CACHE:", os.environ["HF_HUB_CACHE"])
print("HF_XET_HIGH_PERFORMANCE:", os.environ["HF_XET_HIGH_PERFORMANCE"])Altyapı:

Bu kod şunları yapar:

1. RunPod üzerinde ana çalışma dizini olarak /workspace’i ayarlar.
2. llama.cpp’nin nereye klonlanıp derleneceğini tanımlar.
3. GLM-4.7 GGUF model dosyalarının nereye kaydedileceğini tanımlar.
4. Model dizinini, eğer yoksa, oluşturur.
5. Hugging Face önbelleğini daha hızlı indirmeler ve daha fazla disk alanı için /workspace’e taşır.
6. Konteyner ortamlarında Hugging Face sembolik bağlantı uyarılarını devre dışı bırakır.
7. Büyük dosya indirmeleri için Hugging Face Xet yüksek performanslı arka ucunu etkinleştirir.
8. Kurulumu doğrulamak için tüm yolları ve ortam değişkenlerini yazdırır.

Şuna benzer bir çıktı görmelisiniz:

WORKDIR: /workspace
LLAMA_DIR: /workspace/llama.cpp
MODEL_DIR: /workspace/models/unsloth/GLM-4.7-GGUF
HF_HOME: /workspace/.cache/huggingface
HF_HUB_CACHE: /workspace/.cache/huggingface/hub
HF_XET_HIGH_PERFORMANCE: 1Altyapı:

Şimdi NVIDIA sürücülerinin doğru kurulduğunu ve GPU’nun göründüğünü doğrulayın.

!nvidia-smiAltyapı:

80 GB kullanılabilir VRAM’a sahip bir H100 GPU görmelisiniz; bu da ortamın GPU hızlandırması için hazır olduğunu doğrular.

Son olarak, llama.cpp’yi kaynaktan derlemek için gereken sistem bağımlılıklarını kurun.

%%capture
!apt-get update -y
!apt-get install -y build-essential cmake curl libcurl4-openssl-dev git pciutilsAltyapı:

Not: %%capture kullanarak Jupyter’daki ayrıntılı kurulum günlüklerini gizledik ancak komutları çalıştırmaya devam ettik.

CUDA Desteğiyle llama.cpp Kurulumu

Bu adımda, en iyi GPU performansını sağlamak için llama.cpp’yi CUDA etkin şekilde kaynaktan klonlayıp derliyoruz.

Önce resmi depoyu çalışma alanına klonlayın.

!git clone https://github.com/ggml-org/llama.cpp /workspace/llama.cppAltyapı:

Ardından, yapılandırmayı CUDA desteği etkin ve paylaşımlı kütüphaneler devre dışı olacak şekilde yapın.

%%capture
!cmake /workspace/llama.cpp -B /workspace/llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ONAltyapı:

Sonra gerekli ikili dosyaları yayın kipinde derleyin.

%%capture
!cmake --build /workspace/llama.cpp/build --config Release -j --clean-first --target llama-cli llama-serverAltyapı:

Derleme tamamlandıktan sonra ikili dosyaları ana dizine kopyalayın ve çıktıyı doğrulayın.

%%capture
!cp /workspace/llama.cpp/build/bin/llama-* /workspace/llama.cpp/
!ls -la /workspace/llama.cpp | sed -n '1,60p'Altyapı:

Bu aşamada, llama.cpp tam CUDA desteğiyle hazırdır ve GLM-4.7’yi CLI veya sunucu üzerinden çalıştırmak için kullanılabilir.

Xet Desteğiyle GLM 4.7 Modelini İndirme

Bu adımda, büyük model indirmelerini önemli ölçüde hızlandırmak için Xet ve HF Transfer desteğiyle Hugging Face kütüphanelerini kuruyoruz. Xet, GLM-4.7’yi verimli bir şekilde indirmek için kritik olan ve Git LFS’ten çok daha hızlı performans sağlar.

Önce gerekli Hugging Face bağımlılıklarını kurun ve HF Transfer’i etkinleştirin.

!pip -q install -U "huggingface_hub[hf_xet]" hf-xet
!pip -q install -U hf_transferAltyapı:

Ortam değişkeni ayarlayarak HF Transfer’i etkinleştirin.

import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"Altyapı:

Bu paketleri kurduktan sonra, yeni ayarların etkili olması için Jupyter çekirdeğini yeniden başlatın.

Sonra, Hugging Face’ten snapshot_download kullanarak GLM-4.7 GGUF modelini indirin. Depolama ve bellek kullanımını azaltmak için indirmeyi önerilen dinamik 2-bit kuantizasyona kısıtlıyoruz.

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="unsloth/GLM-4.7-GGUF",
    local_dir=MODEL_DIR,
    allow_patterns=["*UD-Q2_K_XL*"],  # recommended dynamic 2-bit
)
print("Downloaded into:", MODEL_DIR)Altyapı:

Xet ve HF Transfer etkinleştirildiğinde indirme hızları saniyede 726 MB’a ve daha sonra saniyede 1.2 GB’a kadar çıkabilir. Bu kurulum olmadan, indirme hızları genellikle saniyede 50 MB civarındadır; bu da bu boyuttaki bir modelin indirilmesinin neredeyse tüm günü almasına neden olabilir.

İndirme tamamlandığında, GLM-4.7 modeli çalışma alanındaki model dizininde yerel olarak kullanılabilir olacak ve llama.cpp ile çıkarıma hazır hale gelecektir.

GLM 4.7’yi Etkileşimli Modda Çalıştırma

Şimdi GLM-4.7’yi llama.cpp CLI kullanarak etkileşimli modda çalıştıracağız.

JupyterLab içinde bir terminal açarak başlayın. JupyterLab’de Artı (+) düğmesine tıklayın, aşağı kaydırın ve Terminal’i seçin. Bu, RunPod ortamında yeni bir kabuk oturumu açacaktır.

Terminalde, etkileşimli CLI’ı başlatmak için aşağıdaki komutu çalıştırın.

 /workspace/llama.cpp/llama-cli \
  --model "/workspace/models/unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf" \
  --jinja \
  --threads -1 \
  --ctx-size 16384 \
  --temp 1.0 \
  --top-p 0.95 \
  --seed 3407 \
  --fit onAltyapı:

Bu komut GLM-4.7 dinamik 2-bit modelini yükler ve etkileşimli bir sohbet oturumu başlatır. --fit on bayrağı, llama.cpp’nin mümkün olduğunca çok sayıda katmanı ve KV önbellek bloklarını GPU’ya otomatik olarak offload etmesine, kalan bileşenleri ise güvenli şekilde sistem RAM’ine taşmasına olanak tanır. Bu, manuel katman ayarı ihtiyacını ortadan kaldırır ve bellek yetersizliği hatalarını önlemeye yardımcı olur.

Model yüklemeyi bitirdiğinde, llama.cpp başlığını ve ardından etkileşimli bir istemi görürsünüz. Artık basit bir selamlaşma gibi bir mesaj yazabilir ve model yanıt üretmeye başlayacaktır.

Her yanıtın sonunda, llama.cpp token üretim hızı da dahil olmak üzere performans istatistiklerini yazdırır. Bu aşamada model yaklaşık saniyede 2.2 token hızında çalışır; bu da modelin tek bir H100 GPU üzerinde doğru şekilde çalıştığını doğrular. 

Sonraki adımlarda, çıktıyı artırmak ve hedef olan saniyede 20 token’a daha da yaklaşmak için ek optimizasyonlar uygulayacağız.

GLM 4.7 Çıkarım Sunucusunu Çalıştırma

Bu adımda, GLM-4.7’yi llama.cpp kullanarak kalıcı bir çıkarım sunucusu olarak, tek bir H100 PCIe GPU için optimize edilmiş şekilde çalıştırıyoruz. Bu ayarlar, istekleri yanıtlarken çıktı, kararlılık ve bellek verimliliğini artıracak şekilde ayarlanmıştır.

Kararlı ve verimli performans elde etmek için aşağıdaki optimizasyonlar kullanılır:

1. GPU Offload (--fit on): Modelin ve KV önbelleğinin mümkün olduğunca büyük kısmını GPU belleğine otomatik olarak offload eder, kalan kısmı güvenle sistem RAM’ine taşır. Bu, manuel katman ayarından kaçınır ve bellek yetersizliği hatalarını önler.
2. Flash Attention (--flash-attn auto): H100 gibi desteklenen GPU’larda optimize edilmiş dikkat (attention) çekirdeklerini etkinleştirir; token üretim hızını önemli ölçüde artırır ve bellek yükünü azaltır.
3. Bağlam Boyutu Ayarı (--ctx-size 8192): Büyük bağlam pencereleri zamanla kod çözmeyi yavaşlatır. Bağlam boyutunu 16k’dan 8k’ya düşürmek, çoğu iş yükü için daha tutarlı token çıktısı sağlar.
4. Toplu İşleme (--batch-size, --ubatch-size): Token’ları daha büyük ve verimli partiler halinde işleyerek GPU kullanımını ve toplam çıktıyı artırır.
5. CPU İş Parçacığı Kontrolü (--threads 32): RunPod gibi bulut ortamlarında CPU aşırı aboneliğini önler ve zamanlama yükünü azaltır.

GLM-4.7 çıkarım sunucusunu başlatmak için terminalde aşağıdaki komutu çalıştırın.

/workspace/llama.cpp/llama-server \
  --model "/workspace/models/unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf" \
  --alias "GLM-4.7" \
  --threads 32 \
  --host 0.0.0.0 \
  --ctx-size 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --port 8080 \
  --fit on \
  --prio 3 \
  --jinja \
  --flash-attn auto \
  --batch-size 1024 \
  --ubatch-size 256Altyapı:

Model yüklemeyi tamamladığında, sunucu 8080 portu üzerinde dinlemeye başlar ve çıkarım isteklerini kabul etmeye hazır hale gelir. Bu noktada GLM-4.7, tek bir H100 GPU üzerinde yüksek performanslı bir çıkarım hizmeti olarak çalışmaktadır.

Bir sonraki adımda, llama.cpp sunucusuyla birlikte gelen yerleşik web arayüzünü kullanarak sunucuyu test edeceğiz.

llama.cpp Web Arayüzü ile GLM 4.7’yi Test Etme

Çalışan çıkarım sunucusunu test etmek için RunPod kontrol panelinizi açın ve açığa çıkarılmış 8080 portundaki HTTP hizmetini bulun. Bağlantıya tıklayın; tarayıcınızda llama.cpp web arayüzü açılacaktır.

llama.cpp web arayüzü, ChatGPT’ye benzer. İstemler girebilir, dosya ekleyebilir, ayarları düzenleyebilir ve arayüzden mevcut modelleri seçebilirsiniz.

GLM-4.7 modelini seçtikten sonra, dosya yolları, bağlam boyutu, model boyutu, parametre sayısı, gömme (embedding) boyutları ve diğer çalışma zamanı ayrıntıları dahil olmak üzere yüklenen model hakkında ayrıntılı bilgiler görürsünüz. Bu, doğru model ve yapılandırmanın etkin olduğunu doğrular.

Artık ilk isteminizi girin. Bir saniye içinde model, yanıt üretmeye web arayüzünde doğrudan başlayacaktır.

Önceden uygulanan optimize edilmiş sunucu ayarlarıyla, model yaklaşık saniyede 19 token hızına ulaşır; bu da çıkarım hattının verimli şekilde çalıştığını doğrular. Yanıtlar doğru ve tutarlıdır.

Ardından genel bir bilgi sorgusu gibi takip sorusu sorabilirsiniz. Testlerde GLM-4.7, akıl yürütme ve yanıt token’ları dahil olmak üzere tutarlı bir şekilde yaklaşık saniyede 20 token hızına ulaşır; bu da tek bir H100 GPU üzerinde kararlı yüksek performansı gösterir.

OpenAI Python SDK ile GLM 4.7’yi Test Etme

Bu bölümde, llama.cpp çıkarım sunucusunu OpenAI uyumlu Python SDK ile test edeceğiz. Bu, sunucunun programatik erişim için doğru çalıştığını ve gerçek uygulamalara entegre edilebileceğini doğrular.

Önce tekrar Jupyter Notebook’a dönün. Terminalde llama-server sürecinin hâlâ çalıştığından emin olun; durdurmayın veya yeniden başlatmayın.

Sunucunun etkin olduğunu ve 8080 portunda dinlediğini doğrulamak için aşağıdaki komutu çalıştırın:

!ss -lntp | grep 8080 || trueAltyapı:

Aşağıdakine benzer bir çıktı görmelisiniz; bu, llama-server’ın dinlediğini doğrular:

LISTEN 0      512          0.0.0.0:8080       0.0.0.0:*    users:(("llama-server",pid=1108,fd=15))Altyapı:

Ardından yerel sunucuya istek göndermek için kullanacağımız OpenAI Python SDK’yı kurun.

!pip -q install openaiAltyapı:

Şimdi yerel llama.cpp sunucusunu işaret eden bir OpenAI istemcisi oluşturun. API anahtarı değeri gerekli değildir; ancak uyumluluk için sağlanmalıdır.

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="sk-no-key-required",
)Altyapı:

Çok dilli yetenekleri test etmek için basit bir sohbet tamamlama isteği gönderin.

resp = client.chat.completions.create(
    model="GLM-4.7",
    messages=[{"role": "user", "content": "Say hello in Urdu and explain what you said."}],
    temperature=0.7,
)

print(resp.choices[0].message.content)Altyapı:

Model Urduca yanıt verir ve her kelimeyi net şekilde açıklar; bu da hem çok dilli anlayışı hem de akıl yürütme yeteneğini gösterir.

Ardından, sohbet arayüzleri gibi gerçek zamanlı uygulamalar için kritik olan akışlı çıkarımı test edin.

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="sk-no-key-required",
)

stream = client.chat.completions.create(
    model="GLM-4.7",
    messages=[
        {
            "role": "user",
            "content": "What makes ChatGPT so successful and popular, given that it's "just" a chatbot?"
        }
    ],
    temperature=0.7,
    stream=True,
)

for event in stream:
    choice = event.choices[0]
    if getattr(choice, "delta", None) and getattr(choice.delta, "content", None):
        text = choice.delta.content
        print(text, end="", flush=True)
        full_text.append(text)Altyapı:

Yanıt, token token sorunsuz şekilde akar; bu da GLM-4.7 ile llama.cpp akışının güvenilir çalıştığını doğrular. Üretilen yanıt tutarlı, iyi yapılandırılmış ve doğrudur; bu kurulum, üretim tarzı iş yükleri için uygundur.

Bu noktada GLM-4.7, hem web arayüzü hem de OpenAI uyumlu API üzerinden, optimize edilmiş ayarlarla tek bir H100 GPU üzerinde verimli şekilde çalışır durumdadır.

Son Düşünceler

llama.cpp son birkaç ayda hızla olgunlaştı; artık büyük dil modellerini çalıştırmak için Ollama ve diğer yerel sohbet uygulamalarının yerini tamamen alabilecek düzeye geldi. 

Yüksek derecede yapılandırılabilir ve hızlı bir çıkarım motoru, etkileşimli kullanım için terminal tabanlı bir CLI ve ChatGPT deneyimini yakından andıran yerleşik bir web arayüzü sunar. 

Ayrıca çalışma zamanı bayrakları ve arayüz ayarları aracılığıyla model davranışı üzerinde ince ayar kontrolü elde edersiniz; bu da donanımınıza göre performans ve kaliteyi ayarlamanıza olanak tanır.

Önemli bir çıkarım olarak, GLM-4.7’yi çalıştırmak için kurumsal donanıma ihtiyacınız yok. Yeterli sistem RAM’ı ve RTX 3090 gibi bir GPU ile, 2-bit GLM-4.7 modeli --fit on kullanılarak ve doğru llama.cpp optimizasyonları uygulanarak yerelde çalıştırılabilir. 

llama.cpp ekosisteminin büyük ve aktif bir topluluğu vardır; bu da belirli GPU’lar veya iş yükleri için optimize edilmiş yapılandırmalar ve ince ayar yaparken yardım bulmayı kolaylaştırır.

Bu eğitimde RunPod ortamını kurduk, CUDA desteğiyle llama.cpp’yi derledik, yüksek hızlı Hugging Face transferleriyle GLM-4.7 modelini indirdik ve modeli etkileşimli modda çalıştırdık. Ardından optimize edilmiş bir çıkarım sunucusu başlattık, web arayüzü üzerinden test ettik ve OpenAI uyumlu API’yi kullanarak programatik olarak doğruladık.

Sonuç, tek bir GPU üzerinde güçlü doğruluk ve gerçeğe yakın zamanlı çıkarım sunan tamamen yerel, yüksek performanslı bir GLM-4.7 dağıtımıdır. Bu kurulum; kontrol, performans ve şeffaflığın önemli olduğu denemeler, araştırmalar ve hatta üretim tarzı iş yükleri için uygundur.