Saltar al contenido principal

Cómo Ejecutar Xiaomi MiMo-V2-Flash Localmente: Guía Completa de Instalación

BlogsXiaomiMiMo-V2-FlashLocal AIAI ModelsSGLangAlrededor de 5 min

Cómo Ejecutar Xiaomi MiMo-V2-Flash Localmente: Guía Completa de Instalación

El MiMo-V2-Flash de Xiaomi representa un avance en el diseño eficiente de modelos de IA, con un total de 309 mil millones de parámetros, de los cuales solo 15 mil millones están activos durante la inferencia. Esta arquitectura Mixture-of-Experts ofrece un rendimiento excepcional manteniendo requisitos de hardware razonables para su implementación local. En esta guía completa, te mostraremos varios métodos para ejecutar MiMo-V2-Flash localmente en tu máquina.

¿Por qué Ejecutar MiMo-V2-Flash Localmente?

Ejecutar MiMo-V2-Flash localmente ofrece numerosas ventajas:

  • Privacidad de Datos: Tus datos sensibles nunca salen de tu máquina
  • Eficiencia de Costos: No hay cargos por token o suscripciones API
  • Baja Latencia: Acceso directo al hardware para tiempos de inferencia más rápidos
  • Personalización: Control total sobre los parámetros del modelo y fine-tuning
  • Capacidad Offline: No requiere conexión a internet después de la instalación
  • Rendimiento: Aprovecha tu GPU local para máxima velocidad

Requisitos de Hardware

Requisitos Mínimos del Sistema

ComponenteRequisitoRecomendado
GPUNVIDIA RTX 3080 (12GB VRAM)RTX 4090 (24GB VRAM) o A6000
RAM32GB64GB o más
Almacenamiento100GB espacio libre200GB+ NVMe SSD
CPUIntel i7-10700K / AMD Ryzen 7 3700XIntel i9-12900K / AMD Ryzen 9 5900X
CUDA11.8+12.4+

Consideraciones Sobre el Tamaño del Modelo

  • Tamaño Total del Modelo: ~180GB (formatos cuantizados)
  • Pico de Memoria GPU: 15-20GB VRAM (parámetros activos)
  • Longitud de Contexto: 256K tokens (usa RAM significativa)

Requisitos de Software

Antes de la instalación, asegúrate de tener:

  1. Python 3.10+ instalado
  2. CUDA Toolkit 11.8+ o 12.4+
  3. Drivers NVIDIA (última versión)
  4. Git para clonar repositorios

Verificar Instalación de CUDA

nvidia-smi
nvcc --version

Método 1: Instalar Usando SGLang (Recomendado)

SGLang es el framework recomendado para MiMo-V2-Flash, ofreciendo un rendimiento optimizado para modelos MoE.

Paso 1: Instalar SGLang

# Crear entorno virtual
python -m venv mimo-env
source mimo-env/bin/activate  # En Windows: mimo-env\Scripts\activate

# Instalar PyTorch con soporte CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Instalar SGLang
pip install sglang

Paso 2: Descargar el Modelo

# Iniciar sesión en Hugging Face
huggingface-cli login

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

Paso 3: Lanzar el Servidor 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

Paso 4: Probar la Instalación

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": "Escribe una función en Python para calcular números de Fibonacci"}
    ],
    "temperature": 0.7,
    "max_tokens": 500
}

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

Método 2: Instalación con Hugging Face Transformers

Paso 1: Instalar Dependencias

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

Paso 2: Script Básico de Uso

Crea run_mimo.py:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# ID del modelo
model_id = "XiaomiMiMo/MiMo-V2-Flash"

# Cargar tokenizer y modelo
print("Cargando tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

print("Cargando modelo...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True,  # Habilitar cuantización en 8 bits
    max_memory={0: "15GB"}  # Limitar uso de memoria GPU
)

# Generar texto
prompt = "Explica el concepto de aprendizaje automático"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

print("Generando respuesta...")
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}")

Paso 3: Ejecutar el Script

python run_mimo.py

Método 3: Usando Ollama (Experimental)

Paso 1: Instalar Ollama

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

# Windows: Descargar desde ollama.com

Paso 2: Crear Archivo Modelfile Personalizado

Crea un Modelfile para MiMo-V2-Flash:

FROM ./models/MiMo-V2-Flash

# Configurar parámetros
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 50
PARAMETER num_ctx 262144

Paso 3: Construir y Ejecutar

# Crear el modelo
ollama create mimo-v2-flash -f Modelfile

# Ejecutar el modelo
ollama run mimo-v2-flash

Método 4: Despliegue con Docker

Paso 1: Crear Dockerfile

Crea Dockerfile:

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

# Instalar Python y dependencias
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

# Copiar modelo y aplicación
COPY models/MiMo-V2-Flash /app/models/MiMo-V2-Flash
COPY app.py /app/

