> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/mimo-v2-flash.md).

# MiMo-V2-Flash

Clore.ai पर speculative decoding के साथ MiMo-V2-Flash (309B MoE) डिप्लॉय करें — 150+ tok/s के साथ अल्ट्रा-फ़ास्ट इन्फ़रेंस

> MiMo-V2-Flash एक **309 अरब पैरामीटर वाला विशेषज्ञों का मिश्रण** भाषा मॉडल है जो प्रति टोकन 15B पैरामीटर सक्रिय करता है। उन्नत speculative decoding (EAGLE/MTP) के साथ निर्मित, यह प्रदान करता है **150+ टोकन/सेकंड** 8×H100 पर, frontier-स्तरीय प्रदर्शन बनाए रखते हुए। के अंतर्गत जारी किया गया **MIT लाइसेंस**यह कुशल बड़े-स्तरीय inference की अत्याधुनिक सीमा का प्रतिनिधित्व करता है।

## संक्षेप में

* **मॉडल आकार**: 309B कुल / 15B सक्रिय पैरामीटर (MoE)
* **लाइसेंस**: MIT (पूर्णतः व्यावसायिक)
* **संदर्भ**: 32K टोकन
* **प्रदर्शन**: तर्क-सम्बंधी बेंचमार्क पर अत्याधुनिक
* **VRAM**: \~320GB FP16 (न्यूनतम 4×A100 80GB)
* **गति**: speculative decoding के साथ 8×H100 पर 150+ tok/s

## MiMo-V2-Flash क्यों?

**क्रांतिकारी गति**: MiMo-V2-Flash EAGLE (Extrapolation Algorithm for Greater Language model Efficiency) और MTP (Multi-Token Prediction) के माध्यम से अभूतपूर्व inference गति प्राप्त करता है। जहाँ पारंपरिक मॉडल एक समय में एक टोकन उत्पन्न करते हैं, MiMo-V2 एक साथ कई टोकनों की भविष्यवाणी और सत्यापन करता है।

**उत्पादन-तैयार पैमाना**: 309B पैरामीटर के साथ, MiMo-V2-Flash सबसे बड़े frontier मॉडलों के साथ प्रतिस्पर्धा करता है, जबकि वास्तविक हार्डवेयर कॉन्फ़िगरेशन पर तैनात रहने योग्य बना रहता है। 15B सक्रिय पैरामीटर विशाल पैरामीटर संख्या के बावजूद कुशल inference सुनिश्चित करते हैं।

**उन्नत संरचना**: मानक MoE से आगे, MiMo-V2-Flash मॉडल आर्किटेक्चर में मूल रूप से speculative decoding को शामिल करता है। यह post-training optimization नहीं है — यह आधार में ही निर्मित है, जिससे गारंटीकृत गति-लाभ मिलते हैं।

**उद्यम-स्तरीय गुणवत्ता**: MIT लाइसेंसिंग के साथ, बिना उपयोग प्रतिबंधों के। लाइसेंस संबंधी चिंता के बिना बड़े पैमाने पर तैनात करें, fine-tune करें, या व्यावसायिक उत्पादों में एकीकृत करें।

## GPU सिफारिशें

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

| सेटअप           | VRAM  | प्रदर्शन       | दैनिक लागत\* |
| --------------- | ----- | -------------- | ------------ |
| **4×A100 80GB** | 320GB | \~80 tok/s     | \~$16.00     |
| **8×A100 40GB** | 320GB | \~70 tok/s     | \~$28.00     |
| **2×H100**      | 160GB | \~90 tok/s     | \~$12.00     |
| **8×H100**      | 640GB | **150+ tok/s** | \~$48.00     |
| 4×H200          | 564GB | \~120 tok/s    | \~$32.00     |

