Wie wir bei Ultralytics YOLO-Modelle auf deinem bevorzugten Chip beschleunigen

Bei Ultralytics entwickeln wir Computer-Vision-Modelle – im Grunde bringen wir Computern das Sehen bei! Stell dir diese Modelle als riesige mathematische Rezepte vor. Sie bestehen aus Rechenoperationen (die wir Schichten nennen) und einem gewaltigen Haufen Zahlen, den wir Gewichte nennen.

Unsere Ultralytics-YOLO-Modelle verarbeiten Bilder so, wie sie tatsächlich sind: als Zahlenfelder! Jedes Pixel besteht einfach aus Farbwerten – den Anteilen von Rot, Grün und Blau (RGB) an jedem einzelnen Punkt, aus dem sich das Bild zusammensetzt. Diese Zahlenfelder nennen wir „Tensoren“, weil das viel cooler klingt als „mehrdimensionale Matrizen“ – und das klingt wiederum viel cooler als „Zahlen, die auf Zahlen gestapelt sind, die auf Zahlen gestapelt sind“.

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 Schicht um Schicht gleitet, dabei umgewandelt, gefaltet und auf die schönste Art mathematisch durcheinandergebracht wird. Denk an eine Tanzparty, auf der Zahlen sich vermischen und miteinander ins Gespräch kommen, um herauszufinden, was eine Katze zur Katze oder ein Auto zum Auto macht. Diesen Vorgang nennen wir Merkmalsextraktion.

Was kommt am anderen Ende heraus? Mehr Zahlen! Aussagekräftige Zahlen. Bei Erkennungsaufgaben verraten sie dir genau, wo sich Dinge in deinem Bild befinden und worum es sich wahrscheinlich handelt. „Hey, mit 95 % Wahrscheinlichkeit ist das bei den Koordinaten (x, y) ein Hund!“ Diesen faszinierenden Vorgang nennen wir Inferenz.

Bevor unsere Modelle ihre Magie entfalten können, müssen sie erst zur Schule – sie müssen trainiert werden. Beim Training wird es richtig anspruchsvoll.

Während des Trainings erhalten wir jedes Mal, wenn wir dem Netzwerk ein Bild präsentieren, nicht einfach nur eine Antwort. Wir führen zwei besonders aufwendige Schritte aus. Erstens berechnen wir, wie weit das Netzwerk danebenlag (das nennen wir Verlust, also im Grunde die Entfernung zum Volltreffer). Zweitens – und das ist der wichtige Teil – aktualisieren wir jede einzelne Zahl (oder jedes Gewicht) im Netzwerk anhand dieses Verlusts. Stell es dir so vor, als würden Tausende winziger Regler gleichzeitig justiert, wobei jede Anpassung berechnet wird, damit das Netzwerk mit jedem Schritt genauer wird.

Im Grunde trainieren wir das Netzwerk durch Korrekturen: Jeder Fehler zeigt ihm, was es NICHT tun soll, und wir passen all diese Gewichte so an, dass das Netzwerk bei einem ähnlichen Bild der richtigen Antwort näherkommt. Das Netzwerk lernt also, indem es nach und nach in die richtige Richtung geschubst wird – Fehler für Fehler –, bis es immer treffsicherere Vorhersagen macht.

Über wie viele Zahlen sprechen wir? Unser niedliches kleines YOLO11n hat ein paar Millionen Parameter. Aber YOLO11x? Dieses Kraftpaket bringt es auf über 50 Millionen Parameter! Mehr Parameter bedeuten, dass sich mehr Details kodieren lassen – etwa so, als würdest du statt mit Wachsmalstiften mit einer vollständigen Künstlerpalette malen.

Bei der Inferenz wird diese Anzahl an Parametern entscheidend. Ein Netzwerk mit 3 Millionen Parametern auszuführen ist wie eine kleine Runde um den Block zu joggen. Ein Netzwerk mit 50 Millionen Parametern auszuführen? Das ist eher, als würde man einen Marathon laufen und dabei brennende Fackeln jonglieren.

Was genau ist also Berechnung? Wie läuft diese ganze Zahlenverarbeitung eigentlich ab? Wie können wir sie beschleunigen? Und was bedeutet „Berechnungen optimieren“ überhaupt?

Wie Chips tatsächlich rechnen#