# Exponer puerto
EXPOSE 30000

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

Paso 2: Construir y Ejecutar

# Construir imagen
docker build -t mimo-v2-flash .

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

Configuración Avanzada

Habilitar Flash Attention

Para mejorar rendimiento, instala Flash Attention:

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

Luego añade a tu configuración del modelo:

from sglang import set_default_backend, RuntimeBackend

set_default_backend(RuntimeBackend.CUDA)

Optimización de Memoria

Si encuentras errores de memoria insuficiente:

# Usar cuantización
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_4bit=True,  # Usar cuantización en 4 bits
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

Configuración Multi-GPU

Para sistemas con múltiples GPUs:

# Distribuir modelo entre GPUs
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    max_memory={0: "10GB", 1: "10GB", 2: "10GB", 3: "10GB"}
)

Optimización de Rendimiento

1. Ajustar Utilización de Memoria GPU

python -m sglang.launch_server \
    --gpu-memory-utilization 0.95  # Usar 95% de la memoria GPU

2. Optimizar Longitud del Contexto

# Reducir longitud de contexto para mayor velocidad
--max-model-len 32768  # 32K en lugar de 256K

3. Habilitar Paralelismo Tensorial

# Usar múltiples GPUs para inferencia
--tensor-parallel-size 4

Resolución de Problemas Comunes

Problema 1: Memoria Insuficiente (OOM)

Solución:

# Habilitar gradient checkpointing
model.gradient_checkpointing_enable()

# O usar tamaños de batch más pequeños
batch_size = 1  # En lugar de valores mayores

Problema 2: CUDA Out of Memory

Solución:

  • Reducir --gpu-memory-utilization a 0.8
  • Habilitar cuantización (8-bit o 4-bit)
  • Cerrar otras aplicaciones que usen GPU intensivamente

Problema 3: Errores al Cargar el Modelo

Solución:

# Limpiar caché y re-descargar
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash --resume-download

Problema 4: Inferencia Lenta

Soluciones:

  1. Habilitar Flash Attention: pip install flash-attn
  2. Usar paralelismo tensorial para multi-GPU
  3. Reducir longitud de contexto
  4. Aumentar utilización de memoria GPU

Problema 5: Errores de Importación

Solución:

# Reinstalar dependencias
pip uninstall torch torchvision torchaudio
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

pip uninstall sglang
pip install sglang

Prueba de la Instalación

Script de Prueba Completo

Crea test_mimo.py:

import requests
import json

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

    # Prueba 1: Generación de texto básica
    data1 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Escribe un programa hello world en Python"}],
        "max_tokens": 100
    }

    # Prueba 2: Generación de código
    data2 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Crea una API REST con FastAPI"}],
        "max_tokens": 200
    }

    # Prueba 3: Razonamiento matemático
    data3 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Resuelve: ¿Cuál es la derivada de 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"Prueba {i} aprobada!")
            print(response.json()["choices"][0]["message"]["content"])
        else:
            print(f"Prueba {i} falló: {response.status_code}")

if __name__ == "__main__":
    test_mimo()

Ejecuta la prueba:

python test_mimo.py

Mejores Prácticas

  1. Monitorea Uso de GPU: Usa nvidia-smi para controlar memoria y temperatura
  2. Ajusta Tamaño de Batch: Comienza con batch size 1 y aumenta gradualmente
  3. Usa Entornos Virtuales: Aisla dependencias con venv o conda
  4. Actualiza Regularmente: Mantén drivers y CUDA toolkit actualizados
  5. Respalda el Modelo: Guarda una copia de los archivos del modelo descargados

Benchmark de Rendimiento

Ejecutar un Benchmark Simple

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 para benchmark
prompt = "Escribe una explicación detallada sobre la computación cuántica"
tps = benchmark_model(model, tokenizer, prompt)
print(f"Tokens por segundo: {tps:.2f}")

Conclusión

Ejecutar MiMo-V2-Flash de Xiaomi localmente es una forma poderosa de aprovechar capacidades de IA de última generación mientras mantienes privacidad y control. Ya sea que elijas SGLang para máximo rendimiento o Hugging Face Transformers por su facilidad de uso, esta guía te ofrece toda la información necesaria para comenzar.

Puntos Clave:

  • Se recomienda SGLang para un rendimiento óptimo
  • Asegura memoria GPU adecuada (15GB+ VRAM)
  • Usa cuantización si tienes memoria limitada
  • Experimenta con la longitud de contexto para balancear rendimiento y velocidad
  • Monitorea el uso de GPU para evitar sobrecalentamiento

Para escalar más allá del hardware local o si encuentras limitaciones, considera proveedores de GPU en la nube. Comienza con el método recomendado SGLang y experimenta con otros frameworks según tus necesidades específicas y configuración de hardware.

Recursos Adicionales:

Ahorra en alojamiento VPS económico