Kimi K2.5 İndirme: Eksiksiz Yerel Kurulum ve Yükleme Rehberi

Kimi K2.5 Yerel Depolama Gereksinimleri (planlama referansı):
┌─────────────────────────────────────────────────────┐
│ Resmi checkpoint dosyaları:    ~2,000 GB            │
│ Çalışma önbelleği/geçici:     100-300 GB            │
│ Günlükler ve dağıtım payı:    100-300 GB            │
├─────────────────────────────────────────────────────┤
│ Tam hassasiyet toplamı:     ~2,200+ GB              │
│ Nicelenmiş/topluluk kurulumu:  600+ GB             │
└─────────────────────────────────────────────────────┘

# Kimi K2.5 için GPU bellek hesaplaması
class GPUMemoryCalculator:
    def __init__(self):
        self.model_params = 1e12  # 1 trilyon
        self.bytes_per_param = 2   # FP16
        self.activation_factor = 4  # Aktivasyon ek yükü
    
    def calculate_required_memory(self, batch_size=1, seq_length=128000):
        # Model ağırlıkları
        model_memory = self.model_params * self.bytes_per_param / (1024**3)  # GB
        
        # Sekans için aktivasyonlar
        activation_memory = (
            batch_size * seq_length * self.activation_factor / (1024**3)
        )
        
        # 128K bağlam için KV cache
        kv_cache_per_layer = 128 * seq_length * 2 / (1024**3)  # GB
        total_kv_cache = kv_cache_per_layer * 96  # 96 katman
        
        total = model_memory + activation_memory + total_kv_cache
        
        return {
            "model_weights_gb": model_memory,
            "activations_gb": activation_memory,
            "kv_cache_gb": total_kv_cache,
            "total_gb": total,
            "recommended_gpus": self._recommend_gpus(total)
        }
    
    def _recommend_gpus(self, total_memory_gb):
        a100_80gb = 80
        num_gpus = (total_memory_gb / a100_80gb) * 1.2  # %20 pay
        return max(2, int(num_gpus))

# Hugging Face CLI'yi yükle
pip install huggingface-cli

# Giriş yap (kimlik doğrulama gerektirir)
huggingface-cli login

# Kimi K2.5 ağırlıklarını indir
# Not: Hugging Face üzerinde lisans koşullarının kabul edilmesini gerektirir
huggingface-cli download moonshotai/Kimi-K2.5 \
  --local-dir ./kimi-k2-5 \
  --local-dir-use-symlinks False

# Git LFS'yi yükle
git lfs install

# Depoyu klonla
git clone https://huggingface.co/moonshotai/Kimi-K2.5
cd Kimi-K2.5

# LFS dosyalarını çek (büyük model ağırlıkları)
git lfs pull

# Model parçalarını indirmek için Python betiği
import requests
from tqdm import tqdm
import os

def download_kimi_weights(output_dir="./kimi-k2-5"):
    """Kimi K2.5 model ağırlıklarını indir"""
    
    base_url = "https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main"
    
    files = [
        "config.json",
        "tokenizer.json",
        "model.safetensors.index.json",
        # Parçalar index.json içinde listelenecek
    ]
    
    os.makedirs(output_dir, exist_ok=True)
    
    for file in files:
        url = f"{base_url}/{file}"
        response = requests.get(url, stream=True)
        
        total_size = int(response.headers.get('content-length', 0))
        
        with open(os.path.join(output_dir, file), 'wb') as f:
            with tqdm(total=total_size, unit='B', unit_scale=True, desc=file) as pbar:
                for chunk in response.iter_content(chunk_size=8192):
                    if chunk:
                        f.write(chunk)
                        pbar.update(len(chunk))
    
    print(f"{output_dir} konumuna indirildi")
    print("Not: Resmi tam hassasiyetli checkpoint'ler kabaca 2TB sınıfındadır")

# Ollama'yı yükle
curl -fsSL https://ollama.com/install.sh | sh

# Kimi K2.5 bulut girişini çek
ollama pull kimi-k2.5:cloud

# Ollama üzerinden çalıştır
ollama run kimi-k2.5:cloud

# Modeli test et
>>> What is the capital of France?
The capital of France is Paris.

# Not: Bu Ollama girişi bulut çıkarımı kullanır ve tam yerel ağırlıkları indirmez.

# vLLM'yi yükle
pip install vllm

# Kimi K2.5'i indir ve çalıştır
python -m vllm.entrypoints.openai.api_server \
  --model moonshotai/Kimi-K2.5 \
  --tensor-parallel-size 4 \
  --pipeline-parallel-size 2 \
  --max-model-len 128000 \
  --gpu-memory-utilization 0.95 \
  --port 8000

# Kimi K2.5 için Dockerfile
FROM nvidia/cuda:12.1-devel-ubuntu22.04

WORKDIR /app