Berechnungen finden auf Chips statt. Diese kleinen Siliziumplättchen 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 eingebettet. In bestimmten Bereichen des Chips gibt es tatsächlich physische Schaltkreise, die Zahlen addieren, und andere für logische Operationen. Das ist, als gäbe es eine winzige Stadt, in der sich verschiedene Viertel auf verschiedene Arten der Mathematik spezialisiert haben.

Das klingt wahrscheinlich seltsam, selbst wenn du Informatiker bist. Denn seit 40 Jahren bauen wir Abstraktionsschicht um Abstraktionsschicht auf – wie eine technologische Lasagne, die so hoch geworden ist, dass wir die unterste Schicht 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 das so vorgesehen ist!

Lass uns diese Schichten abtragen. Nehmen wir diesen denkbar einfachen Python-Code:

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

Wir erstellen eine Variable x, weisen ihr den Wert 1 zu und erstellen, falls x gleich 1 ist (kleiner Spoiler: Das ist der Fall), eine Variable y mit dem Wert x plus 1. Drei Zeilen. Ganz einfach.

Aber hier wird es interessant. Zwischen diesen drei harmlosen Zeilen und den tatsächlichen Elektronen, die sich durch Silizium bewegen, liegen MINDESTENS vier gewaltige Übersetzungsschichten (tatsächlich sind es mehr, aber unsere Digital-Content-Managerin sagt, meine Wortzahl treibe ihr schon jetzt den Angstschweiß auf die Stirn). Ich nehme dich mit auf diese verblüffende Reise:

Schicht 1: Python → Bytecode Zuerst liest Python deinen Code und kompiliert ihn in sogenannten Bytecode – eine Zwischensprache, die Computer leichter verarbeiten können, bei deren Anblick dir aber die Augen bluten würden.

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

Schicht 3: Maschinencode → Mikrocode Unerwartete Wendung! Moderne Prozessoren führen Maschinencode nicht einmal direkt aus. Sie zerlegen ihn weiter in Mikrocode – noch kleinere Operationen, mit denen die internen Komponenten des Chips umgehen 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 tatsächliche elektrische Signale aus, die durch Transistoren fließen. Milliarden winziger Schalter werden ein- und ausgeschaltet, Elektronen bewegen sich durch sorgfältig entworfene Leiterbahnen und irgendwie, wie durch Zauberei, wird aus 1 + 1 eine 2.

Jede Schicht verbirgt die wahnsinnige Komplexität der darunterliegenden Schicht. Das ist wie bei russischen Matrjoschkas – nur spricht jede Puppe eine völlig andere Sprache und die kleinste besteht buchstäblich aus Blitzen, die in Sand gefangen sind.

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

Die Architektur#

Jede einzelne Operation wird physisch im Silizium umgesetzt, und WO sie auf dem Chip stattfindet, hängt vollständig von dessen Topologie ab. Das ist wie Stadtplanung, nur für Elektronen. Hier sitzt der Addierer, dort der Multiplikator, 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, wie Operationen im physischen Bereich angeordnet und umgesetzt werden. Das nennen wir Architektur, und davon gibt es ganz schön viele:

• x86 (Intel und AMD) – der Urvater der Desktop-Computer: komplex, aber leistungsstark
• ARM – steckt in deinem Smartphone und zunehmend auch in deinem Laptop; 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 Wissenschaft: einfach und elegant
• SPARC – Sun Microsystems’ (heute Oracle) Beitrag zum Hochleistungsrechnen
• GPU-Architekturen (NVIDIAs CUDA-Kerne, AMDs RDNA) – wahre Giganten der parallelen Verarbeitung

Jede Architektur ordnet nicht nur ihre Transistoren anders an, sondern spricht auch eine andere Sprache. Die Abstraktionen, mit denen wir diesen Maschinen Anweisungen übermitteln, unterscheiden sich vollständig. Das ist, als müsstest du für jemanden eine Wegbeschreibung schreiben, aber je nach Auto musst du dafür Französisch oder Mandarin verwenden oder einen Ausdruckstanz aufführen.

Der Herzschlag des Siliziums#

