Lokale Modellbereitstellung

Viele Leute denken, KI kann nur in der Cloud verwendet werden: Bei der Nutzung von ChatGPT werden Daten an die Server von OpenAI gesendet, und bei der Nutzung von Claude werden Anfragen an die Rechenzentren von Anthropic gesendet.

Tatsächlichkönnen KI-Modelle vollständig auf Ihrem eigenen Computer ausgeführt werden。

Stellen Sie sich vor: Sie können KI ohne Netzwerk nutzen, sensible Daten verlassen niemals Ihren Computer, keine Bezahlung pro Aufruf und Sie können sie nach Belieben anpassen.

Das ist der Wert des lokalen Modell-Deployments.

Dieses Modul führt Sie von Null dazu, Ihr erstes lokales KI-Modell auf Ihrem eigenen Computer auszuführen.

Warum lokale KI benötigt wird

Cloud-KI ist praktisch, aber lokale KI hat unersetzliche Vorteile.

Datenschutz

Dies ist der Hauptgrund, warum sich viele Menschen für ein lokales Deployment entscheiden.

Wenn Sie mit Verträgen, Krankenakten, Finanzdaten oder internen Dokumenten zu tun haben, ist das Senden dieser Daten an Server von Drittanbietern riskant.

Bei lokaler Ausführungwerden alle Daten auf Ihrem eigenen Computer verarbeitet und verlassen Ihr Gerät niemals。

Nutzung in Offline-Umgebungen

In Flugzeugen, Zügen oder an Orten mit instabilen Netzwerken ist Cloud-KI unbrauchbar.

Einmal heruntergeladene lokale Modelle sind für immer verfügbar und erfordern keine Netzwerkinverbindung.

Kostenkontrolle

Cloud-KI berechnet Gebühren basierend auf der Anzahl der Aufrufe oder Token, und starke Nutzung kann zu einer erheblichen Ausgabe werden.

Lokale Modelle werden einmal heruntergeladen und können danach frei ohne zusätzliche Kosten verwendet werden.

Anpassungsmöglichkeiten

Sie können Cloud-Modelle nicht modifizieren; Sie können nur die bereitgestellten Funktionen nutzen.

Mit lokalen Modellen können Sie Feinabstimmungen vornehmen, quantisieren, Prompt-Vorlagen ändern und sie vollständig an Ihre eigenen Bedürfnisse anpassen.

Vergleich dieser Vorteile:

Merkmal	Cloud-KI	Lokale KI
Datenschutz	Daten müssen hochgeladen werden	Daten sind vollständig lokal
Netzwerkabhängigkeit	Internetverbindung erforderlich	Kein Netzwerk erforderlich
Nutzungskosten	Pay-per-Use	Einmaliger Download, unbegrenzte Nutzung
Anpassungsfähigkeit	Eingeschränkt	Vollständig steuerbar
Benutzerfreundlichkeit	Sofort einsatzbereit	Erfordert Konfiguration
Antwortgeschwindigkeit	Abhängig vom Netzwerk	Abhängig von der Hardware

Nicht, dass Cloud-KI schlecht ist, sondernBeide haben ihre eigenen AnwendungszenarienFür den täglichen Chat nutzen Sie die Cloud; für sensible Daten nutzen Sie lokale Lösungen; für einfache Aufgaben nutzen Sie die Cloud; für spezielle Anpassungen nutzen Sie lokale Lösungen.

Bewertung der Hardwareanforderungen

Ob ein lokales Modell ausgeführt werden kann und wie schnell es läuft, hängt hauptsächlich von Ihrer Hardwarekonfiguration ab.

CPU-Inferenz vs. GPU-Inferenz

Es gibt zwei Möglichkeiten, Modelle auszuführen: CPU-Inferenz und GPU-Inferenz.

Die CPU-Inferenz verwendet den Hauptprozessor des Computers zur Ausführung von Modellen. Der Vorteil ist die gute Kompatibilität; fast jeder Computer kann sie ausführen. Der Nachteil ist die langsame Geschwindigkeit; große Modelle können viel Zeit in Anspruch nehmen.

Die GPU-Inferenz verwendet Grafikkarten. Der Kernvorteil isteine starke parallele Rechenleistung, wodurch die Modellausführung Dutzende Male schneller wird.。

Für NVIDIA-Grafikkarten müssen Sie das CUDA-Toolkit installieren; für AMD-Grafikkarten können Sie ROCm verwenden; für Intel-Grafikkarten können Sie OpenVINO verwenden.

Beziehung zwischen VRAM-Anforderungen und Modellgröße

Der VRAM bestimmt, wie groß das Modell sein kann, das Sie ausführen.

Je mehr Parameter ein Modell hat, desto mehr VRAM benötigt es. Mit Quantisierungstechniken können Sie jedoch größere Modelle mit weniger VRAM ausführen.

