LFM2-24B-A2B

Despliega LFM2-24B-A2B de Liquid AI en Clore.ai: arquitectura híbrida SSM+atención con 24B en total / 2B parámetros activos

LFM2-24B-A2B representa un avance en el modelado de lenguaje eficiente gracias al híbrido de Liquid AI Modelo de espacio de estados + atención arquitectura. Con 24B parámetros totales pero solo 2B activos por token, ofrece un rendimiento impresionante mientras requiere solo ~6 GB de VRAM para inferencia FP16. El modelo alcanza ~350 tok/s en una RTX 4090, lo que lo convierte en uno de los modelos de lenguaje grandes más rápidos disponibles.

De un vistazo

• Tamaño del modelo: 24B parámetros totales / 2B activos (SSM híbrido+atención)

• Licencia: Licencia Abierta de Liquid AI (uso gratuito no comercial, licencia comercial disponible)

• Contexto: 32K tokens

• Rendimiento: Competitivo con modelos densos de 7B-13B

• VRAM: ~6 GB FP16, ~3 GB INT8

• Velocidad: ~350 tok/s en RTX 4090, ~200 tok/s en RTX 3090

¿Por qué LFM2-24B-A2B?

Arquitectura revolucionaria: LFM2-24B-A2B combina Modelos de Espacio de Estados (SSMs) con mecanismos de atención selectiva. Los SSMs manejan el procesamiento secuencial de forma eficiente mientras que las capas de atención se centran en el razonamiento complejo. Este enfoque híbrido logra la calidad de un modelo grande con la eficiencia de un modelo pequeño.

Velocidad excepcional: El diseño de 2B parámetros activos permite una inferencia rapidísima. A diferencia de los modelos tradicionales, donde se activan todos los parámetros, LFM2 activa selectivamente solo los componentes necesarios, lo que da como resultado más de 350 tokens/segundo en hardware de consumo.

Eficiente en memoria: Con solo 6 GB de VRAM para FP16, LFM2-24B-A2B funciona cómodamente en GPUs de gama media. Esto lo hace ideal para despliegue en el edge, entornos de desarrollo y configuraciones de producción sensibles al coste.

Innovación de Liquid AI: Desarrollado por Liquid AI (fundada por investigadores del MIT), LFM2 representa investigación de vanguardia en arquitectura neuronal. El diseño híbrido SSM+Atención podría ser el futuro del modelado de lenguaje eficiente.

Nota de licencia: La Licencia Abierta de Liquid AI permite el uso gratuito no comercial. El despliegue comercial requiere una licencia aparte de Liquid AI. Esto es no MIT — verifica los términos de la licencia antes de usarlo en producción.

Recomendaciones de GPU

GPU	VRAM	Rendimiento	Coste diario*
RTX 3060 12GB	12GB	~180 tok/s	~$0.80
RTX 3070	8GB	~220 tok/s	~$0.90
RTX 4060 Ti	16GB	~300 tok/s	~$1.20
RTX 4090	24GB	~350 tok/s	~$2.10
RTX 3090	24GB	~200 tok/s	~$1.10
A100 40GB	40 GB	~400 tok/s	~$3.50

Mejor relación calidad-precio: La RTX 4060 Ti de 16 GB ofrece un rendimiento excelente por dólar. Velocidad máxima: La RTX 4090 libera todo el potencial de LFM2.

*Precios estimados del marketplace de Clore.ai

Despliega con vLLM

Instalar vLLM

pip install vllm>=0.6.0
# o la versión más reciente
pip install git+https://github.com/vllm-project/vllm.git

Configuración para una sola GPU

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --dtype float16 \
  --max-model-len 32768 \
  --served-model-name lfm2-24b \
  --trust-remote-code \\
  --disable-log-stats

Consultar el servidor

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="lfm2-24b",
    messages=[
        {"role": "system", "content": "Eres un asistente de IA útil especializado en explicaciones técnicas."},
        {"role": "user", "content": "Explica las diferencias entre los Modelos de Espacio de Estados y los Transformers tradicionales"}
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)

Desplegar con Ollama

Ollama proporciona la ruta de despliegue más simple:

# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descargar el modelo LFM2
ollama pull liquid-ai/lfm2:24b

# Ejecutar de forma interactiva
ollama run liquid-ai/lfm2:24b

# Modo API
ollama serve

Uso de la API de Ollama

import requests

# Completación simple
response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'prompt': 'Escribe una función de Python para calcular números de Fibonacci usando memoización',
        'stream': False
    }
)

print(response.json()['response'])

# Formato de chat
chat_response = requests.post('http://localhost:11434/api/chat',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'messages': [
            {'role': 'user', 'content': 'Explica el entrelazamiento cuántico en términos simples'}
        ],
        'stream': False
    }
)

print(chat_response.json()['message']['content'])

Plantilla de Docker

FROM nvidia/cuda:12.8.1-devel-ubuntu22.04

