LFM2-24B-A2B

LFM2-24B-A2B von Liquid AI auf Clore.ai bereitstellen — hybride SSM+Attention-Architektur mit 24B Gesamt- / 2B aktiven Parametern

LFM2-24B-A2B stellt einen Durchbruch in effizienter Sprachmodellierung durch Liquid AIs hybriden Zustandsraummodell + Attention Architektur dar. Mit 24B Gesamtparametern, aber nur 2B aktiven pro Token, liefert es beeindruckende Leistung und benötigt nur ca. 6 GB VRAM für FP16-Inferenz. Das Modell erreicht ca. 350 Tok/s auf einer RTX 4090 und gehört damit zu den schnellsten verfügbaren großen Sprachmodellen.

Auf einen Blick

• Modellgröße: 24B insgesamt / 2B aktive Parameter (hybrides SSM+Attention)

• Lizenz: Liquid AI Open License (kostenlos für nicht-kommerzielle Nutzung, kommerzielle Lizenz erhältlich)

• Kontext: 32K Tokens

• Leistung: Wettbewerbsfähig mit 7B–13B dichten Modellen

• VRAM: ~6GB FP16, ~3GB INT8

• Geschwindigkeit: ~350 tok/s auf RTX 4090, ~200 tok/s auf RTX 3090

Warum LFM2-24B-A2B?

Revolutionäre Architektur: LFM2-24B-A2B kombiniert Zustandsraummodelle (SSMs) mit selektiven Attention-Mechanismen. SSMs verarbeiten Sequenzen effizient, während Attention-Schichten sich auf komplexes Schlussfolgern konzentrieren. Dieser hybride Ansatz erreicht die Qualität großer Modelle bei der Effizienz kleiner Modelle.

Außergewöhnliche Geschwindigkeit: Das Design mit 2B aktiven Parametern ermöglicht blitzschnelle Inferenz. Im Gegensatz zu traditionellen Modellen, bei denen alle Parameter aktiviert werden, aktiviert LFM2 selektiv nur die notwendigen Komponenten, was zu über 350 Tokens/Sekunde auf Consumer-Hardware führt.

Speichereffizient: Mit nur 6 GB VRAM für FP16 läuft LFM2-24B-A2B problemlos auf GPUs der Mittelklasse. Dadurch eignet es sich ideal für Edge-Deployments, Entwicklungsumgebungen und kostenbewusste Produktionsumgebungen.

Liquid AI Innovation: Entwickelt von Liquid AI (gegründet von MIT-Forschern) repräsentiert LFM2 Spitzenforschung in neuronalen Architekturen. Das hybride SSM+Attention-Design könnte die Zukunft effizienter Sprachmodellierung sein.

Lizenzhinweis: Die Liquid AI Open License erlaubt kostenlose nicht-kommerzielle Nutzung. Kommerzielle Bereitstellung erfordert eine separate Lizenz von Liquid AI. Dies ist nicht MIT — überprüfen Sie die Lizenzbedingungen vor dem produktiven Einsatz.

GPU-Empfehlungen

GPU	VRAM	Leistung	Tägliche Kosten*
RTX 3060 12GB	12GB	~180 tok/s	~$0.80
RTX 3070	8GB	~220 tok/s	~$0.90
RTX 4060 Ti	16GB	~300 tok/s	~$1.20
RTX 4090	24GB	~350 tok/s	~$2.10
RTX 3090	24GB	~200 tok/s	~$1.10
A100 40GB	40GB	~400 tok/s	~$3.50

Bestes Preis-Leistungs-Verhältnis: RTX 4060 Ti 16GB bietet ausgezeichnete Performance pro Dollar. Maximale Geschwindigkeit: RTX 4090 entfesselt LFM2s volles Potenzial.

*Geschätzte Clore.ai-Marktplatzpreise

Bereitstellung mit vLLM

vLLM installieren

pip install vllm>=0.6.0
# oder neueste
pip install git+https://github.com/vllm-project/vllm.git

