---
title: Kimi-K2.5-W4A8
canonical_url: "https://www.modelscope.ai/models/AMD/Kimi-K2.5-W4A8"
md_url: "https://www.modelscope.ai/models/AMD/Kimi-K2.5-W4A8.md"
repository: AMD/Kimi-K2.5-W4A8
last_updated: 2026-06-05
license: other
pipeline_tag: image-text-to-text
tasks:
  - image-text-to-text
model_type:
  - kimi_k25
architectures:
  - KimiK25ForConditionalGeneration
base_model:
  - moonshotai/Kimi-K2.5
base_model_relation: quantized
parameters: 139.3B
tensor_type:
  - BF16
  - I32
  - F32
library_name:
  - safetensors
  - pytorch
frameworks:
  - pytorch
downloads: 123
stars: 0
---

# Kimi-K2.5-W4A8

> Kimi-K2.5-W4A8 - An open-source model by AMD on ModelScope. Model Architecture: Kimi-K2.5 Input: Text Output: Text Supported Hardware Microarchitecture: AMD MI300/MI325/MI350/MI355 ROCm: 7.1.0 Operating System(s): Linux Inference Engine: vLLM Model…

AMD/Kimi-K2.5-W4A8 is a 139.3B-parameter image-text-to-text model on ModelScope. licensed under other. derived from moonshotai/Kimi-K2.5.

- **Repository**: AMD/Kimi-K2.5-W4A8
- **License**: other
- **Tasks**: image-text-to-text
- **Parameters**: 139.3B
- **Base model**: moonshotai/Kimi-K2.5
- **Downloads**: 123
- **Stars**: 0
- **Last updated**: 2026-06-05

Source: https://www.modelscope.ai/models/AMD/Kimi-K2.5-W4A8

---

# Model Overview

- **Model Architecture:** Kimi-K2.5
  - **Input:** Text
  - **Output:** Text
- **Supported Hardware Microarchitecture:** AMD MI300/MI325/MI350/MI355
- **ROCm:** 7.1.0
- **Operating System(s):** Linux
- **Inference Engine:** [vLLM](https://docs.vllm.ai/en/latest/)
- **Model Optimizer:** [AMD-Quark](https://quark.docs.amd.com/latest/index.html)
  - **Weight quantization:** MOE-only, INT4 Per-Channel & FP8E4M3, Static
  - **Activation quantization:** MOE-only, FP8E4M3, Dynamic

This model was built with Kimi-K2.5 model by applying [AMD-Quark](https://quark.docs.amd.com/latest/index.html) for INT4-FP8 quantization.

# Model Quantization

The model was quantized from [moonshotai/Kimi-K2.5](https://huggingface.co/moonshotai/Kimi-K2.5) using [AMD-Quark](https://quark.docs.amd.com/latest/index.html). The weights and activations are quantized to INT4-FP8.

```python
#!/usr/bin/env python3
"""Kimi-K2.5 W4A8 re-quantization via AMD Quark (File-to-File Quantization)."""

import argparse
import os
from quark.torch.quantization.config.config import (
    FP8E4M3PerTensorSpec, Int4PerChannelSpec, ProgressiveSpec,
    QConfig, QLayerConfig,
)
from quark.torch.quantization.api import ModelQuantizer


def get_config():
    exclude_layers = [
        "*self_attn*", "*mlp.gate", "*lm_head",
        "*mlp.gate_proj", "*mlp.up_proj", "*mlp.down_proj",
        "*shared_experts*", "*mm_projector*", "*vision_tower*",
    ]

    input_spec = FP8E4M3PerTensorSpec(
        observer_method="min_max", scale_type="float32", is_dynamic=True,
    ).to_quantization_spec()

    weight_spec = ProgressiveSpec(
        first_stage=FP8E4M3PerTensorSpec(
            observer_method="min_max", scale_type="float32", is_dynamic=False,
        ),
        second_stage=Int4PerChannelSpec(
            symmetric=True, scale_type="float32",
            round_method="half_even", is_dynamic=False, ch_axis=0,
        ),
    ).to_quantization_spec()

    return QConfig(
        global_quant_config=QLayerConfig(input_tensors=input_spec, weight=weight_spec),
        exclude=exclude_layers,
    )


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--model-path", type=str, required=True,
                        help="Path to moonshotai/Kimi-K2.5 checkpoint")
    parser.add_argument("--export-path", type=str, required=True,
                        help="Path to save quantized output")
    args = parser.parse_args()

    quantizer = ModelQuantizer(get_config())
    quantizer.direct_quantize_checkpoint(
        pretrained_model_path=args.model_path,
        save_path=args.export_path,
    )
    print("[INFO] Quantization completed")
```

# Deployment
### Use with vLLM

This model can be deployed efficiently using the [vLLM](https://docs.vllm.ai/en/latest/) backend.

## Evaluation
The model was evaluated on GSM8K benchmarks. 

### Accuracy

<table>
  <tr>
   <td><strong>Benchmark</strong>
   </td>
   <td><strong>Kimi-K2.5 </strong>
   </td>
   <td><strong>Kimi-K2.5-W4A8(this model) </strong>
   </td>
   <td><strong>Recovery</strong>
   </td>
  </tr>
  <tr>
   <td>GSM8K (flexible-extract)
   </td>
   <td>94.09
   </td>
   <td>93.40
   </td>
   <td>99.27%
   </td>
  </tr>
</table>

### Reproduction

The GSM8K results were obtained using the `lm-evaluation-harness` framework, based on the Docker image `vllm/vllm-openai-rocm:v0.14.0`.

Install the vLLM `(commit ecb4f822091a64b5084b3a4aff326906487a363f)` and lm-eval `(Version: 0.4.10)` in container first.
```
git clone https://github.com/vllm-project/vllm.git
cd vllm
python3 setup.py develop

pip install lm-eval
```

#### Launching server
```
VLLM_ROCM_USE_AITER_MLA=0 VLLM_ROCM_USE_AITER=1 VLLM_ROCM_USE_AITER_FUSION_SHARED_EXPERTS=0 VLLM_ROCM_USE_AITER_FP4BMM=0 vllm serve amd/Kimi-K2.5-W4A8 \
  --tensor-parallel-size 8 \
  --mm-encoder-tp-mode data \
  --tool-call-parser kimi_k2 \
  --reasoning-parser kimi_k2 \
  --trust-remote-code \
  --enforce-eager
```

#### Evaluating model in a new terminal
```
lm_eval \
  --model local-completions \
  --model_args "model=amd/Kimi-K2.5-W4A8,base_url=http://0.0.0.0:8000/v1/completions,tokenized_requests=False,tokenizer_backend=None,num_concurrent=32" \
  --tasks gsm8k \
  --num_fewshot 5 \
  --batch_size 1
```

# License
Modifications Copyright(c) 2025 Advanced Micro Devices, Inc. All rights reserved.