LFM2-24B-A2B

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

LFM2-24B-A2B representa un avance en la modelación de lenguaje eficiente gracias al híbrido de Liquid AI Modelo de Espacio de Estado + Atención arquitectura. Con 24B parámetros totales pero solo 2B activos por token, ofrece un rendimiento impresionante mientras requiere únicamente ~6GB de VRAM para inferencia FP16. El modelo alcanza ~350 tok/s en 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 totales / 2B parámetros activos (híbrido SSM+Atención)

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

• Contexto: 32K tokens

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

• VRAM: ~6GB FP16, ~3GB 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 Estado (SSM) con mecanismos de atención selectiva. Los SSM 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 modelos grandes con la eficiencia de modelos pequeños.

Velocidad excepcional: El diseño de 2B parámetros activos permite una inferencia ultrarrápida. A diferencia de los modelos tradicionales donde se activan todos los parámetros, LFM2 activa selectivamente solo los componentes necesarios, resultando en más de 350 tokens/segundo en hardware de consumo.

Eficiencia de memoria: Con solo 6GB de VRAM para FP16, LFM2-24B-A2B funciona cómodamente en GPUs de gama media. Esto lo hace ideal para despliegue en el borde, entornos de desarrollo y configuraciones de producción conscientes del costo.

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 de la modelación de lenguaje eficiente.

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

Recomendaciones de GPU

GPU	VRAM	Rendimiento	Costo 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	40GB	~400 tok/s	~$3.50

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

*Precios estimados del mercado Clore.ai

Despliegue con vLLM

Instalar vLLM

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

Configuración de GPU única

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 servicial especializado en explicaciones técnicas."},
        {"role": "user", "content": "Explica las diferencias entre los Modelos de Espacio de Estado y los Transformers tradicionales"}
    ],
    max_tokens=1024,
    temperature=0.7
)

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

Despliegue con Ollama

Ollama ofrece la ruta de despliegue más sencilla:

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

# Extraer 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

# Compleción simple
response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'prompt': 'Escribe una función en Python para calcular los 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 sencillos'}
        ],
        'stream': False
    }
)

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

Plantilla Docker

FROM nvidia/cuda:12.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

# Establecer 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

Prueba 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 la prueba de velocidad
speed_test()

Cuantización para menor VRAM

Para GPUs con VRAM limitada, use versiones cuantizadas:

Cuantización GPTQ

# Instalar auto-gptq
pip install auto-gptq

# Usar modelo cuantizado (reduce a ~3GB 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 8GB:

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

El híbrido SSM+Atención de LFM2 ofrece ventajas únicas:

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

Atención selectiva: Solo los tokens críticos activan mecanismos de atención completos, reduciendo 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 SSM sobresalen en tareas secuenciales como la generación de texto, logrando mayor rendimiento que los mecanismos basados únicamente en atención.

Consejos para usuarios de Clore.ai

• Enfoque en GPU única: LFM2-24B-A2B está optimizado para despliegue en una sola GPU. Las configuraciones con múltiples GPUs no ofrecen beneficios significativos.

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

• Ajustes de temperatura: Temperaturas más bajas (0.1-0.3) maximizan la velocidad de inferencia al reducir la incertidumbre.

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

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

Solución de problemas

Problema	Solución
ImportError: liquid_transformers	Instalar: pip install git+https://github.com/LiquidAI-project/liquid-transformers.git
Inicio lento	Pre-descargar: huggingface-cli download liquid-ai/LFM2-24B-A2B
OutOfMemoryError	Use la versión cuantizada o reduzca max-model-len
Respuestas de mala calidad	Verifique las restricciones de licencia: algunas versiones del modelo tienen capacidades limitadas
Errores en la capa SSM	Actualizar 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	~14GB	~180 tok/s
LFM2-24B-A2B	2B	~6GB	~350 tok/s
Mistral 7B	7B	~14GB	~200 tok/s
Phi-3.5 3.8B	3.8B	~8GB	~250 tok/s

LFM2-24B-A2B logra la mejor relación velocidad/VRAM en su categoría.

Recursos

• LFM2-24B-A2B en Hugging Face

• Compañía Liquid AI

• Artículo sobre arquitectura SSM

• Licencias de Liquid AI

• Soporte SSM en vLLM