Pular para o conteúdo

Como Executar o Xiaomi MiMo-V2-Flash Localmente: Um Guia Completo de Instalação

BlogsXiaomiMiMo-V2-FlashLocal AIAI ModelsSGLangPor volta de 5 min

Como Executar o Xiaomi MiMo-V2-Flash Localmente: Um Guia Completo de Instalação

O MiMo-V2-Flash da Xiaomi representa um avanço no design eficiente de modelos de IA, apresentando 309 bilhões de parâmetros totais, sendo apenas 15 bilhões ativos durante a inferência. Essa arquitetura Mixture-of-Experts oferece desempenho excepcional mantendo exigências razoáveis de hardware para implantação local. Neste guia abrangente, vamos mostrar diversas formas de rodar o MiMo-V2-Flash localmente na sua máquina.

Por que Executar o MiMo-V2-Flash Localmente?

Executar o MiMo-V2-Flash localmente traz diversas vantagens:

  • Privacidade de Dados: Seus dados sensíveis nunca saem da sua máquina
  • Custo Benefício: Sem cobranças por token ou taxas de assinatura
  • Baixa Latência: Acesso direto ao hardware significa tempos de inferência mais rápidos
  • Customização: Controle total sobre parâmetros do modelo e fine-tuning
  • Funcionamento Offline: Não requer conexão com a internet após a instalação
  • Desempenho: Aproveita sua GPU local para velocidade ideal

Requisitos de Hardware

Requisitos Mínimos do Sistema

ComponenteRequisitoRecomendado
GPUNVIDIA RTX 3080 (12GB VRAM)RTX 4090 (24GB VRAM) ou A6000
RAM32GB64GB ou mais
Armazenamento100GB de espaço livreSSD NVMe 200GB+
CPUIntel i7-10700K / AMD Ryzen 7 3700XIntel i9-12900K / AMD Ryzen 9 5900X
CUDA11.8+12.4+

Considerações Sobre o Tamanho do Modelo

  • Tamanho Total do Modelo: ~180GB (formatos quantizados)
  • Pico de Memória da GPU: 15-20GB VRAM (parâmetros ativos)
  • Comprimento do Contexto: 256K tokens (usa muita RAM)

Pré-requisitos de Software

Antes da instalação, certifique-se de ter:

  1. Python 3.10+ instalado
  2. CUDA Toolkit 11.8+ ou 12.4+
  3. Drivers NVIDIA (versão mais recente)
  4. Git para clonar repositórios

Verifique a Instalação do CUDA

nvidia-smi
nvcc --version

Método 1: Instalar Usando SGLang (Recomendado)

SGLang é o framework recomendado para o MiMo-V2-Flash, oferecendo desempenho otimizado para modelos MoE.

Passo 1: Instalar SGLang

# Criar ambiente virtual
python -m venv mimo-env
source mimo-env/bin/activate  # No Windows: mimo-env\Scripts\activate

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

# Instalar SGLang
pip install sglang

Passo 2: Baixar o Modelo

# Login no Hugging Face
huggingface-cli login

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

Passo 3: Iniciar o 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

Passo 4: Testar a Instalação

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())

Método 2: Instalar Usando Hugging Face Transformers

Passo 1: Instalar Dependências

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

Passo 2: Script Básico de Uso

Crie run_mimo.py:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

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

# Carregar tokenizer e modelo
print("Carregando tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True
)

print("Carregando modelo...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
    load_in_8bit=True,  # Ativa quantização 8-bit
    max_memory={0: "15GB"}  # Limita o uso da memória GPU
)

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

print("Gerando resposta...")
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}")

Passo 3: Executar o Script

python run_mimo.py

Método 3: Usando Ollama (Experimental)

Passo 1: Instalar Ollama

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

# Windows: Baixe em ollama.com

Passo 2: Criar Modelfile Personalizado

Crie um Modelfile para MiMo-V2-Flash:

FROM ./models/MiMo-V2-Flash

# Definir parâmetros
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 50
PARAMETER num_ctx 262144

Passo 3: Construir e Executar

# Criar o modelo
ollama create mimo-v2-flash -f Modelfile

# Rodar o modelo
ollama run mimo-v2-flash

Método 4: Implantação com Docker

Passo 1: Criar Dockerfile

Crie Dockerfile:

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

# Instalar Python e dependências
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 e aplicação
COPY models/MiMo-V2-Flash /app/models/MiMo-V2-Flash
COPY app.py /app/

# Expor porta
EXPOSE 30000

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

