Radxa AICore DX-M1M: KI-Power für deinen Raspberry Pi 5

Servus, liebe Homelab-Freunde und Technik-Enthusiasten!

Heute tauchen wir in ein Thema ein, das mein Herz als Linux-Admin und Bastler höherschlagen lässt: KI-Beschleunigung auf dem Raspberry Pi 5. Der Pi 5 ist an sich schon ein kleines Kraftpaket, aber wenn es um ernsthafte KI-Workloads geht, stößt auch er an seine Grenzen. Genau hier kommt der Radxa AICore DX-M1M ins Spiel – ein M.2-Modul, das deinem Pi 5 satte 25 TOPS (Tera Operations Per Second) an KI-Rechenleistung spendiert. Das ist ein Game Changer für lokale Objekterkennung, Sprachverarbeitung oder sogar kleinere LLM-Anwendungen direkt auf deiner Edge-Hardware.

In meiner Erfahrung ist die Hürde bei solchen spezialisierten Hardware-Addons oft nicht die Hardware selbst, sondern das drumherum: Treiber, SDKs, die Integration in bestehende Frameworks. Genau das packen wir heute an. Ich zeige dir Schritt für Schritt, wie du dieses kleine Biest zum Laufen bringst und in deine Homelab-Projekte integrieren kannst – so, als hättest du es selbst schon zigmal gemacht. Denn mal ehrlich, wer will schon seine Daten für jeden kleinen KI-Task in die Cloud schicken, wenn es auch lokal und datenschutzfreundlich geht?

Dieser Guide richtet sich an dich, wenn du bereits Erfahrung mit Linux, der Kommandozeile und vielleicht schon dem einen oder anderen Raspberry Pi Projekt hast. Wir gehen nicht auf die absoluten Basics ein, sondern konzentrieren uns auf die spezifischen Schritte für den AICore DX-M1M.

Voraussetzungen: Was du brauchst, bevor es losgeht

Bevor wir uns in die Tiefen der Installation stürzen, lass uns kurz checken, ob du alles beisammen hast. Nichts ist ärgerlicher, als mitten im Prozess festzustellen, dass ein wichtiges Teil fehlt.

Hardware-Anforderungen:

• Raspberry Pi 5: Logisch, oder? Ein 4GB oder 8GB Modell ist hier meine Empfehlung, da KI-Modelle oft Arbeitsspeicher fressen.
• Radxa AICore DX-M1M: Das Herzstück unserer Beschleunigung. Achte darauf, dass du die M.2-2230-Variante hast, die für den Pi 5 vorgesehen ist.
• Raspberry Pi M.2 HAT+ oder kompatibler PCIe-Adapter: Der Pi 5 hat keinen direkten M.2-Slot. Du brauchst einen HAT, der den PCIe-Anschluss des Pi 5 auf einen M.2-Slot erweitert. Der offizielle Raspberry Pi M.2 HAT+ ist hier eine hervorragende Wahl und funktioniert in meiner Erfahrung am besten.
• Passendes Netzteil: Ein 5V/5A USB-C Netzteil ist für den Pi 5 mit M.2 HAT Pflicht. Unterdimensionierte Netzteile sind eine der häufigsten Ursachen für instabile Systeme, gerade wenn zusätzliche Hardware wie der AICore Strom zieht.
• Speichermedium: Eine schnelle microSD-Karte (min. 32GB, A2-Klasse) oder, noch besser, eine NVMe SSD, die du ebenfalls über den M.2 HAT anschließen kannst, um das Betriebssystem darauf zu installieren. Letzteres ist für Performance und Lebensdauer des Speichers definitiv mein Tipp.
• Kühlkörper/Lüfter: Der Pi 5 wird unter Last warm, und der AICore kann auch Wärme entwickeln. Eine gute Kühlung ist essenziell für Stabilität und Langlebigkeit.

Software-Anforderungen:

• Raspberry Pi OS (64-bit): Die aktuellste Version, idealerweise die Lite-Variante ohne Desktop, wenn du den Pi headless betreibst.
• Internetverbindung: Für Updates, Paketinstallationen und das Herunterladen des SDK.
• Grundkenntnisse in Linux und der Kommandozeile: Du solltest wissen, wie man Pakete installiert, Dateien editiert und grundlegende Systembefehle ausführt.