Der Treibstoff unserer Chips sind Elektronen: Strom, der in den Chip fließt und die Energie für Berechnungen liefert. Aber Energie allein reicht nicht. Damit ein Chip tatsächlich funktioniert und Daten durch seine komplexe Topologie bewegt, kommt es auf eine entscheidende Komponente an: den Takt. Er sorgt dafür, dass Elektronen zu bestimmten Zeiten bestimmte Wege nehmen. Ohne ihn wäre das Silizium zwar mit Strom versorgt, würde aber nichts tun.

Stell dir vor, du müsstest eine riesige Aufführung koordinieren, bei der Milliarden von Komponenten perfekt synchron agieren müssen. Ohne Takt wäre das Chaos. Genau das leistet der Takt für deinen Prozessor. Ein Kristall schwingt mit einer unglaublich konstanten Frequenz und sendet Milliarden Mal pro Sekunde elektrische Impulse aus.

Wenn du „3,5-GHz-Prozessor“ hörst, bezeichnet GHz (Gigahertz) die Taktfrequenz: 3,5 Milliarden Takte pro Sekunde. Jeder Takt heißt Taktzyklus und ist die grundlegende Zeiteinheit in der Informatik.

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

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

Manche Operationen benötigen einen Taktzyklus (eine einfache Addition), andere viele (eine Division oder das Abrufen von Daten aus dem RAM). Milliarden von Komponenten führen ihre jeweiligen Operationen präzise choreografiert aus und sind alle auf diesen unerbittlichen Takt abgestimmt.

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

Früher wurden diese Operationen mit Maschinen umgesetzt, die ganze Räume füllten. Die Komponenten, die all diese Berechnungen ausführen, sind jedoch bemerkenswert einfach: Es sind schlicht Schalter. Ein- oder ausgeschaltete Schalter.

Verbindet man genügend solcher Schalter im richtigen Muster miteinander, erhält man einen Computer. Die gesamte digitale Revolution beruht auf einer ausgeklügelten Anordnung von Schaltern.

Diese Einfachheit bedeutet: Wenn du Schalter hast – beliebige Schalter –, kannst du einen Computer bauen. Menschen haben funktionierende Computer aus Wasserrohren und Ventilen, Dominosteinen, LEGO-Steinen, Murmeln und sogar mit 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 machen. Dein Smartphone hat mehr Rechenleistung als alle Computer, mit denen Menschen zum Mond geflogen sind, und passt in deine Tasche, weil wir gelernt haben, Schalter im atomaren Maßstab herzustellen.

Wenn wir neuronale Netze 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 folgt dem Takt.

Kein Wunder, dass dein Computer beim Trainieren von Modellen klingt, als würde er gleich abheben!

Neuronale Netze so richtig zum Laufen bringen#

Also gut, wir haben Chips mit Milliarden von Schaltern, die im Takt eines Kristalls tanzen, und wollen darauf neuronale Netze mit Millionen von Parametern ausführen. Das dürfte einfach sein, oder? Wir werfen einfach die Zahlen auf den Chip und legen los!

Neuronale Netze schnell auszuführen ist, als wollte man ein Fünf-Gänge-Menü in einer Küche kochen, deren Kühlschrank drei Häuserblocks entfernt steht, in der man nur eine Pfanne hat und jede Zutat 500 Pfund wiegt. Die Mathematik selbst ist nicht das größte Problem – es ist alles andere.

Die Diskrepanz zwischen Architekturen#

Die meisten Chips wurden für Microsoft Word entwickelt, nicht für neuronale Netze. Deine CPU wurde so konzipiert, dass sie ihr Leben mit if-Anweisungen und Schleifen verbringt und gelegentlich deine Steuer berechnet (die eine Berechnung, die selbst Supercomputer emotional erschöpft). Sie ist auf sequenzielle Abläufe optimiert: erst dies, dann das, dann jenes.

Neuronale Netze funktionieren jedoch völlig anders. Sie wollen ALLES AUF EINMAL erledigen. Beim Training aktualisierst du Millionen von Gewichten anhand der Fehler deiner Vorhersagen. Bei der Inferenz (also bei der tatsächlichen Verwendung des trainierten Modells) leitest 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 sie – Gott segne sie – eine nach der anderen abarbeiten, wie ein sehr schneller, aber äußerst methodischer Buchhalter.

