# MiMo-V2-Flash

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

## एक नज़र में

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

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

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

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

**उन्नत वास्तुकला**: मानक MoE से परे, MiMo-V2-Flash मॉडल आर्किटेक्चर में अनुमानात्मक डिकोडिंग को मूल रूप से शामिल करता है। यह पोस्ट-प्रशिक्षण अनुकूलन नहीं है — यह नींव में निर्मित है, जो गारंटीकृत स्पीडअप सक्षम बनाता है।

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

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

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

**श्रेष्ठ मूल्य**: 4×A100 80GB प्रति डॉलर उत्कृष्ट प्रदर्शन प्रदान करता है। **अधिकतम प्रदर्शन**: 8×H100 अनुमानात्मक डिकोडिंग की पूर्ण क्षमता खोलता है।

\*अनुमानित Clore.ai मार्केटप्लेस कीमतें

## SGLang के साथ तैनात करें (अनुशंसित)

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

### 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": "You are an expert AI researcher."},
        {"role": "user", "content": "Explain the EAGLE speculative decoding algorithm and why it enables faster 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 भी अनुमानात्मक डिकोडिंग के साथ 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
```

## डॉकर टेम्पलेट

```dockerfile
FROM nvidia/cuda:12.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"]
```

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

```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
```

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

### अनुमानात्मक डिकोडिंग का अनुकूलन

अपने वर्कलोड के आधार पर अनुमानात्मक पैरामीटर फ़ाइन-ट्यून करें:

```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": "Write a detailed explanation of quantum computing in exactly 500 words"}
        ],
        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"Generated {tokens} tokens in {duration:.2f}s")
    print(f"Speed: {tokens_per_second:.1f} tokens/second")
    
    return tokens_per_second

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

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

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

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

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

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

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

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)
* [अनुमानात्मक डिकोडिंग गाइड](https://huggingface.co/blog/assisted-generation)