Mistral stellt neue lokale Modelle vor: Le Chat und Mistral Large 2

Mistral stellt neue lokale Modelle vor: Le Chat und Mistral Large 2

Mistral AI erweitert die Grenzen von Open-Weight-Sprachmodellen mit zwei bedeutenden Neuveröffentlichungen: **Le Chat**, einem leichten, lokal ausführbaren Konversations-KI, und **Mistral Large 2**, einem leistungsstarken Flaggschiff-Modell für anspruchsvolle Denk- und Programmieraufgaben. Diese Modelle markieren eine strategische Neuausrichtung hin zur Bereitstellung hochwertiger KI auf Consumer-Hardware, ohne dabei Abstriche bei der Leistung zu machen. In diesem Artikel untersuchen wir ihre Fähigkeiten, führen Schritt für Schritt durch die Installation mit Ollama und Hugging Face und geben praktische Anwendungsbeispiele.

Voraussetzungen

Bevor Sie mit der Installation beginnen, stellen Sie sicher, dass Ihr System die folgenden Mindestanforderungen für die lokale Ausführung dieser Modelle erfüllt:

Hardware-Anforderungen

• **CPU**: 4+ Kerne (x86_64 oder ARM64)
• **RAM**: 8 GB für Le Chat, 32 GB für Mistral Large 2 (quantisierte Versionen können dies reduzieren)
• **Speicher**: 10 GB frei für Le Chat, 40 GB für Mistral Large 2
• **GPU (optional, aber empfohlen)**: NVIDIA-GPU mit 6+ GB VRAM (z. B. RTX 3060 oder höher) für beschleunigte Inferenz

Software-Anforderungen

• **Betriebssystem**: Linux (Ubuntu 22.04+), macOS 12+ oder Windows 10/11 mit WSL2
• **Python**: 3.10 oder neuer
• **Abhängigkeiten**: Ollama (für einfache Bereitstellung) oder Hugging Face `transformers` (für fortgeschrittene Integration)
• **Internet**: Erforderlich zum Herunterladen der Modellgewichte

Schritt-für-Schritt-Installation

Wir behandeln zwei Ansätze: die Verwendung von Ollama für eine problemlose Einrichtung und die Verwendung von Hugging Face für mehr Kontrolle über die Modellparameter.

Methode 1: Installation über Ollama

Ollama vereinfacht die Ausführung lokaler Modelle mit einem einzigen Befehl. Installieren Sie zuerst Ollama:

# Ollama herunterladen und installieren (Linux/macOS)
curl -fsSL https://ollama.com/install.sh | sh

Überprüfen Sie die Installation:

ollama --version
# Erwartete Ausgabe: ollama version 0.3.0 oder neuer

Laden Sie nun Mistrals Le Chat-Modell (2,7B Parameter, optimiert für Chat):

ollama pull mistral:le-chat

Für Mistral Large 2 (70B Parameter, benötigt mehr Speicher):

ollama pull mistral:large2

Wenn Ihr System über begrenzten RAM verfügt, verwenden Sie die quantisierte 4-Bit-Version von Mistral Large 2:

ollama pull mistral:large2-q4_0

Methode 2: Installation über Hugging Face Transformers

Für Entwickler, die eine fein abgestimmte Kontrolle benötigen, verwenden Sie die Hugging Face `transformers`-Bibliothek. Erstellen Sie zuerst eine Python-Virtual-Umgebung:

python3 -m venv mistral_env
source mistral_env/bin/activate  # Unter Windows: mistral_env\Scripts\activate

Installieren Sie die erforderlichen Pakete:

pip install torch transformers accelerate bitsandbytes

Laden Sie die Le Chat-Modellgewichte herunter:

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Le-Chat-2.7B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
print("Modell erfolgreich geladen")

Für Mistral Large 2 (erfordert ein Hugging Face-Token mit Zugriffsberechtigung von Mistral):

from huggingface_hub import login

login()  # Geben Sie Ihr Token ein, wenn Sie dazu aufgefordert werden

model_name = "mistralai/Mistral-Large-2-70B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
    load_in_4bit=True  # Reduziert den Speicher auf ~40 GB
)

Anwendungsbeispiele

Beispiel 1: Chat mit Le Chat über Ollama

Starten Sie eine interaktive Sitzung:

ollama run mistral:le-chat

Sie sehen eine Eingabeaufforderung. Versuchen Sie eine Konversationsabfrage:

>>> Schreiben Sie eine kurze Python-Funktion, um einen String umzukehren.

Le Chat antwortet:

def reverse_string(s):
    return s[::-1]

# Beispielverwendung
print(reverse_string("hallo"))  # Ausgabe: "ollah"

Beispiel 2: Batch-Inferenz mit Mistral Large 2