Deshalb wurden GPUs zum Rückgrat der KI-Berechnung. GPUs wurden für Videospiele entwickelt, bei denen die Farbe von Millionen von Pixeln gleichzeitig berechnet werden muss. Wie sich herausstellt, sind die Berechnung von Pixelfarben und die Mathematik neuronaler Netze überraschend ähnlich: Bei beidem wird dieselbe Operation parallel auf riesige Datenmengen angewendet.

Aber selbst GPUs sind nicht perfekt für neuronale Netze geeignet. Deshalb entwickeln Unternehmen inzwischen spezialisierte KI-Chips (TPUs, NPUs und jede andere Abkürzung, die auf PU endet). Diese Chips werden von Grund auf für eine einzige Aufgabe entwickelt: neuronale Netze schnell auszuführen. Das ist, als würde man einen Koch einstellen, der nur ein einziges Gericht zubereiten kann, es aber mit übermenschlicher Geschwindigkeit kocht. Während deine CPU Matrixoperationen mühsam nacheinander ausführt und deine GPU sie recht gut parallel verarbeitet, verschlingen diese Spezialchips Matrizen zum Frühstück, Mittag- und Abendessen.

Die Speicherbarriere (oder: Warum Bits zu verschieben schwieriger ist als zu rechnen)#

Bei modernen Berechnungen mit neuronalen Netzen verbringen wir mehr Zeit und Energie damit, Daten zu VERSCHIEBEN, 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 auf der anderen Seite der Stadt stehen. Jede Gleichung kann er sofort lösen, aber zuerst muss er sich die Zahlen besorgen – und dieser Weg dauert eine Ewigkeit.

Dein Chip kann zwei Zahlen in einem Taktzyklus multiplizieren (du erinnerst dich: Das ist einer dieser Milliarden Takte pro Sekunde). Blitzschnell! Aber die Zahlen aus dem Speicher zum Chip zu holen? Das kann HUNDERTE Taktzyklen dauern. Als könnte dein Mathematiker ein Problem in einer Sekunde lösen, bräuchte aber fünf Minuten, um zur Bibliothek und zurück zu gehen.

Der Grund dafür sind Entfernungen (und der Platz). Strom bewegt sich schnell, aber nicht unendlich schnell. Je weiter die Daten auf dem Chip zurücklegen müssen, desto länger dauert es. Computerentwickler haben das Problem gelöst, indem sie eine Speicherhierarchie mit mehreren Speicherorten in unterschiedlichen Entfernungen geschaffen haben:

• Register (direkt in die Recheneinheiten integriert): der Schreibtisch deines Mathematikers. Sofortiger Zugriff! Aber der Platz ist winzig; hier passen nur etwa 32 Zahlen hin. Das ist, als lägen Haftnotizen direkt vor dir.
• L1-Cache (wenige Mikrometer entfernt): das Bücherregal im Büro. Das Abrufen dauert 3–4 Taktzyklen. Hier passen ein paar Tausend Zahlen hinein.
• L2-Cache (wenige Millimeter entfernt): der Aktenschrank am Ende des Flurs. Der Zugriff dauert 10–15 Taktzyklen, und es passen ein paar Millionen Zahlen hinein.
• L3-Cache (auf der anderen Seite des Chips): der Lagerraum im Untergeschoss. Der Zugriff dauert 30–50 Taktzyklen; dort finden zig Millionen Zahlen Platz.
• RAM (auf einem völlig anderen Chip): das Lagerhaus auf der anderen Seite der Stadt. Der Zugriff dauert 100–300 Taktzyklen. Hier befinden sich deine Milliarden Zahlen.
• SSD/Festplatte (über Kabel verbunden): eine ganz andere Stadt. Der Zugriff dauert Millionen von Taktzyklen. Riesiger Speicher, aber eisige Geschwindigkeit.

Die genauen Strukturen unterscheiden sich: Der Chip deines Smartphones hat möglicherweise keinen L3-Cache, während eine Server-CPU davon sehr viel haben kann. Das Grundprinzip bleibt jedoch gleich: Speicher in der Nähe ist schneller, aber kleiner.

Hier wird es für neuronale Netze problematisch. Stell dir vor, dein Ultralytics-YOLO-Modell hat 50 Millionen Parameter (ChatGPT hat übrigens Milliarden). Das sind 50 Millionen Zahlen, die zwischen Speicher und Recheneinheiten hin- und herbewegt werden müssen. Selbst wenn jede Zahl nur 4 Byte belegt, müssen 200 Megabyte Daten durch dein System transportiert werden.

