LLM Inference
& Quantization.

import numpy as np

def quantize_asymmetric(x: np.ndarray, n_bits: int = 8):
    """Asimetrik quantization: scale + zero_point hesapla."""
    x_min, x_max = x.min(), x.max()
    q_min, q_max = 0, 2**n_bits - 1      # int8: 0..255

    scale = (x_max - x_min) / (q_max - q_min)
    zero_point = round(q_min - x_min / scale)
    zero_point = int(np.clip(zero_point, q_min, q_max))

    x_q = np.clip(np.round(x / scale + zero_point), q_min, q_max).astype(np.uint8)
    return x_q, scale, zero_point

def dequantize(x_q: np.ndarray, scale: float, zero_point: int):
    """Quantize edilmiş değeri geri float'a çevir."""
    return scale * (x_q.astype(np.float32) - zero_point)

# Örnek kullanım
weights = np.random.randn(1000).astype(np.float32)
w_q, s, z = quantize_asymmetric(weights)
w_reconstructed = dequantize(w_q, s, z)

error = np.abs(weights - w_reconstructed).mean()
print(f"Ortalama mutlak hata: {error:.6f}")  # ~0.001

# pip install auto-gptq transformers accelerate
from auto_gptq import AutoGPTQForCausalLM
from transformers import AutoTokenizer

model_name = "TheBloke/Llama-2-7B-GPTQ"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    use_safetensors=True,
    device="cuda:0",
    inject_fused_attention=False,
    bits=4,
    group_size=128,
)

prompt = "Yapay zeka nedir?"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda:0")

output = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True,
)
print(tokenizer.decode(output[0], skip_special_tokens=True))

from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer
import torch

pretrained_model_name = "meta-llama/Llama-3.1-8B"
quantized_model_dir = "./llama-3.1-8b-gptq-4bit"

# Quantization konfigürasyonu
quantize_config = BaseQuantizeConfig(
    bits=4,           # 4-bit quantization
    group_size=128,   # 128 ağırlık başına bir scale
    desc_act=False,   # activation ordering (kaliteyi artırır ama yavaşlatır)
)

tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name)
model = AutoGPTQForCausalLM.from_pretrained(
    pretrained_model_name, quantize_config
)

# Kalibrasyon verisi — model kalibrasyon için bu örneklere bakacak
examples = [
    tokenizer("Transformer mimarisi attention mekanizmasını kullanır.",
              return_tensors="pt"),
    tokenizer("Python programlama dili veri biliminde yaygın kullanılır.",
              return_tensors="pt"),
    # ... daha fazla örnek ekleyin (~128 öneri)
]

model.quantize(examples)
model.save_quantized(quantized_model_dir, use_safetensors=True)
tokenizer.save_pretrained(quantized_model_dir)
print(f"Model kaydedildi: {quantized_model_dir}")

# pip install autoawq transformers
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_name = "TheBloke/Llama-2-7B-AWQ"

tokenizer = AutoTokenizer.from_pretrained(
    model_name, trust_remote_code=True
)
model = AutoAWQForCausalLM.from_quantized(
    model_name,
    fuse_layers=True,      # kernel fusion → daha hızlı inference
    trust_remote_code=True,
    safetensors=True,
)

# Basit metin üretimi
prompt = "[INST] Makine öğrenmesini kısaca açıkla. [/INST]"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        do_sample=True,
        temperature=0.8,
        top_p=0.95,
    )

response = tokenizer.decode(
    outputs[0][inputs["input_ids"].shape[1]:],
    skip_special_tokens=True
)
print(response)

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "meta-llama/Llama-3.1-8B-Instruct"
quant_path = "./llama-3.1-8b-awq"

quant_config = {
    "zero_point": True,   # asymmetric quantization
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM",     # GEMM veya GEMV (düşük batch için GEMV)
}

model = AutoAWQForCausalLM.from_pretrained(
    model_path, low_cpu_mem_usage=True
)
tokenizer = AutoTokenizer.from_pretrained(
    model_path, trust_remote_code=True
)

model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

# pip install huggingface_hub
huggingface-cli download \
    TheBloke/Llama-2-7B-Chat-GGUF \
    llama-2-7b-chat.Q4_K_M.gguf \
    --local-dir ./models \
    --local-dir-use-symlinks False

from huggingface_hub import hf_hub_download

model_path = hf_hub_download(
    repo_id="bartowski/Llama-3.2-3B-Instruct-GGUF",
    filename="Llama-3.2-3B-Instruct-Q4_K_M.gguf",
    local_dir="./models",
)
print(f"İndirildi: {model_path}")

# Kaynak kodu indir
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# CPU-only derleme
cmake -B build
cmake --build build --config Release -j $(nproc)

# CUDA ile derleme
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j $(nproc)

# macOS Metal ile derleme
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j $(nproc)

# Tek seferlik sorgu
./build/bin/llama-cli \
    -m ./models/llama-3.2-3b-q4_k_m.gguf \
    -p "Transformer mimarisi nedir?" \
    -n 200 \      # max token sayısı
    --threads 8   # CPU thread sayısı

# İnteraktif sohbet modu
./build/bin/llama-cli \
    -m ./models/llama-3.2-3b-q4_k_m.gguf \
    -i \               # interactive mode
    -c 4096 \         # context window
    --threads 8 \
    --temp 0.7 \      # temperature
    --top-p 0.9 \    # nucleus sampling
    --top-k 40       # top-k sampling

