LFM2-24B-A2B

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

LFM2-24B-A2B stellt einen Durchbruch im effizienten Sprachmodellieren durch das hybride System von Liquid AI dar Zustandsraummodell + Attention Architektur. Mit insgesamt 24B Parametern, aber nur 2B aktiven pro Token, liefert es beeindruckende Leistung und benötigt für FP16-Inferenz nur etwa 6 GB VRAM. Das Modell erreicht etwa 350 tok/s auf der 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 verfügbar)

• Kontext: 32K Token

• Leistung: Konkurrenzfähig mit dichten 7B-13B-Modellen

• VRAM: ~6 GB FP16, ~3 GB 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 State-Space-Modelle (SSMs) mit selektiven Attention-Mechanismen. SSMs verarbeiten Sequenzen effizient, während die 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. Anders als bei herkömmlichen Modellen, bei denen alle Parameter aktiviert werden, bindet LFM2 selektiv nur die notwendigen Komponenten ein, was auf Consumer-Hardware zu 350+ Tokens pro Sekunde führt.

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

Liquid AI Innovation: Entwickelt von Liquid AI (gegründet von MIT-Forschern), repräsentiert LFM2 Spitzenforschung in der neuronalen Architektur. Das hybride SSM+Attention-Design könnte die Zukunft des effizienten Sprachmodellierens sein.

Lizenzhinweis: Die Liquid AI Open License erlaubt kostenlose nicht-kommerzielle Nutzung. Für die kommerzielle Bereitstellung ist eine separate Lizenz von Liquid AI erforderlich. Dies ist nicht MIT — prüfen Sie die Lizenzbedingungen vor dem Produktionseinsatz.

GPU-Empfehlungen

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

Bestes Preis-Leistungs-Verhältnis: Die RTX 4060 Ti 16 GB bietet ein ausgezeichnetes Preis-Leistungs-Verhältnis. Maximale Geschwindigkeit: Die RTX 4090 entfesselt das volle Potenzial von LFM2.

*Geschätzte Preise auf dem Clore.ai-Marktplatz

Mit vLLM bereitstellen

vLLM installieren

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

Einzel-GPU-Setup

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": "Du bist ein hilfreicher KI-Assistent, der sich auf technische Erklärungen spezialisiert hat."},
        {"role": "user", "content": "Erkläre die Unterschiede zwischen State-Space-Modellen und traditionellen Transformern"}
    ],
    max_tokens=1024,
    temperature=0.7
)

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

Mit Ollama bereitstellen

Ollama bietet den einfachsten Bereitstellungsweg:

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

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

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

# API-Modus
ollama serve

Ollama API-Nutzung

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 von 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.8.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 festlegen
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 die außergewöhnliche Inferenzgeschwindigkeit von LFM2:

import time
from openai import OpenAI

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

def speed_test():
    prompts = [
        "Erkläre maschinelles Lernen in einem Absatz",
        "Schreibe einen schnellen Python-Sortieralgorithmus",
        "Beschreibe die Vorteile erneuerbarer Energien",
        "Was ist die Hauptstadt von Frankreich und warum ist sie wichtig?",
        "Erstelle 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}, Zeit: {duration:.2f}s, Geschwindigkeit: {tokens/duration:.1f} tok/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Durchschnittsgeschwindigkeit: {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

# auto-gptq installieren
pip install auto-gptq

# Quantisiertes Modell verwenden (reduziert auf ~3 GB 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

# autoawq installieren
pip install autoawq

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

Erweiterte Konfiguration

Speicheroptimiertes Setup

Für 8-GB-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

Durchsatzoptimiertes Setup

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. Das ermöglicht eine effiziente Verarbeitung langer Kontexte.

Selektive Attention: Nur kritische Token lösen volle Attention-Mechanismen aus, wodurch der Rechenaufwand sinkt.

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

Schnelle sequentielle Verarbeitung: SSMs eignen sich hervorragend für sequenzielle Aufgaben wie die Textgenerierung und erreichen einen höheren Durchsatz als reine Attention-Mechanismen.

Tipps für Clore.ai-Nutzer

• Fokus auf Einzel-GPU: LFM2-24B-A2B ist für den Einsatz auf einer einzelnen GPU optimiert. Multi-GPU-Setups bieten keinen wesentlichen Vorteil.

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

• Temperatureinstellungen: Niedrigere Temperaturen (0,1-0,3) maximieren die Inferenzgeschwindigkeit, indem sie die Unsicherheit reduzieren.

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

• Lizenz-Compliance: Prüfen Sie die kommerziellen Lizenzanforderungen mit Liquid AI vor der Produktionseinführung.

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	Prüfen Sie die Lizenzbeschränkungen — einige Modellversionen haben eingeschränkte Fähigkeiten
SSM-Layer-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	~14 GB	~180 tok/s
LFM2-24B-A2B	2B	~6GB	~350 tok/s
Mistral 7B	7B	~14 GB	~200 tok/s
Phi-3.5 3.8B	3.8B	~8 GB	~250 tok/s

LFM2-24B-A2B erzielt das beste Verhältnis von Geschwindigkeit zu VRAM in seiner Klasse.

Ressourcen

• LFM2-24B-A2B auf Hugging Face

• Liquid AI Unternehmen

• SSM-Architektur-Papier

• Liquid AI-Lizenzierung

• vLLM-SSM-Unterstützung