Cara Menjalankan Xiaomi MiMo-V2-Flash Secara Lokal: Panduan Instalasi Lengkap

MiMo-V2-Flash dari Xiaomi merupakan terobosan dalam desain model AI yang efisien, dengan total 309 miliar parameter namun hanya 15 miliar yang aktif saat inference. Arsitektur Mixture-of-Experts ini memberikan performa luar biasa sambil menjaga kebutuhan perangkat keras yang masuk akal untuk deployment lokal. Dalam panduan lengkap ini, kami akan membimbing Anda melalui berbagai metode untuk menjalankan MiMo-V2-Flash secara lokal di mesin Anda.

Mengapa Menjalankan MiMo-V2-Flash Secara Lokal?

Menjalankan MiMo-V2-Flash secara lokal menawarkan banyak keuntungan:

• Privasi Data: Data sensitif Anda tidak pernah keluar dari mesin Anda
• Efisiensi Biaya: Tidak ada biaya API per-token atau langganan
• Latensi Rendah: Akses langsung ke perangkat keras berarti waktu inference lebih cepat
• Kustomisasi: Kontrol penuh atas parameter model dan fine-tuning
• Kemampuan Offline: Tidak perlu koneksi internet setelah instalasi
• Performa: Memanfaatkan GPU lokal Anda untuk kecepatan optimal

Persyaratan Perangkat Keras

Persyaratan Sistem Minimum

Komponen	Persyaratan	Rekomendasi
GPU	NVIDIA RTX 3080 (12GB VRAM)	RTX 4090 (24GB VRAM) atau A6000
RAM	32GB	64GB atau lebih
Penyimpanan	100GB ruang kosong	NVMe SSD 200GB+
CPU	Intel i7-10700K / AMD Ryzen 7 3700X	Intel i9-12900K / AMD Ryzen 9 5900X
CUDA	11.8+	12.4+

Pertimbangan Ukuran Model

• Total Ukuran Model: ~180GB (format terkuantisasi)
• Memori GPU Puncak: 15-20GB VRAM (parameter aktif)
• Panjang Konteks: 256K token (menggunakan RAM signifikan)

Prasyarat Perangkat Lunak

Sebelum instalasi, pastikan Anda memiliki:

1. Python 3.10+ terpasang
2. CUDA Toolkit 11.8+ atau 12.4+
3. Driver NVIDIA (versi terbaru)
4. Git untuk cloning repository

Verifikasi Instalasi CUDA

nvidia-smi
nvcc --version

Metode 1: Instal Menggunakan SGLang (Direkomendasikan)

SGLang adalah framework yang direkomendasikan untuk MiMo-V2-Flash, menawarkan performa teroptimasi untuk model MoE.

Langkah 1: Instal SGLang

# Buat virtual environment
python -m venv mimo-env
source mimo-env/bin/activate  # Di Windows: mimo-env\Scripts\activate

# Instal PyTorch dengan dukungan CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Instal SGLang
pip install sglang

Langkah 2: Unduh Model

# Login ke Hugging Face
huggingface-cli login

# Unduh MiMo-V2-Flash
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash

Langkah 3: Jalankan Server SGLang

python -m sglang.launch_server \
    --model-path ./models/MiMo-V2-Flash \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --dtype float16 \
    --max-model-len 262144 \
    --gpu-memory-utilization 0.9

Langkah 4: Uji Instalasi

import requests
import json

url = "http://localhost:30000/v1/chat/completions"
headers = {"Content-Type": "application/json"}
data = {
    "model": "MiMo-V2-Flash",
    "messages": [
        {"role": "user", "content": "Write a Python function to calculate fibonacci numbers"}
    ],
    "temperature": 0.7,
    "max_tokens": 500
}

response = requests.post(url, headers=headers, data=json.dumps(data))
print(response.json())

Metode 2: Instal Menggunakan Hugging Face Transformers

Langkah 1: Instal Dependensi

