Construisez des modèles multimodaux spécialisés avec LFM3

LFM3 est notre nouvelle génération de Liquid Foundation Models (LFMs), conçue pour être le point de départ d'une intelligence spécialisée. Elle réunit des modèles de texte, vision, audio, omni et décision sur un seul backbone partagé, tous dans la gamme des 2B de paramètres. Cela signifie que vous pouvez choisir le modèle correspondant à votre modalité, l'affiner sur vos propres données sur un seul GPU, et le déployer là où votre application s'exécute.

LFM3 apporte quatre changements principaux par rapport à notre précédente famille LFM2 :

• Plus de capacité par paramètre : une nouvelle architecture tri-hybride et une nouvelle recette d'entraînement permettent à LFM3-1.7B de surpasser LFM2.5-2.6B tout en utilisant 35 % de paramètres en moins.
• Toutes les modalités sur un seul backbone : six modèles de classe 2B (texte, vision, audio, omni et décision) entraînés à partir de LFM3-1.7B-Base, dont notre premier modèle omni et l'entrée vidéo pour notre modèle de vision.
• Conçu pour l'edge : le modèle de texte tient dans environ 1 Go en précision 4-bit, de nouveaux encodeurs vision et audio internes accélèrent le traitement, et la fenêtre de contexte de 256K du modèle de texte permet aux agents de s'exécuter sur l'appareil.
• Fait pour être spécialisé : chaque modèle s'affine sur un seul GPU, ce qui vous permet de l'adapter à vos données, votre terminologie et votre environnement de déploiement.

Comment nous avons construit un backbone plus expressif

LFM2 a montré qu'un hybride de convolutions courtes et d'attention pouvait s'exécuter rapidement sur l'appareil sans sacrifier la qualité. Pour LFM3, nous avons utilisé notre recherche d'architecture hardware-in-the-loop pour repenser cette architecture pour les cas d'usage agentiques, qui exigent plus de capacité par paramètre et une inférence rapide sur de longs contextes. La recherche couvre désormais 14 combinaisons d'appareils et de backends, des téléphones et d'un Raspberry Pi 5 aux ordinateurs portables, CPU cloud, GPU et au Qualcomm Hexagon NPU.

LFM3-1.7B-Base compte 24 couches et quatre changements principaux :

1. Mélange de couches tri-hybride : 13 convolutions courtes à portes, 5 couches d'attention à fenêtre glissante (SWA) avec une fenêtre de 256 tokens, et 6 couches d'attention globale. Les convolutions utilisent une taille de noyau de 7, contre 3 dans LFM2.
2. Attention à portes par tête : une porte sigmoïde met à l'échelle la sortie de chaque tête, de sorte qu'une tête peut se désactiver quand elle n'a rien à ajouter. Cela peut aider à supprimer les valeurs d'activation aberrantes qui nuisent à la quantization.
3. RoPE partiel : les couches d'attention globale ne font tourner que la moitié de plus haute fréquence de chaque tête, si bien que l'autre moitié correspond sur le contenu quelle que soit la distance. Les couches SWA conservent le RoPE complet.
4. Sandwich norm : chaque bloc normalise à la fois son entrée et sa sortie pour maintenir les activations bien mises à l'échelle.

Le bénéfice apparaît sur les longs contextes. À paramètre égal, LFM3-1.7B égale LFM2-1.2B sur des prompts courts sur les appareils edge, et avec 8K tokens en contexte, il est environ 25 % plus rapide. LFM3-1.7B-Base a été pré-entraîné sur 22T de tokens avec le même vocabulaire de 128K que LFM2.5-8B-A1B. Les derniers 3.5T de tokens constituent une étape de mid-training sur des données organisées avec une part plus importante de traces agentiques et d'appels d'outils, ce qui étend également la fenêtre de contexte à 256K tokens.

Un seul backbone pour six modèles

Chaque modèle LFM3 dérive de LFM3-1.7B-Base. Au lieu d'exécuter un grand modèle à usage général, vous choisissez celui qui correspond à vos entrées, vous le personnalisez et vous l'exécutez sur l'appareil.

Les modèles vision et audio bénéficient également de deux nouveaux encodeurs internes :

• Encodeur vision : il combine convolution et attention et utilise 3x moins de calcul que l'encodeur SigLIP2 des précédents modèles LFM VL. Notre encodeur de 164M de paramètres égale l'encodeur vision de Qwen3.5-2B en précision tout en nécessitant 2.2x moins de FLOPs (les deux mesurés avec le même backbone de langage LFM2.5-230M). Pour la vidéo, il intègre chaque paire d'images échantillonnées dans une seule tranche temporelle, divisant par deux la longueur de la séquence temporelle.
• Encodeur audio et LiquidCodec : l'encodeur audio mélange attention à fenêtre glissante et courtes convolutions et est entièrement causal, si bien que le modèle peut effectuer le prefill pendant que vous parlez, avec un time to first token pouvant descendre à 50 ms. LiquidCodec, notre nouveau tokenizer audio, transforme les tokens générés en parole à environ 87x le temps réel sur un seul thread CPU d'un Apple M4 Max et prend en charge le décodage en streaming.

