LFM2.5-Encoders para inferencia rápida de contexto largo en CPU

Hoy lanzamos dos nuevos modelos encoder en Hugging Face: LFM2.5-Encoder-230M y LFM2.5-Encoder-350M. Estos modelos igualan la calidad de opciones más grandes, pero mantienen su velocidad a medida que las entradas aumentan de longitud. Esto permite ejecutar tareas a escala de documentos en el hardware que ya posee, incluso en una CPU convencional.

  • Potentes para su tamaño: igualan o superan a encoders más grandes en GLUE, SuperGLUE y tareas multilingües.
  • Contexto de 8,192 tokens: con una latencia que crece lentamente a medida que las entradas son más largas.
  • Rápidos en CPU: aproximadamente 3.7 veces más veloces que ModernBERT-base en contextos largos.

Con estos modelos, puede construir routers de intención, linters de políticas, detectores de PII y clasificadores de texto que se ejecutan de forma económica durante todo el día. Consulte las demostraciones en vivo a continuación.

¿Por qué creamos un encoder de propósito general?

El mes pasado lanzamos los LFM2.5-Retrievers, diseñados para búsqueda multilingüe. Los LFM2.5-Encoders provienen de la misma familia, pero sirven para un propósito más amplio. Están preentrenados con un objetivo de lenguaje enmascarado (masked-language), por lo que puede ajustarlos (fine-tune) para clasificación, tareas a nivel de token y búsqueda por igual. La búsqueda es solo una de las capacidades de un encoder; por eso construimos un modelo de propósito general en lugar de reutilizar los retrievers.

Los encoders impulsan muchas aplicaciones modernas de PNL en producción: clasificadores, routers de intención y filtros de seguridad. Estos trabajos se ejecutan constantemente, generalmente en CPU, con entradas cada vez más largas. BERT estableció esta clase de modelo, y recientemente ModernBERT impulsó su precisión, velocidad y contexto. Los LFM2.5-Encoders dan el siguiente paso en la arquitectura LFM2, donde el costo crece lentamente a medida que las entradas aumentan.

¿Cómo se construyen estos encoders?

Inicializamos los encoders a partir de sus respectivos backbones de decodificador LFM2: LFM2.5-230M y LFM2.5-350M. Luego, transformamos cada decodificador causal en un encoder bidireccional con algunos cambios:

  • Máscara de atención bidireccional: cada token ahora ve los tokens en ambos lados, no solo los anteriores.
  • Convoluciones cortas no causales: las rellenamos simétricamente para que la convolución de cada token mezcle a sus vecinos en ambos lados.
  • Modelado de lenguaje enmascarado: enmascaramos el 30% de los tokens durante el entrenamiento.

Entrenamos ambos modelos en dos etapas:

  • Competencia lingüística general: un objetivo de lenguaje enmascarado de contexto corto en un gran corpus web con un contexto de 1,024 tokens.
  • Adaptación a contexto largo: extendiendo el contexto a 8,192 tokens en la mezcla completa de datos, fortaleciendo la competencia factual, legal y multilingüe.

Resultados de los benchmarks

Ajustamos (fine-tune) cada modelo completamente en cada tarea y reportamos el puntaje resultante. En la tabla, se incluyen 14 modelos en 17 tareas extraídas de GLUE, SuperGLUE y clasificación multilingüe.

Ranking de rendimiento en benchmarks comparando 14 modelos en 17 tareas diferentes
Ranking de rendimiento en benchmarks comparando 14 modelos en 17 tareas diferentes

La imagen superior ilustra el desempeño comparativo de los modelos analizados en las distintas pruebas estandarizadas del sector.

Reportamos la media a través de cinco semillas (seeds) distintas, por lo que los números son estables entre ejecuciones. El framework completo y los resultados crudos son de código abierto.

El LFM2.5-Encoder-350M ocupa el cuarto lugar de los 14 modelos. Los tres que lo superan son más grandes, incluyendo un modelo de 3.5B que es casi 10 veces su tamaño. El LFM2.5-Encoder-230M supera a ModernBERT-base y a cada modelo EuroBERT, siendo más pequeño que la mayoría de ellos. Ambos también obtienen puntajes muy superiores a nuestros propios LFM2.5-Retrievers en esta categoría.

Velocidad de inferencia en CPU y GPU

Gráfico de velocidad de inferencia comparando modelos en CPU según longitud de secuencia
Gráfico de velocidad de inferencia comparando modelos en CPU según longitud de secuencia

