So machen wir bei Ultralytics YOLO-Modelle auf deinem bevorzugten Chip schneller

Bei Ultralytics entwickeln wir Modelle für Computer Vision – im Grunde bringen wir Computern das Sehen bei! Stell dir diese Modelle als riesige mathematische Rezepte vor. Sie bestehen aus Operationen (wir nennen sie Layer) und einer gewaltigen Ansammlung von Zahlen, die wir Gewichte nennen.

Unsere Ultralytics YOLO-Modelle verarbeiten Bilder als das, was sie tatsächlich sind: Zahlen-Arrays! Jedes Pixel besteht im Grunde nur aus Farbwerten – der Menge an Rot, Grün und Blau (also RGB) für jeden einzelnen Punkt, aus dem das Bild besteht. Wir nennen diese Zahlen-Arrays „Tensoren“, weil das viel cooler klingt als „mehrdimensionale Matrizen“, was wiederum viel cooler klingt als „Zahlen auf Zahlen auf Zahlen gestapelt“.

Wenn du ein Bild in unser Modell einspeist, begibt es sich auf eine epische Reise durch das Netzwerk. Stell dir vor, wie dein Tensor durch Layer um Layer surft und dabei auf die schönstmögliche Weise transformiert, gefaltet und mathematisch durcheinandergebracht wird. Es ist wie eine Tanzparty, bei der sich Zahlen vermischen und austauschen und dabei herausarbeiten, was eine Katze zur Katze oder ein Auto zum Auto macht. Diesen Prozess nennen wir Merkmalsextraktion.

Was kommt am anderen Ende heraus? Noch mehr Zahlen! Aussagekräftige Zahlen. Bei Erkennungsaufgaben sagen sie dir genau, wo sich etwas in deinem Bild befindet und was dieses Etwas wahrscheinlich ist. „Hey, mit 95 % Wahrscheinlichkeit ist das bei den Koordinaten (x, y) ein Hund!“ Diesen magischen Prozess nennen wir Inferenz.

Bevor unsere Modelle jedoch ihre Magie wirken können, müssen sie zur Schule gehen – sie müssen trainiert werden. Beim Training wird es intensiv.

Während des Trainings erhalten wir nicht einfach nur eine Antwort, wenn wir dem Netzwerk ein Bild präsentieren. Wir tun zwei besonders aufwendige Dinge. Erstens berechnen wir, wie falsch das Netzwerk lag (wir nennen das Verlust, im Grunde die Entfernung vom Volltreffer). Zweitens – und das ist der wichtige Teil – aktualisieren wir jede einzelne Zahl (also jedes Gewicht) im Netzwerk auf Grundlage dieses Verlusts. Stell dir vor, du justierst Tausende winziger Regler gleichzeitig, wobei jede Anpassung darauf ausgelegt ist, das Netzwerk von Mal zu Mal genauer zu machen.

Im Grunde trainieren wir das Netzwerk durch Korrektur: Jeder Fehler bringt ihm bei, was es NICHT tun soll, und wir passen all diese Gewichte an, damit es beim nächsten ähnlichen Bild näher an die richtige Antwort herankommt. Das Netzwerk lernt also, indem es nach und nach in die richtige Richtung gelenkt wird – Fehler für Fehler –, bis seine Vorhersagen immer besser sitzen.

Über wie viele Zahlen sprechen wir? Unser kleines YOLO11n hat ein paar Millionen Parameter. Aber YOLO11x? Dieses Kraftpaket bringt es auf über 50 Millionen Parameter! Mehr Parameter bedeuten, dass du mehr Details codieren kannst – etwa den Unterschied zwischen Zeichnen mit Wachsmalstiften und einer vollständigen Künstlerpalette.

Während der Inferenz wird diese Parameteranzahl entscheidend. Ein Netzwerk mit 3 Millionen Parametern auszuführen, ist wie eine Runde um den Häuserblock zu joggen. Ein Netzwerk mit 50 Millionen Parametern auszuführen? Das ist eher wie ein Marathonlauf mit brennenden Fackeln in beiden Händen.

Was genau IST also Berechnung? Wie läuft diese ganze Zahlenverarbeitung tatsächlich ab? Wie machen wir sie schneller? Und was bedeutet „Berechnung optimieren“ überhaupt?

Wie Chips tatsächlich rechnen#

Berechnungen finden in Chips statt. Diese kleinen Siliziumquadrate sind im Grunde die am besten organisierten Sandburgen des Universums. Jede einzelne Operation, die dein Computer ausführt – jede Addition, jeder Vergleich, jedes „wenn dies, dann das“ – ist physisch in das Silizium eingebaut. In bestimmten Bereichen des Chips gibt es echte physische Schaltungen zum Addieren von Zahlen, andere sind für logische Operationen zuständig. Es ist wie eine winzige Stadt, in der sich verschiedene Viertel auf unterschiedliche Arten von Mathematik spezialisiert haben.

Das klingt wahrscheinlich seltsam, selbst wenn du Informatiker bist. Der Grund ist, dass wir in den vergangenen 40 Jahren Schicht um Schicht an Abstraktion aufgebaut haben – wie bei einer technologischen Lasagne, die so hoch geworden ist, dass wir den untersten Teller nicht mehr sehen können. Wir haben die Dinge so stark vereinfacht, dass die meisten Programmierer heute keine Ahnung haben, wie Berechnungen tatsächlich im Silizium ablaufen. Nicht, weil sie etwas falsch gemacht hätten, sondern weil es genau so entworfen wurde!