Der Chip kann jede Zahl zwar in einem einzigen Taktzyklus verarbeiten, aber wenn es 100 Taktzyklen dauert, diese Zahl aus dem RAM abzurufen, verbringst du 99 % deiner Zeit mit Warten auf die Lieferung. Das ist, als säße ein Formel-1-Rennwagen im Stau. Die ganze Rechenleistung steht herum und wartet darauf, dass die Daten ankommen.

Hier ist die entscheidende Erkenntnis: Das ist DER Flaschenhals moderner Computertechnik. Er heißt Von-Neumann-Flaschenhals. Chips schneller rechnen zu lassen, 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 Netze beschleunigen, machen sie selten die Berechnungen schneller. Stattdessen suchen sie nach cleveren Möglichkeiten, weniger Daten zu verschieben, sie besser im Cache vorzuhalten oder intelligenter darauf zuzugreifen.

Moderne KI-Chips konzentrieren sich nicht nur auf die Rechengeschwindigkeit, sondern auch intensiv auf Speicherbandbreite und Verfahren zur Datenbewegung. Sie lesen Daten vorab ein, verwenden bereits im Cache gespeicherte Werte erneut und ordnen Berechnungen so an, dass möglichst wenige Speicherzugriffe erforderlich sind. Die Gewinner im Wettrennen um KI-Hardware sind nicht diejenigen mit den schnellsten Rechnern, sondern diejenigen, die herausgefunden haben, wie sie diese Rechner zuverlässig mit Daten versorgen. Entscheidend ist die Optimierung der Speicherzugriffsmuster.

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

Deshalb klingt dein Laptop beim Trainieren neuronaler Netze wie ein Düsentriebwerk. Nicht die Mathematik erzeugt die Wärme, sondern die Bewegung der Daten. Jedes Aktualisieren von Parametern, 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 Wärme abführen? Es ist wie Übertakten, nur steht der Takt immer auf 11 und wir versuchen lediglich, keinen Brand auszulösen.

Die Lösung? Architekturorientiertes Design#

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

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

Das ist wie der Unterschied zwischen einem Rezept, in dem steht „Verwende Zutaten aus deinem örtlichen Supermarkt“, und einem, für das du Gewürze aus Tibet, Käse aus Frankreich und Wasser aus der Antarktis importieren musst. Beides schmeckt vielleicht gut, aber eines ist definitiv praktischer.

Und deshalb ist es eine Kunst, neuronale Netze schnell zu machen. Gute Mathematik allein reicht nicht aus; du musst die Hardware verstehen, die Speicherhierarchie berücksichtigen und perfekt mit der Architektur zusammenspielen.

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

So machen wir YOLO schneller#

Wenn du ein YOLO-Modell trainierst, erhältst du ein neuronales Netz, das auf deiner Trainingsumgebung hervorragend funktioniert. Doch dein Gaming-GPU, dein iPhone und der winzige Chip in einer Überwachungskamera sprechen völlig unterschiedliche Sprachen. Sie haben unterschiedliche Stärken und Schwächen und ganz eigene Vorstellungen davon, wie Daten verarbeitet werden sollten.

Stell es dir so vor: Ein GPU hat Tausende von Kernen, die alle gleichzeitig arbeiten können – er ist auf parallele Verarbeitung ausgelegt. Ein mobiler Chip kann dagegen spezielle Schaltkreise für KI-Operationen haben, aber nur bestimmte Arten von Berechnungen ausführen. Und das Edge-Gerät in deiner Türklingelkamera versucht, KI mit einem geringeren Strombudget als eine LED-Glühbirne auszuführen.

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

Operationen zusammenführen: Mit weniger mehr erreichen#

Im ursprünglichen YOLO-Modell laufen viele Operationen nacheinander ab. Zum Beispiel führen wir zuerst eine Faltung aus, normalisieren dann die Ergebnisse und wenden anschließend eine Aktivierungsfunktion an. Das sind drei separate Schritte, die jeweils eigene Speicherzugriffe zum Lesen und Schreiben erfordern.