Comment utiliser les modèles LFM3

Chaque modèle fonctionne dans transformers. Les extraits ci-dessous proviennent des model cards, qui listent également les autres moteurs d'inférence pris en charge par chaque modèle.

LFM3-1.7B

Optez pour LFM3-1.7B lorsque vous avez besoin d'agents locaux, d'appel d'outils, de sorties structurées ou d'une base pour un fine-tuning spécifique à un domaine. Il est post-entraîné pour fonctionner dans des harnesses agentiques telles que Hermes Agent, Pi et OpenClaw. Il surpasse son prédécesseur, LFM2.5-2.6B, avec 35% de paramètres en moins, et les plus grands gains concernent les tâches agentiques : sur WebArena-Verified, il obtient 38.42 contre 3.02, et il bat même Qwen3.5-9B sur les tâches longues dans les navigateurs et les applications professionnelles. Vous trouverez plus de détails dans la model card de LFM3-1.7B.

Pour exécuter LFM3-1.7B, installez la dernière version de transformers:

pip install -U transformers

Chargez puis exécutez ensuite le modèle :

from transformers import pipeline

generator = pipeline(
    "text-generation",
    model="LiquidAI/LFM3-1.7B",
    trust_remote_code=True,
)

messages = [{"role": "user", "content": "What is C. elegans?"}]
output = generator(
    messages,
    do_sample=True,
    temperature=0.1,
    top_k=50,
    repetition_penalty=1.1,
    max_new_tokens=2048,
)
print(output[0]["generated_text"][-1]["content"])

Pour la configuration d'un agent local, consultez le guide Agent Harnesses.

LFM3-VL-2B

Optez pour LFM3-VL-2B lorsque vous avez besoin de compréhension visuelle sur l'appareil. C'est le premier modèle de vision LFM qui prend la vidéo en entrée ; il raisonne étape par étape avant de répondre, et il détecte les objets et raisonne sur leur disposition, une base solide pour la robotique. Comparé à LFM2.5-VL-3B, il a moins de paramètres (1.9B contre 3.1B) mais fait passer la moyenne sur 62 benchmarks de vision de 57.6 à 71.4, au niveau de Gemma 4 12B, un modèle plus de six fois plus grand. Vous trouverez plus de détails dans la model card de LFM3-VL-2B.

Pour exécuter LFM3-VL-2B, installez transformers>=5.21.0 avec ses dépendances vision :

pip install "transformers>=5.21.0" torch torchvision pillow

Chargez puis exécutez le modèle :

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

model_id = "LiquidAI/LFM3-VL-2B"

model = AutoModelForImageTextToText.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto", trust_remote_code=True)
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://placecats.com/300/200"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        do_sample=True,
        temperature=0.1,
        top_k=50,
        repetition_penalty=1.1,
        max_new_tokens=16384,  # generate() needs an explicit limit; reasoning can be long
    )

generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
print(processor.batch_decode(generated_ids, skip_special_tokens=True)[0])

Consultez la fiche du modèle LFM3-VL-2B pour l'appel d'outils, la recherche d'outils et l'inférence sur appareil avec llama.cpp.

LFM3-Audio-2B

Optez pour LFM3-Audio-2B lorsque vous avez besoin de chat vocal, de reconnaissance vocale, de synthèse vocale ou de traduction dans 18 langues sur un ordinateur portable ou un appareil edge. Il prend du texte ou de l'audio en entrée et répond par du texte, de la voix ou les deux, et il peut transformer des requêtes vocales en appels d'outils. Comparé à LFM2.5-Audio-1.5B, il utilise un nouvel encodeur audio et un codec vocal internes, parle avec une meilleure qualité (UTMOSv2 3.83 contre 3.22) et ajoute la compréhension audio, le raisonnement audio à usage général et l'appel d'outils. Vous trouverez plus de détails dans la fiche du modèle LFM3-Audio-2B.

Pour exécuter LFM3-Audio-2B, installez transformers>=5.20.2 avec ses dépendances audio :

pip install "transformers>=5.20.2" torch accelerate librosa soundfile

Chargez le modèle et le processeur directement depuis le Hugging Face Hub :

import torch
import soundfile as sf

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "LiquidAI/LFM3-Audio-2B"
device = "cuda" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16 if device == "cuda" else torch.float32

model = AutoModelForMultimodalLM.from_pretrained(
    model_id, dtype=dtype, device_map=device, trust_remote_code=True
).eval()
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
codec = processor.audio_tokenizer.to(device=device).eval()