Lass uns diese Schichten abtragen. Hier ist ein denkbar einfacher Python-Code:

x = 1
if x == 1:
    y = x + 1

Wir erstellen eine Variable x, setzen sie auf 1, und wenn x gleich 1 ist (kleiner Spoiler: Das ist der Fall), erstellen wir y mit dem Wert von x plus 1. Drei Zeilen. Ganz einfach.

Aber jetzt wird es interessant. Zwischen diesen drei harmlosen Zeilen und den tatsächlichen Elektronen, die sich durch das Silizium bewegen, liegen mindestens vier gewaltige Übersetzungsschichten (tatsächlich sind es mehr, aber unsere Leitung für digitale Inhalte meint, meine Wortzahl verursache ihr bereits Angstzustände). Ich nehme dich auf dieser verblüffenden Reise mit:

Schicht 1: Python → Bytecode Zuerst liest Python deinen Code und kompiliert ihn zu etwas, das Bytecode genannt wird – einer Zwischensprache, die Computer leichter verarbeiten können, bei deren Anblick dir aber die Augen bluten würden.

Schicht 2: Bytecode → Maschinencode Der Python-Interpreter (zum Beispiel CPython) nimmt diesen Bytecode und übersetzt ihn in Maschinencode, also die tatsächlichen Anweisungen, die dein Prozessor versteht. Hier wird dein elegantes „if x == 1“ zu etwas wie „LOAD register, COMPARE register, JUMP if zero flag set“.

Schicht 3: Maschinencode → Mikrocode Überraschung! Moderne Prozessoren führen Maschinencode nicht einmal direkt aus. Sie zerlegen ihn weiter in Mikrocode, also noch kleinere Operationen, die die internen Komponenten des Chips verarbeiten können. Aus deiner einzelnen „ADD“-Anweisung können mehrere Mikrooperationen werden.

Schicht 4: Mikrocode → physische Elektronik Schließlich erreichen wir das Silizium. Diese Mikrooperationen lösen echte elektrische Signale aus, die durch Transistoren fließen. Milliarden winziger Schalter werden ein- und ausgeschaltet, Elektronen tanzen durch sorgfältig entworfene Bahnen, und irgendwie wird auf magische Weise 1 + 1 zu 2.

Jede Schicht dient dazu, die wahnsinnige Komplexität der darunterliegenden Schicht zu verbergen. Es ist wie bei russischen Matrjoschka-Puppen – nur dass jede Puppe eine völlig andere Sprache spricht und die kleinste buchstäblich aus in Sand eingeschlossenem Blitz besteht.

Die Ironie? Diese drei Python-Zeilen lösen wahrscheinlich MILLIONEN von Schaltvorgängen in Transistoren aus. Dank dieser Abstraktionen musst du dir darüber jedoch keine Gedanken machen. Du schreibst einfach „y = x + 1“ und vertraust darauf, dass irgendwo tief im Silizium die Magie geschieht.

Die Architektur#

Jede einzelne Operation ist physisch im Silizium implementiert, und WO sie auf dem Chip stattfindet, hängt vollständig von der Topologie des Chips ab. Es ist wie Stadtplanung, nur für Elektronen. Der Addierer befindet sich hier, der Multiplizierer dort, und alle müssen effizient miteinander kommunizieren.

Auf dem Markt gibt es Hunderte verschiedener Chips, die jeweils für unterschiedliche Zwecke entwickelt wurden. Was unterscheidet sie? Die Topologie – also die Anordnung und physische Umsetzung der Operationen. Das nennen wir Architektur, und davon gibt es wirklich jede Menge:

• x86 (Intel und AMD) – Der Großvater der Desktop-Computer: komplex, aber leistungsstark
• ARM – Treibt dein Smartphone und zunehmend auch deinen Laptop an; auf Effizienz ausgelegt
• RISC-V – Der Open-Source-Rebell, der überall an Bedeutung gewinnt
• PowerPC – IBMs Kraftpaket, das noch immer in Spielekonsolen und Servern läuft
• MIPS – Der Liebling der Hochschulen: einfach und elegant
• SPARC – Sun Microsystems’ (heute Oracle) Beitrag zum Hochleistungsrechnen
• GPU-Architekturen (NVIDIAs CUDA-Kerne, AMDs RDNA) – Monster der parallelen Verarbeitung

Jede Architektur ordnet nicht nur ihre Transistoren anders an, sondern spricht auch eine andere Sprache. Die Abstraktionen, mit denen wir Anweisungen an diese Maschinen senden, unterscheiden sich grundlegend. Es ist, als müsstest du jemandem eine Wegbeschreibung schreiben, aber je nach Auto musst du sie auf Französisch, Mandarin oder in Ausdruckstanz verfassen.

Der Herzschlag des Siliziums#

Der Treibstoff unserer Chips sind Elektronen – Elektrizität, die in den Chip fließt und die Energie für Berechnungen liefert. Energie allein reicht jedoch nicht aus. Damit ein Chip tatsächlich funktioniert und Daten durch seine komplexe Topologie bewegt, hängt alles von einer entscheidenden Komponente ab: dem Taktgeber. Er sorgt dafür, dass Elektronen zu bestimmten Zeiten durch bestimmte Wege fließen. Ohne ihn hättest du nur mit Strom versorgtes Silizium, das nichts tut.