Nuestros encoders heredan la inferencia rápida del backbone LFM2. Dado que tanto nuestros encoders como ModernBERT admiten un contexto de 8,192 tokens, medimos la velocidad en todo el rango. La gráfica anterior detalla el comportamiento del throughput en procesadores.

Nuestros encoders muestran su mayor ventaja en CPU. Aquí, el LFM2.5-Encoder-230M es el más rápido en cada longitud de secuencia (incluso más rápido que el ModernBERT-base más pequeño para entradas cortas). Con el aumento de la longitud de entrada, el throughput disminuye drásticamente para ModernBERT, mientras que nuestros LFM2.5-Encoders suben al rango medio antes de estabilizarse. A 8,192 tokens, ModernBERT-base toma más de un minuto y medio por paso de avance (forward pass) frente a unos 28 segundos para el LFM2.5-Encoder-230M. Esto es aproximadamente 3.7 veces más rápido. Para los desarrolladores, esto significa que puede escanear o clasificar un contrato completo, una transcripción o un hilo de soporte largo en menos de 30 segundos en la CPU de un computador portátil.

Gráfico de velocidad de inferencia comparando modelos en GPU según longitud de secuencia
Gráfico de velocidad de inferencia comparando modelos en GPU según longitud de secuencia

En GPU, se observa un patrón similar con un margen menor: ModernBERT-base lidera por debajo de ~1K tokens en la GPU de Apple. Nuestros encoders toman la delantera a partir de los 2K tokens aproximadamente. Esto demuestra que para entradas largas, los LFM2.5-Encoders son la opción más rápida, y si está ejecutando en CPU, la diferencia es drástica.

Demos de LFM2.5-Encoders

Construimos las siguientes demostraciones a partir de los LFM2.5-Encoders ajustados. Cada una se ejecuta en un espacio de Hugging Face exclusivo para CPU:

  • Zero-shot prompt routing: defina sus propios carriles de enrutamiento como texto libre. El modelo puntúa todo el prompt contra cada carril en una sola pasada.
  • Zero-shot policy linting: verifique el texto contra las reglas de su empresa, escritas como texto libre. Puntúa cada token contra cada regla en una sola pasada.
  • PII detection: detecte y elimine 40 tipos de información personal en 16 idiomas.
  • Masked-diffusion text generation (bonus): ejecute el encoder como un chatbot que genera texto mediante desenmascaramiento iterativo en lugar de izquierda a derecha.

Cómo usar y ajustar los LFM2.5-Encoders

Utilice un LFM2.5-Encoder cuando tenga una tarea de comprensión de alto volumen, como clasificación, enrutamiento, extracción o puntuación, que se ejecute constantemente y deba mantenerse económica y rápida. Para trabajos como estos, un encoder ajustado es más pequeño, más rápido y mucho más barato de ejecutar que un LLM generativo, y cabe en las CPUs que ya tiene.

Entre los dos tamaños de encoder:

  • LFM2.5-Encoder-350M: elíjalo cuando la precisión sea lo más importante.
  • LFM2.5-Encoder-230M: elíjalo para hardware más limitado o un throughput mayor.

Puede comenzar en pocas líneas. Cargue un modelo con transformers. Luego ejecútelo directamente para la predicción de tokens enmascarados, o adjunte su propia cabeza (head) y ajústelo para su tarea.

Cargar y ejecutar el modelo

Instale la última versión de transformers:

Código
pip install -U transformers

Ejecute la predicción de tokens enmascarados:

Código
from transformers import AutoModelForMaskedLM, AutoTokenizer
import torch

model_id = "LiquidAI/LFM2.5-Encoder-230M"

tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
mlm = AutoModelForMaskedLM.from_pretrained(model_id, trust_remote_code=True)

text = f"The capital of France is {tok.mask_token}."

enc = tok(text, return_tensors="pt")

with torch.no_grad():
    logits = mlm(**enc).logits
pos = (enc["input_ids"][0] == tok.mask_token_id).nonzero()[0].item()

print([tok.decode([t]).strip() for t in logits[0, pos].topk(5).indices.tolist()])

Para tareas posteriores, cargue el cuerpo del encoder y adjunte su propia cabeza (clasificación, clasificación de tokens, regresión, recuperación):

Código
from transformers import AutoModel

body = AutoModel.from_pretrained(model_id, trust_remote_code=True)

Si su GPU lo admite, use Flash Attention 2 para obtener la mayor eficiencia:

Código
pip install flash-attn

Ajuste fino para su tarea

Un encoder base le ofrece representaciones de propósito general, no salidas de tarea. Por lo tanto, debe ajustarlo para cada tarea específica. Vía Hugging Face.