Posez ensuite une question à voix haute et obtenez une réponse en texte et en parole :

conversation = [
    {"role": "system", "content": "Respond with interleaved text and audio."},
    {"role": "user", "content": [{"type": "audio", "audio": "question.wav"}]},
    {"role": "assistant", "content": "<|mixed_start|>"},
]
inputs = processor.apply_chat_template(
    conversation,
    continue_final_message=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(device)
with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=1024,
        audio_temperature=1.0,
        audio_top_k=128,
        audio_repetition_penalty=1.1,
        audio_repetition_window=4096,
        return_dict_in_generate=True,
    )

    text = processor.decode(
        outputs.sequences[0, inputs["input_ids"].shape[1]:],
        skip_special_tokens=True,
    )
    waveform = codec.decode(
        outputs.audio_codes[:1, :, :outputs.audio_lengths[0]]
    ).audio_values[0]  # 24 kHz
print(text)
sf.write("reply.wav", waveform.float().cpu().numpy(), 24_000)

Consultez la fiche du modèle LFM3-Audio-2B pour la reconnaissance vocale en direct, la synthèse de la parole, la compréhension audio et l'appel d'outils.

LFM3-Omni-2B

Optez pour LFM3-Omni-2B lorsque vous avez besoin d'un modèle embarqué unique qui voit, écoute et répond, à la place d'un modèle ASR séparé, d'un modèle vision-langage, d'un LLM et d'un modèle TTS. Il peut répondre oralement à des questions sur une image, regarder et écouter une vidéo simultanément, et transformer ce qu'il voit et entend en appels d'outils. C'est notre premier modèle omni, avec des entrées texte, vision et audio et des sorties à la fois texte et parole, et il conserve les capacités principales des modèles LFM3 autonomes, notamment la réponse aux questions visuelles, la reconnaissance vocale, la synthèse de la parole et le suivi d'instructions. Comme LFM3-Audio-2B, il parle par l'intermédiaire de LiquidCodec, qui convertit les tokens générés en parole plus vite qu'en temps réel, si bien que les réponses orales sont diffusées en streaming pendant que le modèle les génère. En compréhension audio-visuelle de vidéos, il surpasse des modèles allant jusqu'à 10.7B de paramètres, tels que Qwen2.5-Omni-7B, sur Daily-Omni, WorldSense et AV-SpeakerBench. Vous trouverez plus de détails dans la fiche du modèle LFM3-Omni-2B.

Pour exécuter LFM3-Omni-2B, installez transformers>=5.20.2 avec ses dépendances vision et audio :

pip install "transformers>=5.20.2" torch torchvision torchcodec accelerate pillow librosa soundfile

import torch
import soundfile as sf

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "LiquidAI/LFM3-Omni-2B"
device = "cuda" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16 if device == "cuda" else torch.float32

model = AutoModelForMultimodalLM.from_pretrained(
    model_id, dtype=dtype, device_map=device, trust_remote_code=True
).eval()
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
codec = processor.audio_tokenizer.to(device=device).eval()

Posez ensuite une question sur une photo par la voix :

conversation = [
    {
        "role": "system",
        "content": "Answer questions about the provided image. Base every answer only on what can be seen. Respond with text.",
    },
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "photo.jpg"},
            {"type": "audio", "audio": "question.wav"},
        ],
    },
]
inputs = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=1024, generation_mode="text")

print(processor.decode(
    outputs.sequences[0, inputs["input_ids"].shape[1]:outputs.sequence_lengths[0]],
    skip_special_tokens=True,
))

Consultez la fiche du modèle LFM3-Omni-2B pour la sortie parole, la vidéo avec sa bande sonore et l'appel d'outils.

d1-2B et d1-omni-2B

Optez pour les modèles d1 lorsque vous avez besoin de décisions structurées rapides plutôt que de texte généré. Donnez-leur une situation (un ticket d'assistance, une facture, un écran d'application, une photo, un message vocal) et une liste de questions, et ils répondent à toutes en une seule passe, chacune avec une probabilité calibrée. Au-delà des oui/non, des choix et des scores, ils peuvent désormais pointer vers des objets, lire des valeurs dans des documents, estimer des nombres avec une plage et choisir toutes les options applicables. Vous trouverez plus de détails dans les fiches des modèles d1-2B et d1-omni-2B.

Entre les deux modèles d1 :

• d1-2B: choisissez-le pour le texte, les images et la vidéo. Il remplace d1-3B avec un tiers de paramètres en moins et obtient de meilleurs scores sur nos quatre suites de décision, par exemple 75.5 contre 64.0 sur ImajevBench.
• d1-omni-2B: choisissez-le lorsque vos entrées incluent de l'audio. Si vous posez la question par la voix plutôt que par écrit, il conserve presque toute sa précision.