# pip install llama-cpp-python
# CUDA: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python
from llama_cpp import Llama

llm = Llama(
    model_path="./models/llama-3.2-3b-q4_k_m.gguf",
    n_ctx=4096,         # context window uzunluğu
    n_threads=8,        # CPU thread sayısı (fiziksel çekirdek)
    n_gpu_layers=0,     # GPU'ya yüklenen katman: 0=CPU-only, -1=tümü
    verbose=False,
)

# Basit tamamlama
output = llm(
    "Makine öğrenmesi nedir? Kısaca açıkla:",
    max_tokens=256,
    temperature=0.7,
    top_p=0.9,
    top_k=40,
    stop=["\n\n", "###"],
    echo=False,
)
print(output["choices"][0]["text"])

# Chat completion (OpenAI uyumlu)
response = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "Sen yardımcı bir asistansın."},
        {"role": "user", "content": "Türkiye'nin başkenti neresidir?"},
    ],
    temperature=0.1,
    max_tokens=128,
)
print(response["choices"][0]["message"]["content"])

llm = Llama(
    model_path="./models/llama-3.1-8b-q4_k_m.gguf",
    n_ctx=2048,
    n_threads=6,
    n_gpu_layers=20,   # 20 katman GPU'ya (RTX 3060 8GB için uygun)
    n_batch=512,        # prompt işleme batch boyutu
)

# Linux/macOS kurulumu
curl -fsSL https://ollama.com/install.sh | sh

# Model indir ve çalıştır
ollama pull llama3.2
ollama run llama3.2

# Diğer faydalı komutlar
ollama list                   # indirilen modelleri listele
ollama show llama3.2          # model bilgilerini göster
ollama rm llama3.2             # modeli sil
ollama ps                     # çalışan modelleri listele
ollama serve                  # sunucuyu manuel başlat (genelde otomatik)

# Generate endpoint
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Yapay zeka nedir?",
  "stream": false
}'

# Chat endpoint (OpenAI uyumlu)
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2",
    "messages": [{"role": "user", "content": "Merhaba!"}]
  }'

# Temel model
FROM llama3.2

# Sistem prompt'u
SYSTEM """Sen Türkçe konuşan, yardımsever bir teknik asistansın.
Cevaplarında her zaman kod örnekleri ver ve açık bir dil kullan."""

# Parametreler
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 4096

# Sohbet şablonu (opsiyonel)
TEMPLATE """<|system|>
<|end|>
<|user|>
<|end|>
<|assistant|>
<|end|>"""

# Modelfile'dan özel model oluştur
ollama create teknik-asistan -f ./Modelfile
ollama run teknik-asistan

# pip install ollama
import ollama

# Basit sorgu
response = ollama.chat(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "Python'da decorators ne işe yarar?"}
    ]
)
print(response["message"]["content"])

# Streaming yanıt
for chunk in ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Fibonacci serisini açıkla"}],
    stream=True,
):
    print(chunk["message"]["content"], end="", flush=True)

# OpenAI uyumlu istemci ile
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",   # herhangi bir değer olabilir
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Merhaba!"}],
)
print(response.choices[0].message.content)

# pip install flash-attn --no-build-isolation
# (CUDA 11.8+ ve PyTorch 2.0+ gerektirir)
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "meta-llama/Llama-3.1-8B-Instruct"

# Flash Attention 2 ile model yükle
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",   # anahtar parametre
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Bellek kullanımını karşılaştır
def measure_memory(model, prompt, max_new_tokens=100):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    torch.cuda.reset_peak_memory_stats()
    _ = model.generate(**inputs, max_new_tokens=max_new_tokens)
    peak_mem = torch.cuda.max_memory_allocated() / 1e9
    return peak_mem

mem = measure_memory(model, "Transformer nedir?")
print(f"Peak memory (Flash Attn 2): {mem:.2f} GB")

# pip install vllm
# OpenAI uyumlu API sunucusu başlat
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --dtype bfloat16 \
    --max-model-len 8192 \
    --tensor-parallel-size 1 \      # GPU sayısı
    --gpu-memory-utilization 0.90 \ # VRAM kullanım oranı
    --port 8000

from openai import OpenAI

# vLLM OpenAI uyumlu endpoint
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="vllm",
)

response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "Sen yardımcı bir asistansın."},
        {"role": "user", "content": "Attention mekanizmasını açıkla."},
    ],
    max_tokens=512,
    temperature=0.7,
)
print(response.choices[0].message.content)

# Toplu istek örneği (throughput testi)
import time

prompts = [
    "Python nedir?",
    "Makine öğrenmesi nedir?",
    "Transformer ne anlama gelir?",
    "GPU neden AI için önemlidir?",
]

start = time.time()
responses = []
for p in prompts:
    r = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[{"role": "user", "content": p}],
        max_tokens=128,
    )
    responses.append(r)

elapsed = time.time() - start
total_tokens = sum(r.usage.completion_tokens for r in responses)
print(f"Toplam: {total_tokens} token | Süre: {elapsed:.2f}s | Throughput: {total_tokens/elapsed:.1f} tok/s")