Download Kimi K2.5: Panduan Lengkap Setup dan Instalasi Lokal

Persyaratan Penyimpanan Lokal Kimi K2.5 (referensi perencanaan):
┌─────────────────────────────────────────────────────┐
│ File checkpoint resmi:         ~2,000 GB            │
│ Cache runtime/file sementara: 100-300 GB            │
│ Log dan buffer deployment:    100-300 GB            │
├─────────────────────────────────────────────────────┤
│ Total full-precision:       ~2,200+ GB              │
│ Setup terkuantisasi/komunitas: 600+ GB             │
└─────────────────────────────────────────────────────┘

# Perhitungan memori GPU untuk Kimi K2.5
class GPUMemoryCalculator:
    def __init__(self):
        self.model_params = 1e12  # 1 triliun
        self.bytes_per_param = 2   # FP16
        self.activation_factor = 4  # Overhead aktivasi
    
    def calculate_required_memory(self, batch_size=1, seq_length=128000):
        # Bobot model
        model_memory = self.model_params * self.bytes_per_param / (1024**3)  # GB
        
        # Aktivasi untuk sekuens
        activation_memory = (
            batch_size * seq_length * self.activation_factor / (1024**3)
        )
        
        # KV cache untuk konteks 128K
        kv_cache_per_layer = 128 * seq_length * 2 / (1024**3)  # GB
        total_kv_cache = kv_cache_per_layer * 96  # 96 layer
        
        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  # margin 20%
        return max(2, int(num_gpus))

# Instal Hugging Face CLI
pip install huggingface-cli

# Login (membutuhkan autentikasi)
huggingface-cli login

# Unduh bobot Kimi K2.5
# Catatan: Membutuhkan persetujuan ketentuan lisensi di Hugging Face
huggingface-cli download moonshotai/Kimi-K2.5 \
  --local-dir ./kimi-k2-5 \
  --local-dir-use-symlinks False

# Instal Git LFS
git lfs install

# Kloning repositori
git clone https://huggingface.co/moonshotai/Kimi-K2.5
cd Kimi-K2.5

# Tarik file LFS (bobot model besar)
git lfs pull

# Skrip Python untuk mengunduh shard model
import requests
from tqdm import tqdm
import os

def download_kimi_weights(output_dir="./kimi-k2-5"):
    """Unduh bobot model Kimi K2.5"""
    
    base_url = "https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main"
    
    files = [
        "config.json",
        "tokenizer.json",
        "model.safetensors.index.json",
        # Shard akan terdaftar di index.json
    ]
    
    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"Diunduh ke {output_dir}")
    print("Catatan: Checkpoint full-precision resmi kira-kira berada di kelas 2TB")

# Instal Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Tarik entry cloud Kimi K2.5
ollama pull kimi-k2.5:cloud

# Jalankan melalui Ollama
ollama run kimi-k2.5:cloud

# Uji model
>>> What is the capital of France?
The capital of France is Paris.

# Catatan: Entry Ollama ini menggunakan inferensi cloud dan tidak mengunduh bobot lokal lengkap.

# Instal vLLM
pip install vllm

# Unduh dan jalankan Kimi K2.5
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

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

WORKDIR /app

# Instal dependensi
RUN apt-get update && apt-get install -y \
    python3-pip \
    git \
    git-lfs \
    && rm -rf /var/lib/apt/lists/*

# Instal paket Python
RUN pip install torch transformers accelerate vllm

# Unduh model (atau pasang sebagai volume)
RUN git lfs install && \
    git clone https://huggingface.co/moonshotai/Kimi-K2.5 /models/kimi-k2-5

# Ekspos port API
EXPOSE 8000

# Jalankan server
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

# Build dan jalankan
docker build -t kimi-k2-5 .
docker run --gpus all -p 8000:8000 -v /path/to/models:/models kimi-k2-5

# Inferensi langsung dengan Transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Muat tokenizer
tokenizer = AutoTokenizer.from_pretrained(
    "moonshotai/Kimi-K2.5",
    trust_remote_code=True
)

# Muat model (membutuhkan memori GPU yang besar)
model = AutoModelForCausalLM.from_pretrained(
    "moonshotai/Kimi-K2.5",
    torch_dtype=torch.float16,
    device_map="auto",  # Otomatis mendistribusikan ke seluruh GPU
    trust_remote_code=True
)

# Hasilkan teks
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)

# Server FastAPI untuk Kimi K2.5
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")

# Model dan tokenizer global
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("Memuat Kimi K2.5... Ini mungkin memakan waktu beberapa menit.")
    
    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 berhasil dimuat!")

@app.post("/v1/chat/completions")
async def chat_completion(request: ChatRequest):
    # Format pesan
    prompt = tokenizer.apply_chat_template(
        request.messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    # Tokenisasi
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    # Hasilkan
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=request.max_tokens,
            temperature=request.temperature,
            do_sample=True
        )
    
    # Dekode
    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)

# Build GGUF dikelola oleh komunitas (repo resmi Moonshot menyediakan checkpoint asli)
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

# Jalankan dengan llama.cpp
./main -m ./models/kimi-k2-5-Q4_K_M.gguf \
  -c 32768 \
  -n 512 \
  -p "Hello, my name is"

# Menggunakan AWQ untuk kuantisasi 4-bit
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}

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

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

# Simpan
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

Berdasarkan asumsi di atas, deployment lokal mencapai titik impas pada:
- ~46M token/bulan (rata-rata tertimbang input + output)
- ~18 bulan pada 100M token/bulan
- ~36 bulan pada 50M token/bulan

# Solusi untuk error OOM

# 1. Kurangi ukuran batch
model.generate(**inputs, batch_size=1)

# 2. Aktifkan gradient checkpointing (untuk training)
model.gradient_checkpointing_enable()

# 3. Gunakan CPU offloading
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. Kurangi panjang konteks
max_length = 65536  # Sebagai ganti 128000

# Teknik optimasi

# 1. Gunakan Flash Attention
from transformers import AutoModelForCausalLM

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

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

# 3. Gunakan speculative decoding
from transformers import SpeculativeDecoding

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

# Autentikasi API key
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)
):
    # Proses permintaan
    pass