Pour exécuter d1-2B, installez transformers>=5.19 avec ses dépendances vision :

pip install "transformers>=5.19" torch torchvision pillow

Chargez ensuite d1-2B et posez-lui plusieurs questions sur un même ticket d'assistance en une seule passe :

import torch
from transformers import AutoModel

device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
dtype = torch.float32 if device == "cpu" else torch.bfloat16
model = AutoModel.from_pretrained("LiquidAI/d1-2B", trust_remote_code=True, dtype=dtype).to(device)

# Several named questions over one state, answered in one pass
questions = {
    "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},  # yes/no: P(yes)
    "team": {"type": "choice", "instructions": "Which team should handle this?",
             "criteria": {"billing": "Charges, refunds, invoices", "shipping": "Delivery and parcels",
                          "technical": "App or site faults"}},
    "topics": {"type": "choice", "multiple": True, "instructions": "Which topics does the message raise?",
               "criteria": {"billing": "Payments and charges", "delivery": "Shipping and parcels",
                            "login": "Signing in to the account"}},
    "urgency": {"type": "score", "instructions": "How urgent is this ticket?", "criteria": ["low", "medium", "high"]},
}
out = model.system_one("I was charged twice and my parcel never arrived. Please refund one charge.", questions)
a = out["answers"]
urgency = a["urgency"]["legend"][str(int(a["urgency"]["score"]))]
print(round(a["refund"]["noul"], 2), a["team"]["choice"], a["topics"]["choices"], urgency)
# 1.0 billing ['billing', 'delivery'] medium

Par souci de concision, nous n'incluons que l'exemple pour d1-2B. Consultez la fiche du modèle d1-omni-2B pour les clips audio et les questions orales.

Fine-tunez LFM3 pour votre tâche

LFM3 est conçu pour être spécialisé. Les modèles de pointe sont de puissants généralistes, mais ils ne sont pas nécessairement experts dans votre cas d'usage. LFM3 intègre une capacité supplémentaire dans un modèle petit et rapide, si bien qu'un court fine-tuning peut en faire un expert fiable de votre tâche, avec vos données, votre terminologie et vos outils. Comme il est petit, vous pouvez déployer le modèle fine-tuné là où votre application s'exécute, des appareils à l'infrastructure privée en passant par le cloud.

Chaque modèle peut être fine-tuné sur un seul GPU, et ces notebooks vous guident à travers une tâche complète pour les modèles texte, vision, audio et omni, de la préparation des données à l'évaluation.

Exemple : apprendre à LFM3 à agir

Nous adaptons LFM3-VL-2B en trois modèles de robotique complémentaires pour l'orchestration, la navigation et la manipulation. L'orchestrateur pilote un bras robotisé par des appels d'outils : il localise les objets en pointant, les mesure avec des outils de profondeur, invoque des planificateurs de mouvement et vérifie les résultats dans des images caméra ultérieures. Le navigateur suit des descriptions d'itinéraires à l'aide d'observations RGB récentes, prédisant des cibles spatiales et une trajectoire de points de passage en seulement cinq tokens. Le VLA de manipulation convertit les images, le langage et l'état du robot en blocs d'actions continues de huit étapes en une seule passe avant. Entraîné conjointement sur 15 embodiments, le VLA atteint un taux de réussite moyen de 96.2% sur les quatre suites LIBERO et de 45.7% sur les tâches de table RoboCasa-GR1, générant des blocs d'actions en moins de 50 ms sur un Jetson AGX Orin avec TensorRT FP16. Ces résultats mettent en évidence LFM3-VL-2B comme une base compacte pour la robotique, couvrant de la planification de haut niveau au contrôle de bas niveau avec une génération d'actions en temps réel sur du matériel embarqué.

Regardez LFM3-VL-2B gérer la perception, la navigation et la manipulation dans cette vidéo de démonstration.

Commencer avec LFM3

Tous les modèles LFM3 sont en open-weight et disponibles sur Hugging Face dès aujourd'hui :

• Télécharger : la collection LFM3 sur Hugging Face, incluant LFM3-1.7B-Base pour votre propre post-training.
• Fine-tuner : adaptez LFM3 à votre tâche avec nos notebooks de fine-tuning.
• Utiliser dans votre harness : suivez notre guide sur comment exécuter un agent local, comme OpenClaw, Hermes Agent et Pi.

Nous avons hâte de voir ce que vous construirez.

Citation

Si vous utilisez ce travail, veuillez citer le blog de publication :

@article{liquidAI2026LFM3,
  author = {Liquid AI},
  title = {Introducing LFM3: Every Modality for Specialized Intelligence},
  journal = {Liquid AI Blog},
  year = {2026},
  note = {www.liquid.ai/blog/lfm3},
}