Einführung

Das lokale Ausführen von Open-Source-KI-Modellen auf unseren eigenen Computern gibt uns Privatsphäre, endlose Möglichkeiten zum Basteln und Freiheit von großen Unternehmen. Es geht fast um freie Meinungsäußerung.

Für uns GPU-arme Menschen scheint der Besitz eines eigenen KI-Computers jedoch ein kostspieliger Traum zu sein. MacBook M3 Max ? 3200 $, autsch! Nvidia 4090 ? 1850 $; Das tut weh, selbst wenn man eins bekommen kann. Microsoft Surface Laptop 6 ? Ab 1200 $ ist es immer noch zu viel.

Was wäre, wenn ich Ihnen sage, dass Sie für 300 US-Dollar einen nützlichen KI-Computer bekommen können? Interessiert? Sie müssen Ihren eigenen Monitor, Ihre eigene Tastatur und Ihre eigene Maus mitbringen. Und Sie müssen ein wenig mit dem Linux-Betriebssystem, den Treibern, der Middleware und den Konfigurationen herumbasteln.

Zur Klarstellung: Es geht hier NICHT um „Training“ oder „Feinabstimmung“ großer generativer KI-Modelle. Wir werden uns auf die Ausführung von Open-Source-LLM (große Sprachmodelle wie z. B Lama 2 7B) lokal, sowie die Generierung von Bildern mit Stabile Diffusion .

Jetzt machen wir weiter.

Was macht einen guten (und günstigen) KI-Computer aus?

Nehmen wir an, einer der Hauptanwendungsfälle für einen Heim-KI-Computer ist der Betrieb große Sprachmodelle oder LLM-Inferenz. Für diese Aufgabe ist eigentlich überhaupt keine GPU erforderlich, da alles in der CPU erledigt werden kann. lama.cpp ist eine Open-Source-Software, die eine sehr schnelle LLM-Inferenz mit normaler CPU ermöglicht. Es wurde ursprünglich für das MacBook mit einer Apple M-Serie-CPU entwickelt, funktioniert aber auch auf Intel/AMD-CPUs.

Für eine schnellere Inferenzgeschwindigkeit benötigen Sie jedoch Folgendes. Andernfalls werden Sie so sein, als würden Sie Haare auf Ihrer Handfläche wachsen sehen, während der LLM einen Token nach dem anderen ausspuckt.

• Schnelle CPU-zu-Speicher-Bandbreite
• Schnellerer DRAM (mindestens DDR4, DDR5 wäre noch besser)
• Viel Speicher (z. B. mindestens 16 GB), insbesondere wenn Sie größere Modelle (über 7B) betreiben möchten

Für die Bilderzeugung mit stabiler Diffusion benötigen Sie GPU-Leistung. Allerdings muss man dafür keine besonders schicke GPU haben. Sie können die bereits in Ihren Heimcomputern integrierte GPU nutzen:

1. Alle Macs mit M1/M2/M3-CPU, die CPU, GPU und Hochgeschwindigkeitsspeicher integriert (sie sind wirklich gut, aber aus Preisgründen von diesem speziellen Artikel ausgeschlossen)

   
   

2. AMD APU (z. B. Ryzen 7 5700U), die CPU und GPU für preisgünstige Mini-PCs integriert. Dies wird der Schwerpunkt dieses Artikels sein.

   
   

3. Intel-CPU (z. B. Core i5-1135G7), die auch CPU und GPU integriert. Sie liegen etwas über dem Budget von 300 US-Dollar für den gesamten Mini-PC, aber Leser können sie gerne auf eigene Faust weiter erkunden.

Und der 300-Dollar-KI-Computer kostet?

Ein AMD-basierter Mini-PC mit den folgenden Spezifikationen wird normalerweise für weniger als 300 US-Dollar verkauft. Ich möchte keine bestimmte Marke unterstützen, Sie können also selbst suchen:

