LFM2 di Liquid AI: l'architettura alternativa per l'edge

#LFM2 di Liquid AI: perché un modello progettato per la CPU

Liquid AI è una società nata dal MIT (CSAIL), fondata nel 2023 attorno alle «liquid neural networks» e ai modelli a stato continuo. Dopo una prima generazione LFM1 chiusa, l'azienda ha pubblicato nel luglio 2025 i pesi di LFM2, la seconda generazione, in tre dimensioni: 350M, 700M e 1,2B di parametri. Sono seguite altre varianti (2,6B, una versione MoE 8B-A1B, modelli di visione e audio, poi la generazione LFM2.5). Il filo conduttore non cambia: questi modelli puntano all'esecuzione sul dispositivo, cioè su un telefono, un portatile senza scheda grafica, un mini-PC o una scheda embedded.

Quasi tutti i piccoli modelli aperti che conosci (Qwen3, Gemma 3, Llama 3.2, SmolLM) sono transformer classici: ogni strato applica il meccanismo di attenzione all'intero contesto. Funziona molto bene su GPU, ma su CPU ogni token generato richiede di rileggere una cache chiave-valore (KV cache) che cresce con la conversazione, e il prefill di un prompt lungo è oneroso. LFM2 affronta proprio questi due punti sostituendo la maggior parte degli strati di attenzione con blocchi di convoluzione corta, che richiedono molta meno memoria e banda passante.

Obiettivo

Inferenza sul dispositivo: CPU x86 o ARM, NPU, GPU integrata. La GPU dedicata non è il principale ambito d'uso, anche se funziona.

Promessa quantificata

Liquid AI annuncia un decoding e un prefill fino a 2 volte più rapidi rispetto a Qwen3 di dimensioni comparabili su CPU (misure pubblicate su un AMD Ryzen AI 9 HX 370 e un Samsung Galaxy S24 Ultra).

Qualità

A parità di parametri, LFM2 si colloca allo stesso livello o leggermente al di sopra dei transformer concorrenti nei benchmark di conoscenze, istruzioni e matematica; il modello da 1,2B rivaleggia con Qwen3-1,7B su MMLU e IFEval.

Licenza

LFM Open License v1.0: uso commerciale libero al di sotto di una soglia di fatturato annuo (10 milioni di dollari); oltre tale soglia occorre contattare Liquid AI. Non è Apache 2.0: rileggi il testo prima di un deployment in azienda.

#Cosa cambia con l'architettura ibrida LFM

LFM2 dispone 16 blocchi in sequenza. Dieci sono blocchi di convoluzione a corto raggio con doppio gate (double-gated short-range convolution), sei sono blocchi di attenzione con query raggruppate (grouped query attention, GQA), come in un transformer moderno. Liquid AI descrive questi blocchi di convoluzione come operatori LIV (linear input-varying): i pesi applicati a ogni posizione dipendono dall'input, il che conferisce al blocco una forma di selettività simile a quella dei modelli a spazio di stato (Mamba) o delle RNN moderne, senza il loro complesso stato ricorrente.

In concreto, un blocco di convoluzione considera solo alcuni token vicini. Il suo costo per token è costante, indipendentemente dal contesto già generato, e non ha nulla da memorizzare in una cache KV. Solo i sei blocchi di attenzione conservano una cache, contro 28 o 36 livelli in un transformer di dimensioni comparabili. Due conseguenze dirette sulla CPU:

Decodifica più veloce

Generare un token consiste soprattutto nel rileggere i pesi e la cache KV dalla RAM. Con meno cache da rileggere, la larghezza di banda della memoria, che è il vero collo di bottiglia di una CPU, viene utilizzata meglio.

Prefill efficace

Elaborare un prompt di 4.000 token (un documento per il RAG, una cronologia di chat) costa proporzionalmente meno rispetto a un transformer completo, perché dieci blocchi su sedici operano con una finestra locale.

Memoria stabile

Il consumo aumenta lentamente con l'aumentare del contesto: la cache KV di sei strati resta piccola, il che conta su un telefono o una scheda con 4 o 8 GB di RAM condivisa.

Contesto nativo 32k

LFM2 è stato addestrato con una finestra di 32.768 token (128k su alcune varianti più recenti), sufficiente per riassunti e RAG leggeri.

Nel training, Liquid AI ha utilizzato circa 10.000 miliardi di token per la prima generazione LFM2, con un mix dominato dall'inglese, circa il 20% di dati multilingui (tra cui francese, tedesco, spagnolo, arabo, cinese, giapponese e coreano) e un po' di codice, più una distillazione dal LFM1-7B interno. È per questo che un LFM2-1,2B riesce a tenere una conversazione in francese corretto, cosa non garantita per tutti i modelli di questa dimensione.

