Dank der welt­wei­ten Open-Source-Gemein­schaft ist es heute ein­fa­cher denn je, leis­tungs­starke große Sprach­mo­delle (LLM) auf Ver­brau­cher-Lap­tops oder CPU-basier­ten Ser­vern aus­zu­füh­ren und über gut gestal­tete gra­fi­sche Benut­zer­ober­flä­chen ein­fach mit ihnen zu interagieren.

Dies ist beson­ders wert­voll für alle Orga­ni­sa­tio­nen, die keine Dienste nut­zen dür­fen oder wol­len, die das Sen­den von Daten an einen Drit­ten erfordern.

Die­ses Tuto­rial zeigt, wie man einen loka­len LLM mit einer ChatGPT-ähn­li­chen Benut­zer­ober­flä­che in vier ein­fa­chen Schrit­ten ein­rich­tet. Wenn Sie die vor­aus­ge­setzte Soft­ware instal­liert haben, wer­den Sie nicht mehr als 15 Minu­ten Arbeit benö­ti­gen (abge­se­hen von der Rechen­zeit, die in eini­gen der Schritte benö­tigt wird).

Diese Anlei­tung setzt vor­aus, dass Sie die fol­gen­den Pro­gramme auf Ihrem Rech­ner instal­liert haben:

• Oll­ama
• Docker
• React
• Python und gemein­same Pakete ein­schließ­lich Transformatoren

Also, los geht’s!

Schritt 1 – Ent­schei­den Sie, wel­ches Hug­ging­face LLM Sie ver­wen­den möchten

Der erste Schritt besteht darin, zu ent­schei­den, wel­chen LLM Sie vor Ort durch­füh­ren möch­ten. Viel­leicht haben Sie bereits eine Idee. Ansons­ten scheint für Eng­lisch die instru­ierte Ver­sion von Mis­tral 7b die erste Wahl zu sein. 

Sobald Sie sich für ein LLM ent­schie­den haben, kopie­ren Sie den Huggingface-„Pfad“ in das Modell. Für Mis­tral 7b wäre das „mistralai/Mistral-7B-v0.1“. Du wirst ihn im nächs­ten Schritt brauchen.

Schritt 2 – Quan­ti­sie­rung des LLM

Der nächste Schritt ist die Quan­ti­sie­rung des gewähl­ten Modells, es sei denn, Sie haben ein Modell aus­ge­wählt, das bereits quan­ti­siert wurde. Wenn der Name Ihres Modells auf GGUF oder GPTQ endet, ist es bereits quantisiert.

Die Quan­ti­sie­rung ist eine Tech­nik, bei der die Gewichte eines Modells (seine gelern­ten Para­me­ter) in einen klei­ne­ren Daten­typ als das Ori­gi­nal umge­wan­delt wer­den, z. B. von fp16 in int4. Dadurch nimmt das Modell weni­ger Spei­cher­platz in Anspruch und die Infe­renz wird schnel­ler aus­ge­führt, was eine nette Funk­tion ist, wenn man auf der CPU arbeitet.

Das Skript quantize.py in mei­nem Repo local_llm wurde von Maxime Labon­nes fan­tas­ti­schem Colab-Notiz­buch adap­tiert (siehe sei­nen LLM-Kurs für andere groß­ar­tige LLM-Res­sour­cen). Sie kön­nen sein Notiz­buch oder mein Skript ver­wen­den. Die Methode wurde an Mis­tral und Mis­tral-ähn­li­chen Model­len getestet.

Um zu quan­ti­sie­ren, klo­nen Sie zunächst mein Repo:

git clone https://github.com/KasperGroesLudvigsen/local_llm.git

Ändern Sie nun die Varia­ble MODEL_ID in der Datei quantize.py so, dass sie das Modell Ihrer Wahl wider­spie­gelt. Hier brauchst du den Huggingface-„Pfad“, den du im ers­ten Schritt kopiert hast. Wenn du also Mis­tral 7b ver­wen­den willst:

MODEL_ID = "mistralai/Mistral-7B-v0.1"

Füh­ren Sie dann das Skript in Ihrem Ter­mi­nal aus:

python quantize.py

Dies wird einige Zeit in Anspruch neh­men. Wäh­rend der Quan­ti­sie­rungs­pro­zess läuft, kön­nen Sie mit dem nächs­ten Schritt fortfahren.

Das Skript erzeugt ein Ver­zeich­nis, das die Modell­da­teien für das von Ihnen aus­ge­wählte Modell sowie die quan­ti­sierte Ver­sion des Modells mit der Datei­er­wei­te­rung „.gguf“ enthält.

Schritt 3: Erstel­lung und Aus­füh­rung der Oll­ama-Ver­sion des Modells

Wir wer­den das Modell mit Oll­ama aus­füh­ren. Oll­ama ist ein Soft­ware-Frame­work, das ein Modell sau­ber in eine API ver­packt. Oll­ama lässt sich auch leicht mit ver­schie­de­nen Frontends inte­grie­ren, wie wir im nächs­ten Schritt sehen werden.