Stell dir vor, du müsstest eine gewaltige Aufführung koordinieren, bei der Milliarden von Komponenten perfekt synchron bewegt werden müssen. Ohne Takt wäre das Chaos. Genau das leistet der Taktgeber für deinen Prozessor. Er besteht aus einem Kristall, der mit unglaublich gleichmäßiger Frequenz schwingt und Milliarden elektrischer Impulse pro Sekunde aussendet.

Wenn du „3,5-GHz-Prozessor“ hörst, bezeichnet GHz (Gigahertz) die Taktfrequenz – 3,5 Milliarden Takte pro Sekunde. Jeder Takt wird als Taktzyklus bezeichnet und ist die grundlegende Zeiteinheit in der Datenverarbeitung.

Zwischen den Taktzyklen passiert NICHTS. Der gesamte Computer hält an und wartet auf den nächsten Takt. Es ist wie das extremste Rot-grün-Spiel des Universums. Bei jedem „grünen Licht“ (Taktimpuls):

• Daten werden zwischen Komponenten bewegt
• Berechnungen werden ausgeführt
• Logische Entscheidungen werden getroffen
• Der Speicher wird gelesen oder beschrieben

Manche Operationen benötigen einen Zyklus (eine einfache Addition), andere viele Zyklen (eine Division oder das Abrufen von Daten aus dem RAM). Alles ist präzise choreografiert: Milliarden von Komponenten führen ihre jeweiligen Operationen aus, synchronisiert durch diesen unerbittlichen Takt.

Du kannst deinen Prozessor übertakten, indem du den Kristall schneller schwingen lässt. Dann läuft alles schneller, erzeugt aber auch mehr Wärme und wird instabiler. Übertreibst du es, stürzt dein Computer ab, weil die Elektronen mit dem Takt buchstäblich nicht mehr Schritt halten können.

Früher wurden diese Operationen mit Maschinen von der Größe ganzer Räume umgesetzt. Die Komponenten, die all diese Berechnungen ausführen, sind jedoch bemerkenswert einfach: Es handelt sich lediglich um Schalter. Ein- oder Ausschalter.

Verbindet man genügend dieser Schalter im richtigen Muster, erhält man Berechnungen. Die gesamte digitale Revolution läuft auf eine ausgefeilte Anordnung von Schaltern hinaus.

Diese Einfachheit bedeutet: Wenn du Schalter hast – irgendwelche Schalter –, kannst du einen Computer bauen. Menschen haben funktionierende Computer aus Wasserrohren und Ventilen, Dominosteinen, LEGO-Steinen, Murmeln und sogar Redstone in Minecraft gebaut.

Die Grundprinzipien haben sich seit den 1940er-Jahren nicht verändert. Wir sind lediglich unglaublich gut darin geworden, Schalter extrem klein zu bauen. Dein Smartphone verfügt über mehr Rechenleistung als alle Computer, die Menschen zum Mond geschickt haben, und passt in deine Hosentasche, weil wir gelernt haben, Schalter im atomaren Maßstab herzustellen.

Wenn wir neuronale Netzwerke mit Millionen von Parametern ausführen, schalten wir diese winzigen Schalter Milliarden Mal pro Sekunde um – perfekt synchronisiert mit dem Herzschlag des Kristalls. Jede Gewichtsaktualisierung, jede Matrixmultiplikation und jede Aktivierungsfunktion bewegt sich im Takt der Uhr.

Kein Wunder, dass dein Computer beim Training von Modellen klingt, als wolle er abheben!

Neuronale Netzwerke zum BRRRRR bringen#

Also gut: Wir haben diese Chips mit Milliarden von Schaltern, die im Takt eines Kristalls tanzen, und möchten darauf neuronale Netzwerke mit Millionen von Parametern ausführen. Sollte einfach sein, oder? Wir werfen die Zahlen einfach auf den Chip und lassen ihn loslegen!

Neuronale Netzwerke schnell auszuführen ist, als wolltest du ein Fünf-Gänge-Menü in einer Küche kochen, deren Kühlschrank drei Häuserblocks entfernt ist, in der du nur eine Pfanne hast und jede Zutat 225 Kilogramm wiegt. Die Mathematik selbst ist nicht das größte Problem – es ist alles andere.

Die fehlende Übereinstimmung der Architekturen#

Die meisten Chips wurden für Microsoft Word entwickelt, nicht für neuronale Netzwerke. Deine CPU wurde mit der Vorstellung gebaut, dass sie ihr Leben mit If-Anweisungen, Schleifen und gelegentlichen Steuerberechnungen verbringt (der einen Berechnung, die selbst Supercomputer emotional erschöpft). Sie ist für sequenzielle Operationen optimiert: erst dies, dann das, dann jenes.

Neuronale Netzwerke funktionieren jedoch völlig anders. Sie wollen ALLES GLEICHZEITIG erledigen. Während des Trainings aktualisierst du Millionen von Gewichten auf Grundlage der Fehler deiner Vorhersagen. Während der Inferenz (also bei der tatsächlichen Verwendung des trainierten Modells) schickst du Daten gleichzeitig durch Millionen von Berechnungen. Stell dir vor, du müsstest eine Million Zahlen mit einer weiteren Million Zahlen multiplizieren. Deine CPU möchte diese Aufgabe – Gott segne sie – einzeln erledigen, wie ein sehr schneller, aber äußerst methodischer Buchhalter.