Passo 2: Construir e Rodar

# Construir a imagem
docker build -t mimo-v2-flash .

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

Configuração Avançada

Ativar Flash Attention

Para melhor desempenho, instale Flash Attention:

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

Depois, adicione à configuração do modelo:

from sglang import set_default_backend, RuntimeBackend

set_default_backend(RuntimeBackend.CUDA)

Otimização de Memória

Se ocorrerem erros de falta de memória:

# Usar quantização
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    load_in_4bit=True,  # Usar quantização 4-bit
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

Configuração Multi-GPU

Para sistemas com múltiplas GPUs:

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

Otimização de Desempenho

1. Ajustar Uso de Memória da GPU

python -m sglang.launch_server \
    --gpu-memory-utilization 0.95  # Usar 95% da memória da GPU

2. Otimizar o Comprimento do Contexto

# Reduzir comprimento do contexto para mais velocidade
--max-model-len 32768  # 32K ao invés de 256K

3. Ativar Paralelismo Tensor

# Usar múltiplas GPUs para inferência
--tensor-parallel-size 4

Solução de Problemas Comuns

Problema 1: Falta de Memória (OOM)

Solução:

# Ativar checkpointing de gradiente
model.gradient_checkpointing_enable()

# Ou usar tamanhos de batch menores
batch_size = 1  # Ao invés de valores maiores

Problema 2: CUDA Out of Memory

Solução:

  • Reduzir --gpu-memory-utilization para 0.8
  • Ativar quantização (8-bit ou 4-bit)
  • Fechar outros aplicativos que consumam GPU

Problema 3: Erros ao Carregar o Modelo

Solução:

# Limpar cache e baixar novamente
huggingface-cli download XiaomiMiMo/MiMo-V2-Flash --local-dir ./models/MiMo-V2-Flash --resume-download

Problema 4: Inferência Lenta

Soluções:

  1. Ativar Flash Attention: pip install flash-attn
  2. Usar paralelismo tensor para multi-GPU
  3. Reduzir comprimento do contexto
  4. Aumentar uso de memória da GPU

Problema 5: Erros de Importação

Solução:

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

pip uninstall sglang
pip install sglang

Testando Sua Instalação

Script Completo de Teste

Crie test_mimo.py:

import requests
import json

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

    # Teste 1: Geração básica de texto
    data1 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Write a hello world program in Python"}],
        "max_tokens": 100
    }

    # Teste 2: Geração de código
    data2 = {
        "model": "MiMo-V2-Flash",
        "messages": [{"role": "user", "content": "Create a REST API with FastAPI"}],
        "max_tokens": 200
    }

    # Teste 3: Raciocínio matemático
    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"Teste {i} passou!")
            print(response.json()["choices"][0]["message"]["content"])
        else:
            print(f"Teste {i} falhou: {response.status_code}")

if __name__ == "__main__":
    test_mimo()

Execute o teste:

python test_mimo.py

Melhores Práticas

  1. Monitore o Uso da GPU: Use nvidia-smi para monitorar memória e temperatura da GPU
  2. Ajuste o Tamanho do Batch: Comece com batch size 1 e aumente gradualmente
  3. Use Ambientes Virtuais: Isole dependências com venv ou conda
  4. Atualize Regularmente: Mantenha drivers e CUDA toolkit atualizados
  5. Faça Backup do Modelo: Guarde uma cópia dos arquivos do modelo baixados

Benchmark de Desempenho

Executar Benchmark Simples

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 = "Write a detailed explanation of quantum computing"
tps = benchmark_model(model, tokenizer, prompt)
print(f"Tokens por segundo: {tps:.2f}")

Conclusão

Executar localmente o MiMo-V2-Flash da Xiaomi é uma forma poderosa de aproveitar capacidades de IA avançadas mantendo privacidade e controle. Seja usando SGLang para desempenho máximo ou Hugging Face Transformers para facilidade, este guia oferece todas as informações para começar.

Principais Pontos:

  • SGLang é recomendado para desempenho ótimo
  • Garanta memória GPU suficiente (15GB+ VRAM)
  • Use quantização se a memória for limitada
  • Experimente o comprimento do contexto para equilibrar desempenho e velocidade
  • Monitore o uso da GPU para evitar superaquecimento

Para escalar além do hardware local ou superar limitações, considere provedores de GPU na nuvem. Comece com o método recomendado SGLang e experimente outros frameworks conforme suas necessidades e configuração de hardware.

Recursos Adicionais:

Economize Muito em VPS Barato