VRAM-Größe	Ausführbare Modelle (FP16)	Ausführbare Modelle (nach Quantisierung)	Empfohlene Szenarien
8 GB	7B-Modelle sind etwas schwierig	7B (Q4), 13B (Q4) laufen gerade so	Einfacher Chat, leichte Aufgaben
16 GB	7B-, 13B-Modelle	7B、13B（Q4/Q8）、33B（Q4）	Täglicher Gebrauch, bestes Preis-Leistungs-Verhältnis
24 GB	7B-, 13B-, 33B-Modelle	7B、13B、33B（Q4/Q8）、70B（Q4）	Professioneller Gebrauch, reibungslose Erfahrung
48 GB+	33B-, 70B-Modelle	Alle Mainstream-Modelle	Forschung, Produktionsumgebungen

Vorteile der Mac M-Serie

Apple Silicon (Chips der Serien M1, M2, M3) hat einzigartige Vorteile bei lokaler KI.

Apples Metal-Framework und die Unified Memory Architecture machen Macs äußerst effizient bei der Ausführung lokaler Modelle.

Unified Memory bedeutetCPU und GPU teilen sich den Speicherund können automatisch Speicher leihen, wenn der VRAM nicht ausreicht.

Ein MacBook Pro mit 16 GB Unified Memory kann quantisierte 7B- und 13B-Modelle reibungslos ausführen.

Empfohlene Konfigurationspläne

Basierend auf unterschiedlichen Budgets und Anforderungen finden Sie hier mehrere Konfigurationsoptionen:

Plan	Konfiguration	Geeignet für	Erwartete Erfahrung
Einsteiger-Plan	Jeder Computer (8 GB+ RAM)	Anfänger, die lokale KI erleben möchten	Kann kleine Modelle ausführen, relativ langsam
Plan mit bestem Preis-Leistungs-Verhältnis	16 GB RAM + 6 GB+ VRAM	Persönlicher täglicher Gebrauch	Reibungslose Ausführung von 7B/13B-Modellen
Professioneller Plan	32 GB RAM + 12 GB+ VRAM	Entwickler, Forscher	Reibungslose Ausführung von 33B-Modellen
Mac-Plan	M1/M2/M3 + 16 GB Unified Memory	Erste Wahl für Mac-Benutzer	Reibungslose Ausführung von 7B/13B-Modellen

Lassen Sie sich nicht einschüchtern von dem Begriff „großes Modell“. Die heutige Quantisierungstechnologie ermöglicht es bereits, dass 7B-Modelle auf gewöhnlichen Computern reibungslos laufen, und die Leistungsfähigkeit von 7B-Modellen reicht für die meisten täglichen Aufgaben aus.

Ollama: Das einfachste lokale KI-Tool

Offizielle Ollama-Website:https://ollama.com/
Liste der von Ollama unterstützten Modelle:https://ollama.com/search
Ollama-Tutorial:https://www.example.com/ollama/ollama-tutorial.html

Ollama ist derzeit das beliebteste lokale Modelltool. Um es in einem Satz zusammenzufassen:Installieren Sie Modelle wie Apps, nutzen Sie KI wie die Befehlszeile。

Installation und Konfiguration

Ollama unterstützt macOS, Linux und Windows, und der Installationsprozess ist sehr einfach.

Link zum Download des Installers:https://ollama.com/download

Mit einem Befehl installieren:

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

macOS-Benutzer können den Installer direkt herunterladen oder mit Homebrew installieren:

# macOS 使用 Homebrew 安装
brew install ollama

# 或者下载安装包：https://ollama.com/download

Windows-Benutzer können den Installer einfach von der offiziellen Website herunterladen und ausführen.

Nach der Installation starten Sie den Ollama-Dienst:

ollama serve

Sobald Sie sehen, dass der Dienst erfolgreich gestartet wurde, können Sie ihn verwenden.

Modelle herunterladen

Ollama's Modellbibliothek ist sehr umfangreich und umfasst Mainstream-Modelle wie Llama, Qwen, Gemma und Mistral.

Das Herunterladen eines Modells erfordert nur einen Befehl:

Beispiel

# Llama 3 herunterladen (8B Parameter)
ollama pull llama3

# Qwen herunterladen (Tongyi Qianwen, Chinesisch-freundlich)
ollama pull qwen

# Gemma herunterladen (von Google)
ollama pull gemma

# Mistral herunterladen
ollama pull mistral

Sie können auch den Befehlollama run + model nameverwenden, der das angegebene Modell automatisch herunterlädt, falls es noch nicht vorhanden ist:

ollama run qwen

Führen Sie das qwen-Modell aus und laden Sie es herunter, falls es nicht verfügbar ist.

Jedes Modell hat verschiedene Versionen wie 8B, 70B oder verschiedene quantisierte Versionen.

Sie könnenollama listverwenden, um bereits heruntergeladene Modelle anzuzeigen:

ollama list