Deshalb wurden GPUs zum Rückgrat der KI-Datenverarbeitung. GPUs wurden für Videospiele entwickelt, bei denen die Farbe von Millionen Pixeln gleichzeitig berechnet werden muss. Es stellt sich heraus, dass die Berechnung von Pixelfarben und neuronale Netzwerkberechnungen überraschend ähnlich sind: In beiden Fällen wird dieselbe Operation parallel auf riesige Datenmengen angewendet.

Aber auch GPUs sind für neuronale Netzwerke nicht perfekt geeignet. Deshalb entwickeln Unternehmen inzwischen spezialisierte KI-Chips (TPUs, NPUs und jedes andere Kürzel, das auf PU endet). Diese Chips werden von Grund auf für eine einzige Aufgabe entwickelt: neuronale Netzwerke schnell auszuführen. Sie sind wie ein Koch, der nur ein Gericht zubereiten kann, dieses aber mit übermenschlicher Geschwindigkeit kocht. Während deine CPU sich sequenziell durch Matrixoperationen quält und deine GPU sie parallel recht gut verarbeitet, verschlingen diese spezialisierten Chips Matrizen zum Frühstück, Mittag- und Abendessen.

Die Speicherwand (oder: Warum das Verschieben von Bits schwieriger ist als Mathematik)#

Bei modernen Berechnungen neuronaler Netzwerke verbringen wir mehr Zeit und Energie damit, Daten zu BEWEGEN, als tatsächlich mit ihnen zu RECHNEN.

Stell dir deinen Computerchip wie einen brillanten Mathematiker vor, der blitzschnell arbeitet, dessen Nachschlagewerke aber in verschiedenen Gebäuden in der ganzen Stadt lagern. Er kann jede Gleichung sofort lösen, muss sich aber zuerst die Zahlen holen – und diese Reise dauert ewig.

Dein Chip kann zwei Zahlen in einem Taktzyklus multiplizieren (du erinnerst dich: einem von Milliarden Takten pro Sekunde). Blitzschnell! Aber diese Zahlen aus dem Speicher zum Chip zu holen? Das kann HUNDERTE von Zyklen dauern. Es ist, als könnte dein Mathematiker ein Problem in einer Sekunde lösen, aber fünf Minuten braucht, um zur Bibliothek und zurück zu gehen.

Der Grund ist die Entfernung (und der Platz). Elektrizität bewegt sich schnell, aber nicht unendlich schnell. Je weiter die Daten auf dem Chip reisen müssen, desto länger dauert es. Computerentwickler haben dieses Problem gelöst, indem sie eine Speicherhierarchie geschaffen haben – ähnlich wie mehrere Speicherorte in unterschiedlichen Entfernungen:

• Register (direkt in die Recheneinheiten integriert): Der Schreibtisch deines Mathematikers. Sofortiger Zugriff! Sie sind aber winzig – du kannst hier nur etwa 32 Zahlen aufbewahren. Es ist wie mit Haftnotizen direkt vor dir.
• L1-Cache (wenige Mikrometer entfernt): Das Bücherregal im Büro. Das Abrufen dauert 3–4 Zyklen. Hier passen einige Tausend Zahlen hinein.
• L2-Cache (wenige Millimeter entfernt): Der Aktenschrank auf dem Flur. Der Zugriff dauert 10–15 Zyklen, und es passen einige Millionen Zahlen hinein.
• L3-Cache (auf der anderen Seite des Chips): Der Lagerraum im Untergeschoss. Der Zugriff dauert 30–50 Zyklen; dort finden mehrere zehn Millionen Zahlen Platz.
• RAM (auf einem vollständig anderen Chip): Das Lagerhaus auf der anderen Seite der Stadt. Der Zugriff dauert 100–300 Zyklen. Hier liegen deine Milliarden von Zahlen.
• SSD/Festplatte (über Kabel verbunden): Eine völlig andere Stadt. Der Zugriff dauert Millionen von Zyklen. Riesige Speicherkapazität, eisige Geschwindigkeit.

Die genauen Strukturen unterscheiden sich. Der Chip deines Smartphones überspringt möglicherweise den L3-Cache, während eine Server-CPU große Mengen davon besitzen kann. Das Prinzip bleibt jedoch gleich: Näherer Speicher ist schneller, aber kleiner.

Jetzt wird es für neuronale Netzwerke schmerzhaft. Stell dir vor, dein Ultralytics YOLO-Modell hat 50 Millionen Parameter (ChatGPT hat übrigens Milliarden). Das sind 50 Millionen Zahlen, die vom Speicher zu den Recheneinheiten und zurück bewegt werden müssen. Selbst wenn jede Zahl nur 4 Byte belegt, müssen 200 Megabyte Daten durch dein System bewegt werden.

Der Chip verarbeitet möglicherweise jede Zahl in einem einzigen Zyklus. Wenn es aber 100 Zyklen dauert, diese Zahl aus dem RAM abzurufen, verbringst du 99 % deiner Zeit mit Warten auf die Lieferung. Es ist wie ein Formel-1-Rennwagen im Stau. Die gesamte Rechenleistung sitzt da und wartet auf die Daten.

