> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/lfm2-24b.md).

# 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

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

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

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

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

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

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

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

## Cuantización para menos VRAM

Para GPUs con VRAM limitada, usa versiones cuantizadas:

### Cuantización GPTQ

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

```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 8 GB:

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

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](https://huggingface.co/liquid-ai/LFM2-24B-A2B)
* [Empresa Liquid AI](https://liquid.ai/)
* [Documento sobre la arquitectura SSM](https://arxiv.org/abs/2312.00752)
* [Licencias de Liquid AI](https://liquid.ai/licensing)
* [Compatibilidad de vLLM con SSM](https://docs.vllm.ai/en/latest/models/supported_models.html#liquid-ai)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.