Der clevere Kniff ist jedoch, dass wir diese Operationen zu einem einzigen Schritt zusammenfassen können. Wenn wir YOLO für den Einsatz exportieren, führen wir diese Operationen zusammen. Statt:

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

Tun wir Folgendes:

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

Bei einem typischen YOLO-Modell, das ein Bild mit 640×640 Pixeln verarbeitet, vermeidet dieser einfache Trick unnötige Speicherübertragungen im Gigabyte-Bereich. Auf einem Mobiltelefon ist das der Unterschied zwischen flüssiger Erkennung in Echtzeit und frustrierenden Verzögerungen.

Kleinere Zahlen verwenden: Die Magie der Quantisierung#

YOLO benötigt keine besonders präzisen Zahlen, um Objekte zuverlässig zu erkennen. Beim Training verwenden wir 32 Bit, um jedes Gewicht darzustellen – das ist, als würde man die Zutaten für ein Sandwich mit einem wissenschaftlichen Taschenrechner abmessen. Für den tatsächlichen Einsatz? 8 Bit reichen völlig aus.

Das nennt man Quantisierung, und sie 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–4-mal schneller
• Es verbraucht deutlich weniger Strom (der Akku deines Smartphones wird es dir danken)

Nicht alle Schichten in YOLO reagieren gleich empfindlich auf diese Verringerung. Die frühen Schichten, die grundlegende Kanten und Formen erkennen? Sie sind robust – wir können problemlos 8-Bit-Zahlen verwenden. Die letzten Erkennungsschichten, die bestimmen, „Ist das eine Katze oder ein Hund?“, benötigen etwas mehr Präzision. Deshalb passen wir die Präzision Schicht für Schicht an und verwenden nur so viele Bits wie nötig, um die Genauigkeit zu erhalten und gleichzeitig die Geschwindigkeit zu maximieren.

Wir haben festgestellt, dass Ultralytics YOLO bei sorgfältiger Quantisierung 99,5 % seiner ursprünglichen Genauigkeit beibehält und auf Smartphones zugleich dreimal 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 verschiedene Möglichkeiten, dieselbe mathematische Operation auszuführen. Eine einfache Faltung (die zentrale Operation in YOLO) lässt sich mit völlig unterschiedlichen Algorithmen berechnen. Welche Wahl am besten ist, hängt von deiner konkreten Hardware und der Eingabegröße ab.

Beim Export von YOLO testet unser Optimierungsframework verschiedene Algorithmen und wählt den schnellsten für deinen konkreten Anwendungsfall aus. Das ist, als gäbe es mehrere Wege zum selben Ziel und man würde je nach aktueller Verkehrslage den besten auswählen. Auf einem GPU könnten wir einen Algorithmus verwenden, der viele Pixel gleichzeitig verarbeitet. Auf einem CPU könnten wir einen Algorithmus verwenden, der für die sequenzielle Verarbeitung optimiert ist. Die Mathematik bleibt dieselbe, aber die Ausführungsstrategie ist völlig anders.

Speicher: Der verborgene Engpass#

Erinnerst du dich daran, dass der Speicher der eigentliche Engpass moderner Computer ist? Das gilt besonders für YOLO. Das Modell kann 50 Millionen Parameter haben und während der Inferenz Gigabytes an Zwischenergebnissen erzeugen. All diese Daten zu bewegen, ist oft langsamer als die eigentliche Berechnung.

Wir verwenden verschiedene Tricks, um 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-Pyramiden-Netzwerk verringert 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. So kann der Prozessor mit schnellem, lokalem Speicher arbeiten, anstatt ständig Daten aus dem langsamen Hauptspeicher abzurufen.

Wiederverwendung von Puffern: Statt ständig neuen Speicher für Zwischenergebnisse anzulegen, verwenden wir dieselben Speicherpuffer wieder. Das ist äußerst effizient – das gesamte Backbone von YOLO kann mit einer Handvoll wiederverwendbarer Puffer ausgeführt werden.

Beschneidung: Weniger ist mehr#

Eine überraschende Tatsache: YOLO-Modelle sind oft überdimensioniert. In vielen Schichten können wir 30 % der Kanäle entfernen, ohne die Genauigkeit nennenswert zu beeinträchtigen. Dadurch wird das Modell nicht nur kleiner, sondern auch schneller, weil tatsächlich weniger Berechnungen anfallen.