#Famiglia LFM2: dimensioni e varianti

Tutte le varianti condividono la stessa architettura di base e lo stesso formato di chat (tag im_start/im_end in stile ChatML). Ecco quelle che contano per un utilizzo edge, con la dimensione approssimativa del file GGUF in Q4_K_M, che corrisponde all'incirca alla RAM occupata dai pesi quando il modello viene eseguito sulla CPU.

LFM2-350M

Intorno a 250 MB in Q4. Classificazione, estrazione, riscrittura breve. Funziona su quasi qualsiasi dispositivo, anche su un Raspberry Pi o un vecchio portatile.

LFM2-700M

Circa 450 MB in Q4. Un buon compromesso per un telefono recente o un assistente molto leggero.

LFM2-1.2B

Circa 730 MB in Q4. Modello di riferimento della famiglia: chat, riassunto, RAG semplice, chiamate a strumenti. È quello che questo manuale installa.

LFM2-2.6B

Circa 1,5 GB in Q4. Uscito alla fine del 2025, nettamente più solido nel ragionamento e nelle attività multilingue, funziona ancora molto bene su un portatile senza GPU.

LFM2-8B-A1B

Mixture of Experts: 8,3B di parametri in totale, circa 1,5B attivi per token. Circa 5 GB in Q4: serve la RAM di un 8B, ma la velocità rimane quella di un modello piccolo.

Varianti specializzate

LFM2-VL (visione, 450M e 1,6B), LFM2-Audio e varianti sottoposte a fine-tuning per l'estrazione dei dati, il RAG o le chiamate agli strumenti. La generazione LFM2.5 (a partire da gennaio 2026) riprende l'architettura con un addestramento prolungato; il catalogo del sito ne raccoglie le schede, comprese quelle dei modelli da 2,6B e 7B.

#Prerequisiti

Niente di esotico. L'importante è avere una versione recente del motore di inferenza: il supporto per l'architettura LFM2 è stato aggiunto a llama.cpp nel luglio 2025 e a Hugging Face Transformers nella versione 4.54. Le versioni di Ollama e di LM Studio pubblicate successivamente includono questo supporto, a condizione di aggiornarle.

Macchina

Qualsiasi PC o Mac recente. Una CPU a 4 core e 8 GB di RAM sono sufficienti per il modello 1,2B; prevedi 16 GB per il modello 8B-A1B.

Ollama aggiornato

Ollama ascolta per impostazione predefinita su http://localhost:11434. Aggiornalo prima di scaricare il modello: una versione precedente all'estate 2025 rifiuterà il GGUF con un errore di architettura sconosciuta.

O llama.cpp

Un binario recente (compilato o scaricato dalle release GitHub) permette di accedere a llama-cli, llama-server e soprattutto llama-bench per misurare la velocità.

Python opzionale

Per utilizzare i pesi originali (non quantizzati) con Transformers ≥ 4.54, ad esempio per il fine-tuning o un'esportazione verso un SDK mobile.

#Installare e testare LFM2 in locale

Liquid AI pubblica i suoi modelli su Hugging Face sotto l'organizzazione LiquidAI, con un repository dei pesi originali (LiquidAI/LFM2-1.2B) e un repository GGUF già quantizzato (LiquidAI/LFM2-1.2B-GGUF) per ogni dimensione. Il modo più semplice consiste nello scaricare direttamente questo GGUF in Ollama, senza passare per un Modelfile.

1. 01
   Aggiornare Ollama

   Su Linux, esegui di nuovo lo script di installazione ufficiale; su macOS e Windows, l'applicazione si aggiorna da sola o tramite il suo menu. Verifica con ollama --version.
2. 02
   Scaricare il GGUF da Hugging Face

   La sintassi hf.co/organisation/dépôt:quantification funziona con qualsiasi repository GGUF pubblico. Per LFM2-1.2B in Q4_K_M, il download pesa circa 730 MB.
3. 03
   Avviare una prima chat

   ollama run ouvre une session interactive. Posez une question en français pour vérifier la qualité de la langue avant de creuser.
4. 04
   Forzare l'uso della CPU per il confronto

   Se il tuo computer ha una GPU, puoi disattivarla per questo modello impostando num_gpu a 0 e osservare il comportamento reale usando solo la CPU.
5. 05
   Collegare un'interfaccia

   Il modello appare immediatamente in Open WebUI, LM Studio o in qualsiasi client compatibile con OpenAI configurato per usare la porta 11434.

# Vérifier la version (doit être récente, été 2025 ou plus)
ollama --version

# Tirer LFM2-1.2B quantifié en Q4_K_M depuis Hugging Face
ollama pull hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M