• AMD Ryzen 7 5800H (8C/16T, bis zu 4,4 GHz)
• 16 GB RAM DDR4 (32 GB empfohlen)
• 512 GB NVME M.2 SSD

Ich habe mich ein bisschen gegönnt und mich für das 400-Dollar-Modell mit 32 GB RAM und 1 TB SSD entschieden (alles andere gleich). Der Hauptgrund ist, dass ich zu Open-Source-LLMs forsche und neben Stable Difusion auch größere Modelle ausführen möchte. Mit dem 300-Dollar-Computer sollten Sie jedoch fast alles in diesem Artikel tun können.

Vorbereitung 1: Genügend iGPU-Speicher zuweisen

Für AMD-APUs wie die Ryzen 7 5800H , der Speicher wird zwischen CPU und iGPU (integrierte GPU) geteilt. In meinem Fall habe ich insgesamt 32 GB RAM, aber die Standardzuweisung für die iGPU betrug nur 3 GB! Dies ist von Computer zu Computer unterschiedlich und wird während der Herstellung im BIOS konfiguriert.

Sie müssen das je nach Ihrem Hauptanwendungsfall ändern:

1. Wenn Sie nur die LLM-Inferenz ausführen müssen, können Sie diesen gesamten Vorbereitungsschritt überspringen. Da die LLM-Inferenz nur die CPU beanspruchen muss, sollten Sie den größten Teil des RAM für die CPU einsparen, damit Sie größere LLM-Modelle ausführen können.

   
   

2. Wenn Sie laufen müssen Stabile Diffusion , besonders SDXL (1024 x 1024), Sie müssen der iGPU so viel RAM zuweisen, wie das System zulässt (normalerweise die Hälfte des gesamten RAM).

In meinem Fall möchte ich sowohl Stable Diffusion XL als auch LLM-Inferenz auf demselben Mini-PC ausführen. Daher möchte ich der GPU 16 GB (von insgesamt 32 GB) zuweisen.

Dies können Sie erreichen, indem Sie die Einstellungen im BIOS ändern. Normalerweise gibt es eine Obergrenze, und die Standardeinstellung kann viel niedriger als die Obergrenze sein. Auf meinem Computer lag die Obergrenze bei 16 GB oder der Hälfte des insgesamt verfügbaren RAM.

Gutes BIOS

Wenn das BIOS Ihres Computers solche Einstellungen unterstützt, fahren Sie fort und ändern Sie die gewünschte Zahl. Mein BIOS hat keine solche Einstellung.

Schlechtes BIOS: Verwenden Sie das Universal AMD Tool

Wenn Ihr BIOS diese Einstellung nicht hat, folgen Sie bitte der netten Anleitung „GPU-Speicherzuweisung auf AMD Ryzen™ APU entsperren?“ von Winston Ma. Ich habe es versucht und es hat gut funktioniert, sodass ich jetzt 16 GB VRAM habe.

https://winstonhyypia.medium.com/amd-apu-how-to-modify-the-dedicated-gpu-memory-e27b75905056

Vorbereitung 2: Treiber und Middleware installieren

Richten Sie die Sterne aus

AMDs ROCm (Radeon Open Compute-Plattform), vergleichbar mit der von Nvidia CUDA ist eine Suite von Treibern und Middleware, die es Entwicklern ermöglicht, die Leistung der GPUs von ADM zu nutzen. Und typischerweise benötigen KI-Anwendungen ROCm, um GPU-Beschleunigung zu erreichen.

Um AMDs ROCm zu installieren und zum Laufen zu bringen, müssen Sie sicherstellen, dass die Versionen von GPU-Hardware, Linux-Distribution, Kernel, Python, HIP-Treiber, ROCm-Bibliothek und Pytorch kompatibel sind. Wenn Sie den geringsten Schmerz und die größtmögliche Chance auf einen ersten Erfolg wünschen, bleiben Sie bei den empfohlenen und überprüften Kombinationen.

Voraussetzung