Hier liegt die entscheidende Erkenntnis: Das ist DER Flaschenhals der modernen Datenverarbeitung. Er wird als von-Neumann-Flaschenhals bezeichnet. Chips beim Rechnen schneller zu machen, ist vergleichsweise einfach. Den Speicher schneller zu machen, stößt an physikalische Grenzen. Deshalb findet fast die GESAMTE Leistungsoptimierung in der KI auf Speicherebene statt. Wenn Ingenieure neuronale Netzwerke beschleunigen, machen sie die Mathematik nur selten schneller. Stattdessen suchen sie nach cleveren Möglichkeiten, weniger Daten zu bewegen, sie besser zwischenzuspeichern oder intelligenter darauf zuzugreifen.

Moderne KI-Chips konzentrieren sich nicht nur auf die Rechengeschwindigkeit, sondern auf Speicherbandbreite und Strategien zur Datenbewegung. Sie laden Daten im Voraus, verwenden bereits im Cache vorhandene Werte wieder und organisieren Berechnungen so, dass Speicherzugriffe minimiert werden. Die Gewinner im Wettlauf um KI-Hardware sind nicht diejenigen mit den schnellsten Rechnern, sondern diejenigen, die herausgefunden haben, wie sie diese Rechner kontinuierlich mit Daten versorgen. Das gesamte Spiel dreht sich um die Optimierung von Speicherzugriffsmustern.

Jedes Mal, wenn du ein Datenbit bewegst, verbrauchst du Energie. Nicht viel – wir sprechen von Pikojoule –, aber bei Terabytes pro Sekunde summiert sich das SCHNELL. Tatsächlich verbraucht das Verschieben von Daten um 1 mm auf einem Chip mehr Energie als die eigentliche Berechnung!

Deshalb klingt dein Laptop beim Training neuronaler Netzwerke wie ein Düsenjet. Nicht die Mathematik erzeugt die Wärme, sondern die Datenbewegung. Jede Parameteraktualisierung, jede Gradientenberechnung und jeder Vorwärtsdurchlauf heizt buchstäblich deinen Raum auf.

Moderne KI-Beschleuniger sind im Grunde Übungen in Thermodynamik. Wie viel Rechenleistung können wir unterbringen, bevor der Chip schmilzt? Wie schnell können wir die Wärme abführen? Es ist wie Übertakten, nur dass der Takt immer auf 11 steht und wir lediglich versuchen, keinen Brand auszulösen.

Die Lösung? Architekturorientiertes Design#

Die schnellsten neuronalen Netzwerke sind nicht unbedingt die intelligentesten. Es sind diejenigen, die mit Blick auf die Chips entwickelt wurden. Sie:

• Halten Daten so weit wie möglich lokal
• Verwenden Berechnungen zwanghaft wieder
• Passen perfekt zu den Fähigkeiten der Hardware
• Minimieren die Datenbewegung um jeden Preis

Es ist der Unterschied zwischen einem Rezept, das sagt „Verwende Zutaten aus deinem örtlichen Supermarkt“, und einem, das Gewürze aus Tibet, Käse aus Frankreich und Wasser aus der Antarktis verlangt. Beides kann gut schmecken, aber eines ist eindeutig praktischer.

Und genau deshalb ist es eine Kunst, neuronale Netzwerke schnell zu machen. Gute Mathematik allein reicht nicht aus. Du musst die Hardware verstehen, die Speicherhierarchie respektieren und perfekt mit der Architektur zusammenspielen.

Willkommen in einer Welt, in der Informatik auf Physik, Technik und pure Zauberei trifft. Wo das Bewegen einer Zahl mehr kostet als die Berechnung mit ihr. Wo Parallelität schnell, Synchronisierung aber tödlich ist. Wo dein größter Feind nicht die Komplexität, sondern die Entfernung ist.

Wie wir YOLO schneller machen#

Wenn du ein YOLO-Modell trainierst, erhältst du ein neuronales Netzwerk, das auf deiner Trainingsumgebung hervorragend funktioniert. Aber hier liegt der entscheidende Punkt: Deine Gaming-GPU, dein iPhone und der winzige Chip in einer Sicherheitskamera sprechen völlig unterschiedliche Sprachen. Sie haben unterschiedliche Stärken und Schwächen und sehr unterschiedliche Vorstellungen davon, wie Daten verarbeitet werden sollen.

Stell es dir so vor: Eine GPU verfügt über Tausende Kerne, die alle gleichzeitig arbeiten können – sie ist für parallele Verarbeitung gebaut. Ein mobiler Chip besitzt dagegen möglicherweise spezielle Schaltungen, die eigens für KI-Operationen entwickelt wurden, kann aber nur bestimmte Arten von Mathematik verarbeiten. Und das Edge-Gerät in deiner Türklingelkamera versucht, KI mit einem geringeren Energieverbrauch als eine LED-Glühbirne auszuführen.

Bei Ultralytics unterstützen wir mehr als ein Dutzend verschiedene Exportformate, weil jedes davon für andere Hardware optimiert ist. Es geht nicht darum, zu viele Optionen zu haben. Es geht darum, die richtige Option für DEINE spezifischen Anforderungen zu haben.

Operationen fusionieren: Mit weniger mehr erreichen#

Im ursprünglichen YOLO-Modell laufen viele Operationen nacheinander ab. Zum Beispiel führen wir zunächst eine Faltung durch, normalisieren anschließend die Ergebnisse und wenden dann eine Aktivierungsfunktion an. Das sind drei separate Schritte, von denen jeder eigene Lese- und Schreibzugriffe auf den Speicher erfordert.

