💧Liquid LFM2.5 : Comment exécuter & 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 hybride de raisonnement de 1,17 milliard de paramètres entraîné sur 28T de tokens et RL, offrant des performances de premier plan à l'échelle du milliard de paramètres pour le suivi d'instructions, l'utilisation d'outils et les tâches agentiques.

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

Texte LFM2.5-InstructVision LFM2.5-VL

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

Spécifications du modèle :

• Paramètres: 1,17B

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

• Budget d'entraînement: 28T de 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 maximale du contexte : 32,768

Format du modèle de conversation

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 sous forme d'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 le dernier 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-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

🦥 Fine-tuning de LFM2.5 avec Unsloth

Unsloth prend en charge le fine-tuning 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 :

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

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

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

• Notebook 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 nécessitant beaucoup de 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")

🎉 Serving & déploiement 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 plan à l'échelle du milliard de paramètres et propose une inférence CPU rapide avec une faible utilisation mémoire :

💧 Guide Liquid LFM2.5-1.2B-VL

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

Tutoriel d'exécutionTutoriel de fine-tuning

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

Spécifications du modèle :

• Noyau LM: LFM2.5-1.2B-Base

• Encodeur vision: SigLIP2 NaFlex optimisé en 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 à résolution native: Gère des images jusqu'à 512×512 pixels sans suréchantillonnage et préserve les rapports d'aspect non standard sans distorsion

• Stratégie de découpage en tuiles: Divise les grandes images en mosaïques non chevauchantes de 512×512 et inclut un encodage miniature pour le contexte global

• Flexibilité à l'inférence: Paramètres utilisateur ajustables pour le nombre maximal de tokens image et le nombre de tuiles afin de gérer le 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 conversation

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 serviable 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

🦥 Fine-tuning de LFM2.5-VL avec Unsloth

Unsloth prend en charge le fine-tuning 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 :

• Notebook 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, # Mettre sur False pour l'instant
    finetune_language_layers   = True, # False si vous n'affinez pas les couches de langage
    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), # À utiliser obligatoirement !
    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, # Mettre 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 plan :

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