Ausgabe ähnelt:

NAME              ID              SIZE      MODIFIED
qwen3.5:latest    6488c96fa5fa    6.6 GB    3 months ago

Kommandozeilen-Nutzung

Nachdem das Modell heruntergeladen wurde, können Sie es direkt ausführen, um eine Unterhaltung zu beginnen:

# 运行 Llama 3，没有会下载
ollama run llama3

# 运行 Qwen，没有会下载
ollama run qwen3.5

qwen3.5 ist für gewöhnliche Aufgaben mehr als ausreichend:

Dann können Sie direkt mit dem Modell sprechen:

>>> 你好，请介绍一下你自己
你好！我是 Llama 3，由 Meta 开发的 AI 助手。我可以帮你回答问题、
写作、编程、分析数据等。有什么我可以帮你的吗？

>>> 用 Python 写一个 Hello World 程序
好的，这是一个简单的 Python Hello World 程序：

print("Hello, World!")

>>> /bye  # 输入 /bye 退出

Gängige Befehle:

Befehl	Funktion	Beispiel
ollama pull <model>	Modell herunterladen	ollama pull llama3
ollama run <model>	Modell ausführen	ollama run llama3
ollama list	Installierte Modelle auflisten	ollama list
ollama rm <model>	Modell löschen	ollama rm llama3
ollama show <model>	Modellinformationen anzeigen	ollama show llama3

API-Schnittstellenaufrufe

Ollama verfügt über eine HTTP-API, sodass Sie es nicht nur über die Kommandozeile, sondern auch mit Code aufrufen können.

Standardmäßig befindet sich Ollama unterhttp://localhost:11434um den API-Dienst bereitzustellen.

Ollama-API mit Python aufrufen:

Beispiel

# Dateipfad: /Users/example/ollama_test.py
# Ollama-API mit Python aufrufen

import requests
import json

# Ollama-API-Adresse
OLLAMA_URL = "http://localhost:11434/api/generate"

def ask_ollama(prompt: str, model: str = "llama3") -> str:
"""
Anfrage an Ollama senden, um eine Modellantwort zu erhalten

Argumente:
prompt: die vom Benutzer eingegebene Eingabeaufforderung
model: der zu verwendende Modellname, standardmäßig llama3

Rückgabe:
Der Antworttext des Modells
"""
# Anfragedaten konstruieren
payload = {
"model": model, # Zu verwendendes Modell
"prompt": prompt, # Benutzereingabe
"stream": False # Keine Streaming-Ausgabe verwenden, alles auf einmal zurückgeben
}

try:
# POST-Anfrage senden
response = requests.post(OLLAMA_URL, json=payload)
response.raise_for_status() # Prüfen, ob die Anfrage erfolgreich war

# Das zurückgegebene JSON parsen
result = response.json()
return result.get("response", "")

except requests.exceptions.ConnectionError:
return "Error: Cannot connect to Ollama service, please confirm Ollama is started"
except requests.exceptions.RequestException as e:
return f"Request error: {str(e)}"

# Testen
if __name__ == "__main__":
# Testfrage 1
question1 = "Please introduce EXAMPLE tutorial in one sentence"
answer1 = ask_ollama(question1)
print(f"Question: {question1}")
print(f"Answer: {answer1}")
print("-" * 50)

# Testfrage 2
question2 = "Write a Python function to calculate the Fibonacci sequence"
answer2 = ask_ollama(question2)
print(f"Question: {question2}")
print(f"Answer: {answer2}")

Führen Sie dieses Skript aus:

Beispiel

# Zuerst die requests-Bibliothek installieren (falls noch nicht installiert)
pip install requests

# Skript ausführen
python ollama_test.py

Wenn Sie einen Wrapper auf einer höheren Ebene wünschen, können Sie Ollamas offizielle Python-Bibliothek verwenden:

Beispiel

# Dateipfad: /Users/example/ollama_advanced.py
# Verwendung der Ollama-Python-Bibliothek

# Zuerst installieren: pip install ollama

import ollama

def chat_with_example():
"""
Verwenden Sie die Ollama-Python-Bibliothek für Unterhaltungen mit mehreren Schritten
"""
# Nachrichtenverlauf
messages = [
{
"role": "system",
"content": "You are a friendly programming assistant named ExampleBot. Your answers should be concise and practical, with more code examples."
}
]

print("ExampleBot is started! Enter 'quit' to exit.")
print("-" * 50)

while True:
# Benutzereingabe abrufen
user_input = input(Sie:)

if user_input.lower() in ["quit", "exit", Beenden]:
print(Auf Wiedersehen!)
break

# Benutzernachricht zum Verlauf hinzufügen
messages.append({
"role": "user",
"content": user_input
})

# Modell aufrufen
response = ollama.chat(
model="llama3",
messages=messages
)

# Antwort abrufen
assistant_message = response["message"]["content"]
print(f"ExampleBot：{assistant_message}")
print("-" * 50)

