Spezialisierte multimodale Modelle mit LFM3 bauen

LFM3 ist unsere neue Generation der Liquid Foundation Models (LFMs), entwickelt als Ausgangspunkt für spezialisierte Intelligenz. Es vereint Text-, Vision-, Audio-, Omni- und Entscheidungsmodelle auf einem gemeinsamen Backbone, alle im 2B-Parameterbereich. Das bedeutet: Sie wählen das Modell für Ihre Modalität, feintunen es mit Ihren eigenen Daten auf einer einzigen GPU und setzen es dort ein, wo Ihre Anwendung läuft.

LFM3 bringt gegenüber unserer vorherigen LFM2-Familie vier wesentliche Änderungen mit:

• Mehr Leistung pro Parameter: eine neue Tri-Hybrid-Architektur und ein neues Trainingsrezept ermöglichen es LFM3-1.7B, LFM2.5-2.6B zu übertreffen, während es 35% weniger Parameter verwendet.
• Jede Modalität auf einem Backbone: sechs 2B-Klasse-Modelle (Text, Vision, Audio, Omni und Decision), trainiert aus LFM3-1.7B-Base, darunter unser erstes Omni-Modell und Videoeingabe für unser Vision-Modell.
• Gebaut für den Edge-Bereich: das Textmodell passt bei 4-Bit-Präzision in etwa 1 GB, neue eigene Vision- und Audio-Encoder beschleunigen die Verarbeitung, und das 256K-Kontextfenster des Textmodells ermöglicht es Agents, auf dem Gerät zu laufen.
• Gemacht, um spezialisiert zu werden: jedes Modell lässt sich auf einer einzigen GPU feintunen, sodass Sie es an Ihre Daten, Ihre Terminologie und Ihre Deployment-Umgebung anpassen können.

Wie wir einen ausdrucksstärkeren Backbone gebaut haben

LFM2 zeigte, dass eine Hybridarchitektur aus kurzen Faltungen und Attention schnell auf dem Gerät laufen kann, ohne Qualität einzubüßen. Für LFM3 haben wir unsere Hardware-in-the-Loop-Architektursuche genutzt, um diese Architektur für agentische Anwendungsfälle neu zu entwerfen, die mehr Leistung pro Parameter und schnelle Inferenz über lange Kontexte erfordern. Die Suche umfasst jetzt 14 Geräte- und Backend-Kombinationen, von Smartphones und einem Raspberry Pi 5 bis hin zu Laptops, Cloud-CPUs, GPUs und der Qualcomm Hexagon NPU.

LFM3-1.7B-Base hat 24 Schichten und vier wesentliche Änderungen:

1. Tri-Hybrid-Schichtmischung: 13 gated short convolutions, 5 Sliding-Window-Attention-Schichten (SWA) mit einem 256-Token-Fenster und 6 globale Attention-Schichten. Die Faltungen verwenden eine Kernelgröße von 7, gegenüber 3 in LFM2.
2. Head-wise gated attention: ein Sigmoid-Gate skaliert den Output jedes Heads, sodass ein Head abschalten kann, wenn er nichts beizutragen hat. Dies kann helfen, Aktivierungs-Ausreißer zu unterdrücken, die der Quantisierung schaden.
3. Partial RoPE: globale Attention-Schichten rotieren nur die Hälfte mit den höchsten Frequenzen jedes Heads, sodass die andere Hälfte unabhängig von der Entfernung auf Inhalte passt. SWA-Schichten behalten volles RoPE.
4. Sandwich norm: jeder Block normalisiert sowohl seine Eingabe als auch seine Ausgabe, um die Aktivierungen gut skaliert zu halten.

Der Nutzen zeigt sich bei langem Kontext. Pro Parameter entspricht LFM3-1.7B LFM2-1.2B bei kurzen Prompts auf Edge-Geräten, und mit 8K Token im Kontext ist es etwa 25% schneller. LFM3-1.7B-Base wurde auf 22T Token vortrainiert, mit demselben 128K-Vokabular wie LFM2.5-8B-A1B. Die letzten 3.5T Token sind eine Mid-Training-Phase mit kuratierten Daten und einem größeren Anteil an agentischen Traces und Tool-Aufrufen, wodurch auch das Kontextfenster auf 256K Token erweitert wird.