Einzel-GPU-Konfiguration

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --dtype float16 \
  --max-model-len 32768 \
  --served-model-name lfm2-24b \
  --trust-remote-code \
  --disable-log-stats

Den Server abfragen

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="lfm2-24b",
    messages=[
        {"role": "system", "content": "Sie sind ein hilfreicher KI-Assistent, der sich auf technische Erklärungen spezialisiert hat."},
        {"role": "user", "content": "Erklären Sie die Unterschiede zwischen Zustandsraummodellen und traditionellen Transformern"}
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)

Bereitstellung mit Ollama

Ollama bietet den einfachsten Bereitstellungsweg:

# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# LFM2-Modell ziehen
ollama pull liquid-ai/lfm2:24b

# Interaktiv ausführen
ollama run liquid-ai/lfm2:24b

# API-Modus
ollama serve

Ollama API Verwendung

import requests

# Einfache Vervollständigung
response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'prompt': 'Schreibe eine Python-Funktion zur Berechnung der Fibonacci-Zahlen mit Memoisierung',
        'stream': False
    }
)

print(response.json()['response'])

# Chat-Format
chat_response = requests.post('http://localhost:11434/api/chat',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'messages': [
            {'role': 'user', 'content': 'Erkläre Quantenverschränkung in einfachen Worten'}
        ],
        'stream': False
    }
)

print(chat_response.json()['message']['content'])

Docker-Vorlage

FROM nvidia/cuda:12.1-devel-ubuntu22.04

