Jak uruchomić Xiaomi MiMo-V2-Flash lokalnie: Kompletny przewodnik instalacji

Xiaomi MiMo-V2-Flash to przełom w projektowaniu wydajnych modeli AI, charakteryzujący się 309 miliardami łącznie parametrów, z czego tylko 15 miliardów jest aktywnych podczas inferencji. Ta architektura Mixture-of-Experts oferuje wyjątkową wydajność przy jednoczesnym zachowaniu rozsądnych wymagań sprzętowych do lokalnego wdrożenia. W tym kompleksowym przewodniku przeprowadzimy Cię przez kilka metod uruchomienia MiMo-V2-Flash lokalnie na Twoim komputerze.

Dlaczego warto uruchomić MiMo-V2-Flash lokalnie?

Uruchomienie MiMo-V2-Flash lokalnie niesie ze sobą liczne zalety:

• Prywatność danych: Twoje wrażliwe dane nigdy nie opuszczają urządzenia
• Efektywność kosztowa: Brak opłat za tokeny czy subskrypcji API
• Niska latencja: Bezpośredni dostęp do sprzętu zapewnia szybszą inferencję
• Personalizacja: Pełna kontrola nad parametrami modelu i fine-tuningiem
• Praca offline: Nie wymaga połączenia z Internetem po instalacji
• Wydajność: Wykorzystuje lokalną kartę GPU dla optymalnej prędkości

Wymagania sprzętowe

Minimalne wymagania systemowe

Komponent	Wymagania minimalne	Zalecane
GPU	NVIDIA RTX 3080 (12GB VRAM)	RTX 4090 (24GB VRAM) lub A6000
RAM	32GB	64GB lub więcej
Pojemność dysku	100GB wolnego miejsca	200GB+ NVMe SSD
CPU	Intel i7-10700K / AMD Ryzen 7 3700X	Intel i9-12900K / AMD Ryzen 9 5900X
CUDA	11.8+	12.4+

Uwagi dotyczące rozmiaru modelu

• Całkowity rozmiar modelu: ~180GB (w formatach kwantyzowanych)
• Szczytowe zużycie pamięci GPU: 15-20GB VRAM (aktywne parametry)
• Długość kontekstu: 256K tokenów (duże zapotrzebowanie na RAM)

Wymagania programowe

Przed instalacją upewnij się, że masz:

1. Zainstalowany Python 3.10+
2. CUDA Toolkit 11.8+ lub 12.4+
3. Najnowsze Sterowniki NVIDIA
4. Git do klonowania repozytorium

Sprawdzenie instalacji CUDA

nvidia-smi
nvcc --version

Metoda 1: Instalacja za pomocą SGLang (zalecana)

SGLang to rekomendowany framework dla MiMo-V2-Flash, oferujący zoptymalizowaną wydajność dla modeli MoE.

Krok 1: Instalacja SGLang

# Utwórz wirtualne środowisko
python -m venv mimo-env
source mimo-env/bin/activate  # W systemie Windows: mimo-env\Scripts\activate

# Zainstaluj PyTorch z obsługą CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Zainstaluj SGLang
pip install sglang

Krok 2: Pobierz model

# Zaloguj się do Hugging Face
huggingface-cli login

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

Krok 3: Uruchom serwer 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

Krok 4: Test instalacji

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": "Napisz funkcję w Pythonie obliczającą liczby Fibonacciego"}
    ],
    "temperature": 0.7,
    "max_tokens": 500
}

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

Metoda 2: Instalacja z użyciem Hugging Face Transformers

Krok 1: Zainstaluj zależności

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

Krok 2: Podstawowy skrypt użycia

Utwórz plik run_mimo.py:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

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

# Załaduj tokenizer i model
print("Ładowanie tokenizera...")
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

print("Ładowanie modelu...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True,  # Włącz kwantyzację 8-bit
    max_memory={0: "15GB"}  # Limit pamięci GPU
)

# Generowanie tekstu
prompt = "Wyjaśnij pojęcie uczenia maszynowego"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Generowanie odpowiedzi...")
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}")

Krok 3: Uruchom skrypt

python run_mimo.py

Metoda 3: Użycie Ollama (eksperymentalne)

Krok 1: Instalacja Ollama

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

# Windows: Pobierz ze strony ollama.com

Krok 2: Utwórz własny plik Modelfile

Stwórz Modelfile dla MiMo-V2-Flash:

FROM ./models/MiMo-V2-Flash

# Ustaw parametry
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 50
PARAMETER num_ctx 262144

Krok 3: Budowa i uruchomienie

# Utwórz model
ollama create mimo-v2-flash -f Modelfile

# Uruchom model
ollama run mimo-v2-flash

Metoda 4: Wdrożenie za pomocą Dockera

Krok 1: Utwórz Dockerfile

Stwórz plik Dockerfile:

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

# Instalacja Pythona i zależności
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

# Kopiuj model i aplikację
COPY models/MiMo-V2-Flash /app/models/MiMo-V2-Flash
COPY app.py /app/

# Udostępnij port
EXPOSE 30000

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

Krok 2: Buduj i uruchom