Erster Schritt: Hardware-Installation – Nervenkitzel für Bastler

Die physische Installation ist meist der einfachste, aber auch kritischste Teil. Nimm dir Zeit und sei sorgfältig. Ein falsch sitzendes Kabel oder eine schief eingesteckte Karte können zu Frust führen.

1. Raspberry Pi 5 vorbereiten

Stelle sicher, dass dein Raspberry Pi 5 ausgeschaltet und vom Strom getrennt ist. Das ist nicht nur eine Sicherheitsmaßnahme, sondern auch wichtig, um Schäden an den Komponenten zu vermeiden.

2. M.2 HAT+ montieren

Wenn du den offiziellen Raspberry Pi M.2 HAT+ verwendest, ist die Montage recht einfach:

1. Stecke den HAT auf die GPIO-Pins des Raspberry Pi 5.
2. Verbinde den kurzen Flex-Kabel vom HAT mit dem PCIe-Anschluss des Pi 5. Achte hier auf die richtige Ausrichtung – die Kontakte müssen sauber sitzen.
3. Verschraube den HAT mit den mitgelieferten Abstandshaltern und Schrauben am Pi 5, um eine stabile Verbindung zu gewährleisten.

Wichtig zu wissen: Der PCIe-Anschluss des Pi 5 ist empfindlich. Übe keinen übermäßigen Druck aus und stelle sicher, dass das Kabel gerade sitzt.

3. AICore DX-M1M einsetzen

Jetzt kommt unser KI-Beschleuniger an die Reihe:

1. Schiebe den Radxa AICore DX-M1M vorsichtig in den M.2-Slot auf deinem HAT. Er sollte leichtgängig in den Slot gleiten.
2. Sichere die Karte mit der kleinen Schraube, die meist beim HAT dabei ist. Diese Schraube fixiert das Modul am Ende des Slots und verhindert ein Herausrutschen.

Mein Tipp: Berühre die Goldkontakte des AICore so wenig wie möglich, um statische Entladung zu vermeiden. Wenn du ein Antistatik-Armband hast, nutze es!

4. Stromversorgung und Kühlung

Schließe dein 5V/5A USB-C Netzteil an den Pi 5 an. Wenn du einen Lüfter oder Kühlkörper hast, montiere ihn jetzt. Gerade bei KI-Workloads, die den Prozessor und den AICore gleichzeitig fordern, ist eine gute Wärmeableitung entscheidend.

Software-Setup: Das Herzstück zum Laufen bringen

Hardware ist die halbe Miete, aber ohne die richtige Software bleibt der AICore ein teurer Briefbeschwerer. Hier wird es etwas technischer, aber keine Sorge, wir gehen das Schritt für Schritt durch.

1. Raspberry Pi OS vorbereiten

Boote deinen Raspberry Pi 5 mit dem frisch installierten Raspberry Pi OS. Sobald du im System bist (entweder über SSH oder direkt am Monitor), geht’s los.

# Zuerst alles auf den neuesten Stand bringen
sudo apt update
sudo apt full-upgrade -y

# Oft übersehen, aber für M.2-Support und PCIe-Stabilität entscheidend: Firmware-Update
sudo rpi-update
# Nach dem rpi-update ist ein Neustart fast immer Pflicht
sudo reboot

Wichtig zu wissen: Das rpi-update kann manchmal zu Problemen führen, da es auf experimentelle Firmware-Versionen zugreifen kann. Für den Pi 5 und M.2 ist es aber oft notwendig, um die neuesten PCIe-Fixes zu erhalten. Wenn du auf Nummer sicher gehen willst, mach ein Backup deiner SD-Karte/NVMe.

2. Treiber und SDK installieren

Radxa wird für den AICore ein spezifisches Software Development Kit (SDK) bereitstellen, das die Treiber, Bibliotheken und Tools enthält, um mit dem Beschleuniger zu kommunizieren. Da der Heise-Artikel keine konkreten Links oder Befehle nennt, simuliere ich hier einen realistischen Installationsprozess, wie ich ihn von anderen Embedded-KI-Plattformen kenne.

Typischerweise lädst du das SDK von der Radxa-Website herunter. Nehmen wir an, es ist ein `.deb`-Paket oder ein Archiv mit einem Installationsskript.