# Antwort des Assistenten zum Verlauf hinzufügen
messages.append({
"role": "assistant",
"content": assistant_message
})

if __name__ == "__main__":
chat_with_example()

Integration mit Open WebUI

Die Kommandozeile ist praktisch, aber eine grafische Oberfläche ist benutzerfreundlicher.

Open WebUI ist eine sehr schöne Weboberfläche, die sich mit Ollama verbinden kann, sodass Sie lokale Modelle genau wie ChatGPT nutzen können.

Open WebUI installieren:

Beispiel

# Open WebUI mit Docker installieren
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

# Wenn Sie kein Docker verwenden, können Sie es auch mit pip installieren
pip install open-webui
open-webui serve

Nach der Installation im Browser öffnenhttp://localhost:3000, und Sie sehen eine Benutzeroberfläche, die ChatGPT sehr ähnelt.

Ollama + Open WebUI ist derzeit die am meisten empfohlene lokale KI-Kombination – einfach zu installieren, benutzerfreundliche Oberfläche und leistungsstark, geeignet für die allermeisten Benutzer.

LM Studio: Bedienung über grafische Benutzeroberfläche

Wenn Sie die Befehlszeile nicht mögen, ist LM Studio eine großartige Wahl –Reine grafische Benutzeroberfläche, das Herunterladen und Ausführen von Modellen erfolgt vollständig im Fenster.。

LM Studio installieren

LM Studio unterstützt Windows, macOS und Linux.

Von der offiziellen Websitehttps://lmstudio.aiLaden Sie das Installationspaket herunter und installieren Sie es direkt.

Modell-Download und -Verwaltung

Öffnen Sie LM Studio, die Modellbibliothek befindet sich auf der linken Seite.

Sie können nach Modellnamen suchen, zum Beispiel nach "llama", "qwen", "mistral" suchen, das gewünschte Modell finden und auf Herunterladen klicken.

LM Studio listet automatisch verschiedene Versionen desselben Modells auf:

Version	Beschreibung	Empfohlenes Szenario
Q4_K_M	4-Bit-Quantisierung, geringer Qualitätsverlust	Die Wahl der Meisten
Q5_K_M	5-Bit-Quantisierung, bessere Qualität, etwas größere Größe	Wählen Sie dies, wenn Sie genügend VRAM haben
Q8_0	8-Bit-Quantisierung, nahe an nativer Qualität	Für diejenigen, die Qualität anstreben und über genügend VRAM verfügen
FP16	Volle Präzision, größte Größe	Für Forschungszwecke

Heruntergeladene Modelle werden in der Liste "My Models" angezeigt.

Lokaler API-Dienst

LM Studio kann auch einen API-Dienst bereitstellen, der mit dem API-Format von OpenAI kompatibel ist.

Das bedeutet, dass Sie für den von Ihnen geschriebenen OpenAI-Code nur die API-Adresse und den Key ändern müssen, um ein lokales Modell zu verwenden.

Beispiel

# File path: /Users/example/lmstudio_openai.py
# LM Studio is compatible with OpenAI API format

from openai import OpenAI

# Connect to LM Studio local server
# Note: You need to start the server in LM Studio first
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # LM Studio can just use this placeholder
)

def ask_local_model(prompt: str, system_prompt: str = "You are a helpful assistant.") -> str:
"""
Aufrufen des lokalen LM-Studio-Modells über die OpenAI-kompatible Schnittstelle
"""
response = client.chat.completions.create(
model="local-model", # This field will be ignored by LM Studio
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt}
],
temperature=0.7,
)
return response.choices[0].message.content

# Test
if __name__ == "__main__":
question = "Introduce the features of the Python tutorial"
answer = ask_local_model(
prompt=question,
system_prompt="You are Example's dedicated customer service, professionally answering questions about programming learning."
)
print(f"Q: {question}")
print(f"A: {answer}")

Diese Funktion ist sehr nützlich – Sie können denselben Code verwenden, um je nach Bedarf zwischen Cloud-Modellen und lokalen Modellen zu wechseln.

Für Benutzer, die neu bei lokaler KI sind, empfehle ich: Beginnen Sie zunächst mit LM Studio, um die Grundkonzepte und -abläufe zu verstehen; sobald Sie vertraut sind, verwenden Sie Ollama für Automatisierung und Integration.

Erste Schritte mit der Modellquantisierung

Quantisierung ist eine Schlüsseltechnologie, die es großen Modellen ermöglicht, auf gewöhnlichen Computern zu laufen –Führen Sie größere Modelle mit weniger VRAM aus und behalten Sie gleichzeitig die meisten Funktionen bei。

Was ist Quantisierung

Einfach ausgedrückt ist Quantisierung die Reduzierung der Präzision von Modellparametern.

