LLMs uitvoeren met llama.cpp

Introductie

llama.cpp is een lichtgewicht, hoogwaardige C/C++ implementatie voor het uitvoeren van LLMs. Het maakt efficiënte LLM-inferentie mogelijk op consumentenhardware, inclusief ARM64-apparaten zoals NVIDIA Jetson. Het is de standaard geworden voor lokale LLM-inferentie vanwege de efficiëntie en brede formaatondersteuning.

Waar Ollama een gebruiksvriendelijke wrapper biedt rond llama.cpp, geeft het direct begrijpen van llama.cpp je:

Maximale controle over inferentieparameters
Beter begrip van hoe LLMs onder de motorkap werken
Mogelijkheid om te optimaliseren voor specifieke use cases
Ondersteuning voor aangepaste kwantisatieformaten

llama-cpp

Waarom llama.cpp?

Functie	Beschrijving
Puur C/C++	Geen zware afhankelijkheden, minimale footprint
Meerdere backends	CPU, CUDA, Metal, OpenCL, Vulkan ondersteuning
GGUF-formaat	Native ondersteuning voor gekwantiseerde modellen
Inbedbaar	Gemakkelijk te integreren in applicaties
CPU-fallback	Werkt zelfs zonder GPU
Streaming	Realtime token-streaming

Installatie op Jetson

Vereisten

Zorg ervoor dat de build-tools zijn geïnstalleerd:

bash

# Pakketlijst bijwerken
sudo apt-get update

# Build essentials installeren
sudo apt-get install -y build-essential git cmake

# CUDA-omgevingsvariabelen toevoegen aan .bashrc
echo '
# CUDA Environment
export CUDA_HOME=/usr/local/cuda
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
export CUDACXX=$CUDA_HOME/bin/nvcc
' >> ~/.bashrc

# Shell-configuratie opnieuw laden
source ~/.bashrc

# CUDA-installatie verifiëren
nvcc --version

llama.cpp klonen en bouwen

bash

# Repository klonen
cd ~
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Bouwen met CUDA-ondersteuning voor Jetson
#make -j$(nproc) GGML_CUDA=1

# Alternatief: CMake gebruiken
mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j$(nproc)

builded_llamacpp

Installatie verifiëren

bash

# Controleren of binaries zijn gebouwd
ls ~/llama.cpp/build/bin/llama-cli

# Versie testen
~/llama.cpp/build/bin/llama-cli --version

llama_v

Je eerste model verkrijgen

llama.cpp gebruikt het GGUF-formaat (GGML Universal Format) — een efficiënt binair formaat voor het opslaan van gekwantiseerde modellen.

Een model downloaden

bash

# Models-directory maken
mkdir -p ~/llama.cpp/models
cd ~/llama.cpp/models

# Llama 3.2 3B downloaden (Q4_K_M kwantisatie - 4-bit)
wget https://huggingface.co/bartowski/Llama-3.2-3B-Instruct-GGUF/resolve/main/Llama-3.2-3B-Instruct-Q4_K_M.gguf

# Of downloaden vanaf Hugging Face met curl
huggingface-cli download bartowski/Llama-3.2-3B-Instruct-GGUF Llama-3.2-3B-Instruct-Q4_K_M.gguf --local-dir ./models

GGUF-kwantisatie begrijpen

Kwantisatie	Bits	Bestandsgrootte	Kwaliteit	Snelheid
Q2_K	2-bit	Zeer klein	Lager	Snelste
Q3_K_M	3-bit	Klein	Acceptabel	Zeer snel
Q4_K_M	4-bit	Medium	Goed	Snel
Q5_K_M	5-bit	Medium-groot	Zeer goed	Matig
Q6_K	6-bit	Groot	Uitstekend	Langzamer
Q8_0	8-bit	Zeer groot	Nabij origineel	Langzaamste

Voor Jetson-apparaten:

Orin Nano 4GB: Gebruik Q2_K of Q3_K_M
Orin Nano 8GB: Gebruik Q3_K_M of Q4_K_M
Orin NX 16GB+: Gebruik Q4_K_M of Q5_K_M

Aanbevolen modellen voor Jetson

bash

# Qwen3 4B downloaden (uitstekende multilinguale ondersteuning)
wget https://huggingface.co/bartowski/Qwen3-4B-Instruct-GGUF/resolve/main/Qwen3-4B-Instruct-Q4_K_M.gguf