# Navigiere in dein Home-Verzeichnis oder einen temporären Ordner
cd ~

# Beispiel: Herunterladen des SDK (URL ist hypothetisch!)
# Ersetze 'VERSION' mit der tatsächlichen SDK-Version
wget https://downloads.radxa.com/aicore/sdk/radxa-aicore-sdk_VERSION_arm64.deb

# Installation des DEB-Pakets
sudo dpkg -i radxa-aicore-sdk_VERSION_arm64.deb

# Abhängigkeiten auflösen, falls dpkg welche bemängelt hat
sudo apt --fix-broken install -y

# Alternativ, wenn es ein tar.gz mit einem Installationsskript ist:
# wget https://downloads.radxa.com/aicore/sdk/radxa-aicore-sdk-VERSION.tar.gz
# tar -xzf radxa-aicore-sdk-VERSION.tar.gz
# cd radxa-aicore-sdk-VERSION
# sudo ./install.sh # oder ähnliches

Nach der Installation sollten die notwendigen Kernel-Module geladen und die Bibliotheken im System verfügbar sein. Oft ist ein weiterer Neustart nach der Treiberinstallation ratsam.

sudo reboot

Installation von Entwickler-Tools und Python-Umgebung

Für die Arbeit mit KI-Modellen brauchst du fast immer Python und einige Entwicklungstools.

# Installiere grundlegende Build-Tools
sudo apt install -y build-essential dkms pkg-config

# Richte eine isolierte Python-Umgebung ein (mein absoluter Tipp für Sauberkeit!)
sudo apt install -y python3-pip python3-venv
python3 -m venv ~/aicore_env
source ~/aicore_env/bin/activate

# Jetzt bist du in deiner virtuellen Umgebung.
# Alle weiteren Python-Pakete werden hier installiert.
pip install --upgrade pip

Verifizierung der Installation

Das SDK sollte Tools mitbringen, um den AICore zu erkennen und zu testen. Ein hypothetisches Beispiel:

# Nach dem Aktivieren der virtuellen Umgebung
source ~/aicore_env/bin/activate

# Überprüfen, ob der AICore erkannt wird
radxa-ai-tool info

# Oder einen einfachen Hardware-Test ausführen
radxa-ai-tool test --device /dev/aicore0

# Die Ausgabe sollte Informationen über den AICore, seine Firmware und den Status anzeigen.
# Wenn hier Fehler auftauchen, liegt es oft an fehlenden Treibern oder einer fehlerhaften Hardware-Installation.

3. Integration mit AI-Frameworks

Der Radxa AICore wird höchstwahrscheinlich über ein "Delegate" oder einen "Execution Provider" in gängige KI-Frameworks integriert. Das bedeutet, dass du dem Framework mitteilst, dass es bestimmte Teile der Berechnung an den AICore auslagern soll.

TensorFlow Lite Integration

Für Edge-Geräte wie den Raspberry Pi ist TensorFlow Lite (TFLite) oft die erste Wahl. Radxa wird ein TFLite Delegate bereitstellen.

# In deiner virtuellen Umgebung
source ~/aicore_env/bin/activate

# Installiere TensorFlow Lite Runtime (wenn nicht schon Teil des SDK)
pip install tflite-runtime

# Installiere das Radxa TFLite Delegate (hypothetisch, kann Teil des SDK sein)
# pip install radxa-aicore-tflite-delegate # oder ein DEB-Paket

Im Python-Code würde die Integration dann so aussehen:

import tensorflow as tf

# Pfad zum TFLite-Modell (z.B. ein MobileNetV2)
model_path = 'model.tflite'

# Pfad zum Radxa AICore Delegate Shared Library (hypothetisch)
# Diese Datei wird vom Radxa SDK bereitgestellt
delegate_path = '/usr/lib/aarch64-linux-gnu/radxa-aicore/libtflite_radxa_delegate.so'

# Konfiguration für den Interpreter
interpreter = tf.lite.Interpreter(
    model_path=model_path,
    experimental_delegates=[
        tf.lite.load_delegate(delegate_path)
    ]
)
interpreter.allocate_tensors()

# ... (Input vorbereiten, Inference ausführen, Output verarbeiten)
# Jetzt sollte die Berechnung über den AICore laufen!

ONNX Runtime Integration