Native Modelle speichern jeden Parameter typischerweise mit 16-Bit-Gleitkommazahlen (FP16) oder 32-Bit-Gleitkommazahlen (FP32).

Nach der Quantisierung verwenden wir zur Speicherung 8-Bit-Ganzen Zahlen (INT8) oder sogar 4-Bit-Ganzen Zahlen (INT4).

Die Präzision nimmt ab, aber die Größe und die VRAM-Anforderungen werden stark reduziert.

Zum Beispiel:

Precision	7B Modellgröße	13B Modellgröße	VRAM-Anforderung	Qualitätsverlust
FP16	13 GB	26 GB	Hoch	Keine
Q8_0	7 GB	13 GB	Mittel	Sehr klein
Q5_K_M	5 GB	9 GB	Niedrig	Akzeptabel
Q4_K_M	4 GB	7 GB	Sehr gering	Gering
Q3_K_M	3 GB	5 GB	Extrem gering	Offensichtlich

Die Faustregel: Q8-Quantisierung hat einen fast unmerklichen Qualitätsverlust, und Q4-Quantisierung reicht für die meisten Aufgaben aus.

GGUF-Format erklärt

GGUF ist derzeit das beliebteste quantisierte Modellformat.

Der Vorgänger von GGUF ist GGML, entwickelt vom llama.cpp-Projekt.

Vorteile dieses Formats:

Erstens,Gute plattformübergreifende Kompatibilität– Funktioniert unter Windows, macOS und Linux; läuft sowohl auf CPU als auch auf GPU.
Zweitens,Unterstützt mehrere Quantisierungsstufen– Von FP16 bis Q3, nach Bedarf wählen.
Drittens,Hohe Inferenzgeschwindigkeit– Stark optimiert für CPU und GPU.

Die meisten lokalen Modell-Tools (Ollama, LM Studio, llama.cpp) unterstützen jetzt das GGUF-Format.

Unterschiede zwischen Q4/Q8-Quantisierung

Q4 und Q8 sind die beiden am häufigsten verwendeten Quantisierungsstufen.

Q8-Quantisierung ist 8-Bit; jeder Parameter wird als 8-Bit-Ganzzahl gespeichert. Der Vorteil von Q8 istMinimaler Qualitätsverlust, fast identisch mit dem Originalmodell; der Nachteil ist, dass die Größe immer noch nicht klein genug ist.
Q4-Quantisierung ist 4-Bit; jeder Parameter wird als 4-Bit-Ganzzahl gespeichert. Der Vorteil von Q4 istKleine Größe und hohe Geschwindigkeit; der Nachteil ist, dass die Qualität bei komplexen Aufgaben merklich abnimmt.

Wie man wählt:

Szenario	Empfohlene Quantisierungsstufe	Grund
Sehr begrenzter VRAM (unter 8GB)	Q4_K_M	Dass es nutzbar ist, hat oberste Priorität
Tägliche Unterhaltung, einfache Aufgaben	Q4_K_M	Bestes Preis-Leistungs-Verhältnis
Schreiben, Programmieren, Analyse	Q5_K_M oder Q6_K	Ausgleich von Qualität und Geschwindigkeit
Fokus auf beste Qualität	Q8_0	Nahe an nativer Qualität

AWQ/GPTQ-Quantisierungsschemata

Neben der GGUF-Quantisierung gibt es zwei weitere gängige Quantisierungsschemata: AWQ und GPTQ.

AWQ (Activation-aware Weight Quantization) zeichnet sich dadurch aus, dassGewichte beibehalten werden, die einen großen Einfluss auf die Ergebnisse haben, was zu einem geringeren Qualitätsverlust nach der Quantisierung führt.

GPTQ (Gradient-based Post-Training Quantization) zeichnet sich dadurch aus, dassGradienteninformationen zur Optimierung der Quantisierung verwendet werden, was für Szenarien mit GPU geeignet ist.

Diese beiden Schemata werden hauptsächlich auf NVIDIA-GPUs verwendet, die CUDA unterstützen.

Einfacher Vergleich:

Quantisierungsschema	Anwendbare Hardware	Geschwindigkeit	Qualität	Empfohlene Tools
GGUF	CPU + verschiedene GPUs	Schnell	Gut	Ollama, LM Studio
AWQ	NVIDIA-GPU	Sehr schnell	Sehr gut	vLLM, Text Generation WebUI
GPTQ	NVIDIA-GPU	Sehr schnell	Sehr gut	AutoGPTQ, ExLlama

Anfänger müssen sich über diese technischen Details keine Gedanken machen – verwenden Sie einfach die in Ollama oder LM Studio empfohlene Version Q4_K_M. Sie ist der durch umfangreiche Tests verifizierte beste Kompromiss.

Modellauswahl-Leitfaden

Es gibt inzwischen Hunderte von Open-Source-Modellen; es ist wichtig, eines auszuwählen, das Ihren Anforderungen entspricht.