Ein Backbone für sechs Modelle

Jedes LFM3-Modell zweigt von LFM3-1.7B-Base ab. Statt ein großes Allzweckmodell zu betreiben, wählen Sie das Modell, das zu Ihren Eingaben passt, passen es an und führen es auf dem Gerät aus.

Die Vision- und Audio-Modelle erhalten zudem zwei neue hauseigene Encoder:

• Vision-Encoder: Er kombiniert Faltung und Attention und benötigt 3x weniger Rechenleistung als der SigLIP2-Encoder in früheren LFM VL-Modellen. Unser 164M-Parameter-Encoder erreicht die Genauigkeit des Vision-Encoders von Qwen3.5-2B, benötigt dabei jedoch 2.2x weniger FLOPs (beide gemessen mit demselben LFM2.5-230M Sprach-Backbone). Bei Video bettet er jedes Paar gesampelter Frames in einen temporalen Slice ein und halbiert damit die temporale Sequenzlänge.
• Audio-Encoder und LiquidCodec: Der Audio-Encoder kombiniert Sliding-Window-Attention mit kurzen Faltungen und ist vollständig kausal, sodass das Modell bereits während des Sprechens prefillen kann, mit einer Time-to-First-Token von bis zu 50 ms. LiquidCodec, unser neuer Audio-Tokenizer, wandelt generierte Tokens mit etwa 87x Echtzeit auf einem einzelnen CPU-Thread auf einem Apple M4 Max in Sprache um und unterstützt Streaming-Decoding.

So verwenden Sie die LFM3-Modelle

Jedes Modell läuft in transformers. Die folgenden Snippets stammen aus den Modellkarten, die auch die anderen von jedem Modell unterstützten Inferenz-Engines auflisten.

LFM3-1.7B

Greifen Sie zu LFM3-1.7B, wenn Sie lokale Agenten, Tool Calling, strukturierte Ausgaben oder eine Basis für domänenspezifisches Fine-Tuning benötigen. Es ist post-trainiert, um in agentic Harnesses wie Hermes Agent, Pi und OpenClaw zu laufen. Es übertrifft seinen Vorgänger LFM2.5-2.6B mit 35% weniger Parametern, und die größten Zuwächse liegen bei agentic Aufgaben: Auf WebArena-Verified erreicht es 38.42 gegenüber 3.02, und es schlägt sogar Qwen3.5-9B bei langen Aufgaben in Browsern und Business-Anwendungen. Weitere Details finden Sie in der LFM3-1.7B Modellkarte.

Um LFM3-1.7B auszuführen, installieren Sie die neueste Version von transformers:

pip install -U transformers

Dann laden und führen Sie das Modell aus:

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"])

Für die Einrichtung lokaler Agenten siehe die Agent Harnesses Anleitung.

LFM3-VL-2B

Greifen Sie zu LFM3-VL-2B, wenn Sie visuelles Verständnis auf dem Gerät benötigen. Es ist das erste LFM Vision-Modell, das Video als Eingabe akzeptiert; es argumentiert Schritt für Schritt, bevor es antwortet, und es findet Objekte und schließt auf deren Anordnung – eine starke Grundlage für Robotik. Im Vergleich zu LFM2.5-VL-3B hat es weniger Parameter (1.9B gegenüber 3.1B), erhöht aber den Durchschnitt über 62 Vision-Benchmarks von 57.6 auf 71.4, auf dem Niveau von Gemma 4 12B, einem mehr als sechsmal größeren Modell. Weitere Details finden Sie in der LFM3-VL-2B Modellkarte.

Um LFM3-VL-2B auszuführen, installieren Sie transformers>=5.21.0 mit seinen Vision-Abhängigkeiten:

pip install "transformers>=5.21.0" torch torchvision pillow

Laden und führen Sie dann das Modell aus:

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])

Siehe die LFM3-VL-2B-Modellkarte für Tool-Aufrufe, Tool-Suche und On-Device-Inferenz mit llama.cpp.

LFM3-Audio-2B

