💧Liquid LFM2.5 : comment exécuter et affiner

Exécutez et affinez LFM2.5 Instruct et Vision localement sur votre appareil !

Liquid AI publie LFM2.5, incluant leur instruct et vision modèle. LFM2.5-1.2B-Instruct est un modèle de raisonnement hybride de 1,17 milliard de paramètres entraîné sur 28T tokens et RL, offrant des performances de premier ordre à l'échelle du milliard de paramètres pour le suivi d'instructions, l'utilisation d'outils et les tâches agentiques. Voir Hugging Face Jobs sur l'utilisation de Codex pour entraîner LFM !

LFM2.5 fonctionne avec moins de 1 Go de RAM et atteint 239 tok/s en décodage sur CPU AMD. Vous pouvez aussi l'affiner localement avec Unsloth.

Texte LFM2.5-InstructVision LFM2.5-VL

GGUF dynamiques	Instruct 16 bits
LFM2.5-1.2B-Instruct-GGUF	LFM2.5-1.2B-Instruct

Spécifications du modèle :

• Paramètres: 1,17 G

• Architecture: 16 couches (10 blocs convolutionnels LIV à double porte + 6 blocs GQA)

• Budget d'entraînement: 28T tokens

• Longueur de contexte: 32 768 tokens

• Taille du vocabulaire: 65,536

• Langues: anglais, arabe, chinois, français, allemand, japonais, coréen, espagnol

⚙️ Guide d'utilisation

Liquid AI recommande ces paramètres pour l'inférence :

• temperature = 0.1

• top_k = 50

• top_p = 0.1

• repetition_penalty = 1.05

• Longueur de contexte maximale : 32,768

Format du modèle de chat

LFM2.5 utilise un format de type ChatML :

tokenizer.apply_chat_template([
    {"role": "system", "content": "You are a helpful assistant trained by Liquid AI."},
    {"role": "user", "content": "What is C. elegans?"},
], add_generation_prompt=True, tokenize=False)

Modèle de chat LFM2.5 :

<|startoftext|><|im_start|>system
You are a helpful assistant trained by Liquid AI.<|im_end|>
<|im_start|>user
What is C. elegans?<|im_end|>
<|im_start|>assistant

Utilisation d'outils

LFM2.5 prend en charge l'appel de fonctions avec des tokens spéciaux <|tool_call_start|> et <|tool_call_end|>. Fournissez les outils en tant qu'objet JSON dans le prompt système :

<|startoftext|><|im_start|>system
Liste d'outils : [{"name": "get_weather", "description": "Gets the current weather", "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}}]<|im_end|>
<|im_start|>user
Quel temps fait-il à Paris ?<|im_end|>
<|im_start|>assistant
<|tool_call_start|>[get_weather(city="Paris")]<|tool_call_end|>

🖥️ Exécuter LFM2.5-1.2B-Instruct

📖 Tutoriel llama.cpp (GGUF)

1. Construire llama.cpp

Obtenez la dernière llama.cpp depuis GitHub. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d’habitude - le support Metal est activé par défaut.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-server
cp llama.cpp/build/bin/llama-* llama.cpp

2. Exécuter directement depuis Hugging Face

./llama.cpp/llama-cli \
    -hf LiquidAI/LFM2.5-1.2B-Instruct-GGUF:Q4_K_M \
    --jinja --ctx-size 32768 \
    --temp 0.1 --top-k 50 --top-p 0.1 --repeat-penalty 1.05

3. Ou téléchargez d'abord le modèle

import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id="LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
    local_dir="LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
    allow_patterns=["*Q4_K_M*"],
)

4. Exécuter en mode conversation

./llama.cpp/llama-cli \
    --model LiquidAI/LFM2.5-1.2B-Instruct-GGUF/LFM2.5-1.2B-Instruct-Q4_K_M.gguf \
    --ctx-size 32768 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.1 \
    --top-k 50 \
    --top-p 0.1 \
    --repeat-penalty 1.05 \
    --jinja

🦥 Affinage (Fine-tuning) de LFM2.5 avec Unsloth

Unsloth prend en charge l'affinage des modèles LFM2.5. Le modèle 1.2B tient confortablement sur un GPU Colab T4 gratuit. L'entraînement est 2x plus rapide avec 50 % de VRAM en moins.