**सर्वोत्तम मूल्य**: 4×A100 80GB प्रति डॉलर उत्कृष्ट प्रदर्शन देता है, उपलब्ध है [bare metal](https://clore.ai/bare-metal). बाज़ार में इसका समकक्ष 4× RTX PRO 6000 Blackwell रिग (380GB) है। **अधिकतम प्रदर्शन**: 8×H100 पूरे speculative decoding सामर्थ्य को अनलॉक करता है।

\*Clore.ai बाज़ार के अनुमानित मूल्य

## SGLang के साथ परिनियोजन करें (अनुशंसित)

SGLang, MiMo-V2-Flash की speculative decoding सुविधाओं के लिए सर्वोत्तम समर्थन प्रदान करता है:

### SGLang स्थापित करें

```bash
pip install "sglang[all]>=0.3.0"
# या नवीनतम
pip install git+https://github.com/sgl-project/sglang.git
```

### MTP के साथ बहु-GPU सेटअप

```bash
python -m sglang.launch_server \
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 8 \\
  --mtp-acceptance-rate 0.8 \\
  --mem-fraction-static 0.85 \\
  --dtype float16 \\
  --context-length 32768 \\
  --served-model-name mimo-v2-flash
```

### OpenAI API के साथ क्वेरी करें

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="mimo-v2-flash",
    messages=[
        {"role": "system", "content": "आप एक विशेषज्ञ AI शोधकर्ता हैं।"},
        {"role": "user", "content": "EAGLE speculative decoding algorithm समझाइए और यह तेज़ inference को कैसे सक्षम करता है"}
    ],
    max_tokens=1024,
    temperature=0.7,
    stream=True  # सर्वोत्तम विलंबता के लिए अनुशंसित
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='', flush=True)
```

## vLLM के साथ डिप्लॉय करें

vLLM भी speculative decoding के साथ MiMo-V2-Flash का समर्थन करता है:

```bash
pip install vllm>=0.6.0

vllm serve mimo-ai/MiMo-V2-Flash \\
  --tensor-parallel-size 8 \\
  --speculative-model mimo-ai/MiMo-V2-Flash-Draft \\
  --speculative-max-model-len 32768 \\
  --speculative-draft-tensor-parallel-size 2 \\
  --use-v2-block-manager \\
  --dtype float16 \\
  --served-model-name mimo-v2-flash \\
  --trust-remote-code