Um ein Oll­ama-Abbild des Modells zu erstel­len, benö­ti­gen Sie eine so genannte Modell­da­tei, eine ein­fa­che Text­da­tei, die das Oll­ama-Abbild kon­fi­gu­riert. Wenn Sie mit Docker­files ver­traut sind, wer­den Ihnen die Modell­da­teien von Oll­ama bekannt vorkommen.

Im fol­gen­den Bei­spiel geben wir zunächst an, wel­cher LLM ver­wen­det wer­den soll. Wir gehen davon aus, dass es in Ihrem Repo einen Ord­ner namens mistral7b gibt und dass die­ser Ord­ner ein Modell namens quantized.gguf ent­hält. Dann set­zen wir das Kon­text­fens­ter des Modells auf 8.000 – die maxi­male Kon­text­größe von Mis­tral 7b. In der Model­da­tei kön­nen Sie auch ange­ben, wel­che Prompt-Vor­lage ver­wen­det wer­den soll, und Sie kön­nen Stop-Token angeben.

Spei­chern Sie die Modell­da­tei, z.B. als Modelfile.txt.

FROM ./mistral7b/quantized.gguf

PARAMETER num_ctx 8000

TEMPLATE """<|im_start|>system {{ .System }}<|im_end|><|im_start|>user {{ .Prompt }}<|im_end|><|im_start|>assistant<|im_end|>"""

PARAMETER stop <|im_end|>
PARAMETER stop <|im_start|>user
PARAMETER stop <|end|>

Nun, da Sie die Modell­da­tei erstellt haben, erstel­len Sie ein Oll­ama-Image aus der Modell­da­tei, indem Sie dies in Ihrem Ter­mi­nal aus­füh­ren. Auch dies wird einige Augen­bli­cke dauern:

ollama create choose-a-model-name -f <location of the file e.g. ./Modelfile>'

Wenn der „Erstel­lungs­pro­zess“ abge­schlos­sen ist, star­ten Sie den Oll­ama-Ser­ver, indem Sie die­sen Befehl aus­füh­ren. Dadurch wer­den alle Ihre Oll­ama-Modelle so dar­ge­stellt, dass die gra­fi­sche Benut­zer­ober­flä­che mit ihnen inter­agie­ren kann.

ollama serve

Schritt 4 – Ein­rich­ten einer Chat-Benut­zer­ober­flä­che für Ollama

Der nächste Schritt besteht darin, eine gra­fi­sche Benut­zer­ober­flä­che für die Inter­ak­tion mit dem LLM ein­zu­rich­ten. Hier­für gibt es meh­rere Optio­nen. In die­sem Tuto­rial wer­den wir „Chat­bot Oll­ama“ ver­wen­den – eine sehr ordent­li­che GUI, die an ChatGPT erin­nert. „Oll­ama WebUI“ ist eine ähn­li­che Option. Sie kön­nen auch Ihre eigene Chat-GUI mit Stream­lit einrichten.

Wenn Sie die bei­den fol­gen­den Befehle aus­füh­ren, klo­nen Sie zunächst das Chat­bot Oll­ama Git­Hub Repo und instal­lie­ren dann die React-Abhängigkeiten:

git clone https://github.com/ivanfioravanti/chatbot-ollama.git
npm ci

Der nächste Schritt besteht darin, ein Docker-Image aus der Docker­da­tei zu erstel­len. Wenn Sie Linux ver­wen­den, müs­sen Sie die Umge­bungs­va­ria­ble OLLAMA_HOST im Docker­file von hhtp://host.docker.internal:11434 auf http://localhost:11434 ändern.

Erstel­len Sie nun das Docker-Image und star­ten Sie einen Con­tai­ner dar­aus, indem Sie diese Befehle in einem Ter­mi­nal aus­füh­ren. Sie müs­sen sich im Stamm­ver­zeich­nis des Pro­jekts befinden.

docker build -t chatbot-ollama .

docker run -p 3000:3000 chatbot-ollama

Die gra­fi­sche Benut­zer­ober­flä­che wird nun in einem Docker-Con­tai­ner auf Ihrem loka­len Com­pu­ter aus­ge­führt. Im Ter­mi­nal sehen Sie die Adresse, unter der die gra­fi­sche Benut­zer­ober­flä­che ver­füg­bar ist (z. B. „http://localhost:3000“).

Rufen Sie diese Adresse in Ihrem Brow­ser auf, und Sie soll­ten nun in der Lage sein, mit dem LLM über die Oll­ama-Chat-Benut­zer­ober­flä­che zu chatten.

Schluss­fol­ge­rung

Dies ist der Abschluss die­ses kur­zen Tuto­ri­als über die ein­fa­che Ein­rich­tung einer Chat-Benut­zer­ober­flä­che, die es Ihnen ermög­licht, mit einem LLM zu inter­agie­ren, der auf Ihrem loka­len Rech­ner läuft. Ein­fach, nicht wahr? Es waren nur vier Schritte erforderlich:

1. Wäh­len Sie ein Modell auf Huggingface
2. (Optio­nal) Quan­ti­sie­rung des Modells
3. Modell in Oll­ama-Image verpacken
4. Erstel­len und Aus­füh­ren eines Docker-Con­tai­ners, der die GUI umhüllt

Den­ken Sie daran, dass dies alles mög­lich ist, weil Open Source groß­ar­tig ist 👏

Quelle: medium.com