Bitte überprüfen Sie den folgenden Link, um die kompatiblen Linux-Betriebssystem- und Kernel-Versionen zu erhalten und diese zu installieren. Anfangs habe ich den Fehler gemacht, einfach mein Lieblings-Linux-Betriebssystem und den Standard-Linux-Kernel zu installieren, und es war sehr mühsam, rückwärts zu gehen, um Kompatibilitätsprobleme zu lösen. Sie können diesen Schmerz vermeiden, indem Sie einfach die offiziell unterstützten Kombinationen verwenden.

https://rocm.docs.amd.com/projects/install-on-linux/en/latest/reference/system-requirements.html

ROCm-Installation

https://rocm.docs.amd.com/en/latest/deploy/linux/os-native/install.html

Wenn die gesamte Installation erfolgreich abgeschlossen wurde, können Sie rocminfo eingeben und es wird etwa Folgendes angezeigt (ich habe nur die relevantesten Teile in Gelb herausgeschnitten):

ROCk module is loaded

=====================

HSA System Attributes

=====================

Runtime Version: 1.1

System Timestamp Freq.: 1000.000000MHz

Sig. Max Wait Duration: 18446744073709551615 (0xFFFFFFFFFFFFFFFF) (timestamp count)

Machine Model: LARGE

System Endianness: LITTLE

Mwaitx: DISABLED

DMAbuf Support: YES

==========

HSA Agents

==========

*******

Agent 1

*******

Name: AMD Ryzen 7 5800H with Radeon Graphics

Uuid: CPU-XX

Marketing Name: AMD Ryzen 7 5800H with Radeon Graphics

Vendor Name: CPU

Pool Info:

Pool 1

Segment: GLOBAL; FLAGS: COARSE GRAINED

Size: 16777216(0x1000000) KB

Python-Umgebung

Die Python-Abhängigkeit kann ziemlich knifflig sein, daher empfiehlt es sich, eine geeignete Umgebung einzurichten. Sie können beides verwenden conda oder venv für diesen Zweck.

• source venv/bin/activate
• conda activate llm

Pytorch

https://pytorch.org/get-started/locally/

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.7

HSA überschreiben

Das Folgende gilt speziell für APUs mit integrierter Grafik. Auch wenn sie von ROCm nicht offiziell unterstützt werden, hat sich Folgendes bewährt.

export HSA_OVERRIDE_GFX_VERSION=9.0.0

So überprüfen Sie

Lassen Sie uns nun nach all den komplizierten Schritten testen, ob ROCm mit Torch funktioniert. Und Sie können sehen, dass ROCm „vorgibt“, CUDA für die Zwecke von Pytorch zu sein.

https://rocm.docs.amd.com/en/latest/how_to/pytorch_install/pytorch_install.html#test-the-pytorch-installation

python3 -c 'import torch' 2> /dev/null && echo 'Success' || echo 'Failure'

Success

python3 -c 'import torch; print(torch.cuda.is_available())'

True

LLM-Inferenz

Beginnen wir mit etwas Einfachem für unseren neu konfigurierten 300-Dollar-KI-Computer: der lokalen Ausführung eines großen Sprachmodells. Wir können einen der beliebten Open-Source-Modi wählen: LLaMA 2 mit 7B-Parametern, die für den Chat optimiert sind.

Darüber hinaus können Sie auch kleine LLMs ausprobieren Mistral , QWen , Zephyr , Und Vicuna . Weitere qualitativ hochwertige LLMs finden Sie hier im sehr nützlichen „Chatbot Arena Leaderboard“ der UC Berkeley LMSYS-Labore .

https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard

Lama.cpp

Wir werden verwenden lama.cpp , das zunächst für die CPU optimiert ist und später auch GPU unterstützt. Meiner Erfahrung nach funktioniert die LLM-Inferenz auf der CPU gut, und mit einer bescheidenen GPU, wie sie in der 300-Dollar-KI-Maschine integriert ist, gibt es wenig zu gewinnen.

