# LFM2-24B-A2B

> 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

```bash
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

```bash
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

```python
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:

```bash
# 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

```python
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

```dockerfile
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:

```bash
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:

```python
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

```bash
# 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

```bash
# 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:

```bash
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:

```bash
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](https://huggingface.co/liquid-ai/LFM2-24B-A2B)
* [Compañía Liquid AI](https://liquid.ai/)
* [Artículo sobre arquitectura SSM](https://arxiv.org/abs/2312.00752)
* [Licencias de Liquid AI](https://liquid.ai/licensing)
* [Soporte SSM en vLLM](https://docs.vllm.ai/en/latest/models/supported_models.html#liquid-ai)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/lfm2-24b.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.