Der clevere Teil ist jedoch: Wir können diese Operationen zu einem einzigen Schritt zusammenfassen. Beim Export von YOLO für die Bereitstellung fusionieren wir diese Operationen. Anstatt:

1. Faltung berechnen → Im Speicher speichern
2. Aus dem Speicher laden → Normalisieren → Im Speicher speichern
3. Aus dem Speicher laden → Aktivierung anwenden → Im Speicher speichern

Tun wir Folgendes:

1. Faltung + Normalisierung + Aktivierung berechnen → Im Speicher speichern

Bei einem typischen YOLO-Modell, das ein Bild mit 640×640 Pixeln verarbeitet, eliminiert dieser einfache Trick Gigabytes an unnötigen Speicherübertragungen. Auf einem Smartphone ist das der Unterschied zwischen flüssiger Erkennung in Echtzeit und frustrierender Verzögerung.

Kleinere Zahlen verwenden: Die Magie der Quantisierung#

YOLO benötigt keine extrem präzisen Zahlen, um Objekte genau zu erkennen. Während des Trainings verwenden wir 32 Bit zur Darstellung jedes Gewichts – das ist ungefähr so, als würdest du die Zutaten für ein Sandwich mit einem wissenschaftlichen Taschenrechner abmessen. Für den eigentlichen Einsatz? 8 Bit reichen völlig aus.

Das nennt man Quantisierung und es ist eine unserer leistungsstärksten Optimierungstechniken. Durch die Verwendung kleinerer Zahlen:

• Das Modell wird um 75 % kleiner (von 200 MB auf 50 MB bei Ultralytics YOLO11x)
• Es läuft auf den meisten Geräten 2- bis 4-mal schneller
• Es verbraucht deutlich weniger Energie (der Akku deines Smartphones wird es dir danken)

Nicht alle Layer in YOLO reagieren gleich empfindlich auf diese Reduzierung. Die frühen Layer, die grundlegende Kanten und Formen erkennen? Sie sind robust – wir können 8-Bit-Zahlen ohne Probleme verwenden. Die abschließenden Erkennungslayer, die bestimmen, ob es sich um eine Katze oder einen Hund handelt, benötigen etwas mehr Präzision. Deshalb passen wir die Präzision Layer für Layer an und verwenden gerade so viele Bits, dass die Genauigkeit erhalten bleibt und gleichzeitig die Geschwindigkeit maximiert wird.

Wir haben festgestellt, dass Ultralytics YOLO bei sorgfältiger Quantisierung 99,5 % seiner ursprünglichen Genauigkeit beibehält und auf Smartphones 3-mal schneller läuft. Das ist der Unterschied zwischen einem Forschungsmodell und etwas, das du tatsächlich in der Praxis einsetzen kannst.

Den besten Algorithmus auswählen#

Es gibt Dutzende verschiedener Möglichkeiten, dieselbe mathematische Operation auszuführen. Eine einfache Faltung (die Kernoperation in YOLO) kann mit völlig unterschiedlichen Algorithmen berechnet werden, und die beste Wahl hängt von deiner spezifischen Hardware und Eingabegröße ab.

Beim Export von YOLO testet unser Optimierungs-Framework tatsächlich verschiedene Algorithmen und wählt den schnellsten für deinen konkreten Anwendungsfall aus. Das ist, als gäbe es mehrere Routen zum selben Ziel und du würdest anhand der aktuellen Verkehrslage die beste auswählen. Auf einer GPU verwenden wir möglicherweise einen Algorithmus, der viele Pixel gleichzeitig verarbeitet. Auf einer CPU kommt vielleicht einer zum Einsatz, der für die sequenzielle Verarbeitung optimiert ist. Die Mathematik bleibt gleich, aber die Ausführungsstrategie ist völlig unterschiedlich.

Speicher: Der versteckte Engpass#

Erinnerst du dich, dass wir darüber gesprochen haben, dass der Speicher der eigentliche Engpass moderner Datenverarbeitung ist? Das gilt besonders für YOLO. Das Modell kann 50 Millionen Parameter haben und während der Inferenz Gigabytes an Zwischenergebnissen erzeugen. Das Verschieben all dieser Daten ist oft langsamer als die eigentliche Berechnung.

Wir verwenden mehrere Tricks, um die Speicherbewegungen zu minimieren:

Intelligente Ablaufplanung: Wir ordnen die Operationen so an, dass Daten sofort verwendet werden, solange sie sich noch im schnellen Cache-Speicher befinden. Bei YOLOs Feature-Pyramid-Netzwerk reduziert das den Speicherverkehr um 40 %.

Kachelung: Statt ein ganzes Bild auf einmal zu verarbeiten, teilen wir es in kleinere Kacheln auf, die in den Cache passen. Dadurch kann der Prozessor mit schnellem lokalem Speicher arbeiten, anstatt ständig Daten aus dem langsamen Hauptspeicher abzurufen.

Pufferwiederverwendung: Anstatt ständig neuen Speicher für Zwischenergebnisse zu reservieren, verwenden wir dieselben Speicherpuffer wieder. Das ist äußerst effizient – YOLOs gesamtes Backbone kann mit nur einer Reihe wiederverwendbarer Puffer ausgeführt werden.

Pruning: Weniger ist mehr#