Verwenden Sie Mistral Large 2 für eine komplexe Denkaufgabe. Erstellen Sie ein Python-Skript `reasoning.py`:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Modell und Tokenizer laden
model_name = "mistralai/Mistral-Large-2-70B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True
)

# Prompt für mathematisches Denken vorbereiten
prompt = """Lösen Sie Schritt für Schritt:
Wenn ein Zug Bahnhof A mit 60 mph verlässt und ein anderer Zug Bahnhof B mit 90 mph verlässt,
und die Bahnhöfe 300 Meilen voneinander entfernt sind, wann treffen sie sich?

Denken Sie Schritt für Schritt:"""

# Tokenisieren und generieren
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(
    inputs.input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

# Dekodieren und ausgeben
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Führen Sie das Skript aus:

python reasoning.py

Die erwartete Ausgabe enthält eine schrittweise Aufschlüsselung:

Schritt 1: Kombinierte Geschwindigkeit = 60 + 90 = 150 mph
Schritt 2: Zeit = Entfernung / Geschwindigkeit = 300 / 150 = 2 Stunden
Antwort: Sie treffen sich nach 2 Stunden.

Beispiel 3: Code-Vervollständigung mit Le Chat

Le Chat zeichnet sich durch Codegenerierung aus. Verwenden Sie Ollama für eine schnelle Code-Vervollständigung:

ollama run mistral:le-chat

Eingabe:

>>> Vervollständigen Sie diese JavaScript-Funktion:
function fibonacci(n) {
  if (n <= 1) return n;

Le Chat vervollständigt:

  return fibonacci(n - 1) + fibonacci(n - 2);
}

Beispiel 4: RAG-Pipeline mit Mistral Large 2 (Fortgeschritten)

Integrieren Sie Mistral Large 2 in eine Retrieval-Augmented-Generation-Pipeline mit Hugging Face und FAISS:

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
from transformers import pipeline

# Embedding-Modell laden und Index erstellen
embedder = SentenceTransformer("all-MiniLM-L6-v2")
documents = [
    "Mistral Large 2 unterstützt ein 128K-Kontextfenster.",
    "Le Chat ist für latenzarmen Chat optimiert.",
    "Beide Modelle sind unter der Apache-2.0-Lizenz verfügbar."
]
embeddings = embedder.encode(documents)
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(np.array(embeddings))

# Abfrage
query = "Was ist das Kontextfenster von Mistral Large 2?"
query_embedding = embedder.encode([query])
distances, indices = index.search(np.array(query_embedding), k=1)
retrieved_doc = documents[indices[0][0]]

# Antwort mit Mistral Large 2 generieren
generator = pipeline("text-generation", model="mistralai/Mistral-Large-2-70B", device=0)
prompt = f"Basierend auf diesem Dokument: {retrieved_doc}\nAntwort: {query}"
result = generator(prompt, max_new_tokens=100)
print(result[0]["generated_text"])

Leistungsüberlegungen

• **Le Chat (2,7B)**: Läuft auf CPU mit 8 GB RAM bei ~10 Token/Sekunde. Mit GPU-Beschleunigung (z. B. RTX 3060) werden Geschwindigkeiten von 50+ Token/Sekunde erreicht.
• **Mistral Large 2 (70B)**: Erfordert 32 GB RAM für volle Präzision. Verwenden Sie 4-Bit-Quantisierung, um in 20 GB zu passen. Auf einer RTX 4090 sind 15-20 Token/Sekunde zu erwarten.
• **Kontextfenster**: Beide Modelle unterstützen bis zu 128K Token, aber der Speicher skaliert linear – Le Chat verwendet ~0,5 GB pro 32K Token, Mistral Large 2 ~4 GB.

Fazit

Mistrals neue lokale Modelle – Le Chat und Mistral Large 2 – stellen einen bedeutenden Schritt zur Demokratisierung der KI dar. Le Chat bietet einen reaktionsschnellen, leichten Assistenten, der sich ideal für alltägliche Aufgaben und Codegenerierung eignet, während Mistral Large 2 unternehmensgerechtes Denken in lokale Umgebungen bringt. Durch den Einsatz von Tools wie Ollama und Hugging Face können Entwickler diese Modelle in Minuten bereitstellen, sei es für Prototyping oder Produktion.

Die wichtigste Erkenntnis: Sie benötigen keine Cloud-APIs mehr, um auf hochmoderne Sprachmodelle zuzugreifen. Mit der richtigen Hardware und den hier beschriebenen Schritten können Sie Mistrals neueste Innovationen vollständig offline ausführen und so Datenschutz und geringe Latenz gewährleisten. Da Mistral diese Modelle auf der Grundlage von Community-Feedback weiter verfeinert, ist mit einer noch engeren Integration in lokale Entwicklungsworkflows zu rechnen. Beginnen Sie noch heute mit Experimenten – Ihr lokaler Rechner ist leistungsfähiger, als Sie denken.