# DeepSeek-R1 1.5B downloaden (gedistilleerd reasoning-model)
wget https://huggingface.co/bartowski/DeepSeek-R1-Distill-Qwen-1.5B-GGUF/resolve/main/DeepSeek-R1-Distill-Qwen-1.5B-Q4_K_M.gguf

# Gemma3 4B downloaden
wget https://huggingface.co/bartowski/gemma-3-4b-it-GGUF/resolve/main/gemma-3-4b-it-Q4_K_M.gguf

Basisgebruik

Eenvoudige tekstgeneratie

bash

cd ~/llama.cpp

# Basale inferentie
./build/bin/llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -p "The future of edge AI is"

Chat-modus (conversatieel)

bash

# Interactieve chat-sessie starten
./build/bin/llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -cnv \
  --chat-template llama3

Opmerking: De -cnv vlag schakelt conversatiemodus in, en --chat-template specificeert hoe het gesprek moet worden opgemaakt.

Veelgebruikte llama-cli vlaggen

Vlag	Beschrijving	Voorbeeld
`-m, --model`	Modelbestandspad	`-m models/model.gguf`
`-p, --prompt`	Initiële prompt	`-p "Hello world"`
`-cnv`	Conversatiemodus	`-cnv`
`-n, --n-predict`	Aantal tokens om te genereren	`-n 256`
`-c, --ctx-size`	Contextgrootte (in tokens)	`-c 4096`
`--temp`	Temperatuur (creativiteit)	`--temp 0.7`
`--top-p`	Nucleus-sampling	`--top-p 0.9`
`-ngl, --n-gpu-layers`	GPU-lagen om af te laden	`-ngl 35`
`-t, --threads`	Aantal CPU-threads	`-t 4`

Optimaliseren voor Jetson GPU

GPU-offloading

Het afladen van modellagen naar de GPU verbetert de prestaties dramatisch:

bash

# Optimale GPU-lagen bepalen
# Begin met -ngl 999 (alle lagen afladen)
./build/bin/llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -p "Explain quantum computing" \
  -ngl 35 \
  -n 256

Tip: Gebruik -ngl 999 om automatisch alle mogelijke lagen naar de GPU af te laden.

Prestaties meten

bash

# Uitvoeren met prestatiestatistieken
./build/bin/llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -p "What is the capital of France?" \
  -n 50 \
  -ngl 35 \
  --perf

llamacpp_test

Belangrijke metric: eval time per token moet onder 100ms liggen voor goede realtime-prestaties.

Geavanceerde functies

De API-server uitvoeren

llama.cpp bevat een servermodus voor REST API-toegang:

bash

# Server starten
./llama-server \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  --host 0.0.0.0 \
  --port 8000 \
  -ngl 35 \
  -c 4096

Toegang tot de server:

bash

# Eenvoudige query
curl -X POST http://localhost:8000/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Once upon a time",
    "n_predict": 100
  }'

# Chat-completion
curl -X POST http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is machine learning?"}
    ],
    "max_tokens": 256
  }'

Systeemprompts

Het gedrag van het model instellen met systeemprompts:

bash

./llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -p "You are a helpful coding assistant. Explain Python list comprehensions." \
  --system "You are an expert Python programmer. Provide concise, practical code examples."

Batchverwerking

Meerdere prompts efficiënt verwerken:

python

# batch_inference.py
import subprocess
import json

prompts = [
    "Explain neural networks",
    "What is GPU acceleration?",
    "Describe edge computing"
]

model_path = "~/llama.cpp/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf"

for prompt in prompts:
    result = subprocess.run(
        ["./llama-cli", "-m", model_path, "-p", prompt, "-n", "100", "--temp", "0.7"],
        capture_output=True,
        text=True
    )
    print(f"Prompt: {prompt}")
    print(f"Response: {result.stdout}\n")

Modellen naar GGUF converteren

Als je een model hebt in Hugging Face-formaat (PyTorch/SafeTensors), kun je het naar GGUF converteren:

bash

cd ~/llama.cpp

# Python-vereisten installeren
pip install -r requirements.txt

# Hugging Face-model naar GGUF converteren
python convert_hf_to_gguf.py \
  /path/to/model \
  --outfile output-model.gguf \
  --outtype q4_k_m