pip install transformers==4.51.0
pip install accelerate
pip install bitsandbytes
pip install torch --index-url https://download.pytorch.org/whl/cu124

Langkah 2: Skrip Penggunaan Dasar

Buat file run_mimo.py:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# ID Model
model_id = "XiaomiMiMo/MiMo-V2-Flash"

# Muat tokenizer dan model
print("Memuat tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

print("Memuat model...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True,  # Aktifkan kuantisasi 8-bit
    max_memory={0: "15GB"}  # Batasi penggunaan memori GPU
)

# Generate teks
prompt = "Explain the concept of machine learning"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Menghasilkan respons...")
outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.7,
    do_sample=True
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"\n{response}")

Langkah 3: Jalankan Skrip

python run_mimo.py

Metode 3: Menggunakan Ollama (Eksperimental)

Langkah 1: Instal Ollama

# macOS/Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows: Unduh dari ollama.com

Langkah 2: Buat Modelfile Kustom

Buat Modelfile untuk MiMo-V2-Flash:

FROM ./models/MiMo-V2-Flash

# Atur parameter
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 50
PARAMETER num_ctx 262144

Langkah 3: Build dan Jalankan

# Buat model
ollama create mimo-v2-flash -f Modelfile

# Jalankan model
ollama run mimo-v2-flash

Metode 4: Deployment dengan Docker

Langkah 1: Buat Dockerfile

Buat Dockerfile:

FROM nvidia/cuda:12.4-devel-ubuntu20.04

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

WORKDIR /app

RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
RUN pip3 install sglang transformers accelerate

# Salin model dan aplikasi
COPY models/MiMo-V2-Flash /app/models/MiMo-V2-Flash
COPY app.py /app/

# Buka port
EXPOSE 30000

# Jalankan server
CMD ["python3", "-m", "sglang.launch_server", "--model-path", "/app/models/MiMo-V2-Flash", "--host", "0.0.0.0", "--port", "30000"]

Langkah 2: Build dan Jalankan

# Build image
docker build -t mimo-v2-flash .

# Jalankan container
docker run --gpus all -p 30000:30000 -v $(pwd)/models:/app/models mimo-v2-flash

Konfigurasi Lanjutan

Aktifkan Flash Attention

Untuk performa lebih baik, instal Flash Attention:

pip install flash-attn --no-build-isolation

Kemudian tambahkan ke konfigurasi model Anda:

from sglang import set_default_backend, RuntimeBackend

set_default_backend(RuntimeBackend.CUDA)

Optimasi Memori

Jika mengalami error out-of-memory:

# Gunakan kuantisasi
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_4bit=True,  # Gunakan kuantisasi 4-bit
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

Konfigurasi Multi-GPU

Untuk sistem dengan banyak GPU:

# Sebar model ke beberapa GPU
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    max_memory={0: "10GB", 1: "10GB", 2: "10GB", 3: "10GB"}
)

Optimasi Performa

1. Sesuaikan Pemanfaatan Memori GPU

python -m sglang.launch_server \
    --gpu-memory-utilization 0.95  # Gunakan 95% memori GPU

2. Optimalkan Panjang Konteks

# Kurangi panjang konteks jika butuh kecepatan lebih tinggi
--max-model-len 32768  # 32K bukan 256K

3. Aktifkan Tensor Parallelism

# Gunakan multi GPU untuk inference
--tensor-parallel-size 4

Pemecahan Masalah Umum

Masalah 1: Out of Memory (OOM)

Solusi:

# Aktifkan gradient checkpointing
model.gradient_checkpointing_enable()

# Atau gunakan batch size lebih kecil
batch_size = 1  # Daripada nilai besar

Masalah 2: CUDA Out of Memory

Solusi:

• Kurangi --gpu-memory-utilization menjadi 0.8
• Aktifkan kuantisasi (8-bit atau 4-bit)
• Tutup aplikasi lain yang menggunakan GPU secara intensif