# Instalar Python 3.10
RUN apt-get update && apt-get install -y \\
    python3.10 python3-pip curl && \
    rm -rf /var/lib/apt/lists/*

# Instalar vLLM
RUN pip install vllm>=0.6.0 transformers

# Configurar el entorno
ENV PYTHONUNBUFFERED=1

# Pre-descargar el modelo (opcional)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('liquid-ai/LFM2-24B-A2B', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "liquid-ai/LFM2-24B-A2B", \
     "--host", "0.0.0.0", \\
     "--port", "8000", \
     "--dtype", "float16", \
     "--max-model-len", "16384", \
     "--trust-remote-code"]

Construir y ejecutar:

docker build -t lfm2-24b .
docker run --gpus all -p 8000:8000 lfm2-24b

Benchmark de velocidad

Prueba la excepcional velocidad de inferencia de LFM2:

import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def speed_test():
    prompts = [
        "Explica el aprendizaje automático en un párrafo",
        "Escribe un algoritmo de ordenación rápido en Python",
        "Describe los beneficios de la energía renovable",
        "¿Cuál es la capital de Francia y por qué es importante?",
        "Crea una estructura simple de página HTML"
    ]
    
    total_tokens = 0
    total_time = 0
    
    for prompt in prompts:
        start_time = time.time()
        
        response = client.chat.completions.create(
            model="lfm2-24b",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
            temperature=0.1
        )
        
        end_time = time.time()
        
        tokens = len(response.choices[0].message.content.split())
        duration = end_time - start_time
        
        total_tokens += tokens
        total_time += duration
        
        print(f"Prompt: {prompt[:30]}...")
        print(f"Tokens: {tokens}, Time: {duration:.2f}s, Speed: {tokens/duration:.1f} tok/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Velocidad media: {avg_speed:.1f} tokens/segundo")
    return avg_speed

# Ejecutar prueba de velocidad
speed_test()

Cuantización para menos VRAM

Para GPUs con VRAM limitada, usa versiones cuantizadas:

Cuantización GPTQ

# Instalar auto-gptq
pip install auto-gptq

# Usar modelo cuantizado (reduce a ~3 GB de VRAM)
vllm serve liquid-ai/LFM2-24B-A2B-GPTQ \
  --model liquid-ai/LFM2-24B-A2B-GPTQ \
  --quantization gptq \
  --dtype float16 \
  --max-model-len 16384

Cuantización AWQ

# Instalar autoawq
pip install autoawq

# Usar modelo cuantizado AWQ
vllm serve liquid-ai/LFM2-24B-A2B-AWQ \
  --model liquid-ai/LFM2-24B-A2B-AWQ \
  --quantization awq \\
  --dtype float16

Configuración avanzada

Configuración optimizada para memoria

Para GPUs de 8 GB:

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --dtype float16 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.85 \
  --swap-space 4 \
  --trust-remote-code

Configuración de alto rendimiento

Para cargas de trabajo de producción:

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --max-num-seqs 32 \
  --max-num-batched-tokens 8192 \
  --dtype float16 \
  --trust-remote-code

Beneficios de la arquitectura SSM

La arquitectura híbrida SSM+Atención de LFM2 ofrece ventajas únicas:

Escalado lineal: Los SSMs escalan linealmente con la longitud de la secuencia, mientras que los transformers tradicionales escalan cuadráticamente. Esto permite un procesamiento eficiente de contexto largo.

Atención selectiva: Solo los tokens críticos activan mecanismos de atención completos, lo que reduce la sobrecarga computacional.

Eficiencia de memoria: El diseño de 2B parámetros activos significa que la mayoría de los 24B parámetros permanecen inactivos durante la inferencia, reduciendo drásticamente los requisitos de ancho de banda de memoria.

Procesamiento secuencial rápido: Los SSMs destacan en tareas secuenciales como la generación de texto, logrando un mayor rendimiento que los mecanismos de atención puros.

Consejos para usuarios de Clore.ai

• Enfocado en una sola GPU: LFM2-24B-A2B está optimizado para despliegue en una sola GPU. Las configuraciones con varias GPUs no ofrecen beneficios significativos.

• Longitud del contexto: Usa contextos más cortos (8K-16K) para obtener la máxima velocidad. Los contextos más largos reducen la ventaja de eficiencia de los SSM.

• Configuración de temperatura: Las temperaturas más bajas (0.1-0.3) maximizan la velocidad de inferencia al reducir la incertidumbre.

• Tamaño de lote: Aumenta el tamaño de lote para múltiples solicitudes concurrentes en lugar de usar varias GPUs.

• Cumplimiento de la licencia: Verifica con Liquid AI los requisitos de licencia comercial antes del despliegue en producción.

Solución de problemas

Problema	Solución
ImportError: liquid_transformers	Instala: pip install git+https://github.com/LiquidAI-project/liquid-transformers.git
Inicio lento	Descarga previa: huggingface-cli download liquid-ai/LFM2-24B-A2B
OutOfMemoryError	Usa la versión cuantizada o reduce max-model-len
Respuestas de baja calidad	Comprueba las restricciones de licencia — algunas versiones del modelo tienen capacidades limitadas
Errores de la capa SSM	Actualiza transformers: pip install transformers>=4.45.0

Comparación de rendimiento

Modelo	Parámetros activos	VRAM (FP16)	Velocidad (RTX 4090)
Llama 3.2 3B	3B	~6GB	~280 tok/s
Qwen2.5 7B	7B	~14 GB	~180 tok/s
LFM2-24B-A2B	2B	~6GB	~350 tok/s
Mistral 7B	7B	~14 GB	~200 tok/s
Phi-3.5 3.8B	3.8B	~8 GB	~250 tok/s

LFM2-24B-A2B logra la mejor relación velocidad por VRAM de su clase.

Recursos

• LFM2-24B-A2B en Hugging Face

• Empresa Liquid AI

• Documento sobre la arquitectura SSM

• Licencias de Liquid AI

• Compatibilidad de vLLM con SSM