Notebook Colab gratuit :

• Carnet SFT LoRA LFM2.5-1.2B-Instruct

• Carnet GRPO LoRA LFM2.5-1.2B-Instruct

• Carnet de pré-entraînement continu LFM2.5-1.2B-Base (complétion de texte)

• Carnet de pré-entraînement continu LFM2.5-1.2B-Base (traduction)

LFM2.5 est recommandé pour les tâches agentiques, l'extraction de données, le RAG et l'utilisation d'outils. Il n'est pas recommandé pour les tâches intensives en connaissances ou la programmation.

Configuration Unsloth pour LFM2.5

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="LiquidAI/LFM2.5-1.2B-Instruct",
    max_seq_length=4096,
    load_in_4bit=False,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules = ["q_proj", "k_proj", "v_proj", "out_proj", "in_proj",
                      "w1", "w2", "w3"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

Configuration d'entraînement

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=4096,
    dataset_num_proc=2,
    packing=False,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=60,
        learning_rate=2e-4,
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)

trainer.train()

Enregistrer et exporter

# Enregistrer les adaptateurs LoRA
model.save_pretrained("lfm25_lora")
tokenizer.save_pretrained("lfm25_lora")

# Fusionner et enregistrer en 16 bits
model.save_pretrained_merged("lfm25_merged", tokenizer, save_method="merged_16bit")

# Exporter en GGUF
model.save_pretrained_gguf("lfm25_gguf", tokenizer, quantization_method="q4_k_m")

🎉 Servir & déployer avec llama-server

Pour déployer LFM2.5 en production avec une API compatible OpenAI :

./llama.cpp/llama-server \
    --model LiquidAI/LFM2.5-1.2B-Instruct-GGUF/LFM2.5-1.2B-Instruct-Q4_K_M.gguf \
    --alias "LiquidAI/LFM2.5-1.2B-Instruct" \
    --threads -1 \
    --n-gpu-layers 99 \
    --ctx-size 32768 \
    --port 8001 \
    --temp 0.1 \
    --top-k 50 \
    --top-p 0.1 \
    --repeat-penalty 1.05 \
    --jinja

Tester avec le client OpenAI :

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8001/v1",
    api_key="sk-no-key-required",
)

completion = client.chat.completions.create(
    model="LiquidAI/LFM2.5-1.2B-Instruct",
    messages=[{"role": "user", "content": "What is 2+2?"}],
)
print(completion.choices[0].message.content)

📊 Benchmarks

LFM2.5-1.2B-Instruct offre des performances de premier ordre à l'échelle du milliard de paramètres et propose une inférence CPU rapide avec une faible utilisation de mémoire :

💧 Guide Liquid LFM2.5-1.2B-VL

LFM2.5-VL-1.6B est un LLM visuel construit sur LFM2.5-1.2B-Base et optimisé pour de meilleures performances dans le monde réel. Vous pouvez désormais l'affiner le faire localement avec Unsloth.

Tutoriel d’exécutionTutoriel d’affinage

GGUF dynamiques	Instruct 16 bits
LFM2.5-VL-1.6B-GGUF	LFM2.5-VL-1.6B

Spécifications du modèle :

• Fond du LM: LFM2.5-1.2B-Base

• Encodeur vision: SigLIP2 NaFlex optimisé pour la forme 400M

• Longueur de contexte: 32 768 tokens

• Taille du vocabulaire: 65,536

• Langues: anglais, arabe, chinois, français, allemand, japonais, coréen et espagnol

• Traitement en résolution native: Gère des images jusqu'à 512×512 pixels sans mise à l'échelle et préserve les rapports d'aspect non standard sans distorsion

• Stratégie de découpage (tiling): Divise les grandes images en patches non chevauchants de 512×512 et inclut un encodage en miniature pour le contexte global

• Flexibilité à l'inférence: Nombre maximal de tokens image et nombre de tuiles réglables par l'utilisateur pour un compromis vitesse/qualité sans réentraînement

⚙️ Guide d'utilisation

Liquid AI recommande ces paramètres pour l'inférence :

• Texte: temperature=0.1, min_p=0.15, repetition_penalty=1.05

• Vision: min_image_tokens=64, max_image_tokens=256, do_image_splitting=True

Format du modèle de chat

LFM2.5-VL utilise un format de type ChatML :