Masalah 3: Error saat Memuat Model

Solusi:

# Bersihkan cache dan unduh ulang
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash --resume-download

Masalah 4: Inference Lambat

Solusi:

1. Aktifkan Flash Attention: pip install flash-attn
2. Gunakan tensor parallelism untuk multi-GPU
3. Kurangi panjang konteks
4. Tingkatkan pemanfaatan memori GPU

Masalah 5: Error Import

Solusi:

# Install ulang dependensi
pip uninstall torch torchvision torchaudio
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

pip uninstall sglang
pip install sglang

Testing Instalasi Anda

Skrip Tes Komprehensif

Buat test_mimo.py:

import requests
import json

def test_mimo():
    url = "http://localhost:30000/v1/chat/completions"
    headers = {"Content-Type": "application/json"}

    # Tes 1: Generate teks dasar
    data1 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Write a hello world program in Python"}],
        "max_tokens": 100
    }

    # Tes 2: Generate kode
    data2 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Create a REST API with FastAPI"}],
        "max_tokens": 200
    }

    # Tes 3: Pemecahan soal matematika
    data3 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Solve: What is the derivative of x^2 + 3x + 5?"}],
        "max_tokens": 100
    }

    for i, data in enumerate([data1, data2, data3], 1):
        response = requests.post(url, headers=headers, data=json.dumps(data))
        if response.status_code == 200:
            print(f"Tes {i} berhasil!")
            print(response.json()["choices"][0]["message"]["content"])
        else:
            print(f"Tes {i} gagal: {response.status_code}")

if __name__ == "__main__":
    test_mimo()

Jalankan tes:

python test_mimo.py

Praktik Terbaik

1. Pantau Penggunaan GPU: Gunakan nvidia-smi untuk memantau memori GPU dan suhu
2. Sesuaikan Ukuran Batch: Mulai dengan batch size 1 dan tingkatkan secara bertahap
3. Gunakan Virtual Environment: Isolasi dependensi dengan venv atau conda
4. Update Rutin: Perbarui driver dan toolkit CUDA
5. Backup Model: Simpan cadangan file model yang sudah diunduh

Benchmarking Performa

Jalankan Benchmark Sederhana

import time
import torch

def benchmark_model(model, tokenizer, prompt):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    start_time = time.time()
    outputs = model.generate(**inputs, max_new_tokens=200)
    end_time = time.time()

    tokens_generated = len(outputs[0])
    tokens_per_second = tokens_generated / (end_time - start_time)

    return tokens_per_second

# Prompt benchmark
prompt = "Write a detailed explanation of quantum computing"
tps = benchmark_model(model, tokenizer, prompt)
print(f"Tokens per second: {tps:.2f}")

Kesimpulan

Menjalankan Xiaomi MiMo-V2-Flash secara lokal adalah cara yang kuat untuk memanfaatkan kemampuan AI terkini sambil menjaga privasi dan kontrol. Baik Anda memilih SGLang untuk performa maksimal atau Hugging Face Transformers untuk kemudahan penggunaan, panduan ini memberikan semua informasi yang Anda butuhkan untuk memulai.

Intisari:

• Disarankan menggunakan SGLang untuk performa optimal
• Pastikan memori GPU mencukupi (VRAM 15GB+)
• Gunakan kuantisasi jika memori terbatas
• Eksperimen dengan panjang konteks untuk menyeimbangkan performa dan kecepatan
• Pantau penggunaan GPU untuk mencegah overheating

Jika ingin skalabilitas di luar perangkat keras lokal atau menemui keterbatasan hardware, pertimbangkan penyedia GPU cloud. Mulailah dengan metode SGLang yang direkomendasikan dan eksplorasi framework lain sesuai kebutuhan dan konfigurasi perangkat keras Anda.

Sumber Daya Tambahan:

• SGLang Documentation
• MiMo-V2-Flash Model Card
• Hugging Face Transformers
• NVIDIA CUDA Installation Guide