https://github.com/ggerganov/llama.cpp

Zuerst müssen Sie wget und git installieren. Befolgen Sie dann die Schritte zum Kompilieren und Installieren von llama.cpp.

sudo apt-get install build-essential

git clone https://github.com/ggerganov/llama.cpp.git

cd llama.cpp

make

Modellgewichte herunterladen

Um die LLMs auf unserem günstigen Rechner statt auf Cloud-Servern mit teuren GPUs auszuführen, müssen wir eine „komprimierte“ Version der Modelle verwenden, damit sie in den RAM-Bereich passen. Als einfaches Beispiel verfügt ein LLaMA-2 7B-Modell über 7B-Parameter, die jeweils durch float16 (2 Bytes) dargestellt werden.

• Float 16: 14B Bytes oder 14GB, die nicht in unseren 8GB RAM passen.

• Quantisiert auf 4-Bit: 3,5 B Bytes oder 3,5 GB, die jetzt in unseren 8 GB RAM passen.

Auch das Dateiformat sollte sein gguf . Also. In unserem Beispiel müssen Sie die Gewichte in dieser Datei herunterladen:

https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/blob/main/llama-2-7b-chat.Q4_0.gguf

Test auf AMD Mini-PC

Zuerst haben wir es auf dem AMD-Mini-PC getestet und dabei etwa 10 Token pro Sekunde erreicht. Das ist eigentlich ganz anständig, und Sie können ohne lange Wartezeiten mit dem LLM chatten.

Systemkonfiguration:

• AMD Ryzen 5800H
• 32 GB RAM

Befehlszeilenanweisung:

./main -m models/llama-2-7b-chat.Q4_0.gguf --color -ins -n 512 --mlock

llama_print_timings: load time = 661.10 ms

llama_print_timings: sample time = 234.73 ms / 500 runs ( 0.47 ms per token, 2130.14 tokens per second)

llama_print_timings: prompt eval time = 1307.11 ms / 32 tokens ( 40.85 ms per token, 24.48 tokens per second)

llama_print_timings: eval time = 50090.22 ms / 501 runs ( 99.98 ms per token, 10.00 tokens per second)

llama_print_timings: total time = 64114.27 ms

Test auf Intel Mini-PC

Als nächstes haben wir es auf einem Intel-Mini-PC getestet und dabei etwa 1,5 Token pro Sekunde erreicht. Für eine erfolgreiche Chat-Sitzung ist das etwas zu langsam. Dies ist kein fairer Vergleich, da der Intel N5105 deutlich schwächer ist als der AMD 5800H. Aber das ist der einzige Intel-Mini-PC in meinem Besitz. Wenn Sie die leistungsstärkere Intel-CPU (z. B. Core i5-1135G7) verwenden, sollten Sie vergleichbare Ergebnisse erhalten. Bitte teilen Sie Ihre Ergebnisse unten in den Kommentaren mit.

Systemkonfiguration:

• 11. Generation 4 Kerne N5105 (bis zu 2,9 GHz) 4 Kerne und 4 Threads
• 16 GB RAM (2 GB VRAM für iGPU)

./main -m models/llama-2-7b-chat.Q4_0.gguf -ins --color -n 512 --mlock

llama_print_timings: load time = 14490.05 ms

llama_print_timings: sample time = 171.53 ms / 97 runs ( 1.77 ms per token, 565.49 tokens per second)

llama_print_timings: prompt eval time = 21234.29 ms / 33 tokens ( 643.46 ms per token, 1.55 tokens per second)

llama_print_timings: eval time = 75754.03 ms / 98 runs ( 773.00 ms per token, 1.29 tokens per second)

Stabile Diffusion

Installation

https://github.com/AUTOMATIC1111/stable-diffusion-webui

Und achten Sie auch auf diese Seite, wenn es um AMD ROCm geht

https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Install-and-Run-on-AMD-GPUs