Vergleich von 7B/13B/70B-Modellen

Die Anzahl der Parameter ist eine wichtige Metrik – 7B, 13B und 70B sind die gängigsten Spezifikationen.

Spezifikation	VRAM-Anforderung (Q4)	Inferenzgeschwindigkeit	Fähigkeitsstufe	Anwendbare Szenarien
7B	4-6 GB	Sehr schnell	Ausreichend	Tägliche Unterhaltung, einfache Aufgaben
13B	7-10 GB	Schnell	Gut	Schreiben, Programmieren, Analyse
33B	15-20 GB	Mittel	Ausgezeichnet	Komplexes Schlussfolgern, professionelle Domänen
70B	30-40 GB	Langsamer	Nahe an GPT-3.5	Forschung, Produktionsumgebungen

Für die meisten Menschen ist die quantisierte 13B Q4-Version der ideale Mittelweg – gute Leistungsfähigkeit bei akzeptabler Geschwindigkeit.

Empfohlene Modelle mit guter chinesischer Unterstützung

Viele ausländische Modelle haben mittelmäßige Chinesisch-Fähigkeiten. Hier sind einige chinesisch-freundliche Modelle:

Modellname	Developer	Funktionen	Ollama-Befehl
Qwen (Tongyi Qianwen)	Alibaba	Starke Chinesisch-Fähigkeiten, abgerundete Leistung	ollama pull qwen
Yi (01.AI)	01.AI	Gutes chinesisches Verständnis, starkes Schlussfolgern	ollama pull yi
DeepSeek	DeepSeek	Starke Programmierfähigkeiten, anständiges Chinesisch	ollama pull deepseek-coder
Llama 3	Meta	Insgesamt stark, aber Chinesisch benötigt Feinabstimmung	ollama pull llama3
Gemma	Google	Solides Fundament, gute Programmierfähigkeit	ollama pull gemma

Für chinesische Aufgaben ist Qwen die erste Wahl; das chinesische Verständnis und die Generierung gehören zu den besten unter den Open-Source-Modellen.

Aufgabenspezifische Modellauswahl

Verschiedene Modelle haben unterschiedliche Stärken; wählen Sie basierend auf Ihrer Aufgabe:

Aufgabentyp	Empfohlenes Modell	Grund
Alltägliche Konversation, Q&A	Llama 3, Qwen, Mistral	Ausgewogene Gesamtleistung
Schreiben, Copywriting	Yi, Llama 3, Claude (Cloud)	Guter Schreibstil, flüssiger Ausdruck
Programmierung, Code	DeepSeek-Coder, CodeLlama, StarCoder	Starkes Codeverständnis und -generierung
Mathematik, Schlussfolgern	Llama 3, Qwen, WizardMath	Gutes logisches Denken
Professionelle Bereiche (Medizin, Recht)	Auf den Bereich feinabgestimmte Modelle	Trainiert mit professionellen Daten

Ein größeres Modell ist nicht immer besser, und auch kein neueres –dasjenige, das zu Ihrer Hardware und Ihrer Aufgabe passt, ist das beste. Beginnen Sie damit, ein paar 7B-Modelle auszuprobieren, um ein Gefühl dafür zu bekommen, und rüsten Sie dann auf.

Praxis: Aufbau einer vollständig offline basierten lokalen Wissensbasis

Einer der praktischsten Anwendungsfälle für lokale Modelle ist der Aufbau Ihrer eigenen privaten Wissensbasis –füttern Sie das Modell mit lokalen Dokumenten und lassen Sie es Fragen basierend darauf beantworten。

Das gesamte System läuft vollständig offline; Daten verlassen niemals Ihren Computer.

Technischer Ansatz

Wir verwenden die RAG-Technologie (Retrieval-Augmented Generation):

1. Dokumente in Abschnitte aufteilen

2. Ein Embedding-Modell verwenden, um jeden Abschnitt in einen Vektor zu konvertieren

3. Vektoren in einer Vektordatenbank speichern

4. Bei einer Frage auch die Frage in einen Vektor konvertieren

5. Die relevantesten Dokumentenabschnitte in der Vektordatenbank finden

6. Die relevanten Dokumente und die Frage zusammen an das lokale LLM senden

7. Das LLM antwortet basierend auf dem Dokumenteninhalt

Das klingt komplex, ist aber mit vorhandenen Werkzeugen einfach.

Implementierung mit Ollama + LangChain

Wir werden Python verwenden, um eine einfache Version zu implementieren:

Beispiel

# Dateipfad: /Users/example/local_knowledge_base.py
# Vollständig offline lokales Wissensbasis-RAG-System

# Zuerst Abhängigkeiten installieren:
# pip install langchain langchain-ollama chromadb pypdf

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
import os

class LocalKnowledgeBase:
"""Klasse für lokale Wissensdatenbank zur Implementierung vollständig offline basierter RAG-Funktionalität"""