tokenizer.apply_chat_template([
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "What's in this image?"}
        ]
    },
    {"role": "assistant", "content": "I can see a cat sitting on a couch."}
], tokenize=False)

Modèle de chat LFM2.5-VL :

<|startoftext|><|im_start|>system
Vous êtes un assistant multimodal utile par Liquid AI.<|im_end|>
<|im_start|>user
<image>Décrivez cette image.<|im_end|>
<|im_start|>assistant
Cette image montre un nématode Caenorhabditis elegans (C. elegans).<|im_end|>

🖥️ Exécuter LFM2.5-VL-1.6B

📖 Tutoriel llama.cpp (GGUF)

1. Construire llama.cpp

Obtenez la dernière version de llama.cpp depuis GitHub. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-server
cp llama.cpp/build/bin/llama-* llama.cpp

2. Exécuter directement depuis Hugging Face

./llama.cpp/llama-cli \
  -hf LiquidAI/LFM2.5-VL-1.6B-GGUF:Q4_0 \
  --image test_image.jpg \
  --image-max-tokens 64 \
  -p "What's in this image?" \
  -n 128

🦥 Affinage de LFM2.5-VL avec Unsloth

Unsloth prend en charge l'affinage des modèles LFM2.5. Le modèle 1.6B tient confortablement sur un GPU Colab T4 gratuit. L'entraînement est 2x plus rapide avec 50 % de VRAM en moins.

Notebook Colab gratuit :

• Carnet SFT LoRA LFM2.5-VL-1.6B

Configuration Unsloth pour LFM2.5

from unsloth import FastVisionModel
import torch

model, tokenizer = FastVisionModel.from_pretrained(
    model_name = "LiquidAI/LFM2.5-VL-1.6B",
    max_seq_length = 4096, 
    load_in_4bit = False, 
)

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = False, # Réglez sur False pour l'instant
    finetune_language_layers   = True, # False si vous n'affinez pas les couches linguistiques
    finetune_attention_modules = True, # False si vous n'affinez pas les couches d'attention
    finetune_mlp_modules       = True, # False si vous n'affinez pas les couches MLP
    r = 16,         
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
)

Configuration d'entraînement

from unsloth.trainer import UnslothVisionDataCollator
from trl import SFTTrainer, SFTConfig

FastVisionModel.for_training(model) # Activer pour l'entraînement !

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    data_collator = UnslothVisionDataCollator(model, tokenizer), # Doit être utilisé !
    train_dataset = converted_dataset,
    args = SFTConfig(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 30,# num_train_epochs = 1, # Utilisez ceci à la place de max_steps pour un entraînement complet
        learning_rate = 2e-4,
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.001,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
        report_to = "none",     # Pour Weights and Biases
        remove_unused_columns = False,
        dataset_text_field = "",
        dataset_kwargs = {"skip_prepare_dataset": True},
        max_length = 2048,
    ),
)

trainer.train()

Enregistrer et exporter

# Enregistrer les adaptateurs LoRA
model.save_pretrained("lfm25_lora")
tokenizer.save_pretrained("lfm25_lora")

# Fusionner et enregistrer en 16 bits
model.save_pretrained_merged("lfm25_merged", tokenizer, save_method="merged_16bit")

# Exporter en GGUF
model.save_pretrained_gguf("lfm25_gguf", tokenizer, quantization_method="q4_k_m")

📊 Benchmarks

LFM2.5-VL-1.6B offre des performances de premier ordre :

Modèle	MMStar	MM-IFEval	BLINK	InfoVQA (Val)	OCRBench (v2)	RealWorldQA	MMMU (Val)	MMMB (moyenne)	Multilingual MMBench (moyenne)
LFM2.5-VL-1.6B	50.67	52.29	48.82	62.71	41.44	64.84	40.56	76.96	65.90
LFM2-VL-1.6B	49.87	46.35	44.50	58.35	35.11	65.75	39.67	72.13	60.57
InternVL3.5-1B	50.27	36.17	44.19	60.99	33.53	57.12	41.89	68.93	58.32
FastVLM-1.5B	53.13	24.99	43.29	23.92	26.61	61.56	38.78	64.84	50.89

📚 Ressources

• Article de blog Liquid AI

• Rapport technique LFM2 (arXiv)

• Documentation Liquid AI

• Liquid Playground