# Bağımlılıkları yükle
RUN apt-get update && apt-get install -y \
    python3-pip \
    git \
    git-lfs \
    && rm -rf /var/lib/apt/lists/*

# Python paketlerini yükle
RUN pip install torch transformers accelerate vllm

# Modeli indir (veya volume olarak bağla)
RUN git lfs install && \
    git clone https://huggingface.co/moonshotai/Kimi-K2.5 /models/kimi-k2-5

# API portunu aç
EXPOSE 8000

# Sunucuyu başlat
CMD python -m vllm.entrypoints.openai.api_server \
    --model /models/kimi-k2-5 \
    --tensor-parallel-size 4 \
    --max-model-len 128000 \
    --host 0.0.0.0 \
    --port 8000

# Derle ve çalıştır
docker build -t kimi-k2-5 .
docker run --gpus all -p 8000:8000 -v /path/to/models:/models kimi-k2-5

# Transformers ile doğrudan çıkarım
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Tokenizer'ı yükle
tokenizer = AutoTokenizer.from_pretrained(
    "moonshotai/Kimi-K2.5",
    trust_remote_code=True
)

# Modeli yükle (önemli ölçüde GPU belleği gerektirir)
model = AutoModelForCausalLM.from_pretrained(
    "moonshotai/Kimi-K2.5",
    torch_dtype=torch.float16,
    device_map="auto",  # GPU'lar arasında otomatik dağıtır
    trust_remote_code=True
)

# Metin üret
inputs = tokenizer("Hello, how are you?", return_tensors="pt")
outputs = model.generate(
    **inputs,
    max_new_tokens=100,
    temperature=0.7
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

# Kimi K2.5 için FastAPI sunucusu
from fastapi import FastAPI
from pydantic import BaseModel
from typing import List, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

app = FastAPI(title="Kimi K2.5 Local API")

# Global model ve tokenizer
model = None
tokenizer = None

class ChatMessage(BaseModel):
    role: str
    content: str

class ChatRequest(BaseModel):
    model: str
    messages: List[ChatMessage]
    temperature: Optional[float] = 0.7
    max_tokens: Optional[int] = 1024

@app.on_event("startup")
async def load_model():
    global model, tokenizer
    
    print("Kimi K2.5 yükleniyor... Bu birkaç dakika sürebilir.")
    
    tokenizer = AutoTokenizer.from_pretrained(
        "moonshotai/Kimi-K2.5",
        trust_remote_code=True
    )
    
    model = AutoModelForCausalLM.from_pretrained(
        "moonshotai/Kimi-K2.5",
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True
    )
    
    print("Model başarıyla yüklendi!")

@app.post("/v1/chat/completions")
async def chat_completion(request: ChatRequest):
    # Mesajları biçimlendir
    prompt = tokenizer.apply_chat_template(
        request.messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    # Tokenleştir
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    # Üret
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=request.max_tokens,
            temperature=request.temperature,
            do_sample=True
        )
    
    # Çöz
    response_text = tokenizer.decode(
        outputs[0][inputs.input_ids.shape[1]:],
        skip_special_tokens=True
    )
    
    return {
        "id": "chatcmpl-local",
        "object": "chat.completion",
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {
                "role": "assistant",
                "content": response_text
            }
        }]
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

# GGUF derlemeleri topluluk tarafından sürdürülür (Moonshot'un resmi deposu orijinal checkpoint'leri sunar)
COMMUNITY_REPO="<community-org>/Kimi-K2.5-GGUF"
GGUF_FILE="kimi-k2-5-Q4_K_M.gguf"
huggingface-cli download ${COMMUNITY_REPO} ${GGUF_FILE} --local-dir ./models

# llama.cpp ile çalıştır
./main -m ./models/kimi-k2-5-Q4_K_M.gguf \
  -c 32768 \
  -n 512 \
  -p "Hello, my name is"

# 4-bit niceleme için AWQ kullanımı
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "moonshotai/Kimi-K2.5"
quant_path = "kimi-k2-5-awq"
quant_config = {"zero_point": True, "q_group_size": 128, "w_bit": 4}

# Modeli yükle
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# Nicele
model.quantize(tokenizer, quant_config=quant_config)

# Kaydet
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

# kimi-k2-5-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kimi-k2-5
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kimi-k2-5
  template:
    metadata:
      labels:
        app: kimi-k2-5
    spec:
      nodeSelector:
        node-type: gpu-a100
      containers:
      - name: kimi-k2-5
        image: your-registry/kimi-k2-5:latest
        ports:
        - containerPort: 8000
        resources:
          limits:
            nvidia.com/gpu: 4
          requests:
            nvidia.com/gpu: 4
        volumeMounts:
        - name: model-storage
          mountPath: /models
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: kimi-model-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: kimi-k2-5-service
spec:
  selector:
    app: kimi-k2-5
  ports:
  - port: 8000
    targetPort: 8000
  type: LoadBalancer

Yukarıdaki varsayımlara göre, yerel dağıtım şu noktada başabaşa ulaşır:
- ~46M token/ay (giriş + çıkış ağırlıklı ortalama)
- 100M token/ay durumunda ~18 ay
- 50M token/ay durumunda ~36 ay

# OOM hataları için çözümler

# 1. Batch boyutunu azalt
model.generate(**inputs, batch_size=1)

# 2. Gradient checkpointing'i etkinleştir (training için)
model.gradient_checkpointing_enable()

# 3. CPU offloading kullan
from accelerate import load_checkpoint_and_dispatch

model = load_checkpoint_and_dispatch(
    model,
    checkpoint="moonshotai/Kimi-K2.5",
    device_map="auto",
    offload_folder="offload"
)

# 4. Bağlam uzunluğunu azalt
max_length = 65536  # 128000 yerine

# Optimizasyon teknikleri

# 1. Flash Attention kullan
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "moonshotai/Kimi-K2.5",
    attn_implementation="flash_attention_2",
    torch_dtype=torch.float16
)

# 2. Modeli derle (PyTorch 2.0+)
model = torch.compile(model)

# 3. Speculative decoding kullan
from transformers import SpeculativeDecoding

speculator = SpeculativeDecoding(
    draft_model="small-draft-model",
    target_model=model
)

# API key kimlik doğrulaması
from fastapi import Security, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

security = HTTPBearer()

API_KEYS = {"your-secure-api-key-here": "admin"}

async def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
    token = credentials.credentials
    if token not in API_KEYS:
        raise HTTPException(status_code=401, detail="Invalid API key")
    return API_KEYS[token]

@app.post("/v1/chat/completions")
async def chat_completion(
    request: ChatRequest,
    user: str = Security(verify_token)
):
    # İsteği işle
    pass