Greifen Sie zu LFM3-Audio-2B, wenn Sie Voice-Chat, Spracherkennung, Sprachsynthese oder Übersetzung in 18 Sprachen auf einem Laptop oder Edge-Gerät benötigen. Es nimmt Text oder Audio als Eingabe entgegen und antwortet mit Text, Sprache oder beidem, und es kann gesprochene Anfragen in Tool-Aufrufe umwandeln. Im Vergleich zu LFM2.5-Audio-1.5B verwendet es einen neuen hauseigenen Audio-Encoder und Speech-Codec, spricht mit höherer Qualität (UTMOSv2 3.83 gegenüber 3.22) und verfügt über Audio-Verständnis, allgemeine Audio-Denkfähigkeiten und Tool-Aufrufe. Weitere Details finden Sie in der LFM3-Audio-2B-Modellkarte.

Um LFM3-Audio-2B auszuführen, installieren Sie transformers>=5.20.2 mit seinen Audio-Abhängigkeiten:

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

Laden Sie das Modell und den Prozessor direkt aus dem 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()

Stellen Sie dann eine Frage laut und erhalten Sie eine Antwort in Text und Sprache:

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)

Sehen Sie sich die LFM3-Audio-2B model card für Live-Spracherkennung, Sprachsynthese, Audioverständnis und Tool Calling an.

LFM3-Omni-2B

Greifen Sie zu LFM3-Omni-2B, wenn Sie ein einzelnes On-Device-Modell benötigen, das sieht, zuhört und antwortet, anstelle eines separaten ASR-Modells, Vision-Sprachmodells, LLM und TTS-Modells. Es kann gesprochene Fragen zu einem Bild beantworten, ein Video gemeinsam ansehen und anhören und aus dem, was es sieht und hört, Tool Calls erzeugen. Es ist unser erstes Omni-Modell, mit Text-, Vision- und Audio-Eingabe sowie sowohl Text- als auch Sprachausgabe, und es bewahrt die Kernfähigkeiten der eigenständigen LFM3-Modelle, darunter visuelle Fragebeantwortung, Spracherkennung, Sprachsynthese und Befehlsbefolgung. Wie LFM3-Audio-2B spricht es über LiquidCodec, das generierte Token schneller als in Echtzeit in Sprache umwandelt, sodass gesprochene Antworten bereits während der Generierung durch das Modell gestreamt werden. Beim audio-visuellen Videoverständnis schlägt es Modelle mit bis zu 10.7B Parametern, wie Qwen2.5-Omni-7B, auf Daily-Omni, WorldSense und AV-SpeakerBench. Weitere Details finden Sie in der LFM3-Omni-2B model card.

Um LFM3-Omni-2B auszuführen, installieren Sie transformers>=5.20.2 mit seinen Vision- und Audio-Abhängigkeiten:

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()

Stellen Sie dann per Stimme eine Frage zu einem Foto:

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,
))

Sehen Sie sich die LFM3-Omni-2B model card für Sprachausgabe, Video mit Tonspur und Tool Calling an.

d1-2B und d1-omni-2B

Greifen Sie zu den d1-Modellen, wenn Sie schnelle, strukturierte Entscheidungen statt generiertem Text benötigen. Geben Sie ihnen eine Situation (ein Support-Ticket, eine Rechnung, einen App-Bildschirm, ein Foto, eine Sprachnotiz) und eine Liste von Fragen, und sie beantworten alle in einem einzigen Forward Pass, jeweils mit einer kalibrierten Wahrscheinlichkeit. Über Ja/Nein, Auswahlmöglichkeiten und Bewertungen hinaus können sie nun auf Objekte zeigen, Werte aus Dokumenten lesen, Zahlen mit einem Bereich schätzen und jede zutreffende Option auswählen. Weitere Details finden Sie in den Model Cards für d1-2B und d1-omni-2B.

Zwischen den beiden d1-Modellen:

• d1-2B: wählen Sie es für Text, Bilder und Video. Es ersetzt d1-3B mit einem Drittel weniger Parametern und erzielt höhere Werte in allen vier unserer Decision-Suites, beispielsweise 75.5 gegen 64.0 auf ImajevBench.
• d1-omni-2B: wählen Sie es, wenn Ihre Eingaben Audio enthalten. Wenn Sie per Stimme statt schriftlich fragen, behält es nahezu seine gesamte Genauigkeit.

Um d1-2B auszuführen, installieren Sie transformers>=5.19 mit seinen Vision-Abhängigkeiten:

pip install "transformers>=5.19" torch torchvision pillow

Laden Sie dann d1-2B und stellen Sie ihm mehrere Fragen zu einem Support-Ticket in einem einzigen Durchlauf:

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

Der Kürze halber führen wir nur das Beispiel für d1-2B an. Sehen Sie sich die d1-omni-2B model card für Audioclips und gesprochene Fragen an.

Fine-tunen Sie LFM3 für Ihre Aufgabe

LFM3 wurde entwickelt, um spezialisiert zu werden. Frontier-Modelle sind leistungsstarke Generalisten, aber sie sind nicht unbedingt Experten für Ihren Anwendungsfall. LFM3 bietet zusätzliche Kapazität in einem kleinen, schnellen Modell, sodass ein kurzes Fine-Tuning es zu einem zuverlässigen Experten für Ihre Aufgabe machen kann – mit Ihren Daten, Ihrer Terminologie und Ihren Tools. Da es klein ist, können Sie das fine-getunte Modell dort einsetzen, wo Ihre Anwendung läuft, von Geräten über private Infrastruktur bis zur Cloud.

Jedes Modell kann auf einer einzelnen GPU fine-getuned werden, und diese Notebooks führen Sie durch eine vollständige Aufgabe für die Text-, Vision-, Audio- und Omni-Modelle, von der Datenaufbereitung bis zur Evaluierung.

Beispiel: LFM3 das Handeln beibringen

Wir adaptieren LFM3-VL-2B zu drei komplementären Robotik-Modellen für Orchestrierung, Navigation und Manipulation. Der Orchestrator steuert einen Roboterarm über Toolaufrufe: Er referenziert Objekte durch Zeigen, vermisst sie mit Depth-Tools, ruft Motion Planner auf und überprüft die Ergebnisse in nachfolgenden Kamerabildern. Der Navigator folgt Routenbeschreibungen anhand aktueller RGB-Beobachtungen und sagt räumliche Ziele sowie eine Wegpunkt-Trajektorie in nur fünf Tokens voraus. Die Manipulations-VLA bildet Bilder, Sprache und Roboterzustand in einem einzigen Forward-Pass auf Acht-Schritt-Chunks kontinuierlicher Aktionen ab. Gemeinsam über 15 Embodiments trainiert, erreicht die VLA im Durchschnitt 96.2% Erfolg über die vier LIBERO-Suiten und 45.7% bei RoboCasa-GR1-Tischtasks und erzeugt Action-Chunks in unter 50 ms auf einem Jetson AGX Orin mit TensorRT FP16. Diese Ergebnisse heben LFM3-VL-2B als kompakte Grundlage für Robotik hervor, die von hochrangiger Planung bis hin zu niedrigrangiger Steuerung mit Echtzeit-Aktionserzeugung auf Embedded-Hardware reicht.

Sehen Sie zu, wie LFM3-VL-2B Wahrnehmung, Navigation und Manipulation bewältigt in dieses Demo-Video.

Einstieg in LFM3

Alle LFM3-Modelle sind Open-Weight und ab heute auf Hugging Face verfügbar:

• Download: die LFM3-Sammlung auf Hugging Face, einschließlich LFM3-1.7B-Base für dein eigenes Post-Training.
• Feinabstimmung: passen Sie LFM3 an Ihre Aufgabe an mit unserem Fine-Tuning-Notebooks.
• Verwenden Sie es in Ihrem Gurtzeug: folgen Sie unserem Leitfaden dazu, wie man einen lokalen Agenten betreibt, wie OpenClaw, Hermes Agent und Pi.

Wir können es kaum erwarten zu sehen, was du baust.

Quellenangabe

Wenn Sie diese Arbeit verwenden, zitieren Sie bitte den Release-Blog-Beitrag:

@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},
}