def __init__(self, model_name: str = "llama3", persist_dir: str = "./chroma_db"):
"""
Wissensdatenbank initialisieren

Argumente:
model_name: Der zu verwendende Ollama-Modellname
persist_dir: Persistenzverzeichnis der Vektordatenbank
"""
self.model_name = model_name
self.persist_dir = persist_dir

# 1. LLM initialisieren (lokales Modell)
self.llm = OllamaLLM(model=model_name)

# 2. Embedding-Modell initialisieren (lokale Embeddings)
# Verwenden Sie nomic-embed-text; dieses Modell funktioniert sowohl für Chinesisch als auch für Englisch gut
self.embeddings = OllamaEmbeddings(model="nomic-embed-text")

# 3. Platzhalter für Vektordatenbank
self.vector_store = None
self.qa_chain = None

def load_documents(self, document_paths: list):
"""
Dokumente laden und Vektordatenbank erstellen

Argumente:
document_paths: Liste der Dokumentpfade
"""
documents = []

for path in document_paths:
if not os.path.exists(path):
print(f"Warnung: Datei {path} existiert nicht, wird übersprungen")
continue

# Loader basierend auf Dateiendung auswählen
if path.lower().endswith(".pdf"):
loader = PyPDFLoader(path)
elif path.lower().endswith(".txt"):
loader = TextLoader(path, encoding="utf-8")
else:
print(f"Warnung: nicht unterstützter Dateityp {path}, wird übersprungen")
continue

documents.extend(loader.load())
print(f"Geladen: {path}")

if not documents:
print("Es wurden keine Dokumente erfolgreich geladen")
return

print(f"Insgesamt {len(documents)} Dokumenten-Chunks geladen")

# 4. Dokumente aufteilen
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, # Jeder Chunk: 500 Zeichen
chunk_overlap=100 # Überlappung zwischen Chunks: 100 Zeichen
)
split_docs = text_splitter.split_documents(documents)
print(f"In {len(split_docs)} Chunks aufgeteilt")

# 5. Vektordatenbank erstellen
print("Vektordatenbank wird erstellt...")
self.vector_store = Chroma.from_documents(
documents=split_docs,
embedding=self.embeddings,
persist_directory=self.persist_dir
)
print("Vektordatenbank erfolgreich erstellt!")

# 6. QA-Chain erstellen
self._build_qa_chain()

def _build_qa_chain(self):
"""RAG-QA-Chain erstellen"""
if not self.vector_store:
print("Bitte laden Sie zuerst ein Dokument!")
return

# Retriever erstellen
retriever = self.vector_store.as_retriever(
search_type="similarity",
search_kwargs={"k": 3} # Die 3 relevantesten Chunks zurückgeben
)

# RAG-Chain erstellen
self.qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)

def load_existing_db(self):
"""Bestehende Vektordatenbank laden"""
if os.path.exists(self.persist_dir):
self.vector_store = Chroma(
persist_directory=self.persist_dir,
embedding_function=self.embeddings
)
self._build_qa_chain()
print("Bestehende Vektordatenbank geladen")
return True
else:
print("Keine bestehende Vektordatenbank gefunden")
return False

def ask(self, question: str) -> dict:
"""
Der Wissensdatenbank eine Frage stellen

Argumente:
question: Frage

Rückgabe:
Ein Wörterbuch, das die Antwort und Referenzquellen enthält
"""
if not self.qa_chain:
return {"error": "Bitte laden Sie zuerst ein Dokument oder eine bestehende Datenbank!"}

# Prompt-Vorlage erstellen, um chinesische Antworten zu fördern
result = self.qa_chain.invoke({
"query": f"""Bitte beantworten Sie die folgende Frage auf Chinesisch. Wenn die Antwort im Kontext enthalten ist, weisen Sie ausdrücklich darauf hin.
Wenn die Antwort nicht im Kontext enthalten ist, sagen Sie ehrlich: „Kann basierend auf den bereitgestellten Informationen nicht beantwortet werden.“

Frage: {question}
"""
})

return {
"question": question,
"answer": result["result"],
"sources": [doc.page_content for doc in result["source_documents"]]
}

# ============================================
# Verwendungsbeispiel
# ============================================

if __name__ == "__main__":
# 1. Instanz der Wissensdatenbank erstellen
kb = LocalKnowledgeBase(model_name="qwen") # Qwen verwenden, besser für Chinesisch

# 2. Versuchen, eine bestehende Datenbank zu laden; andernfalls Dokumente laden
if not kb.load_existing_db():
# Einige Dokumente vorbereiten, z. B. einige EXAMPLE-Tutorials als txt speichern
sample_docs = [
"/Users/example/documents/example_python_tutorial.txt",
"/Users/example/documents/company_handbook.pdf",
]
kb.load_documents(sample_docs)