# Python 3.10 installieren
RUN apt-get update && apt-get install -y \
    python3.10 python3-pip curl && \
    rm -rf /var/lib/apt/lists/*

# vLLM installieren
RUN pip install vllm>=0.6.0 transformers

# Umgebung setzen
ENV PYTHONUNBUFFERED=1

# Modell vorab herunterladen (optional)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('liquid-ai/LFM2-24B-A2B', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "liquid-ai/LFM2-24B-A2B", \
     "--host", "0.0.0.0", \
     "--port", "8000", \
     "--dtype", "float16", \
     "--max-model-len", "16384", \
     "--trust-remote-code"]

Bauen und ausführen:

docker build -t lfm2-24b .
docker run --gpus all -p 8000:8000 lfm2-24b

Geschwindigkeits-Benchmark

Testen Sie LFM2s außergewöhnliche Inferenzgeschwindigkeit:

import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def speed_test():
    prompts = [
        "Erklären Sie maschinelles Lernen in einem Absatz",
        "Schreiben Sie einen schnellen Python-Sortieralgorithmus",
        "Beschreiben Sie die Vorteile erneuerbarer Energien",
        "Was ist die Hauptstadt von Frankreich und warum ist sie wichtig?",
        "Erstellen Sie eine einfache HTML-Seitenstruktur"
    ]
    
    total_tokens = 0
    total_time = 0
    
    for prompt in prompts:
        start_time = time.time()
        
        response = client.chat.completions.create(
            model="lfm2-24b",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
            temperature=0.1
        )
        
        end_time = time.time()
        
        tokens = len(response.choices[0].message.content.split())
        duration = end_time - start_time
        
        total_tokens += tokens
        total_time += duration
        
        print(f"Prompt: {prompt[:30]}...")
        print(f"Tokens: {tokens}, Time: {duration:.2f}s, Speed: {tokens/duration:.1f} tok/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Durchschnittliche Geschwindigkeit: {avg_speed:.1f} Tokens/Sekunde")
    return avg_speed

# Geschwindigkeitstest ausführen
speed_test()

Quantisierung für geringeren VRAM

Für GPUs mit begrenztem VRAM verwenden Sie quantisierte Versionen:

GPTQ-Quantisierung

# Installieren Sie auto-gptq
pip install auto-gptq

# Verwenden Sie das quantisierte Modell (reduziert auf ~3GB VRAM)
vllm serve liquid-ai/LFM2-24B-A2B-GPTQ \
  --model liquid-ai/LFM2-24B-A2B-GPTQ \
  --quantization gptq \
  --dtype float16 \
  --max-model-len 16384

AWQ-Quantisierung

# Installieren Sie autoawq
pip install autoawq

# Verwenden Sie AWQ-quantisiertes Modell
vllm serve liquid-ai/LFM2-24B-A2B-AWQ \
  --model liquid-ai/LFM2-24B-A2B-AWQ \
  --quantization awq \
  --dtype float16

Erweiterte Konfiguration

Speicheroptimierte Einrichtung

Für 8GB-GPUs:

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --dtype float16 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.85 \
  --swap-space 4 \
  --trust-remote-code

High-Throughput-Einrichtung

Für Produktions-Workloads:

vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --max-num-seqs 32 \
  --max-num-batched-tokens 8192 \
  --dtype float16 \
  --trust-remote-code

Vorteile der SSM-Architektur

LFM2s hybrides SSM+Attention bietet einzigartige Vorteile:

Lineare Skalierung: SSMs skalieren linear mit der Sequenzlänge, während traditionelle Transformer quadratisch skalieren. Dies ermöglicht effiziente Verarbeitung langer Kontexte.

Selektive Attention: Nur kritische Tokens lösen die vollständigen Attention-Mechanismen aus, was den Rechenaufwand reduziert.

Speichereffizienz: Das Design mit 2B aktiven Parametern bedeutet, dass die meisten der 24B Parameter während der Inferenz inaktiv bleiben und dadurch die Anforderungen an die Speicherbandbreite drastisch reduzieren.

Schnelle sequenzielle Verarbeitung: SSMs eignen sich besonders für sequenzielle Aufgaben wie Textgenerierung und erreichen höhere Durchsatzraten als reine Attention-Mechanismen.

Tipps für Clore.ai-Benutzer

• Fokus auf einzelne GPU: LFM2-24B-A2B ist für die Bereitstellung auf einer einzelnen GPU optimiert. Multi-GPU-Setups bieten keine signifikanten Vorteile.

• Kontextlänge: Verwenden Sie kürzere Kontexte (8K–16K) für maximale Geschwindigkeit. Längere Kontexte verringern den Effizienzvorteil der SSMs.

• Temperatureinstellungen: Niedrigere Temperaturen (0.1–0.3) maximieren die Inferenzgeschwindigkeit, indem sie die Unsicherheit reduzieren.

• Batchgröße: Erhöhen Sie die Batchgröße für mehrere gleichzeitige Anfragen, anstatt mehrere GPUs zu verwenden.

• Lizenzkonformität: Überprüfen Sie die kommerziellen Lizenzanforderungen mit Liquid AI vor dem Produktionseinsatz.

Fehlerbehebung

Problem	Lösung
ImportError: liquid_transformers	Installieren: pip install git+https://github.com/LiquidAI-project/liquid-transformers.git
Langsamer Start	Vorab herunterladen: huggingface-cli download liquid-ai/LFM2-24B-A2B
OutOfMemoryError	Verwenden Sie die quantisierte Version oder reduzieren Sie max-model-len
Schlechte Antwortqualität	Überprüfen Sie Lizenzbeschränkungen — einige Modellversionen haben eingeschränkte Fähigkeiten
SSM-Schicht-Fehler	Transformers aktualisieren: pip install transformers>=4.45.0

Leistungsvergleich

Modell	Aktive Parameter	VRAM (FP16)	Geschwindigkeit (RTX 4090)
Llama 3.2 3B	3B	~6GB	~280 tok/s
Qwen2.5 7B	7B	~14GB	~180 tok/s
LFM2-24B-A2B	2B	~6GB	~350 tok/s
Mistral 7B	7B	~14GB	~200 tok/s
Phi-3.5 3.8B	3.8B	~8GB	~250 tok/s

LFM2-24B-A2B erzielt das beste Speed-per-VRAM-Verhältnis in seiner Klasse.

Ressourcen

• LFM2-24B-A2B auf Hugging Face

• Liquid AI Unternehmen

• SSM-Architektur-Paper

• Liquid AI Lizenzierung

• vLLM SSM-Unterstützung