ONNX (Open Neural Network Exchange) ist ein offenes Format für KI-Modelle, das von vielen Frameworks unterstützt wird. ONNX Runtime ist ein performanter Inferenzer. Radxa könnte hier einen eigenen Execution Provider anbieten.

# In deiner virtuellen Umgebung
source ~/aicore_env/bin/activate

# Installiere ONNX Runtime (die arm64-Version)
pip install onnxruntime

# Wenn Radxa einen eigenen ONNX Execution Provider anbietet:
# pip install onnxruntime-radxa-aicore # (hypothetisch)

Im Python-Code würdest du den Execution Provider beim Laden des Modells angeben:

import onnxruntime as rt

# Pfad zum ONNX-Modell
model_path = 'model.onnx'

# Erstelle einen Inference Session
# Hier den Radxa AICore Execution Provider angeben (hypothetisch: 'RadxaAICoreExecutionProvider')
# Die Reihenfolge ist wichtig: Dein spezifischer Provider sollte vor 'CPUExecutionProvider' stehen.
sess_options = rt.SessionOptions()
providers = ['RadxaAICoreExecutionProvider', 'CPUExecutionProvider'] # Liste der gewünschten Provider

session = rt.InferenceSession(model_path, sess_options, providers=providers)

# ... (Input vorbereiten, Inference ausführen, Output verarbeiten)
# Das Modell wird nun versuchen, den Radxa AICore zu nutzen.

Mein Tipp: Prüfe die Radxa-Dokumentation genau, welche Frameworks unterstützt werden und wie die genaue API-Integration aussieht. Die hier gezeigten Beispiele basieren auf gängigen Mustern.

Ein Praxisbeispiel: Objekterkennung beschleunigen

Stell dir vor, du betreibst Home Assistant und möchtest eine lokale Objekterkennung für deine Überwachungskamera einrichten – ohne Cloud-Anbindung. Der AICore ist dafür perfekt. Nehmen wir an, du hast ein YOLOv5s-Modell, das du nach ONNX konvertiert hast.

Ohne den AICore würde dein Pi 5 dieses Modell vielleicht mit ein paar Frames pro Sekunde (FPS) verarbeiten, was für Echtzeit-Anwendungen oft zu langsam ist. Mit dem AICore streben wir hier deutlich höhere Bildraten an.

Workflow-Skizze:

1. Eine Kamera liefert Videostreams (z.B. über RTSP).
2. Ein Python-Skript (oder ein Docker-Container) greift auf die Frames zu.
3. Jeder Frame wird durch das ONNX-Modell geschickt, das den AICore als Execution Provider nutzt.
4. Die erkannten Objekte (Personen, Autos, Tiere) werden verarbeitet, z.B. als MQTT-Nachricht an Home Assistant gesendet.

# Beispiel-Python-Skript (stark vereinfacht!)
import cv2
import numpy as np
import onnxruntime as rt

# Annahme: ONNX-Modell ist bereits konvertiert und auf dem Pi vorhanden
MODEL_PATH = 'yolov5s.onnx'
CONF_THRESHOLD = 0.4
NMS_THRESHOLD = 0.45
CLASS_NAMES = ['person', 'bicycle', 'car', ...] # Deine Klassen

# ONNX Runtime Session initialisieren
# Stelle sicher, dass 'RadxaAICoreExecutionProvider' verfügbar ist und bevorzugt wird!
try:
    session = rt.InferenceSession(MODEL_PATH, providers=['RadxaAICoreExecutionProvider', 'CPUExecutionProvider'])
    print("ONNX Runtime Session mit Radxa AICore Provider initialisiert.")
except Exception as e:
    print(f"Fehler beim Initialisieren des AICore Providers: {e}. Fällt auf CPU zurück.")
    session = rt.InferenceSession(MODEL_PATH, providers=['CPUExecutionProvider'])

input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
input_shape = session.get_inputs()[0].shape
input_width, input_height = input_shape[3], input_shape[2] # YOLOv5 Input-Format

# Kamera-Stream öffnen (z.B. eine Webcam oder RTSP-Stream)
# cap = cv2.VideoCapture(0) # Für USB-Webcam
cap = cv2.VideoCapture('rtsp://user:pass@ip_adresse/stream') # Für IP-Kamera