# 3. Interaktive Q&A
print("=" * 50)
print("Beispielhafte lokale Wissensdatenbank wurde gestartet!")
print("Geben Sie Ihre Frage ein oder tippen Sie 'quit', um zu beenden")
print("=" * 50)

while True:
user_input = input("\n"Ihre Frage: ")

if user_input.lower() in ["quit", "exit", "Exit"]:
print("Auf Wiedersehen!")
break

if not user_input.strip():
continue

# Eine Frage stellen
result = kb.ask(user_input)

if "error" in result:
print(f"Fehler: {result['error']}")
continue

print(f"\n"Antwort: {result['answer']}")
print("\n"Referenzquellen: ")
for i, source in enumerate(result["sources"], 1):
print(f"\n[{i}] {source[:200]}...")

Bevor du dieses System verwendest, musst du das Embedding-Modell herunterladen:

Beispiel

# Embedding-Modell herunterladen
ollama pull nomic-embed-text

# Hauptmodell herunterladen (falls noch nicht heruntergeladen)
ollama pull qwen

Auf diese Weise hast du ein privates Wissensdatenbank-System, das vollständig lokal läuft.

Du kannst deine eigenen Notizen, Dokumente und E-Books hinzufügen und die KI dir beim Suchen und Beantworten von Fragen helfen lassen.

Alle Daten in diesem System bleiben auf deinem lokalen Rechner – Dokumente auf deiner Festplatte, Vektordatenbank in deinem Verzeichnis, Modelle auf deinem Computer – sodass du dir überhaupt keine Gedanken über Datenlecks machen musst.

Tipps zur Leistungsoptimierung

Das lokale Modell läuft, aber wie kannst du es schneller machen? Hier sind einige praktische Tipps.

Die richtige Quantisierungsstufe wählen

Dies ist die einfachste und effektivste Optimierung – je niedriger die Quantisierungsstufe, desto schneller die Geschwindigkeit.

Wenn Q4 funktioniert, verwende nicht Q8; wenn Q8 funktioniert, verwende nicht FP16.

Kontextfenstergröße anpassen

Je größer das Kontextfenster, desto mehr Berechnung ist erforderlich.

Wenn du keinen langen Kontext benötigst, kannst du ihn in der Modelfile von Ollama festlegen:

Beispiel

# Ein benutzerdefiniertes Modell mit begrenztem Kontextfenster erstellen
# Eine neue Datei Modelfile erstellen

echo "FROM llama3
PARAMETER num_ctx 2048" > Modelfile

# Das benutzerdefinierte Modell erstellen
ollama create llama3-fast -f Modelfile

# Ausführen
ollama run llama3-fast

Wenn du den Kontext vom Standardwert 8192 auf 2048 reduzierst, wird es spürbar schneller.

GPU-Beschleunigung verwenden

Wenn du eine NVIDIA-GPU oder einen Apple-Silicon-Mac hast, stelle sicher, dass Ollama die GPU statt der CPU verwendet.

Ollama erkennt und verwendet die GPU automatisch, aber manchmal musst du es überprüfen.

In den Ollama-Startprotokollen solltest du Meldungen wie "Metal GPU activated" oder "CUDA activated" sehen.

Schnellere Sampling-Parameter verwenden

Einige Sampling-Parameter können die Geschwindigkeit beeinflussen:

Beispiel

# Eine geschwindigkeitsoptimierte Modelfile erstellen
# Datei: Modelfile.fast

echo "FROM llama3
PARAMETER temperature 0.7
PARAMETER top_k 20
PARAMETER top_p 0.9
PARAMETER num_predict 256" > Modelfile.fast

# Erstellen und ausführen
ollama create llama3-optimized -f Modelfile.fast
ollama run llama3-optimized

Parameterbeschreibungen:

Parameter	Beschreibung	Optimierungsvorschläge
temperature	Zufälligkeit steuern	Mäßig ist in Ordnung, beeinflusst die Geschwindigkeit nicht
top_k	Anzahl der Kandidatenwörter begrenzen	Kleiner einstellen (20-40), um zu beschleunigen
top_p	Kumulativer Wahrscheinlichkeitsschwellenwert	Standard 0.9 ist in Ordnung
num_predict	Maximale Anzahl generierter Token	Nach Bedarf begrenzen
num_ctx	Größe des Kontextfensters	Gerade genug ist in Ordnung, je kleiner, desto schneller

Unnötige Funktionen deaktivieren

Wenn du API-Aufrufe verwendest und keine Streaming-Ausgabe benötigst, kannst du stream auf false setzen.

Obwohl dies die Inferenz nicht schneller macht, kann es den Netzwerkübertragungsaufwand reduzieren.

Leistungsoptimierung ist eine Kunst der Balance – Geschwindigkeit, Qualität und Speicher lassen sich nicht alle gleichzeitig erreichen. Finde den Balancepunkt, der zu deinen Bedürfnissen passt.

Weitere Erweiterungen