# Premier chat
ollama run hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M

# Même chose en CPU pur, même si un GPU est présent
ollama run hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M
>>> /set parameter num_gpu 0
>>> Résume en trois phrases ce qu'est un modèle de langage.

Il nome hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M è lungo da digitare; crea un alias locale con ollama cp per ottenere un semplice lfm2:1.2b. Per le altre dimensioni, sostituisci 1.2B con 350M, 700M o 2.6B, e per il MoE usa il repository LiquidAI/LFM2-8B-A1B-GGUF.

# Alias court
ollama cp hf.co/LiquidAI/LFM2-1.2B-GGUF:Q4_K_M lfm2:1.2b

# Appel API (compatible avec n'importe quel client Ollama)
curl http://localhost:11434/api/chat -d '{
  "model": "lfm2:1.2b",
  "messages": [{"role": "user", "content": "Explique la différence entre RAM et VRAM en deux phrases."}],
  "options": {"temperature": 0.3, "min_p": 0.15, "repeat_penalty": 1.05},
  "stream": false
}'

Se preferisci usare direttamente llama.cpp, il comando llama-cli accetta lo stesso repository Hugging Face con l'opzione -hf. È anche la soluzione da preferire per un server minimalista su una scheda ARM, dove llama-server consuma meno risorse di Ollama.

# Chat interactif, téléchargement automatique du GGUF
llama-cli -hf LiquidAI/LFM2-1.2B-GGUF:Q4_K_M -cnv \
  --temp 0.3 --min-p 0.15 --repeat-penalty 1.05 -t 8

# Serveur API OpenAI-compatible sur le port 8080
llama-server -hf LiquidAI/LFM2-1.2B-GGUF:Q4_K_M -c 8192 -t 8

Infine, per uno script Python con i pesi originali in bfloat16, Transformers basta. Prevedi circa 2,5 GB di RAM per il modello 1,2B in bf16; su CPU, questa soluzione è molto più lenta di llama.cpp e serve solo per lo sviluppo.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "LiquidAI/LFM2-1.2B"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype="bfloat16")