if not cap.isOpened():
    print("Fehler: Kamera konnte nicht geöffnet werden.")
    exit()

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Bild für das Modell vorbereiten (Resizing, Normalisierung)
    img = cv2.resize(frame, (input_width, input_height))
    img = img / 255.0  # Normalisieren
    img = img.transpose(2, 0, 1) # HWC zu CHW
    input_tensor = img[np.newaxis, :, :, :].astype(np.float32)

    # Inference ausführen
    outputs = session.run([output_name], {input_name: input_tensor})
    predictions = outputs[0]

    # Post-Processing (NMS, Bounding Boxen extrahieren, etc. - hier stark vereinfacht)
    # Für ein echtes YOLO-Modell ist das Post-Processing komplexer
    for pred in predictions:
        # Beispiel: Wenn pred[4] > CONF_THRESHOLD ist, dann ist es eine Erkennung
        if pred[4] > CONF_THRESHOLD:
            class_id = np.argmax(pred[5:])
            confidence = pred[4] * pred[5+class_id] # Kombinierte Konfidenz
            if confidence > CONF_THRESHOLD:
                # Bounding Box-Koordinaten umrechnen und zeichnen
                # ... (diese Logik ist modellabhängig und hier ausgelassen)
                x1, y1, x2, y2 = 0,0,0,0 # Platzhalter
                cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                label = f"{CLASS_NAMES[class_id]}: {confidence:.2f}"
                cv2.putText(frame, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
                
                # Hier könntest du eine MQTT-Nachricht senden oder andere Aktionen auslösen
                print(f"Objekt erkannt: {CLASS_NAMES[class_id]} mit Konfidenz {confidence:.2f}")

    # Ergebnis anzeigen (optional, wenn du einen Monitor am Pi hast)
    # cv2.imshow('Object Detection', frame)
    # if cv2.waitKey(1) & 0xFF == ord('q'):
    #    break

cap.release()
# cv2.destroyAllWindows()
print("Objekterkennung beendet.")

Mit der Beschleunigung durch den AICore wirst du hier einen deutlichen Sprung in der Performance erleben. Wo du vorher vielleicht 5 FPS hattest, sind jetzt 20, 30 oder mehr FPS realistisch, je nach Modellgröße und Komplexität. Das ist der Unterschied zwischen einer verzögerten Benachrichtigung und einer echten Echtzeit-Reaktion in deinem Smart Home.

Häufige Fehler und Lösungen

In meiner Erfahrung gibt es ein paar Stolpersteine, über die man immer wieder fällt, besonders bei neuer Hardware. Hier sind die Top 3 und wie du sie behebst:

1. AICore wird nicht erkannt oder Fehler beim Laden der Treiber

Problem: Nach der Installation des SDK zeigt radxa-ai-tool info keine Geräte an oder du bekommst Fehlermeldungen beim Laden von Kernel-Modulen.

Mögliche Ursachen & Lösungen:

• Hardware-Verbindung: Überprüfe, ob der AICore richtig im M.2-Slot sitzt und mit der Schraube fixiert ist. Ist das PCIe-Flexkabel zwischen Pi 5 und HAT korrekt und fest verbunden? Manchmal hilft es, alles einmal abzustecken und neu zu verbinden.
• Firmware des Pi 5: Das ist ein Klassiker! Der Pi 5 benötigt eine aktuelle Firmware, um PCIe 2.0 richtig zu unterstützen. Hast du sudo rpi-update ausgeführt und danach neu gestartet? Wenn nicht, unbedingt nachholen!
• Falscher Treiber/SDK: Hast du die korrekte Version des Radxa SDK für die ARM64-Architektur (aarch64) des Raspberry Pi 5 heruntergeladen und installiert? Ein Blick in die Radxa-Dokumentation hilft hier.
• Kernel-Module: Überprüfe mit lsmod | grep radxa (oder wie immer das Modul heißt), ob die Kernel-Module geladen sind. Wenn nicht, versuche sudo modprobe <modulname>. Manchmal müssen die Module nach der Installation neu gebaut werden, was dkms erledigen sollte.

2. KI-Modell läuft auf dem AICore, aber die Performance ist schlecht oder stürzt ab

Problem: Dein Python-Skript läuft, aber es ist nicht schneller als auf der CPU, oder es kommt zu Abstürzen.

Mögliche Ursachen & Lösungen:

• Falsche Framework-Konfiguration: Hast du den Delegate (TFLite) oder Execution Provider (ONNX Runtime) korrekt angegeben? Ist er der erste in der Liste der Provider? Wenn das Framework den AICore nicht als bevorzugten Provider sieht oder er nicht verfügbar ist, fällt es automatisch auf die CPU zurück.
• Modell nicht optimiert/kompatibel: Nicht jedes KI-Modell kann 1:1 auf einem spezialisierten Beschleuniger laufen. Oft müssen Modelle quantisiert (z.B. von FP32 auf INT8) oder in ein spezifisches Format konvertiert werden, das der AICore optimal verarbeiten kann. Prüfe die Radxa-Doku, welche Operationen (Ops) der AICore unterstützt. Wenn ein Modell unsupported Ops enthält, werden diese meist auf der CPU ausgeführt, was zu Performance-Engpässen führt.
• Speicherprobleme: Gerade bei größeren Modellen kann der RAM des Pi 5 zum Flaschenhals werden. Überwache den Speicherdruck mit htop oder free -h.
• Überhitzung: Eine hohe Last kann zu Überhitzung führen, was den AICore oder den Pi 5 drosselt. Überprüfe die Temperaturen mit vcgencmd measure_temp und stelle sicher, dass deine Kühlung ausreicht.

3. Python-Abhängigkeiten oder Build-Fehler

Problem: Beim pip install oder beim Ausführen von Python-Skripten bekommst du Fehlermeldungen bezüglich fehlender Bibliotheken oder Compiler-Fehler.

Mögliche Ursachen & Lösungen:

• Virtuelle Umgebung vergessen: Hast du source ~/aicore_env/bin/activate ausgeführt? Wenn nicht, werden Pakete global installiert oder fehlen im Pfad.
• Fehlende Systempakete: Oft benötigen Python-Pakete zugrunde liegende C-Bibliotheken oder Compiler-Tools. Fehlermeldungen wie "Python.h not found" deuten auf build-essential oder python3-dev hin. Installiere sie: sudo apt install -y build-essential python3-dev.
• Falsche Architektur: Stelle sicher, dass du Python-Pakete für aarch64 installierst. Manchmal versuchen pip oder andere Tools, x86-Binaries herunterzuladen, wenn die Umgebung nicht korrekt erkannt wird.

Fazit und Ausblick

Der Radxa AICore DX-M1M ist eine fantastische Ergänzung für jeden Raspberry Pi 5 im Homelab, der ernsthaft KI-Projekte lokal betreiben will. Die 25 TOPS sind eine Ansage und ermöglichen Anwendungen, die vorher nur mit deutlich teurerer oder energiehungrigerer Hardware möglich waren.

Die Installation erfordert zwar etwas Sorgfalt und Einarbeitung in die spezifischen Treiber und SDKs von Radxa, aber der Aufwand lohnt sich definitiv. Die Möglichkeit, Objekterkennung, Sprachverarbeitung oder andere neuronale Netze direkt auf der Edge-Hardware auszuführen, eröffnet völlig neue Möglichkeiten für datenschutzfreundliche und reaktionsschnelle Smart-Home-Automatisierungen, lokale Überwachungssysteme oder auch einfach nur spannende Experimente.

Was sind die nächsten Schritte?

• Experimentiere mit verschiedenen Modellen: Lade dir vortrainierte Modelle (z.B. von TensorFlow Hub oder PyTorch Hub) herunter, konvertiere sie in TFLite oder ONNX und teste die Performance.
• Integriere in Docker: Wenn du Home Assistant, N8N oder andere Dienste in Docker betreibst, überlege, wie du den AICore in einem Docker-Container verfügbar machen kannst (Stichwort: --device oder passende Dockerfile-Anweisungen).
• Eigene Trainings: Auch wenn der AICore primär für Inference gedacht ist, kann das Wissen um seine Fähigkeiten dir helfen, Modelle zu trainieren, die optimal auf seine Architektur zugeschnitten sind (z.B. durch Quantisierung im Training).

Ich bin gespannt, welche coolen Projekte du mit dieser neuen Power in deinem Homelab umsetzen wirst. Die Welt der lokalen KI auf dem Pi ist weit offen – viel Spaß beim Experimentieren!