Vorwort
Hallo, liebe Leser, dies ist der meistgelesene Artikel auf dem Blog! Bitte schreib unserem Geschäftsführer Jürgen Mayer über die
info@toowoxx.de, wenn es hier noch mehr Artikel zu KI Themen, wie die Bilderkennung geben soll. Wir beschäftigen uns intensiv mit diversen Themen rund um maschinelles Lernen. Dieser Artikel wurde zuletzt im Mai 2025 geprüft.
Bilderkennung ist ein spannendes Feld der künstlichen Intelligenz, das es Computern ermöglicht, visuelle Informationen zu verarbeiten und zu verstehen. Mithilfe von Machine Learning können Computerprogramme heute Bilder analysieren, Objekte und Personen erkennen und sogar Emotionen aus Gesichtsausdrücken ablesen.
Eines der bekanntesten Open-Source-Projekte für Bilderkennung ist YOLO (You Only Look Once). YOLO ist ein Framework für die Echtzeit-Objekterkennung und -segmentierung, das in der Lage ist, auf sehr schnelle und präzise Weise mehrere Objekte in einem Bild zu erkennen und zu identifizieren. Das Projekt hat seit seiner ersten Veröffentlichung im Jahr 2016 mehrere Iterationen durchlaufen.
In diesem Artikel werfen wir einen Blick auf das unkomplizierte Trainieren einer YOLO Bilderkennungs-KI.
Der vollständige Code dieses Tutorials ist unter
https://github.com/toowoxx/In-30-Minuten-zur-Bilderkennungs-KI/tree/main verfügbar.
Setup
Bevor wir mit dem Training beginnen können, müssen wir zunächst einige Vorbereitungen treffen. Um YOLO verwenden zu können, benötigen wir zuerst eine Python-Installation auf unserem Computer. Wenn Sie Python noch nicht installiert haben, können Sie es kostenlos von der
offiziellen Python-Website herunterladen und installieren.(
https://www.python.org/)
Beim Erstellen des Artikels wurde Python 3.10 verwendet.
Sobald Python installiert ist, sollten Sie ein ‚Jupyter Notebook‘ einrichten, auf dem Sie Ihre YOLO-Experimente durchführen können. ‚Jupyter Notebook‘ ist eine Open-Source- Webanwendung, mit der Sie interaktive Python-Notebooks erstellen und ausführen können. Sie können ‚Jupyter Notebook‘ über den Paket-Manager pip installieren und dann über die Befehlszeile starten:
pip install jupyter
jupyter notebook
Nach dem Einrichten von ‚Jupyter Notebook‘, müssen Sie die erforderlichen Pakete installieren, um mit YOLO arbeiten zu können. Dazu gehören ‚ultralytics‘, das Framework, auf dem YOLO basiert, sowie andere Pakete wie ‚NumPy‘, ‚OpenCV‘ und ‚Pillow‘. Sie können alle diese Pakete mit dem Paket-Manager pip installieren.
pip install ultralytics==8.0.225
pip install simple_image_download==0.4
pip3 install labelImg==1.8.6
pip install Pillow==10.1.0
pip install opencv-python==4.8.1.78
pip install matplotlib==3.8.2
Sobald Sie alle erforderlichen Pakete installiert haben, sind Sie bereit, mit YOLO zu arbeiten und Ihre eigenen Objekterkennungsexperimente durchzuführen.
In den nächsten Kapiteln werden wir eine eigene, auf YOLO basierende, Bilderkennungs-KI trainieren.
Vorbereiten der Trainingsdaten
Die Vorbereitung der Trainingsdaten ist ein wichtiger Schritt beim Aufbau eines erfolgreichen Machine-Learning-Modells.
Zunächst benötigt man einen Datensatz von Bildern. Diesen kann man entweder selbst erstellen oder mit dem Python-Paket ’simple_image_download‘ herunterladen.
pip install simple_image_download==0.4
Folgender Code lädt einen Datensatz an Bilder von Google herunter:
from simple_image_download import simple_image_download as simp
response = simp.simple_image_download
keywords = ["pet"]
limit = 50
for kw in keywords:
response().download(kw, limit)
- Für jedes Suchwort in der Variable ‚keywords‘ wird die Anzahl an Bilder heruntergeladen, die in ‚limit‘ konfiguriert ist.
Nachdem man den Datensatz hat, müssen die Bilder für das Training gelabelt werden. Sprich in einer Text-Datei werden die ‚Objekte‘ auf dem Bild beschrieben. Hierfür wird das Package ‚labelImg‘ benutzt.
Hinweis: Bei Nutzung von labelImg kann es zu unerwarteten Abstürzen kommen. Eine Lösung hierfür finden Sie im GitHub-Kommentar zu
labelImg Issue #872.
- Öffnen Sie den Ordner mit dem Bilddatensatz in der labelImg-Anwendung.
- Legen Sie einen neuen Ordner ‚Labels‘ an und setzen diesen als ‚Save Dir‘
- Einstellen von ‚YOLO‘
Das Datenset kann jezt durch das Ziehen von Boxen gelabelt werden.
Für jedes Bild erstellt ‚labelImg‘ eine korespondierende Text-Datei mit folgendem Aufbau:
- Jedes Objekt auf einem Bild bekommt eine eigene Zeile: <Objekt> <MittelpunktX> <MittelpunktY> <Breite> <Höhe>
Nach dem Labeling der Bilder müssen zwei Ordner erstellt werden: ‚train‘ und ‚val‘. In diesen Ordnern speichert man die Trainings- und Validierungsdatensätze. Zudem muss jeweils ein ‚images‘ und ein ‚labels‘ Unterordner erstellt werden. Fügen Sie in etwa 80-90% Ihrer Trainingsdaten und Labels in den ‚train‘ Ordner ein und den kleineren Datensatz in den ‚val‘ Ordner.
- Validierungsdaten sind beim Training von KI-Modellen unerlässlich, da sie dazu verwendet werden, die Leistung des Modells zu bewerten. Durch die Verwendung von separaten Validierungsdaten kann man sicherstellen, dass das Modell tatsächlich das erlernte Muster erkennt.
Vor dem Training muss noch eine Konfigurationsdatei ‚train_config.yaml‘ erstellt werden:
train: <Pfad zum Ordner train>
val: <Pfad zum Ordner val>
nc: <Anzahl der zu identifizierenden Objekte>
names: ['objekt1', 'objekt2', ...]
- Tipp: Die ‚labenImg‘ Anwendung erstellt normalerweise eine Datei ‚classes.txt‘, die alle Objekt-Klassen auflistet.
Training
Nachdem die Trainingsdaten vorbereitet worden sind, kann das Training angestoßen werden. Hierfür wird folgender Code verwendet:
from ultralytics import YOLO
model = YOLO("yolov8m.pt")
model.train(data = "./train_config.yaml", epochs = 50, imgsz = 640, batch = 2)
Zunächst wird das YOLO-Modell mit einer vortrainierten Gewichtsdatei initialisiert. Anschließend wird das Training gestartet:
- ‚data‘: Dieser Parameter gibt den Pfad zur Konfigurationsdatei an, die zuvor erstellt wurde.
- ‚epochs‘: Dieser Parameter gibt die Anzahl der Epochen an, über die das Modell trainiert werden soll. Eine Epoche bezeichnet dabei einen Durchlauf über den gesamten Trainingsdatensatz.
- ‚imgsz‘: Dieser Parameter gibt die Größe der Eingangsbilder an, die das Modell verarbeiten soll. Je nach Größe der Bilder kann dies die Leistung und Genauigkeit des Modells beeinflussen.
- ‚batch‘: Dieser Parameter gibt die Anzahl der Bilder an, die gleichzeitig in einem Batch verarbeitet werden sollen. Das bedeutet, dass das Modell nach jeder Verarbeitung eines Batches seine Gewichte entsprechend anpasst. Die Batch-Größe kann ebenfalls die Leistung des Modells beeinflussen.
- Indem man diese Parameter entsprechend anpasst, kann man das Training des Modells optimieren und die Leistung des Modells verbessern.
Während des Trainings werden z.B. die Metriken ‚cls_loss‘ (= Class Loss) und ‚box_loss‘ geloggt, die Auskunft über die Performance des Modells in Bezug auf die Klassifikation und die Bounding Boxes geben.
Der Class Loss gibt an, wie gut das Modell die verschiedenen Klassen der Objekte erkennt, während der Box Loss angibt, wie gut das Modell die Bounding Boxes um die Objekte herum vorhersagt. Diese Metriken sind besonders wichtig für Objekterkennungsaufgaben, da sie einen Einblick in die Fähigkeit des Modells geben, Objekte unterschiedlicher Klassen und Größen zu erkennen und zu lokalisieren.
Durch die Überwachung dieser Metriken kann man das Training des Modells optimieren und sicherstellen, dass es gute Ergebnisse auf neuen Daten liefert.
Wenn das Training abgeschlossen ist, werden die Gewichte in ein automatisch erzeugtes Ordnersystem ‚./runs/detect/train/weights‘ abgelegt.
Abfrage der KI
Nach dem erfolgreichen Training, ist es nun an der Zeit, das YOLO-Modell anzuwenden und Vorhersagen auf neuen Daten zu treffen. Hierfür wird folgender Code verwendet, um das trainierte Model zu laden und abzufragen:
from ultralytics import YOLO
from PIL import Image
img = Image.open("./test.png")
model = YOLO("./runs/detect/train/weights/best.pt")
results = model.predict(source=img, save=True)
results = list(results)[0]
print(results)
- Das Package ‚pillow‘ (PIL) wird verwendet um ein Bild zu öffnen und der KI zu übergeben Wenn der Parameter ’save‘ auf ‚True‘ gesetzt ist wird unter ‚./runs/detect/predict‘ das Bild inklusive Klassifikation und Bounding Box gespeichert.
Alternativ kann mit folgendem Code das Bild mit Klassifikation und Bounding Box direkt im Python Notebook ausgegeben werden:
import matplotlib.pyplot as plt
import matplotlib
import cv2
matplotlib.use('TkAgg')
image = results.orig_img
#convert from rgb to bgr
image = image[:, :, ::-1].copy()
#draw the boxes
for box in results.boxes:
print(box)
box = box.numpy().data[0]
if box[4] < 0.5:
continue
cv2.rectangle(image, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])) , (0, 255, 0), 2)
#print label
label = str(float(box[4]))[0:3] + results.names[int(box[5])]
cv2.putText(image, label, (int(box[0]), int(box[1])), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
plt.imshow(image)
plt.show()
GPU Training
Insgesamt bietet das Training von neuronalen Netzen auf einer GPU zahlreiche Vorteile gegenüber der Verwendung einer CPU. Die parallele Verarbeitung von Daten ermöglicht eine deutlich schnellere Ausführung von Berechnungen, was insbesondere bei großen Datensätzen und komplexen Modellen von Vorteil ist. Zudem können GPUs auch aufgrund ihrer speziellen Architektur besonders gut für die Verarbeitung von Bilddaten genutzt werden, was sie zu einem idealen Werkzeug für die Objekterkennung macht.
Um die CUDA-Version von PyTorch herunterzuladen und somit eine YOLO-KI über die Grafikkarte zu trainieren, kann man die folgenden Schritte befolgen:
- Besuchen Sie die offizielle PyTorch-Website unter https://pytorch.org/get-started/locally/ und wählen Sie die gewünschte CUDA-Version aus.
- Kopieren Sie den entsprechenden Installationsbefehl und führen diesen aus.
- Um zu überprüfen, ob PyTorch erfolgreich installiert wurde, öffnen Sie die Python-Shell und führen den folgenden Code aus:
import torch
print(torch.__version__)
War die Installation erfolgreich, sollte die aktuelle Version von PyTorch + der Cuda Version ausgegeben werden:
Beim erneuten Anstoßen des Trainings wird Ihre KI nun effizienter über die GPU trainiert.
- CUDA ist eine Parallel-Computing-Plattform und Programmierschnittstelle, die es Entwicklern ermöglicht, rechenintensive Anwendungen auf NVIDIA-Grafikkarten auszuführen. CUDA-Cores sind spezielle Prozessoreinheiten innerhalb der GPU, die speziell für die parallele Verarbeitung optimiert sind und dazu beitragen, die Leistung von CUDA- fähigen Anwendungen zu verbessern.
Für die bei AMD Grafikkarten verwendete ROCm Schnittstelle existiert ebenso ein PyTorch- Paket, das ähnlich über die offizielle PyTorch-Website installiert werden kann.
Willst du noch mehr über KI wissen. Man kann Sprachmodelle auch lokal laufen lassen, die Hardware ist hier der größte limitierende Faktor. Wie wäre es mit diesem Artikel:
https://www.toowoxx.de/braucht-ihr-unternehmen-ki-in-7-minuten-sprachmodelle-verstehen-fuer-manager-und-interessierte/