messages = [{"role": "user", "content": "Qu'est-ce qu'un modèle hybride convolution + attention ?"}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")
out = model.generate(inputs, max_new_tokens=200, do_sample=True, temperature=0.3, min_p=0.15, repetition_penalty=1.05)
print(tok.decode(out[0][inputs.shape[1]:], skip_special_tokens=True))

#Velocità con la sola CPU: i numeri reali

Su CPU contano due valori: la velocità di prefill (token del prompt elaborati al secondo, che determina il tempo prima della prima parola) e la velocità di generazione (token prodotti al secondo). Lo strumento adatto per misurarli correttamente è llama-bench, incluso in llama.cpp: isola le due fasi e ripete le misurazioni. Forza l'uso della CPU con -ngl 0 anche se è presente una GPU.

# Télécharger le GGUF une fois (llama-cli -hf le met en cache) puis :
llama-bench -m ~/.cache/llama.cpp/LiquidAI_LFM2-1.2B-GGUF_LFM2-1.2B-Q4_K_M.gguf \
  -ngl 0 -t 8 -p 512 -n 128

# Sortie : une ligne pp512 (prefill) et une ligne tg128 (génération), en tokens/s

# Comparer avec un transformer de taille voisine
llama-bench -m ~/.cache/llama.cpp/Qwen_Qwen3-1.7B-GGUF_Qwen3-1.7B-Q4_K_M.gguf -ngl 0 -t 8 -p 512 -n 128

Gli ordini di grandezza riportati di seguito corrispondono a quanto si osserva con llama.cpp in Q4_K_M, usando tutti i core fisici, su macchine comuni. Non sostituiscono una tua misurazione: la banda passante della memoria (DDR4 rispetto a DDR5, numero di canali) fa variare il risultato fino al doppio tra due PC della stessa generazione.

Portatile recente (8 core, DDR5)

LFM2-1.2B: da 40 a 70 token/s in generazione, diverse centinaia di token/s in prefill. Il 350M supera i 100 token/s. Il 2,6B si aggira tra 25 e 40 token/s.

PC desktop con 4–6 core, DDR4

LFM2-1.2B: da 20 a 35 token/s, ben al di sopra della velocità di lettura. Un Qwen3-1,7B sulla stessa macchina scende invece a un intervallo da 12 a 20 token/s.

Mac Apple Silicon (solo CPU)

Paragonabile a un portatile con DDR5 grazie alla memoria unificata; in pratica userai l'accelerazione Metal, ma LFM2 rimane agevole da usare su un MacBook Air anche con la sola CPU.

Raspberry Pi 5 (8 GB)

LFM2-1.2B: da 8 a 12 token/s; LFM2-350M: da 25 a 35 token/s. È il campo in cui la differenza rispetto a un transformer classico è più evidente.

LFM2-8B-A1B

Con 16 GB di RAM DDR5, aspettati da 30 a 50 token/s: solo 1,5 miliardi di parametri sono attivi per token, ma i 5 GB di pesi devono stare in memoria.

Il punto che fa la differenza nell'uso è il prefill. Su un transformer da 1,7B, caricare un documento di 4.000 token su CPU richiede spesso da 15 a 30 secondi prima della prima risposta; LFM2-1.2B riduce questo tempo di un fattore prossimo a due nei test pubblicati da Liquid AI, rendendo un RAG locale su CPU veramente utilizzabile piuttosto che semplicemente possibile.

#Per quali usi preferire LFM2

LFM2 non è un sostituto di Qwen3-8B né di Gemma 3 12B. Su una GPU con VRAM, un transformer più grande sarà più intelligente, punto. LFM2 diventa interessante non appena l'hardware è il vincolo: nessuna GPU, poca RAM, una batteria da preservare o un volume di richieste da gestire a costo costante.

Assistente su portatile senza GPU

Una chat fluida su un ultraportatile, senza una ventola che gira al massimo. Il modello da 1,2B o quello da 2,6B rispondono più velocemente di quanto si riesca a leggere.

Elaborazione batch su server CPU

Classificare ticket, estrarre campi, riscrivere descrizioni prodotto: migliaia di richieste brevi all'ora su una VM senza GPU, con il 350M o il 700M.

RAG locale leggero

Prefill rapido + contesto 32k: indicizzare note o documentazione interna e rispondere su CPU in pochi secondi.

Sistemi embedded e domotica

Raspberry Pi, mini-PC industriale, centralina domotica: interpretare un comando vocale trascritto, generare una risposta breve, chiamare uno strumento.

Mobile

Liquid AI propone il suo SDK LEAP (Liquid Edge AI Platform) per iOS e Android, e l'app Apollo per testare i modelli sul telefono. I GGUF funzionano anche nelle app basate su llama.cpp.

Chiamate agli strumenti

Le varianti instruct di LFM2 supportano nativamente il function calling tramite marcatori dedicati, trasformandolo in un router per agenti compatto ed economico.

Al contrario, mantieni un transformer classico quando hai una GPU e VRAM da sfruttare, quando il compito richiede ragionamenti lunghi (matematica, codice complesso) o quando dipendi da un ecosistema molto ricco di modelli ottenuti tramite fine-tuning: Qwen e Llama mantengono un vantaggio in questo campo.

#Limiti e risoluzione dei problemi

Errore « unknown model architecture: lfm2 »

Il tuo motore è troppo vecchio. Aggiorna Ollama, LM Studio o ricompila llama.cpp da una versione dopo luglio 2025.

Risposte che si ripetono in loop

Abbassa la temperatura a 0,3 e attiva min_p con valore 0.15 e repeat_penalty con valore 1.05, i valori consigliati da Liquid AI. I piccoli modelli sono sensibili alle impostazioni predefinite.

Velocità deludente

Verifica con ollama ps che il modello sia completamente caricato, riduci il numero di thread al numero dei core ad alte prestazioni e chiudi le applicazioni che saturano la banda passante della memoria (ad esempio il browser con decine di schede).

Francese scorretto

Il 350M resta limitato in francese; passa al modello 1,2B o al 2,6B, addestrati con una componente multilingue più utile.

Quantizzazione eccessivamente aggressiva

Su un modello da 350M o 700M, un Q4 degrada di più la qualità rispetto a un 7B. Preferisci Q8_0 per le dimensioni più piccole: il file rimane estremamente piccolo (meno di 800 MB per il 700M).

Licenza per l'uso in azienda

Al di sopra della soglia di fatturato stabilita dalla LFM Open License, l'uso commerciale richiede un accordo con Liquid AI. Verifica prima di mettere in produzione.

#Per approfondire

LFM2 esprime tutto il suo potenziale in una configurazione senza GPU o su una macchina di piccole dimensioni. Queste guide del sito completano la presente guida:

LLM locali senza GPU (CPU)

I modelli consigliati in base alla quantità di RAM e i benchmark in token/s sulla CPU, per confrontare LFM2 con le alternative.

Importare un modello GGUF da Hugging Face in Ollama

Tutto sulla sintassi hf.co, sui Modelfile e sugli alias, utile per fissare i parametri raccomandati di LFM2.

LLM su Raspberry Pi 5

Il caso d'uso embedded per eccellenza, dove la velocità di LFM2 fa la differenza.