```

## Docker टेम्पलेट

```dockerfile
FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# निर्भरताएँ इंस्टॉल करें
RUN apt-get update && \\
    apt-get install -y python3.10 python3-pip git && \\
    rm -rf /var/lib/apt/lists/*

# MTP समर्थन के साथ SGLang स्थापित करें
RUN pip install "sglang[all]>=0.3.0" transformers

# परिवेश चर सेट करें
ENV PYTHONUNBUFFERED=1
ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7

# मॉडल पहले से डाउनलोड करें (वैकल्पिक, स्टार्टअप समय बचाता है)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('mimo-ai/MiMo-V2-Flash', trust_remote_code=True)"

EXPOSE 30000

CMD ["python", "-m", "sglang.launch_server", \\
     "--model-path", "mimo-ai/MiMo-V2-Flash", \\
     "--host", "0.0.0.0", \\
     "--port", "30000", \\
     "--tp-size", "8", \\
     "--enable-mtp", \\
     "--mtp-max-draft-tokens", "8", \\
     "--dtype", "float16"]
```

सभी GPU के साथ चलाएँ:

```bash
docker build -t mimo-v2-flash .
docker run --gpus all -p 30000:30000 \\
  --shm-size=64g \\
  --ulimit memlock=-1 \\
  --ulimit stack=67108864 \\
  mimo-v2-flash
```

## उन्नत कॉन्फ़िगरेशन

### Speculative Decoding का अनुकूलन

अपने वर्कलोड के आधार पर speculative पैरामीटर को fine-tune करें:

```bash
# कोड जनरेशन के लिए (उच्च स्वीकृति दर)
python -m sglang.launch_server \
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 12 \\
  --mtp-acceptance-rate 0.9 \\
  --temperature 0.1

# रचनात्मक लेखन के लिए (निम्न स्वीकृति दर)
python -m sglang.launch_server \
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 8 \\
  --enable-mtp \\
  --mtp-max-draft-tokens 6 \\
  --mtp-acceptance-rate 0.7 \\
  --temperature 0.8
```

### मेमोरी अनुकूलन

मेमोरी-सीमित सेटअप के लिए:

```bash
# मेमोरी उपयोग कम करें (धीमा, लेकिन 4×A100 में फिट होता है)
python -m sglang.launch_server \
  --model-path mimo-ai/MiMo-V2-Flash \\
  --tp-size 4 \\
  --mem-fraction-static 0.75 \\
  --context-length 16384 \\
  --dtype float16 \\
  --disable-cuda-graph  # VRAM बचाता है
```

## बेंचमार्किंग उदाहरण

MiMo-V2-Flash की गति-श्रेष्ठता का परीक्षण करें:

```python
import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:30000/v1", api_key="EMPTY")

def benchmark_generation():
    start_time = time.time()
    
    response = client.chat.completions.create(
        model="mimo-v2-flash",
        messages=[
            {"role": "user", "content": "क्वांटम कंप्यूटिंग की एक विस्तृत व्याख्या ठीक 500 शब्दों में लिखिए"}
        ],
        max_tokens=600,
        temperature=0.1,
        stream=False
    )
    
    end_time = time.time()
    content = response.choices[0].message.content
    
    tokens = len(content.split())  # लगभग टोकन अनुमान
    duration = end_time - start_time
    tokens_per_second = tokens / duration
    
    print(f"{tokens} टोकन {duration:.2f}s में उत्पन्न किए गए")
    print(f"गति: {tokens_per_second:.1f} टोकन/सेकंड")
    
    return tokens_per_second

# बेंचमार्क चलाएँ
speed = benchmark_generation()
print(f"\nMiMo-V2-Flash ने {speed:.1f} tok/s हासिल किया")
```

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

* **बहु-GPU अनिवार्य**: MiMo-V2-Flash के लिए न्यूनतम 4×A100 80GB आवश्यक हैं। सिंगल-GPU परिनियोजन संभव नहीं है।
* **NVLink लाभ**: सर्वोत्तम बहु-GPU संचार के लिए GPUs के बीच NVLink वाले Clore.ai होस्ट चुनें।
* **RAM आवश्यकताएँ**: 8 GPUs के साथ सुचारू संचालन के लिए 256GB+ सिस्टम RAM सुनिश्चित करें।
* **Speculative ट्यूनिंग**: समायोजित करें `mtp-max-draft-tokens` अपने उपयोग-केस के आधार पर — दोहराव वाले कार्यों के लिए अधिक, रचनात्मक कार्य के लिए कम।
* **संदर्भ लंबाई**: 32K संदर्भ सर्वोत्तम है। लंबे संदर्भ speculative decoding की प्रभावशीलता कम करते हैं।

## समस्या निवारण

| समस्या                          | समाधान                                                                            |
| ------------------------------- | --------------------------------------------------------------------------------- |
| `OutOfMemoryError` स्टार्टअप पर | कम करें `mem-fraction-static` या `tp-size`                                        |
| GPU-से-GPU संचार धीमा           | NVLink सत्यापित करें: `nvidia-ml-py3` या `nvidia-smi topo -m`                     |
| MTP गति नहीं बढ़ा रहा           | जाँचें `mtp-acceptance-rate` — बहुत अधिक मान speculation को निष्क्रिय कर देते हैं |
| मॉडल लोडिंग टाइमआउट             | पहले डाउनलोड करें: `huggingface-cli download mimo-ai/MiMo-V2-Flash`               |
| कम टोकन स्वीकृति                | तापमान सेटिंग्स जाँचें — बहुत कम/अधिक तापमान स्वीकृति को कम करते हैं              |

## प्रदर्शन तुलना

| मॉडल              | आकार     | गति (8×H100)   | गुणवत्ता |
| ----------------- | -------- | -------------- | -------- |
| GPT-4 Turbo       | \~1.7T   | \~15-25 tok/s  | ★★★★★    |
| Claude Sonnet 3.5 | \~200B   | \~25-35 tok/s  | ★★★★★    |
| **MiMo-V2-Flash** | **309B** | **150+ tok/s** | ★★★★☆    |
| Llama 3.1 405B    | 405B     | \~30-45 tok/s  | ★★★★☆    |

MiMo-V2-Flash समान मॉडल की तुलना में 3-5x गति-वृद्धि हासिल करता है, जबकि प्रतिस्पर्धी गुणवत्ता बनाए रखता है।

## संसाधन

* [Hugging Face पर MiMo-V2-Flash](https://huggingface.co/mimo-ai/MiMo-V2-Flash)
* [EAGLE पेपर](https://arxiv.org/abs/2401.15077)
* [SGLang दस्तावेज़ीकरण](https://sgl-project.github.io/start/install.html)
* [Multi-Token Prediction](https://arxiv.org/abs/2404.19737)
* [Speculative Decoding गाइड](https://huggingface.co/blog/assisted-generation)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/mimo-v2-flash.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