Beschikbare uitvoertypen:

f16: 16-bit float (geen kwantisatie)
q8_0: 8-bit kwantisatie
q6_k: 6-bit kwantisatie
q5_k_m: 5-bit kwantisatie
q4_k_m: 4-bit kwantisatie (aanbevolen balans)
q3_k_m: 3-bit kwantisatie
q2_k: 2-bit kwantisatie (meest gecomprimeerd)

Integratievoorbeelden

Python-binding

bash

# Python-bindings installeren
pip install llama-cpp-python

# Voor CUDA-ondersteuning (Jetson)
CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir

python

from llama_cpp import Llama

# Model laden
llm = Llama(
    model_path="/path/to/model-Q4_K_M.gguf",
    n_gpu_layers=35,
    n_ctx=4096
)

# Tekst genereren
output = llm(
    "Q: What is the capital of France?\nA:",
    max_tokens=50,
    temperature=0.7
)
print(output["choices"][0]["text"])

# Chat-completion
output = llm.create_chat_completion(
    messages=[
        {"role": "user", "content": "Tell me a joke"}
    ],
    max_tokens=100
)
print(output["choices"][0]["message"]["content"])

Prestatie-benchmarking

Jetson-specifieke optimalisaties

bash

# Optimale instellingen voor Jetson Orin Nano 8GB
./llama-cli \
  -m models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -p "Explain transformers in machine learning" \
  -ngl 35 \
  -t 6 \
  -c 4096 \
  -n 200 \
  --temp 0.7

Benchmark-script

bash

#!/bin/bash
# benchmark.sh

MODEL="models/Llama-3.2-3B-Instruct-Q4_K_M.gguf"
PROMPT="Explain the concept of artificial intelligence and its applications."

echo "Benchmarking llama.cpp on Jetson"
echo "Model: $MODEL"
echo "Prompt: $PROMPT"
echo ""

for gpu_layers in 0 10 20 30 35; do
    echo "Testing with $gpu_layers GPU layers..."
    timeout 120 ./llama-cli \
        -m $MODEL \
        -p "$PROMPT" \
        -ngl $gpu_layers \
        -n 100 \
        --per-test 2>&1 | grep "eval time"
done

Veelvoorkomende problemen en oplossingen

Probleem 1: CUDA niet gedetecteerd

Probleem: GPU-offloading werkt niet

Oplossing:

bash

# Opnieuw bouwen met CUDA
make clean
make -j$(nproc) GGML_CUDA=1

# CUDA-installatie verifiëren
nvidia-smi
nvcc --version

Probleem 2: Onvoldoende geheugen

Probleem: Model laden mislukt met OOM

Oplossing:

bash

# GPU-lagen reduceren
./llama-cli -m model.gguf -ngl 10  # In plaats van -ngl 35

# Kleinere context gebruiken
./llama-cli -m model.gguf -c 2048  # In plaats van standaard 4096

# Aggressievere kwantisatie gebruiken
# Overschakelen van Q5_K_M naar Q4_K_M of Q3_K_M

Probleem 3: Trage CPU-only prestaties

Probleem: Generatie te langzaam zonder GPU

Oplossing:

bash

# Meer threads inschakelen
./llama-cli -m model.gguf -t 8  # 8 CPU-threads gebruiken

# Kleiner model of agressievere kwantisatie gebruiken

# Zorgen dat CPU-governor op performance staat
sudo apt-get install cpufrequtils
sudo cpufreq-set -g performance

Oefening

Voltooi deze taken:

llama.cpp bouwen met CUDA-ondersteuning
3 verschillende modellen downloaden en hun groottes vergelijken
Inferentie uitvoeren op elk model met -ngl 35
Prestaties meten met de --perf vlag
Server starten en API-verzoeken testen
Een Python-script maken dat 5 verschillende prompts batch-verwerkt

Referenties

llama.cpp GitHub
GGUF-formaatspecificatie
TheBloke's GGUF-modellen - Voor-geconverteerde modellen
bartowski's GGUF-modellen - Bijgewerkte modelconversies
Jetson AI Lab - NVIDIA's Jetson-bronnen

Volgende: Ga verder naar Module 5.4: High-Performance Inferentie met vLLM voor productie-klasse LLM serving!

PreviousAan de slag met Ollama

NextHoge prestaties inferentie met vLLM