Das Verfahren ist elegant: Wir analysieren, welche Teile des Netzes am wenigsten zu den endgültigen Erkennungsergebnissen beitragen, entfernen sie und stimmen das Modell anschließend fein ab, um den Verlust auszugleichen. Ein beschnittenes YOLO11m-Modell kann 30 % schneller sein und zugleich 99 % seiner ursprünglichen Genauigkeit beibehalten. Bei Geräten mit Akkubetrieb kann dieser Effizienzgewinn mehrere zusätzliche Betriebsstunden bedeuten.

Hardwarebeschleunigung: Die Stärken jedes Chips nutzen#

Verschiedene Prozessoren eignen sich für unterschiedliche Aufgaben, und die Leistungsunterschiede sind enorm. Dasselbe YOLO11n-Modell benötigt:

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

Diese Geschwindigkeitsunterschiede liegen nicht nur an den Taktfrequenzen, sondern spiegeln grundlegende Architekturunterschiede wider. GPUs haben Tausende von Kernen, die parallel arbeiten – ideal für die Faltungen in YOLO. Mobile NPUs verfügen über spezielle Schaltkreise, die eigens für neuronale Netze entwickelt wurden. CPUs sind Alleskönner: flexibel, aber nicht spezialisiert.

Der Schlüssel zur Optimierung liegt darin, YOLOs Operationen auf die Stärken des jeweiligen Chips abzustimmen. Ein GPU eignet sich besonders dafür, dieselbe Operation gleichzeitig auf vielen Daten auszuführen. Ein mobiler NPU unterstützt möglicherweise nur bestimmte Operationen, führt diese dafür aber äußerst effizient aus. Ein Edge TPU funktioniert nur mit 8-Bit-Ganzzahlen, erzielt innerhalb dieser Einschränkung jedoch bemerkenswerte Geschwindigkeiten.

Die Magie der Kompilierung#

Wenn du ein YOLO-Modell exportierst, geschieht im Hintergrund etwas Bemerkenswertes. Wir wandeln nicht einfach nur das Dateiformat um, sondern kompilieren das Modell gezielt für deine Zielhardware. Das ist wie der Unterschied zwischen Google Übersetzer und einer Person, deren Muttersprache die Zielsprache ist. 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, spezielle, 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 die Leistung um den Faktor 10 steigern. Dasselbe YOLO-Modell kann mit allgemeinem Code nur mühsam laufen, mit passenden, optimierten Anweisungen dagegen regelrecht fliegen.

Praktischer Einsatz auf Edge-Geräten#

Schauen wir uns an, was passiert, wenn YOLO auf die reale Welt trifft – insbesondere 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: Vielleicht insgesamt nur 512 MB bis 2 GB RAM
• Stromversorgung: Oft nur 2–5 Watt (weniger als ein Handy-Ladegerät)
• Kühlung: Keine Lüfter, nur passive Wärmeableitung
• Zuverlässigkeit: Muss ohne Abstürze dauerhaft laufen

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

• Originalmodell: 15 Watt, läuft heiß bei 85 °C, erreicht 20 FPS
• Mit Quantisierung und Beschneidung optimiert: 3 Watt, angenehme 45 °C, erreicht 25 FPS

Wir haben den Stromverbrauch um 80 % gesenkt und zugleich die Leistung verbessert! Das ist der Unterschied zwischen einem Gerät, das überhitzt und den Akku leert, und einem, das jahrelang zuverlässig läuft.

Entscheidend ist, die richtigen Kompromisse zu wählen. Bei Edge-Geräten:

• Verwenden wir INT8-Quantisierung (geringere Präzision, deutlich weniger Stromverbrauch)
• Verarbeiten wir bei geringer Aktivität weniger Einzelbilder
• Verteilen wir die Arbeit auf verschiedene Prozessoren, um die Wärmeentwicklung zu steuern
• Halten wir Modelle klein genug, damit sie vollständig in den schnellen Speicher passen

Der Optimierungsprozess#

Bei Ultralytics verfolgen wir bei der Optimierung einen systematischen Ansatz. Zuerst erstellen wir ein Leistungsprofil des Modells, um herauszufinden, wofür die Zeit tatsächlich aufgewendet wird. Oft liegen die Engpässe nicht dort, wo man sie erwarten würde. Vielleicht entfallen 80 % der Laufzeit auf nur wenige Schichten, oder Speicherübertragungen bestimmen die Rechenzeit.