# Buduj obraz
docker build -t mimo-v2-flash .

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

Zaawansowana konfiguracja

Włącz Flash Attention

Dla lepszej wydajności zainstaluj Flash Attention:

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

Następnie dodaj do konfiguracji modelu:

from sglang import set_default_backend, RuntimeBackend

set_default_backend(RuntimeBackend.CUDA)

Optymalizacja pamięci

Jeśli pojawią się błędy braku pamięci:

# Użyj kwantyzacji
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_4bit=True,  # Kwantyzacja 4-bitowa
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

Konfiguracja multi-GPU

Dla systemów z wieloma GPU:

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

Optymalizacja wydajności

1. Dostosuj wykorzystanie pamięci GPU

python -m sglang.launch_server \
    --gpu-memory-utilization 0.95  # Użyj 95% pamięci GPU

2. Optymalizuj długość kontekstu

# Zmniejsz długość kontekstu, jeśli potrzebujesz większej szybkości
--max-model-len 32768  # 32K zamiast 256K

3. Włącz Tensor Parallelism

# Wykorzystaj wiele GPU do inferencji
--tensor-parallel-size 4

Rozwiązywanie typowych problemów

Problem 1: Brak pamięci (OOM)

Rozwiązanie:

# Włącz gradient checkpointing
model.gradient_checkpointing_enable()

# Lub używaj mniejszych batchy
batch_size = 1  # Zamiast większych wartości

Problem 2: CUDA Out of Memory

Rozwiązanie:

• Zmniejsz --gpu-memory-utilization do 0.8
• Włącz kwantyzację (8-bit lub 4-bit)
• Zamknij inne aplikacje intensywnie korzystające z GPU

Problem 3: Błędy ładowania modelu

Rozwiązanie:

# Wyczyść cache i pobierz ponownie
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash --resume-download

Problem 4: Wolna inferencja

Rozwiązania:

1. Włącz Flash Attention: pip install flash-attn
2. Używaj tensor parallelism na wielu GPU
3. Zmniejsz długość kontekstu
4. Zwiększ wykorzystanie pamięci GPU

Problem 5: Błędy importu

Rozwiązanie:

# Przeinstaluj zależności
pip uninstall torch torchvision torchaudio
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

pip uninstall sglang
pip install sglang

Testowanie instalacji

Kompletny skrypt testowy

Utwórz plik test_mimo.py:

import requests
import json

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

    # Test 1: Podstawowe generowanie tekstu
    data1 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Napisz program hello world w Pythonie"}],
        "max_tokens": 100
    }

    # Test 2: Generowanie kodu
    data2 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Stwórz REST API z FastAPI"}],
        "max_tokens": 200
    }

    # Test 3: Rozumowanie matematyczne
    data3 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Rozwiąż: Jaka jest pochodna 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"Test {i} zaliczony!")
            print(response.json()["choices"][0]["message"]["content"])
        else:
            print(f"Test {i} nie powiódł się: {response.status_code}")

if __name__ == "__main__":
    test_mimo()

Uruchom test:

python test_mimo.py

Najlepsze praktyki

1. Monitoruj wykorzystanie GPU: używaj nvidia-smi do kontroli pamięci i temperatury GPU
2. Dostosuj rozmiar batcha: zaczynaj od batch size 1 i zwiększaj stopniowo
3. Używaj środowisk wirtualnych: izoluj zależności z venv lub conda
4. Regularne aktualizacje: utrzymuj sterowniki i toolkit CUDA aktualne
5. Backup modelu: zachowaj kopię pobranych plików modelu

Benchmarki wydajności

Prost benchmark

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 do benchmarku
prompt = "Napisz szczegółowe wyjaśnienie obliczeń kwantowych"
tps = benchmark_model(model, tokenizer, prompt)
print(f"Tokeny na sekundę: {tps:.2f}")

Podsumowanie

Uruchomienie Xiaomi MiMo-V2-Flash lokalnie to potężny sposób na wykorzystanie najnowocześniejszych możliwości AI z zachowaniem prywatności i kontroli. Niezależnie czy wybierzesz SGLang dla maksymalnej wydajności, czy Hugging Face Transformers dla łatwości użycia, ten przewodnik dostarcza komplet informacji, by zacząć pracę.

Kluczowe wnioski:

• SGLang jest zalecany dla optymalnej wydajności
• Zapewnij odpowiednią pamięć GPU (powyżej 15GB VRAM)
• Używaj kwantyzacji, jeśli masz ograniczoną pamięć
• Eksperymentuj z długością kontekstu dla balansu między wydajnością a szybkością
• Monitoruj obciążenie GPU, aby zapobiec przegrzewaniu

Jeśli potrzebujesz skalowania poza sprzęt lokalny lub napotkasz ograniczenia, rozważ dostawców GPU w chmurze. Zacznij od polecanej metody SGLang i testuj inne frameworki zależnie od swoich potrzeb i konfiguracji sprzętowej.

Dodatkowe zasoby:

• Dokumentacja SGLang
• MiMo-V2-Flash Model Card
• Hugging Face Transformers
• Przewodnik instalacji NVIDIA CUDA