Schnellstart

export HSA_OVERRIDE_GFX_VERSION=9.0.0

source venv/bin/activate

./webui.sh --upcast-sampling --skip-torch-cuda-test --precision full --no-half

Stabiler Diffusionstest 1,5

./webui.sh --upcast-sampling --skip-torch-cuda-test --precision full --no-half

Test 1

• Aufforderung: „Pferd im Wald“

• Schritte: 20, Sampler: DDIM, CFG-Skala: 7, Seed: 519288240, Größe: 512x512, Modell-Hash: 6ce0161689, Modell: v1-5-pruned-emaonly, Version: v1.6.0

• Zeitaufwand: 1 Min. 8,3 Sek.

Stabiler Diffusion XL 1.0-Test

SDXL (maximale Auflösung 1024 x 1024) empfiehlt mindestens 12 GB VRAM, daher müssen Sie auf jeden Fall den Schritt „Vorbereitung 1“ durchführen, um 16 GB VRAM für die iGPU zuzuweisen. Diese Aufgabe ist also nur mit dem 400-Dollar-Mini-PC möglich.

./webui.sh --upcast-sampling

Test 1:

• Aufforderung: „Pferd im Wald“

• Schritte: 20, Sampler: DDIM, CFG-Skala: 7, Seed: 1102941451, Größe: 1024x768, Modell-Hash: 31e35c80fc, Modell: sd_xl_base_1.0, Version: v1.6.0

• Zeitaufwand: 7 Min. 41 Sek

Test 2:

• Aufforderung: „Der junge Taylor Swift im roten Kapuzenpulli reitet auf einem Pferd im Wald“

• Negative Aufforderung: Deformationen, Deformation, deformierte Augen, deformierte Zähne, deformierte Finger, deformiertes Gesicht, deformierte Hände, deformiert

• Schritte: 20, Sampler: DDIM, CFG-Skala: 7, Seed: 2960206663, Größe: 1024 x 1024, Modell-Hash: 31e35c80fc, Modell: sd_xl_base_1.0, Version: v1.6.0

• Zeitaufwand: 6 Min. 12,3 Sek.

Windows 11 und AMD/directml

Obwohl sich dieser Artikel auf Linux-Betriebssysteme konzentriert, können Sie Stable Diffusion auch unter Windows zum Laufen bringen. Hier sind meine Experimente:

https://github.com/lshqqytiger/stable-diffusion-webui-directml

• Zuerst müssen Sie Python 3.10.6 installieren.

• Fügen Sie den Python 3.10.6-Director zu PATH hinzu.

• Wichtig: Der Python-Pfad muss der oberste Pfad sein
• https://realpython.com/add-python-to-path/

• Installieren Sie Git und Git Clone Repo

• Führen Sie webui-user.bat über den Datei-Explorer aus

Test 1:

• Aufforderung: „Pferd im Wald“
• Einstellungen: DPM++ 2M Karras, 512x512, Sampling-Schritte 20
• Zeitaufwand: 1:19 Sekunden

Schlussfolgerungen

Haben Sie also Spaß daran, Ihre eigenen generativen KI-Modelle auf Ihrem neuen 300-Dollar-Mini-PC auszuführen? Ich hoffe du tust.

Open-Source-KI-Modelle, die auf persönlichen Geräten laufen, sind einer der spannendsten Bereiche für Bastler, da keiner von uns über den riesigen GPU-Pool verfügt, um tatsächlich ein grundlegendes Modell zu trainieren. Dies wird eine neue Generation von Apps ermöglichen, die sowohl superintelligent sind als auch unsere Privatsphäre schützen.

Was als nächstes?

• Führen Sie es auf noch kleineren eingebetteten Geräten aus: z. B. Raspberry Pi

• Führen Sie es auf Ihren Smartphones aus (llama.cpp unterstützt iOS und Android)

Und viel Spaß beim Basteln mit KI, Open Source und auf dem Gerät!