Anschließend wenden wir Optimierungen schrittweise an:

1. Wir beginnen mit den größten Engpässen
2. Wir wenden jeweils nur eine Optimierung an
3. Wir messen sowohl die Geschwindigkeitssteigerung als auch die Auswirkungen auf die Genauigkeit
4. Wir behalten Optimierungen bei, die ein gutes Verhältnis zwischen Nutzen und Nachteilen bieten
5. Wir wiederholen den Vorgang, bis wir unsere Ziele erreichen

Zum Beispiel beim Einsatz von YOLO11m auf einem Smartphone:

• Ausgangswert: 200 ms pro Bild, 200 MB Modell
• Nach der Quantisierung: 80 ms pro Bild, 50 MB Modell
• Nach der Beschneidung: 60 ms pro Bild, 35 MB Modell
• Nach dem Zusammenführen von Operationen: 45 ms pro Bild, 35 MB Modell

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

Die Zukunft: Heterogenes Rechnen#

Moderne Geräte werden immer intelligenter darin, mehrere Prozessoren gemeinsam zu nutzen. Dein Smartphone hat nicht nur einen Prozessor, sondern mehrere, die jeweils auf unterschiedliche Aufgaben spezialisiert sind:

• Der Kamerasensor verfügt über einen Bildsignalprozessor (ISP) zur Vorverarbeitung
• Der NPU (Neural Processing Unit) führt die YOLO-Inferenz aus
• Der CPU übernimmt komplexe Logik und Koordination
• Der GPU stellt die Ergebnisse auf dem Bildschirm dar

Bei der zukünftigen Optimierung von YOLO geht es darum, das Modell intelligent auf diese Prozessoren aufzuteilen. Vielleicht übernimmt der NPU die Hauptfaltungen, der CPU die abschließende Erkennungslogik und der GPU die Visualisierung der Ergebnisse. Jeder Prozessor erledigt das, worin er am besten ist. So entsteht eine effizientere Verarbeitungskette, als sie ein einzelner Prozessor erreichen 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 für Datenübertragungen zwischen ihnen.

Das Wichtigste#

Bei der Optimierung von YOLO-Modellen geht es nicht nur darum, Dateiformate umzuwandeln, sondern darum, modernste KI so weiterzuentwickeln, dass sie in der realen Welt tatsächlich funktioniert. Mit Techniken wie Quantisierung (kleinere Zahlen verwenden), Beschneidung (unnötige Teile entfernen), dem Zusammenführen von Operationen (Schritte kombinieren) und intelligenter Speicherverwaltung erzielen wir eine 10- bis 100-fache Leistungssteigerung, ohne die Genauigkeit zu beeinträchtigen.

Das Bemerkenswerte daran? Es gibt keine universell „beste“ Optimierung. Ein Cloud-Server mit unbegrenzter Stromversorgung benötigt andere Optimierungen als eine Drohne mit Akkubetrieb. Ein Smartphone mit einem dedizierten KI-Chip muss anders behandelt werden als ein Raspberry Pi. Deshalb bietet Ultralytics so viele Exportoptionen – jede ist für unterschiedliche Einsatzszenarien optimiert.

Jede besprochene Optimierung verfolgt ein Ziel: Computer Vision überall zugänglich zu machen. Ob du eine intelligente Türklingel, eine Drohnenanwendung oder einen umfangreichen Cloud-Dienst entwickelst – wir stellen dir die Werkzeuge bereit, mit denen YOLO innerhalb deiner Rahmenbedingungen funktioniert.

Wenn du mit Ultralytics ein YOLO-Modell exportierst, speicherst du nicht einfach nur eine Datei. Du profitierst von jahrelanger Forschung dazu, wie sich neuronale Netze praktisch einsetzen lassen. Du machst aus einem hochmodernen KI-Modell etwas, das auf echter Hardware mit realen Einschränkungen ausgeführt werden und tatsächliche Probleme lösen kann.

Genau das tun wir bei Ultralytics. Wir überbrücken die Kluft zwischen KI-Forschung und praktischem Einsatz. 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.