Kimi K2.5 开源指南：许可证、模型权重与本地部署详解

特此免费授予任何获得本模型副本和相关文档文件（"模型"）的人
无限制地处理本模型，包括但不限于使用、复制、修改、合并的权利
发布、分发、再许可和/或销售模型副本，但须遵守以下条件：

1. 如果您的产品/服务超过1亿月活用户
   或月收入超过2000万美元，则必须在所有面向用户的产品/服务中
   显著展示“Kimi K2.5”。

2. 仍需遵守标准 MIT 风格的版权与许可声明义务。

from huggingface_hub import snapshot_download

# 下载完整模型
model_path = snapshot_download(
    repo_id="moonshotai/Kimi-K2.5",
    local_dir="./kimi-k2-5",
    local_dir_use_symlinks=False,
    resume_download=True
)

# 安装 Git LFS
git lfs install

# 克隆仓库
git clone https://huggingface.co/moonshotai/Kimi-K2.5.git

# 或稀疏检出特定文件
git clone --filter=blob:none https://huggingface.co/moonshotai/Kimi-K2.5.git

# 下载特定文件
wget https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main/config.json
wget https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main/model.safetensors.index.json

kimi-k2-5/
├── config.json              # 模型配置
├── tokenizer.json           # 分词器词汇表
├── tokenizer_config.json    # 分词器设置
├── model.safetensors.index.json  # 权重索引
├── model-00001-of-000064.safetensors  # 分片1
├── model-00002-of-000064.safetensors  # 分片2
├── ...
├── model-00064-of-000064.safetensors  # 分片64
├── generation_config.json   # 生成默认配置
└── LICENSE                  # 许可证文件

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型
model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",  # 本地路径
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained(
    "./kimi-k2-5",
    trust_remote_code=True
)

# 推理
inputs = tokenizer("你好，Kimi！", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

# 安装 vLLM
uv pip install -U vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly

# 启动服务器
vllm serve ./kimi-k2-5 \
    -tp 8 \
    --mm-encoder-tp-mode data \
    --trust-remote-code \
    --tool-call-parser kimi_k2 \
    --reasoning-parser kimi_k2

FROM nvidia/cuda:12.1-devel-ubuntu22.04

WORKDIR /app

# 安装依赖
RUN pip install torch vllm transformers

# 复制模型（或挂载为卷）
COPY ./kimi-k2-5 /models/kimi-k2-5

# 暴露端口
EXPOSE 8000

# 启动服务器
CMD python -m vllm.entrypoints.openai.api_server \
    --model /models/kimi-k2-5 \
    --tensor-parallel-size 4 \
    --host 0.0.0.0 \
    --port 8000

# 构建和运行
docker build -t kimi-k2-5 .
docker run --gpus all -p 8000:8000 kimi-k2-5

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:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
        - --model
        - /models/kimi-k2-5
        - --tensor-parallel-size
        - "4"
        volumeMounts:
        - name: model
          mountPath: /models
        resources:
          limits:
            nvidia.com/gpu: "4"
      volumes:
      - name: model
        persistentVolumeClaim:
          claimName: kimi-model-pvc

# 使用GPU实例
aliyun ecs CreateInstance \
    --InstanceType ecs.gn7i-c32g1.8xlarge \
    --ImageId ubuntu_22_04_x64_gpu

# 部署到ACK
# 使用GPU优化实例

# 使用GPU实例
tencentcloud cvm RunInstances \
    --InstanceType GN7.8XLARGE128 \
    --ImageId img-xxx

# 使用Deep Learning AMI
aws ec2 run-instances \
    --image-id ami-xxx \
    --instance-type p4d.24xlarge \
    --key-name my-key

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model
import torch

# 加载基础模型
model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# 配置 LoRA
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# 应用 LoRA
model = get_peft_model(model, lora_config)

# 训练配置
training_args = TrainingArguments(
    output_dir="./kimi-k2-5-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    save_steps=100
)

# 训练
from trl import SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer
)
trainer.train()

# 全量微调，使用DeepSpeed或FSDP
from accelerate import Accelerator

accelerator = Accelerator(deepspeed_plugin=deepspeed_plugin)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    trust_remote_code=True
)

# DeepSpeed配置用于分布式训练
# 需要8x H100或同等配置

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    bnb_8bit_compute_dtype=torch.float16
)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "./kimi-k2-5",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# 社区示例仓库
# https://huggingface.co/unsloth/Kimi-K2.5-GGUF

# 使用前请先检查仓库中的可用文件/标签，再配置 llama.cpp

# 实现输入验证
def validate_input(text):
    max_length = 100000  # 限制输入大小
    if len(text) > max_length:
        raise ValueError("输入太长")
    
    # 阻止有害提示
    blocked_terms = ["..."]  # 您的列表
    for term in blocked_terms:
        if term in text.lower():
            raise ValueError("检测到被阻止的内容")
    
    return text

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def generate_with_logging(prompt):
    logger.info(f"生成请求: {len(prompt)} 字符")
    
    output = model.generate(**inputs)
    
    logger.info(f"生成: {len(output)} tokens")
    return output