Hier ist eine überraschende Tatsache: YOLO-Modelle sind oft überdimensioniert. Wir können in vielen Layern 30 % der Kanäle entfernen, ohne dass sich die Genauigkeit nennenswert verschlechtert. Dabei wird das Modell nicht nur kleiner – es wird auch schneller, weil tatsächlich weniger Berechnungen ausgeführt werden müssen.

Der Prozess ist elegant: Wir analysieren, welche Teile des Netzwerks am wenigsten zu den endgültigen Erkennungsergebnissen beitragen, entfernen sie und optimieren das Modell anschließend weiter, um dies auszugleichen. Ein beschnittenes YOLO11m-Modell kann 30 % schneller sein und dabei 99 % seiner ursprünglichen Genauigkeit beibehalten. Bei akkubetriebenen Geräten kann dieser Effizienzgewinn mehrere zusätzliche Betriebsstunden bedeuten.

Hardwarebeschleunigung: Die Stärken jedes Chips nutzen#

Verschiedene Prozessoren sind in unterschiedlichen Bereichen leistungsfähig, und die Performance-Unterschiede sind enorm. Dasselbe YOLO11n-Modell benötigt:

• 45 Millisekunden pro Frame auf einer modernen Intel-CPU
• 4 Millisekunden auf einer NVIDIA RTX GPU
• 22 Millisekunden auf einem leistungsstarken Smartphone-Prozessor
• 15 Millisekunden auf einem Google Coral Edge TPU

Das sind nicht nur Geschwindigkeitsunterschiede aufgrund der Taktfrequenz – sie spiegeln grundlegende architektonische Unterschiede wider. GPUs verfügen über Tausende von Kernen, die parallel arbeiten – ideal für die Faltungen von YOLO. Mobile NPUs haben spezialisierte Schaltungen, die speziell für neuronale Netzwerke entwickelt wurden. CPUs sind vielseitig einsetzbar: flexibel, aber nicht spezialisiert.

Der Schlüssel zur Optimierung besteht darin, die Operationen von YOLO auf das abzustimmen, was jeder Chip am besten kann. Eine GPU verarbeitet gerne dieselbe Operation gleichzeitig auf großen Datenmengen. Eine mobile NPU unterstützt möglicherweise nur bestimmte Operationen, führt diese aber äußerst effizient aus. Ein Edge TPU arbeitet nur mit 8-Bit-Ganzzahlen, erreicht innerhalb dieser Einschränkung jedoch eine bemerkenswerte Geschwindigkeit.

Die Magie der Kompilierung#

Wenn du ein YOLO-Modell exportierst, geschieht im Hintergrund etwas Bemerkenswertes. Wir konvertieren nicht einfach nur das Dateiformat – wir kompilieren das Modell tatsächlich speziell für deine Zielhardware. Das ist wie der Unterschied zwischen Google Translate und einem Muttersprachler. Der Kompilierungsprozess:

1. Analysiert dein Modell, um seine Struktur und Anforderungen zu verstehen
2. Berücksichtigt die Fähigkeiten deiner Hardware – worin sie gut ist und womit sie Schwierigkeiten hat
3. Erzeugt optimierten Code, der die native Sprache deiner Hardware spricht

Der Compiler kann Operationen neu anordnen, um den Cache deines Prozessors besser zu nutzen, spezialisierte von deinem Chip unterstützte Anweisungen auswählen oder sogar maschinelles Lernen einsetzen, um die beste Optimierungsstrategie zu finden. Ja, wir verwenden KI, um KI zu optimieren – die Zukunft ist da!

Dieser Kompilierungsschritt kann einen zehnfachen Leistungsunterschied bewirken. Dasselbe YOLO-Modell kann mit generischem Code nur langsam vorankommen, aber mit richtig optimierten Anweisungen regelrecht fliegen.

YOLO am Netzwerkrand in der Praxis einsetzen#

Sehen wir uns an, was passiert, wenn YOLO auf die reale Welt trifft – genauer gesagt auf die anspruchsvolle Welt der Edge-Geräte. Stell dir eine Überwachungskamera vor, die YOLO rund um die Uhr zur Objekterkennung ausführen muss. Sie ist mit harten Einschränkungen konfrontiert:

• Speicher: Insgesamt vielleicht nur 512 MB bis 2 GB RAM
• Energie: Oft nur 2 bis 5 Watt (weniger als ein Smartphone-Ladegerät)
• Kühlung: Keine Lüfter, nur passive Wärmeableitung
• Zuverlässigkeit: Muss dauerhaft laufen, ohne abzustürzen

Das erreicht die Optimierung in der Praxis. Eine Überwachungskamera mit YOLO11s:

• Ursprüngliches Modell: 15 Watt, läuft bei 85 °C heiß, erreicht 20 FPS
• Mit Quantisierung und Pruning optimiert: 3 Watt, angenehme 45 °C, erreicht 25 FPS

Wir haben den Energieverbrauch um 80 % gesenkt und gleichzeitig die Leistung verbessert! Das ist der Unterschied zwischen einem Gerät, das überhitzt und Akkus entleert, und einem, das jahrelang zuverlässig läuft.

Der Schlüssel liegt darin, die richtigen Kompromisse zu wählen. Bei Edge-Geräten verwenden wir häufig:

• INT8-Quantisierung (weniger Präzision, deutlich weniger Energieverbrauch)
• Weniger Frames verarbeiten, wenn nur wenig Aktivität erkannt wird
• Die Arbeit auf verschiedene Prozessoren verteilen, um die Wärmeentwicklung zu steuern
• Modelle klein genug halten, damit sie vollständig in den schnellen Speicher passen

Der Optimierungsprozess#

Bei Ultralytics verfolgen wir einen systematischen Ansatz zur Optimierung. Zuerst erstellen wir ein Profil des Modells, um zu verstehen, wo tatsächlich Zeit verbraucht wird. Oft liegen die Engpässe nicht dort, wo du sie erwarten würdest. Vielleicht entfallen 80 % der Zeit auf nur wenige Layer, oder Speicherübertragungen bestimmen die Berechnungszeit.

Anschließend wenden wir die Optimierungen schrittweise an:

1. Mit den größten Engpässen beginnen
2. Jeweils nur eine Optimierung anwenden
3. Sowohl die Geschwindigkeitssteigerung als auch die Auswirkungen auf die Genauigkeit messen
4. Optimierungen beibehalten, die ein gutes Verhältnis von Nutzen und Kosten bieten
5. Wiederholen, bis wir unsere Ziele erreichen

Zum Beispiel bei der Bereitstellung von YOLO11m auf einem Smartphone:

• Ausgangswert: 200 ms pro Frame, 200-MB-Modell
• Nach der Quantisierung: 80 ms pro Frame, 50-MB-Modell
• Nach dem Pruning: 60 ms pro Frame, 35-MB-Modell
• Nach der Operationsfusion: 45 ms pro Frame, 35-MB-Modell

Jeder Schritt verbessert die Leistung und erhält dabei mehr als 99 % der ursprünglichen Genauigkeit. Das Ergebnis? Echtzeit-Objekterkennung auf einem Gerät, das in deine Hosentasche passt.

Die Zukunft: Heterogenes Rechnen#

Moderne Geräte werden immer besser darin, mehrere Prozessoren gemeinsam zu nutzen. Dein Smartphone hat nicht nur einen Prozessor – es verfügt über mehrere, die jeweils auf unterschiedliche Aufgaben spezialisiert sind:

• Der Kamerasensor verfügt über einen ISP (Bildsignalprozessor) für die Vorverarbeitung
• Die NPU (neuronale Verarbeitungseinheit) führt die YOLO-Inferenz aus
• Die CPU übernimmt komplexe Logik und Koordination
• Die GPU rendert die Ergebnisse auf dem Bildschirm

Bei der Optimierung von YOLO geht es künftig darum, das Modell intelligent auf diese Prozessoren aufzuteilen. Vielleicht übernimmt die NPU die wichtigsten Faltungen, die CPU die abschließende Erkennungslogik und die GPU die Visualisierung der Ergebnisse. Jeder Prozessor erledigt das, worin er am besten ist, und erzeugt so eine Pipeline, die effizienter ist, als es ein einzelner Prozessor je sein könnte.

Wir entwickeln intelligente Algorithmen zur Aufteilung, die automatisch ermitteln, wie YOLO am besten auf die verfügbaren Prozessoren verteilt wird. Dabei berücksichtigen sie nicht nur deren Fähigkeiten, sondern auch die Kosten der Datenübertragung zwischen ihnen.

Das Wichtigste in Kürze#

Bei der Optimierung von YOLO-Modellen geht es nicht nur um die Konvertierung von Dateiformaten. Es geht darum, modernste KI in etwas zu verwandeln, das tatsächlich in der realen Welt funktioniert. Mit Techniken wie Quantisierung (Verwendung kleinerer Zahlen), Pruning (Entfernen unnötiger Teile), Operationsfusion (Zusammenfassen von Schritten) und intelligenter Speicherverwaltung erreichen wir Leistungssteigerungen um das 10- bis 100-Fache und erhalten dabei die Genauigkeit.

Das Bemerkenswerte daran? Es gibt keine universell „beste“ Optimierung. Ein Cloud-Server mit unbegrenzter Energie benötigt andere Optimierungen als eine akkubetriebene Drohne. Ein Smartphone mit einem dedizierten KI-Chip braucht eine andere Behandlung als ein Raspberry Pi. Deshalb bietet Ultralytics so viele Exportoptionen – jede davon ist für unterschiedliche Szenarien optimiert.

Jede besprochene Optimierung verfolgt ein Ziel: Computer Vision überall zugänglich zu machen. Ganz gleich, ob du eine intelligente Türklingel, eine Drohnenanwendung oder einen umfangreichen Cloud-Dienst entwickelst – wir stellen dir die Werkzeuge bereit, damit YOLO unter deinen Rahmenbedingungen funktioniert.

Wenn du ein YOLO-Modell mit Ultralytics exportierst, speicherst du nicht einfach nur eine Datei. Du nutzt jahrelange Forschung daran, neuronale Netzwerke praxistauglich zu machen. Du verwandelst ein hochmodernes KI-Modell in etwas, das auf echter Hardware unter realen Einschränkungen laufen und echte Probleme lösen kann.

Das tun wir bei Ultralytics. Wir schließen die Lücke zwischen KI-Forschung und praktischer Bereitstellung. Wir sorgen dafür, dass Computer Vision überall funktioniert, denn bei der Zukunft der KI geht es nicht nur darum, die besten Modelle zu haben – es geht darum, diese Modelle in der realen Welt nutzbar zu machen.