haben wir AlpamayoR1 (AR1) besprochen, ein autonomes Fahrmodell, das einen VLM als logisches Rückgrat integriert. Es basiert auf einem sorgfältig gesammelten Datensatz zur Kausalkette. Das Coaching anhand dieses Datensatzes ermöglicht es AR1, in natürlicher Sprache zu „argumentieren“, um herausfordernde Fahrsituationen zu lösen.

Was aber, wenn natürliche Sprache nicht die beste Unterstützung für das Denken in Fahrszenarien ist? Denn wenn es um eine Fahrsituation geht, die eine sofortige Reaktion erfordert, handeln menschliche Fahrer in der Regel reflexartig und nicht „Schritt für Schritt in der Sprache argumentieren“. Was ist die Different für Fahrmodelle?

In diesem Artikel erläutern wir die LatentVLA-Architektur, eine überzeugende Sicht auf sprachbasierte Ansätze, die erforderlich sind kein Datensatz in natürlicher Sprache, führt Überlegungen im latenten Raum durch und Verwendungen Wissensdestillation um Echtzeitbeschränkungen zu erfüllen.

Latentes Aktionslernen

Ein großer Teil des Erfolgs von AR1 beruht auf dem Datensatz zur Kausalkette, dessen Erfassung einen industriellen Aufwand, eine sorgfältig ausgearbeitete Kennzeichnungspipeline und eine umfassende Validierung erforderte.

Im Gegensatz dazu schlägt LatentVLA eine völlig entgegengesetzte Richtung ein: Die Autoren argumentieren, dass rohe Fahrdaten bereits die Struktur enthalten, die zum Trainieren eines großen Modells erforderlich ist, und dass natürliche Sprache von Natur aus voreingenommen und schwer mit Aktionen abzugleichen ist. Darüber hinaus ist die Generierung von Argumentationsketten in natürlicher Sprache ineffizient, da einige Token keinen sinnvollen Beitrag zum Argumentationsprozess leisten (z. B. Stoppwörter).

Daher führen sie einen selbstüberwachten Rahmen ein, der zur Vorhersage eingesetzt wird egozentrische latente Handlungen in einem kleinen latenten Raum. Mit anderen Worten: Das Modell verwendet unbeschriftete Fahrdaten zur Vorhersage welche Maßnahmen der Fahrer ergriffen haben muss um diese Daten zu generieren. Diese latenten Handlungen werden als Bausteine ​​für das Denken im latenten Raum dienen.

Repräsentationslernen

Um latente Handlungen aus unbeschrifteten Daten vorherzusagen, verwenden die Autoren eine Methode, die an LAPO (Lernen, ohne Handlungen zu handeln) erinnert (2). Dieser Ansatz basiert auf einem Encoder-Decoder-Setup, bei dem der Encoder (auch als „Inverse-Dynamics-Modell“ (IDM) bezeichnet) zwei aufeinanderfolgende Frames verwendet, um einen kontinuierlichen Aktionsvektor vorherzusagen, und der Decoder (als „Ahead-Dynamics-Modell“ (FDM) bezeichnet) den aktuellen Body und den vorhergesagten Aktionsvektor verwendet, um den nächsten Body zu rekonstruieren.

Dieser clevere Aufbau zwingt die erlernte Aktionsdarstellung dazu, zu beschreiben, was Es müssen Maßnahmen ergriffen worden sein um die Zustandsübergänge in unserem Datensatz zu beobachten. Diese kontinuierliche Aktionsdarstellung ist jedoch immer noch nicht mit den VLMs kompatibel, die wir verwenden möchten. Um es zu diskretisieren, verwenden die Autoren einen VQ-VAE (Vector-Quantised Variational Auto-Encoder), der kontinuierliche Vektoren auf die nächstgelegenen diskreten Vektoren in einem erlernten System abbildet Codebuch (dh ein Wörterbuch diskreter Aktionen) auf differenzierbare Weise. Dies ist die Aktion, die vom FDM verwendet wird, um den nächsten Body zu dekodieren.

Durch die Optimierung des Rekonstruktionsfehlers des nächsten Frames haben wir IDM und FDM gemeinsam trainiert, um eine prädiktive Darstellung diskreter Aktionen zu codieren.

Unterscheidung von Ego-Aktionen und Umgebungslärm

Jetzt denken Sie vielleicht: „Die Aktionen des Fahrers sind nicht der einzige Faktor, der das nächste Bild während der Fahrt beeinflusst. Was wäre, wenn ein Vogel vor der Kamera fliegt? Verunreinigt das die Aktionsdarstellung?“ Darauf antworten die Autoren mit Ja Und Nein, es muss einen Mechanismus geben, der die Auswirkungen der Handlungen des Fahrers auf die Zukunft entwirrt Umweltdynamik.

Die elegante Lösung dieses Issues besteht in der Verwendung eines zweistufigen Encoder-Decoder-Aufbaus:

1. Abhängig von der Flugbahn der Grundwahrheit, dem Ego-Zustand und dem vorherigen Body sagt der Encoder eine latente Aktion voraus. Da diese Aktion durch die Flugbahn und den Ego-Zustand von der Fahrzeugdynamik abhängig ist, muss sie nur modelliert werden Umweltdynamik um dem Decoder die Rekonstruktion des nächsten Frames zu ermöglichen. Das „Umweltschutzmaßnahmen“ wird dann quantisiert und das hierfür verwendete Codebuch für die nächste Stufe eingefroren.
2. Bedingt durch den vorherigen Body und die Umweltmaßnahmenkodiert der Encoder eine weitere latente Aktion. Da die Umweltdynamik bekannt und Teil der Konditionierung ist, muss diese zweite latente Aktion ebenfalls kodiert werden egozentrische Dynamik. Mithilfe eines neuen Codebuchs wird diese Aktion in eine diskrete Quantisierung umgewandelt Ego-Aktion.

Schließlich geben wir beide Aktionen an den Decoder weiter, um den nächsten Body zu rekonstruieren. Dieser Aufbau gewährleistet eine klare Trennung von Ego-Aktionen und Umweltdynamik.

VLM-Schulung

Aufbauend auf der erlernten Aktionsdarstellung trainieren die Autoren ein Qwen2.5-VL-Modell, um dieselben latenten Aktionen wie das Encoder-Decoder-Modell vorherzusagen. Dies wird erreicht, indem der Encoder eine Trajektorie von 12 latenten Aktionen für einen bestimmten Eingaberahmen vorhersagt und der VLM seine unfavourable Log-Probability optimiert:

Ein auffälliger Unterschied zu anderen Ansätzen, die Aktionscodebücher verwenden, ist die Anzahl der von LatentVLA verwendeten Aktions-Tokens. Während andere Modelle wie AutoVLA ein Aktionscodebuch mit 2048 Spezialtoken verwenden, LatentVLA verwendet nur 16.

Daraus ergibt sich:

1. Eine einfachere Lernaufgabe: In einem 2048-dimensionalen Codebuch repräsentieren Aktionen wahrscheinlich sehr präzise Fahrentscheidungen wie „im 16-Grad-Winkel nach hyperlinks lenken“. Mit nur 16 Token übernimmt das Modell wahrscheinlich übergeordnete Anweisungen wie „leicht beschleunigen“ oder „eine schmale Rechtskurve nehmen“, deren Erlernen weniger Demonstrationen erfordert.
2. Bewahrung des VLM-Vorwissens vor dem Coaching: Es müssen nicht über 2000 „neue Wörter“ gelernt werden.

Wissensdestillation

Während AlpamayoR1 auf effiziente Tokenisierung und Circulate-Matching-Diffusion setzte, um die Echtzeitleistung aufrechtzuerhalten, verfolgt LatentVLA einen völlig anderen Ansatz: Wissensdestillation. Zu diesem Zweck führen die Autoren a Fusionsmodul innerhalb bestehender E2E-Architekturen (iPad (4) und Transfuser (5)). Dieses Fusionsmodul wird vom VLM mit visuellen und aktionsbezogenen Einbettungen versorgt und gibt Options im BEV-Raum (Chook’s-Eye-View) aus. Diese Einbettungen dienen als Schlüssel und Werte im Zusammenhang mit BEV-Abfragen, die vom E2E-Modell erzeugt werden. Dadurch kann das E2E-Modell Erkenntnisse aus dem VLM integrieren.

Allerdings bleibt der VLM zu groß, um zum Testzeitpunkt effizient genutzt zu werden. Daher ein kleines 50M-Parameter Entscheidungstransformator ist darauf trainiert, die Großen nachzuahmen 3.8B Qwen2.5-VL VLM. Dies wird durch die Minimierung der KL-Divergenz zwischen der Lehrer- und Schülerverteilung erreicht:

Dieses Framework ermöglicht LatentVLA den Betrieb mit einem sehr kompakten Argumentations-Spine und bietet einen allgemeinen Ansatz zur Integration von VLM-Wissen in traditionelle E2E-Architekturen zu geringeren Kosten.

Auswertung

LatentVLA wird auf NavSim (6) trainiert und ausgewertet, einem Datensatz, der aus über 100.000 Frames besteht, die in realen Fahrsimulationen gesammelt wurden. NavSim enthält außerdem a nicht reaktiv Simulator zur Bewertung der Open-Loop-Planung.

Mit anderen Worten: Die Modelle sagen anhand der Eingabebilder eine Flugbahn für die nächsten Sekunden voraus. Anschließend wird diese Trajektorie in einer BEV-Simulation ausgeführt, die unter der Annahme erfolgt, dass Aktionen des Ego-Fahrzeugs erfolgen keinen Einfluss haben die Aktionen anderer Agenten (additionally „nicht reaktiv“). Dies ermöglicht die einfache Messung planungsbezogener Metriken wie des Predictive Driver Mannequin Rating (PDMS): eine zusammengesetzte Metrik, die Fahrsicherheit, Leistung und Risiko durch Integration von Simulationsergebnissen quantifiziert.

Diese Artwork der Bewertung weist jedoch einige wichtige Mängel auf, auf die wir später noch eingehen werden.

Bei diesem Benchmark erzielt LatentVLA Ergebnisse auf dem neuesten Stand der Technik und übertrifft Commonplace-E2E- und LLM-basierte Architekturen. Allerdings scheint die Leistungssteigerung durch die Integration von VLM-Wissen in iPad und Transfuser begrenzt zu sein. Wenn wir uns auf das PDMS konzentrieren, stellen wir fest, dass die iPad-Basislinie einen Wert von 91,7 % erreicht. Die destillierte LatentVLA-Different erhöht den Wert auf 92,1 (+0,4 %) und die nicht destillierte Model erreicht 92,4 (weitere +0,3 %).

Diese kleine Verbesserung wirft die Frage auf, ob ein höheres Denkvermögen und Weltwissen wirklich für das Autofahren unerlässlich sind.

Meiner Meinung nach haben sie das Potenzial, ein neues Niveau an Fahrleistungen zu erschließen, aber dies wird von nicht interaktiven Planungssimulatoren nur unzureichend gemessen.

Die Grenzen der Open-Supply-Planung

In den letzten Jahren hat sich weitgehend die Einsicht durchgesetzt, dass nur die Bewertung von Fahrmodellen im Rahmen der Open-Loop-Planung ein unvollständiges Bild ihrer tatsächlichen Fahrfähigkeiten liefert. Tatsächlich unterscheidet sich die Planung im offenen Regelkreis grundlegend vom Autofahren und ist wohl einfacher. Der Hauptgrund dafür ist, dass die Open-Loop-Planung keine Interaktionen mit der Umgebung beinhaltet (bestenfalls der Simulator). nicht reaktiv) und reduziert sich auf die Nachahmung der Flugbahn eines Experten. Dies führt in realen Szenarien zu mehreren Problemen:

1. Kleine Abweichungen von den gelernten Trajektorien führen zu kaskadierenden Fehlern: Ohne dynamische Interaktionen mit der Umgebung und anderen Agenten haben Open-Loop-Modelle Schwierigkeiten, Flugbahnen zu korrigieren, die leicht von den gelernten abweichen.
2. Flugbahnen sind von Natur aus multimodal: Für jede Fahrsituation gibt es mehrere Trajektorien und Beschleunigungsmuster, die zu sicheren Fahrergebnissen führen. Durch Nachahmungslernen auf einer einzelnen Expertentrajektorie wird diese Multimodalität jedoch zerstört, wodurch die Generalisierungsfähigkeiten des Modells eingeschränkt werden.

Aus diesen Gründen ist es wichtig, Fahrmodelle in geschlossenen (d. h. reaktiven) Simulatoren gründlich zu evaluieren und rechtfertigt die Verwendung von RL-Put up-Coaching-Methoden, wie im AR1-Artikel beschrieben.

Ich wette, dass die Diskrepanz zwischen LatentVLA und seinen Nicht-VLM-Basislinien in diesen Szenarien größer ist, da Argumente dazu beitragen könnten, die Einschränkungen des Open-Loop-Trainings zu mildern.

Abschluss

In diesem Artikel haben wir LatentVLA besprochen, einen Ansatz, der darauf abzielt, VLM-Wissen in Commonplace-E2E-Modelle zu integrieren, ohne auf natürliche Sprache angewiesen zu sein. Dieser Ansatz ist insofern innovativ, als er das Erlernen nützlicher Darstellungen aus unbeschrifteten Daten ermöglicht, während konkurrierende Arbeiten wie AR1 auf sorgfältig annotierten umfangreichen Datensätzen basieren, um die Mehrdeutigkeit natürlicher Sprache zu umgehen.

LatentVLA würde jedoch von einer gründlicheren Evaluierung profitieren, insbesondere in geschlossenen Regelkreisen.

Vielen Dank, dass Sie bis hierher gelesen haben!

Wenn Sie diesen Artikel nützlich fanden, denken Sie bitte darüber nach es teilen; Es trägt wirklich dazu bei, den Zeit- und Arbeitsaufwand zu decken, der in die Erstellung dieser Arbeit investiert wird. Wie immer, zögern Sie nicht Kontaktieren Sie mich wenn Sie Fragen, Gedanken oder Ideen für Folgemaßnahmen haben. Wenn Sie meine unabhängige Forschung und mein Schreiben unterstützen möchten, können Sie dies gerne tun kauf mir einen Kaffee

Bis zum nächsten Mal!

Referenzen

1. LatentVLA
2. LAPO
3. VQ-VAE
4. iPad
5. Transfuser

eroberten die Welt des autonomen Fahrens im Sturm mit ihrer neuen AlpamayoR1-Architektur, die ein großes Imaginative and prescient-Language-Modell als kausal fundiertes Rückgrat integriert. Diese Veröffentlichung, begleitet von einem neuen großen Datensatz und einem fotorealistischen Fahrsimulator, positioniert das Unternehmen bereits im Jahr 2026 als einen der Hauptakteure auf diesem Gebiet.

In diesem Artikel werden wir die AlpamayoR1-Architektur, die Argumentation der Kausalkette sowie das aufwändige Trainingsverfahren, das zum Trainieren des Modells verwendet wird, aufschlüsseln.

Der aktuelle Stand des autonomen Fahrens

Die Veröffentlichung von AlpamayoR1 (AR1) findet Kontext im aktuellen Paradigma der Finish-to-Finish (E2E)-Architekturen. E2E-Modelle zielen darauf ab, rohe sensorische Eingaben (Kameras, LiDAR, Radar usw.) auf Trajektorien in einer vollständig differenzierbaren Architektur abzubilden und so ein einheitliches Ziel zu optimieren.

Ein aufkommender E2E-Pattern besteht darin, das umfangreiche Weltwissen großer Imaginative and prescient-Language-Modelle (VLMs) zu nutzen, um komplexe Fahrsituationen zu bewältigen. Dabei handelt es sich im Allgemeinen um die Verwendung von VLMs als Schlussfolgerungsbasis zur Info über zukünftige Entwicklungen oder als Expertenlehrer, um kleineren Schülermodellen Aufsichtssignale zu geben.

Die AR1-Architektur

AR1 ist ein Paradebeispiel für den Reasoning-VLM-as-a-Spine-Ansatz. Trotz ihrer enormen Größe ist die Architektur für den realen Einsatz optimiert und weist eine Latenz von auf 99ms oder 10Hz auf einer einzelnen BlackWell-GPU, die aus Sicherheitsgründen als allgemeines Ziel gilt. In diesem Abschnitt werden wir die Architektur und ihre zahlreichen Innovationen aufschlüsseln.

Imaginative and prescient-Encoder

AR1 verwendet sowohl visuelle als auch textuelle Eingaben in Type von tokenisierten Kamera-Feeds und Anweisungen in natürlicher Sprache. Für die Leistung ist es entscheidend, dass der Imaginative and prescient-Encoder möglichst wenige Token produziert.

Zu diesem Zweck verwendeten die Autoren einen Imaginative and prescient Transformer (ViT)(2) zur Einzelbild-Tokenisierung. ViTs partitionieren Bilder in einer Folge von Token, die von einem regulären Transformator codiert werden. Beachten Sie, dass die Integration effizienterer Algorithmen wie Flex (3) für die Multi-Video-Tokenisierung zukünftiger Arbeit vorbehalten bleibt.

Argumentationsrückgrat

Die AR1-Architektur basiert auf Cosmos-Motive, einem der VLMs von Nvidia, der speziell für verkörpertes Denken in Anwendungsfällen der physischen KI trainiert wurde. Der übliche Trainingssatz umfasst 3,7 Millionen allgemeine visuelle Frage-Antwort-Beispiele (VQA), um auch den physikalischen allgemeinen Satz des Modells zu verbessern, ergänzt durch 24,7.000 Fahrbeispiele. Dazu gehören Video-VQA, die mit DeepSeek-R1-Argumentationsspuren kommentiert sind, um die nächste Aktion vorherzusagen.

Cosmos-Motive verarbeitet visuelle und Textual content-Tokens zusammen mit der aktuellen Ego-Geschichte (vergangene xy-Positionen und Winkel des Ego-Fahrzeugs) zur Ausgabe Kausalkette Argumentationsspuren, um zukünftige Flugbahnen zu informieren.

Kausalkette

Eine entscheidende Einschränkung von Sprachmodellen liegt in der inhärenten Mehrdeutigkeit von Textbezeichnungen in visuellen Datensätzen. Dazu gehören vage Beschreibungen ohne kausale Struktur. Auf solchen Daten trainierte Modelle weisen eine geringe Korrelation zwischen ihren Argumentationsspuren und vorhergesagten Aktionen sowie kausale Verwirrung auf.

Für einen verkörperten Agenten wie ein autonomes Auto sind ausgeprägte Fähigkeiten zum Kausaldenken unerlässlich. Um diese Probleme zu umgehen, hat das Nvidia-Staff erhebliche Anstrengungen unternommen, um einen Fahrdatensatz mit kausal konsistenten Anmerkungen zu erstellen.

Konkret enthält der Datensatz 20-Sekunden-Clips, die aus realen Fahraufzeichnungen in verschiedenen Umgebungen und Ländern extrahiert wurden. Jeder Clip enthält 2 Sekunden Kontext, der zu einer Fahrentscheidung (z. B. Überholen, Nachgeben, Überfahren einer Kreuzung usw.) und deren Konsequenzen führt. Die kausale Struktur dieser Szenarien wird durch konsistente Textanmerkungen nach einer strengen Vorlage offengelegt.

Die ersten 10 % des Datensatzes werden von Menschen annotiert, während der Relaxation von hochmodernen VLMs wie GPT5 annotiert wird, um den Kennzeichnungsprozess zu skalieren. Auch hier werden erhebliche Anstrengungen unternommen, um die Konsistenz, Qualität und Korrektheit dieser menschlichen und KI-Anmerkungen sicherzustellen.

Flugbahndecoder

Der letzte Schritt des Vorwärtsdurchlaufs besteht darin, die Argumentationsspuren in eine 64-Punkte-Trajektorie zu dekodieren. Während Trajektorien normalerweise als Folge von Wegpunkten (xy-Koordinaten) dekodiert werden, stellte das Nvidia-Staff fest, dass die Verwendung der Einraddynamik (d. h. das Erzeugen einer Folge von Beschleunigungswerten und Lenkwinkeln) konsistentere Ergebnisse lieferte. Insbesondere erleichtert es die Lernaufgabe, indem es verhindert, dass das Modell physikalisch unmögliche Trajektorien vorhersagt (z. B. wenn Punkt t zu weit von Punkt t+1 entfernt ist).

Interessanterweise verwenden die Autoren eine duale Darstellung der Trajektorie, bei der das Modell während des Trainings autoregressiv diskrete Token generiert und Move-Matching verwendet, um zur Inferenzzeit eine kontinuierliche Trajektorie zu generieren. Die Hauptgründe für dieses Design sind folgende:

1. Gemeinsamer Aktionsbegründungs-Token-Raum: Die Verwendung diskreter Aktionstoken ermöglicht eine engere Kopplung zwischen Argumentationsspuren und Aktionen. Wenn das Modell eine Argumentationsspur generiert, werden die nächsten Token in der Sequenz (Beschleunigung und Krümmungen) mathematisch mit dieser Erklärung verknüpft, wodurch Halluzinationen verhindert werden.
2. Erleichterung der RL-Optimierung: Die Beschränkung der Menge möglicher Aktionstoken auf eine diskrete Menge erleichtert die RL-Optimierung erheblich. Tatsächlich wird durch die Auswahl des richtigen Tokens aus einem diskreten Vokabular (z ACCEL_NEG_2) ist wesentlich einfacher als die Bereitstellung eines Gradienten für einen kontinuierlichen Wert wie -2.145 m/s^2. Wie wir im nächsten Abschnitt sehen werden, ermöglicht dies ein RL-Submit-Coaching, was für die Verbesserung der Sicherheit und Konsistenz des Modells von entscheidender Bedeutung ist.
3. Stärkeres Aufsichtssignal: Die Verwendung eines Kreuzentropieverlusts für diskrete Token wirkt wie eine Klassifizierungsaufgabe und erfasst die Multimodalität (z. B. die eindeutige Wahrscheinlichkeit, nach hyperlinks oder rechts abzubiegen) als ein MSE-Verlust an Koordinaten.
4. Flussanpassung für Inferenz: Während sich diskrete Token hervorragend zum Lernen eignen, führen sie typischerweise zu ruckartigen Flugbahnen. Darüber hinaus ist die automatische regressive Generierung einer Sequenz von 128 Token für eine Echtzeitinferenz zu langsam. Um diese Einschränkungen zu beseitigen, stellen die Autoren einen Aktionsexperten vor: eine kleinere Variante der Hauptarchitektur, die den KV-Cache (der visuelle Token, historische Bewegungen und Argumentationsspuren enthält) verwendet, um eine kontinuierliche Flugbahn in einem Durchgang mithilfe von Move-Matching-Diffusion zu dekodieren. Dies ist einer der Hauptgründe, warum AR1 mit einer so geringen Latenz ausgeführt werden kann.

Überwachte Feinabstimmung und RL-Nachschulung

Um das VLM-Spine in eine leistungsstarke Fahrrichtlinie umzuwandeln, wird es einer überwachten Feinabstimmung (SFT) am Datensatz der Kausalkette unterzogen. Insbesondere lernt es, die Argumentationsspuren und die damit verbundenen Grundwahrheitsaktionen zu reproduzieren, indem die Log-Wahrscheinlichkeit der Aktions-Argumentationssequenz maximiert wird:

SFT allein reicht jedoch nicht aus. VLMs leiden bekanntermaßen unter Diskrepanzen zwischen ihren Überlegungen und den vorhergesagten Aktionen. Die statische Natur von Open-Loop-Datensätzen ermöglicht es dem Modell, Argumentationsspuren nachzuahmen, aber das Fehlen von Umweltrückmeldungen hindert sie daran, kausale Reaktionen wirklich zu verinnerlichen.

Glücklicherweise trägt das RL-Submit-Coaching dazu bei, diese Einschränkungen zu mildern, indem es Rückschluss-Suggestions zu den Rollouts des Modells liefert. In diesem Artikel verwenden die Autoren RL für drei Hauptzwecke:

1. Verbesserung der Argumentationsqualität: Ein großes Argumentationsmodell (z. B. DeepSeek-R1) wertet die Argumentationsspuren von AR1 aus, um sicherzustellen, dass keine Inkonsistenzen oder Halluzinationen vorliegen, und weist dementsprechend eine diskrete Belohnung auf einer Skala von 0 bis 5 zu. Während DeepSeek voraussichtlich nicht in der Lage sein wird, qualitativ hochwertige Argumentationsspuren für das Fahren zu generieren, ist es deutlich einfacher, die Argumentation von AR1 auszuwerten Generationsüberprüfungslücke.
2. Durchsetzung der Konsistenz von Argumentation und Handlung: die Autoren extrahieren Meta-Aktionen (beschleunigen, lenken, geradeaus fahren, …) aus dem CoC-Datensatz mithilfe regelbasierter Systeme. Wenn diese Metaaktionen den in den Begründungsspuren genannten entsprechen, erhält das Modell eine zusätzliche Belohnung von 1, andernfalls 0.
3. Qualität der Flugbahn: Eine Flugbahnbelohnung misst den L2-Abstand zwischen der vorhergesagten und der Expertenflugbahn und bestraft Flugbahnen, die zu Kollisionen und starken Stößen führen.

Während der Nachschulung generiert AR1 mehrere parallele Rollouts und sammelt Belohnungen r_i basierend auf den drei oben genannten Belohnungssignalen. Diese Belohnungen werden dann verwendet, um den GRPO-Verlust zu berechnen (4). GRPO berechnet den Vorteil jedes Rollouts im Verhältnis zum Gruppendurchschnitt. Dieser baselinefreie Ansatz (im Gegensatz zu anderen RL-Algorithmen wie PPO) stabilisiert das Coaching, indem er Argumentationspfade belohnt, die ihre Gegenstücke bei derselben Eingabe übertreffen, anstatt sich auf eine willkürliche absolute Punktzahl zu verlassen.

Alles, was Sie über dieses Ziel verstehen müssen, ist, dass es darauf abzielt, die Wahrscheinlichkeit von Trajektorien (dem Log-Time period) mit einem hohen Vorteil (dem Softmax-Time period) im Vergleich zu anderen zu maximieren. Um den Verlust von Imaginative and prescient-Language-Priors aus dem VLM und des während der SFT erlangten Fahrwissens zu vermeiden, wird das Ziel durch eine KL-Divergenz zwischen der aktuellen Richtlinie und der Referenz (der am Ende der SFT erhaltenen Richtlinie) reguliert.

Auswertung

Das Bewertungsprotokoll umfasst vier Abschnitte: Flugbahnvorhersage im offenen Regelkreis, Simulation im geschlossenen Regelkreis, Ablationsstudien und Straßentests im Fahrzeug. Während die Tatsache, dass AR1 in realen Szenarien eingesetzt wurde, beeindruckend ist, sind die Ergebnisse im offenen und geschlossenen Regelkreis etwas undurchsichtig Meiner Meinung nach; Der Hauptgrund dafür ist, dass sie auf Nvidia-Datensätzen (geschlossener Regelkreis: PhysicalAI-AV-Datensatz, geschlossener Regelkreis: AlpaSim) erstellt wurden, die gleichzeitig mit dem Modell veröffentlicht wurden. Dies impliziert einen Mangel an Grundlagen zur Kontextualisierung der Leistungen von AR1.

Beispielsweise enthalten die Closed-Loop-Ergebnisse nur AR1 und eine Basislinie ohne Begründung für 75 Szenarien. Während AR1 bei allen gemessenen Kennzahlen die Basislinie übertrifft, liegt dies im Durchschnitt oft nur um ein Prozent und mit einer viel größeren Varianz als die Basislinie.

Aus diesem Grund würde ich empfehlen, diese Ergebnisse mit Vorsicht zu genießen, bevor andere Frontier-Architekturen in AlpaSim evaluiert werden.

Abschluss

Trotz des Mangels an kontextualisierten Ergebnissen bleiben AR1 und die dazugehörigen Datensätze eine beeindruckende technische Leistung und ein guter Hinweis darauf, wohin sich das autonome Fahren entwickelt: Finish-to-Finish-Modelle, die das Weltwissen von riesigen VLMs übernehmen, die auf verkörperte Aufgaben trainiert wurden.

Allerdings erfordert die Sammlung kausal fundierter Datensätze, die zur Ermöglichung einer Kausalkette erforderlich sind, erhebliche Investitionen und Kennzeichnungsaufwände, was die Reproduzierbarkeit einschränkt bis diese Datensätze veröffentlicht werden. In meinem nächsten Artikel werde ich den AR1-Ansatz einem anderen hochmodernen Modell gegenüberstellen, das vollständig auf Textetiketten verzichtet und stattdessen VLMs darin trainiert, in einem latenten Raum zu handeln und zu argumentieren.

Vielen Dank, dass Sie bis hierher gelesen haben!

Wenn Sie diesen Artikel nützlich fanden, denken Sie bitte darüber nach es teilen; Es trägt wirklich dazu bei, den Zeit- und Arbeitsaufwand zu decken, der in die Erstellung dieser Arbeit investiert wird. Wie immer, zögern Sie nicht Kontaktieren Sie mich wenn Sie Fragen, Gedanken oder Ideen für Folgemaßnahmen haben. Wenn Sie meine unabhängige Forschung und mein Schreiben unterstützen möchten, können Sie dies gerne tun kauf mir einen Kaffee

Bis zum nächsten Mal!

Quellen

Große Sprachmodelle benötigen riesige menschliche Datensätze. Was passiert additionally, wenn das Modell seinen gesamten Lehrplan selbst erstellen und sich selbst den Umgang mit Werkzeugen beibringen muss? Ein Forscherteam von UNC-Chapel Hill, Salesforce Analysis und der Stanford College stellt „Agent0“ vor, ein vollständig autonomes Framework, das leistungsstarke Agenten ohne externe Daten durch mehrstufige Co-Evolution und nahtlose Instrument-Integration entwickelt

Agent0 zielt auf mathematisches und allgemeines Denken ab. Es zeigt, dass eine sorgfältige Aufgabengenerierung und werkzeugintegrierte Rollouts ein Basismodell über seine ursprünglichen Fähigkeiten hinaus in zehn Benchmarks bringen können.

Zwei Agenten aus einem Basismodell

Agent0 beginnt beispielsweise mit einer Basisrichtlinie π_base Qwen3 4B Foundation oder Qwen3 8B Foundation. Es klont diese Richtlinie in:

• A Lehrplanagent πθ, das Aufgaben generiert,
• ein Testamentsvollstrecker πϕ, das diese Aufgaben mit einem Python-Instrument löst.

Das Coaching erfolgt in Iterationen mit zwei Phasen professional Iteration:

1. Lehrplanentwicklung: Der Lehrplanagent generiert einen Stapel von Aufgaben. Für jede Aufgabe prüft der Ausführende mehrere Antworten. Eine zusammengesetzte Belohnung misst, wie unsicher der Ausführende ist, wie oft er das Instrument nutzt und wie vielfältig die Cost ist. πθ wird mit aktualisiert Gruppenrelative Richtlinienoptimierung (GRPO) diese Belohnung nutzen.
2. Weiterentwicklung des Testamentsvollstreckers: Der geschulte Curriculum-Agent ist eingefroren. Es generiert einen großen Pool an Aufgaben. Agent0 filtert diesen Pool, um nur Aufgaben in der Nähe der Fähigkeitsgrenze des Ausführenden zu behalten, und schult den Ausführenden dann für diese Aufgaben mithilfe eines mehrdeutigkeitsbewussten RL-Ziels namens Ambiguity Dynamic Coverage Optimization (ADPO).

Diese Schleife erzeugt einen Suggestions-Zyklus. Da der Ausführende durch die Verwendung des Code-Interpreters stärker wird, muss der Lehrplan komplexere, werkzeugabhängige Probleme generieren, um seinen Nutzen hoch zu halten.

Wie der Lehrplanagent Aufgaben bewertet?

Die Lehrplanbelohnung kombiniert drei Signale:

Unsicherheitsbelohnung: Für jede generierte Aufgabe x prüft der Ausführende ok Antworten und stimmt mehrheitlich für eine Pseudoantwort ab. Die Selbstkonsistenz p̂(x) ist der Anteil der Antworten, die dieser Mehrheit zustimmen. Die Belohnung ist maximal, wenn p̂ nahe bei 0,5 liegt, und niedrig, wenn die Aufgaben zu einfach oder zu schwer sind. Dies fördert Aufgaben, die für den aktuellen Ausführenden herausfordernd, aber dennoch lösbar sind.

Belohnung für Werkzeugnutzung: Der Executor kann mithilfe von einen Sandbox-Code-Interpreter auslösen python markiert und erhält Ergebnisse, die als markiert sind output. Agent0 zählt die Anzahl der Werkzeugaufrufe in einer Flugbahn und gibt eine skalierte, begrenzte Belohnung aus, wobei die Obergrenze C in Experimenten auf 4 festgelegt ist. Dies begünstigt Aufgaben, die tatsächlich Instrument-Aufrufe erfordern, statt reines Kopfrechnen.

Wiederholungsstrafe: Innerhalb jedes Lehrplanstapels misst Agent0 die paarweise Ähnlichkeit zwischen Aufgaben mithilfe einer BLEU-basierten Distanz. Aufgaben werden geclustert und ein Strafzeitraum erhöht sich mit der Clustergröße. Dadurch wird verhindert, dass der Lehrplan viele Beinahe-Duplikate erzeugt.

Eine zusammengesetzte Belohnung multipliziert eine Formatprüfung mit einer gewichteten Summe aus Unsicherheit und Instrument-Belohnungen abzüglich der Wiederholungsstrafe. Dieser zusammengesetzte Wert wird in GRPO eingespeist, um πθ zu aktualisieren.

Wie der Testamentsvollstrecker aus lauten Selbstbezeichnungen lernt?

Der Testamentsvollstrecker wird ebenfalls mit GRPO geschult, jedoch mit Multiturn-, werkzeugintegrierten Trajektorien und Pseudo-Labels anstelle von Floor-Reality-Antworten.

Aufbau von Grenzdatensätzen: Nach der Lehrplanschulung in einer Iteration generiert der eingefrorene Lehrplan einen großen Kandidatenpool. Für jede Aufgabe berechnet Agent0 die Selbstkonsistenz p̂(x) mit dem aktuellen Ausführenden und behält nur Aufgaben bei, bei denen p̂ in einem informativen Bereich liegt, beispielsweise zwischen 0,3 und 0,8. Dies definiert einen herausfordernden Grenzdatensatz, der triviale oder unmögliche Probleme vermeidet.

Integrierte Rollouts mit mehreren Drehwerkzeugen: Für jede Grenzaufgabe generiert der Ausführende eine Flugbahn, die Folgendes verschachteln kann:

• Token für natürliches Denken,
• python Codesegmente,
• output Werkzeug-Suggestions.

Die Generierung pausiert, wenn ein Instrument-Aufruf erscheint, und führt den Code in einem darauf aufbauenden Sandbox-Interpreter aus VeRL-Instrumentund wird dann je nach Ergebnis fortgesetzt. Die Flugbahn endet, wenn das Modell im Inneren eine endgültige Antwort liefert {boxed ...} Tags.

Eine Mehrheitsentscheidung über die erfassten Trajektorien hinweg definiert ein Pseudo-Label und eine Endbelohnung für jede Trajektorie.

ADPO, mehrdeutigkeitsbewusster RL: Normal-GRPO behandelt alle Proben gleich, was instabil ist, wenn Bezeichnungen aus Mehrheitsabstimmungen über mehrdeutige Aufgaben stammen. ADPO modifiziert GRPO auf zwei Arten unter Verwendung von p̂ als Mehrdeutigkeitssignal.

• Es skaliert den normalisierten Vorteil mit einem Faktor, der mit der Selbstkonsistenz zunimmt, sodass Trajektorien aus Aufgaben mit geringem Vertrauen weniger beitragen.
• Es legt eine dynamische Obergrenze für das Wichtigkeitsverhältnis fest, die von der Selbstkonsistenz abhängt. Die empirische Analyse zeigt, dass das feste obere Clipping hauptsächlich Token mit geringer Wahrscheinlichkeit betrifft. ADPO lockert diese Grenze adaptiv, was die Erkundung unsicherer Aufgaben verbessert, wie durch das visualisiert heraufgestufte Token-Wahrscheinlichkeit Statistiken.

Ergebnisse zum mathematischen und allgemeinen Denken

Darüber hinaus wird Agent0 implementiert VeRL und ausgewertet Qwen3 4B Foundation Und Qwen3 8B Foundation. Es verwendet einen Sandbox-Python-Interpreter als einziges externes Instrument.

Das Forschungsteam bewertet anhand von zehn Benchmarks:

• Mathematische Argumentation: AMC, Minerva, MATH, GSM8K, Olympiad Bench, AIME24, AIME25.
• Allgemeine Begründung: SuperGPQA, MMLU Professional, BBEH.

Sie melden „go@1“ für die meisten Datensätze und „imply@32“ für AMC- und AIME-Aufgaben.

Für Qwen3 8B FoundationAgent0 erreicht:

• Mathe-Durchschnitt 58,2 gegenüber 49,2 für das Basismodell,
• allgemeiner Gesamtdurchschnitt 42,1 gegenüber 34,5 beim Basismodell.

Agent0 verbessert sich auch gegenüber starken datenfreien Baselines wie z R Null, Absoluter Nullpunkt, SPIRAL Und Sokratischer Nullpunktsowohl mit als auch ohne Werkzeug. Beim Qwen3 8B übertrifft er R Zero um 6,4 Prozentpunkte und Absolute Zero um 10,6 Punkte im Gesamtdurchschnitt. Es übertrifft auch Socratic Zero, das auf externen OpenAI-APIs basiert.

Über drei Co-Evolution-Iterationen hinweg steigt die durchschnittliche Mathematikleistung auf Qwen3 8B von 55,1 auf 58,2 und auch das allgemeine Denken verbessert sich professional Iteration. Dies bestätigt eher eine stabile Selbstverbesserung als einen Zusammenbruch.

Qualitative Beispiele zeigen, dass sich Lehrplanaufgaben von grundlegenden Geometriefragen zu komplexen Problemen der Erfüllung von Randbedingungen entwickeln, während die Trajektorien des Ausführenden Begründungstext mit Python-Aufrufen mischen, um zu korrekten Antworten zu gelangen.

Wichtige Erkenntnisse

1. Völlig datenfreie Co-Evolution: Agent0 eliminiert externe Datensätze und menschliche Anmerkungen. Zwei Agenten, ein Curriculum-Agent und ein Executor-Agent, werden von demselben Foundation-LLM initialisiert und entwickeln sich nur über Reinforcement Studying und ein Python-Instrument gemeinsam weiter.
2. Grenzlehrplan aus Selbstunsicherheit: Der Lehrplanagent nutzt die Selbstkonsistenz und die Werkzeugnutzung des Ausführenden, um Aufgaben zu bewerten. Es lernt, Grenzaufgaben zu generieren, die weder trivial noch unmöglich sind und die explizit werkzeugintegriertes Denken erfordern.
3. ADPO stabilisiert RL mit Pseudoetiketten: Der Ausführende ist mit Ambiguity Dynamic Coverage Optimization geschult. ADPO verringert die Gewichtung sehr mehrdeutiger Aufgaben und passt den Clipping-Bereich basierend auf der Selbstkonsistenz an, wodurch Aktualisierungen im GRPO-Stil stabil bleiben, wenn Belohnungen von Pseudo-Labels mit Mehrheitsabstimmung kommen.
4. Kontinuierliche Fortschritte in Mathematik und allgemeinem Denken: Auf Qwen3 8B Base verbessert Agent0 die mathematischen Benchmarks von durchschnittlich 49,2 auf 58,2 und das allgemeine Denken von 34,5 auf 42,1, was relativen Zuwächsen von etwa 18 Prozent bzw. 24 Prozent entspricht.
5. Übertrifft frühere Zero-Knowledge-Frameworks: In zehn Benchmarks übertrifft Agent0 frühere sich selbst entwickelnde Methoden wie R Zero, Absolute Zero, SPIRAL und Socratic Zero, einschließlich derjenigen, die bereits Instruments oder externe APIs verwenden. Dies zeigt, dass das Design der Co-Evolution plus Werkzeugintegration einen sinnvollen Schritt über frühere Einzelrunden-Selbstspielansätze hinaus darstellt.

Redaktionelle Anmerkungen

Agent0 ist ein wichtiger Schritt in Richtung praktisches, datenfreies Verstärkungslernen für werkzeugintegriertes Denken. Es zeigt, dass ein Foundation-LLM sowohl als Curriculum-Agent als auch als Executor-Agent fungieren kann und dass GRPO mit ADPO und dem VeRL-Instrument eine stabile Verbesserung gegenüber Pseudo-Labels mit Mehrheitsabstimmung bewirken kann. Die Methode zeigt auch, dass die werkzeugintegrierte Co-Evolution frühere Zero-Knowledge-Frameworks wie R Zero und Absolute Zero auf starken Qwen3-Basislinien übertreffen kann. Agent0 ist ein starkes Argument dafür, dass sich selbst entwickelnde, in Instruments integrierte LLM-Agenten zu einem realistischen Trainingsparadigma werden.

Schauen Sie sich das an PAPIER Und Repo. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Michal Sutter ist ein Knowledge-Science-Experte mit einem Grasp of Science in Knowledge Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

In diesem Tutorial erstellen wir ein Agentic Knowledge and Infrastructure Technique-System unter Verwendung des leichtgewichtigen Qwen2.5-0.5B-Instruct-Modells für eine effiziente Ausführung. Wir beginnen mit der Erstellung eines flexiblen LLM-Agenten-Frameworks und entwickeln dann spezialisierte Agenten, die verschiedene Ebenen der Datenverwaltung verwalten, von der Aufnahme und Qualitätsanalyse bis hin zur Infrastrukturoptimierung. Wir integrieren diese Agenten in einen Orchestrator, der ihre Interaktionen koordiniert und so eine reibungslose Zusammenarbeit mehrerer Agenten in der gesamten Datenpipeline gewährleistet. Anhand praktischer Beispiele wie E-Commerce und IoT-Pipelines untersuchen wir, wie autonome Entscheidungsfindung komplexe Datenvorgänge rationalisieren kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers torch speed up datasets huggingface_hub
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import json, time
from typing import Listing, Dict, Any
from dataclasses import dataclass
from datetime import datetime
import pandas as pd


class LightweightLLMAgent:
   def __init__(self, function: str, model_name: str = "Qwen/Qwen2.5-0.5B-Instruct"):
       self.function = function
       self.model_name = model_name
       self.gadget = "cuda" if torch.cuda.is_available() else "cpu"
       print(f"Loading {model_name} for {function} agent on {self.gadget}...")
       self.tokenizer = AutoTokenizer.from_pretrained(model_name)
       self.mannequin = AutoModelForCausalLM.from_pretrained(
           model_name,
           torch_dtype=torch.float16 if self.gadget == "cuda" else torch.float32,
           device_map="auto"
       )
       self.conversation_history = ()


   def generate_response(self, immediate: str, max_tokens: int = 150) -> str:
       messages = (
           {"function": "system", "content material": f"You're a {self.function} agent in a knowledge infrastructure system."},
           {"function": "consumer", "content material": immediate}
       )
       textual content = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
       model_inputs = self.tokenizer((textual content), return_tensors="pt").to(self.gadget)
       with torch.no_grad():
           generated_ids = self.mannequin.generate(
               model_inputs.input_ids,
               max_new_tokens=max_tokens,
               temperature=0.7,
               do_sample=True,
               top_p=0.95
           )
       generated_ids = (output_ids(len(input_ids):) for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids))
       response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)(0)
       self.conversation_history.append({"immediate": immediate, "response": response})
       return response

Wir beginnen mit der Einrichtung der leichtgewichtigen LLM-Agenten-Infrastruktur mithilfe des Qwen2.5-0.5B-Instruct-Modells. Wir laden das Modell und den Tokenizer und definieren eine Basisagentenklasse, die kontextbezogene Konversationen abwickeln und intelligente Antworten generieren kann. Dies bildet die zentrale Grundlage für die effiziente Arbeit unserer spezialisierten Agenten innerhalb von Colab. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class DataIngestionAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Knowledge Ingestion Specialist")
   def analyze_data_source(self, source_info: Dict) -> Dict:
       immediate = f"""Analyze this knowledge supply and supply ingestion technique:
Supply Sort: {source_info.get('kind', 'unknown')}
Quantity: {source_info.get('quantity', 'unknown')}
Frequency: {source_info.get('frequency', 'unknown')}
Present a quick technique specializing in: 1) Ingestion methodology, 2) Key issues."""
       technique = self.generate_response(immediate, max_tokens=100)
       return {"supply": source_info, "technique": technique, "timestamp": datetime.now().isoformat()}


class DataQualityAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Knowledge High quality Analyst")
   def assess_data_quality(self, data_sample: Dict) -> Dict:
       immediate = f"""Assess knowledge high quality for this pattern:
Completeness: {data_sample.get('completeness', 'N/A')}%
Consistency: {data_sample.get('consistency', 'N/A')}%
Points Discovered: {data_sample.get('points', 0)}
Present transient high quality evaluation and high 2 suggestions."""
       evaluation = self.generate_response(immediate, max_tokens=100)
       return {"evaluation": evaluation, "severity": self._calculate_severity(data_sample), "timestamp": datetime.now().isoformat()}
   def _calculate_severity(self, data_sample: Dict) -> str:
       completeness = data_sample.get('completeness', 100)
       consistency = data_sample.get('consistency', 100)
       avg_score = (completeness + consistency) / 2
       if avg_score >= 90: return "LOW"
       elif avg_score >= 70: return "MEDIUM"
       else: return "HIGH"

Wir entwerfen die Datenaufnahme- und Datenqualitätsagenten so, dass sie sich auf die strukturierte Analyse von Datenpipelines konzentrieren. Wir lassen den Aufnahmeagenten den besten Ansatz für den Datenfluss bestimmen, während der Qualitätsagent die Vollständigkeit, Konsistenz und Probleme der Daten bewertet, um umsetzbare Erkenntnisse zu liefern. Gemeinsam bilden sie die ersten beiden Schichten des autonomen Datenmanagements. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class InfrastructureOptimizationAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Infrastructure Optimization Specialist")
   def optimize_resources(self, metrics: Dict) -> Dict:
       immediate = f"""Analyze infrastructure metrics and counsel optimizations:
CPU Utilization: {metrics.get('cpu_usage', 0)}%
Reminiscence Utilization: {metrics.get('memory_usage', 0)}%
Storage: {metrics.get('storage_used', 0)}GB / {metrics.get('storage_total', 0)}GB
Question Latency: {metrics.get('query_latency', 0)}ms
Present 2 optimization suggestions."""
       suggestions = self.generate_response(immediate, max_tokens=100)
       return {"current_metrics": metrics, "suggestions": suggestions, "precedence": self._calculate_priority(metrics), "timestamp": datetime.now().isoformat()}
   def _calculate_priority(self, metrics: Dict) -> str:
       cpu = metrics.get('cpu_usage', 0)
       reminiscence = metrics.get('memory_usage', 0)
       if cpu > 85 or reminiscence > 85: return "CRITICAL"
       elif cpu > 70 or reminiscence > 70: return "HIGH"
       else: return "NORMAL"

Wir entwickeln den Infrastructure Optimization Agent, um wichtige Kennzahlen wie CPU-, Arbeitsspeicher- und Speicherauslastung kontinuierlich zu analysieren. Daraus generieren wir intelligente Optimierungsvorschläge, die uns helfen, eine hohe Leistung und Ressourceneffizienz aufrechtzuerhalten. Dieser Agent stellt sicher, dass unsere Infrastruktur während der Datenoperationen reaktionsfähig und skalierbar bleibt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class AgenticDataOrchestrator:
   def __init__(self):
       print("n" + "="*70)
       print("Initializing Agentic Knowledge Infrastructure System")
       print("="*70 + "n")
       self.ingestion_agent = DataIngestionAgent()
       self.quality_agent = DataQualityAgent()
       self.optimization_agent = InfrastructureOptimizationAgent()
       self.execution_log = ()
   def process_data_pipeline(self, pipeline_config: Dict) -> Dict:
       outcomes = {"pipeline_id": pipeline_config.get("id", "unknown"), "start_time": datetime.now().isoformat(), "phases": ()}
       print("n(Stage 1) Knowledge Ingestion Evaluation")
       ingestion_result = self.ingestion_agent.analyze_data_source(pipeline_config.get("supply", {}))
       print(f"Technique: {ingestion_result('technique')(:150)}...")
       outcomes("phases").append({"stage": "ingestion", "consequence": ingestion_result})
       print("n(Stage 2) Knowledge High quality Evaluation")
       quality_result = self.quality_agent.assess_data_quality(pipeline_config.get("quality_metrics", {}))
       print(f"Evaluation: {quality_result('evaluation')(:150)}...")
       print(f"Severity: {quality_result('severity')}")
       outcomes("phases").append({"stage": "high quality", "consequence": quality_result})
       print("n(Stage 3) Infrastructure Optimization")
       optimization_result = self.optimization_agent.optimize_resources(pipeline_config.get("infrastructure_metrics", {}))
       print(f"Suggestions: {optimization_result('suggestions')(:150)}...")
       print(f"Precedence: {optimization_result('precedence')}")
       outcomes("phases").append({"stage": "optimization", "consequence": optimization_result})
       outcomes("end_time") = datetime.now().isoformat()
       outcomes("standing") = "accomplished"
       self.execution_log.append(outcomes)
       return outcomes
   def generate_summary_report(self) -> pd.DataFrame:
       if not self.execution_log: return pd.DataFrame()
       summary_data = ()
       for log in self.execution_log:
           summary_data.append({"Pipeline ID": log("pipeline_id"), "Begin Time": log("start_time"), "Standing": log("standing"), "Levels Accomplished": len(log("phases"))})
       return pd.DataFrame(summary_data)

Wir haben einen Agentic Knowledge Orchestrator entwickelt, um alle spezialisierten Agenten im Rahmen eines einheitlichen Workflows zu koordinieren. Wir verwenden es, um die Finish-to-Finish-Pipeline-Ausführung zu verwalten und nacheinander Aufnahme, Qualitätsprüfungen und Optimierung auszulösen. Dadurch bringen wir Struktur, Zusammenarbeit und Automatisierung in das gesamte Multiagentensystem. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def important():
   orchestrator = AgenticDataOrchestrator()
   print("n" + "="*70)
   print("EXAMPLE 1: E-commerce Knowledge Pipeline")
   print("="*70)
   ecommerce_pipeline = {
       "id": "ecommerce_pipeline_001",
       "supply": {"kind": "REST API", "quantity": "10GB/day", "frequency": "real-time"},
       "quality_metrics": {"completeness": 87, "consistency": 92, "points": 15},
       "infrastructure_metrics": {"cpu_usage": 78, "memory_usage": 82, "storage_used": 450, "storage_total": 1000, "query_latency": 250}
   }
   result1 = orchestrator.process_data_pipeline(ecommerce_pipeline)
   print("nn" + "="*70)
   print("EXAMPLE 2: IoT Sensor Knowledge Pipeline")
   print("="*70)
   iot_pipeline = {
       "id": "iot_pipeline_002",
       "supply": {"kind": "Message Queue (Kafka)", "quantity": "50GB/day", "frequency": "streaming"},
       "quality_metrics": {"completeness": 95, "consistency": 88, "points": 8},
       "infrastructure_metrics": {"cpu_usage": 65, "memory_usage": 71, "storage_used": 780, "storage_total": 2000, "query_latency": 180}
   }
   result2 = orchestrator.process_data_pipeline(iot_pipeline)
   print("nn" + "="*70)
   print("EXECUTION SUMMARY REPORT")
   print("="*70 + "n")
   summary_df = orchestrator.generate_summary_report()
   print(summary_df.to_string(index=False))
   print("n" + "="*70)
   print("Tutorial Full!")
   print("="*70)
   print("nKey Ideas Demonstrated:")
   print("✓ Light-weight LLM agent structure")
   print("✓ Specialised brokers for various knowledge duties")
   print("✓ Multi-agent orchestration")
   print("✓ Infrastructure monitoring and optimization")
   print("✓ Autonomous decision-making in knowledge pipelines")


if __name__ == "__main__":
   important()

Wir demonstrieren unser komplettes System anhand von zwei realen Beispielen, einem E-Commerce- und einer IoT-Datenpipeline. Wir beobachten, wie jeder Agent seine Rolle autonom ausführt und gleichzeitig zu einem gemeinsamen Ziel beiträgt. Abschließend erstellen wir einen zusammenfassenden Bericht, der die Effizienz der Orchestrierung und die Leistungsfähigkeit der leichtgewichtigen Agentenintelligenz bestätigt.

Abschließend entwerfen und implementieren wir ein intelligentes Dateninfrastruktur-Framework mit mehreren Agenten, das auf einem kompakten Open-Supply-Modell basiert. Wir erleben, wie unabhängige und dennoch kooperative Agenten reale Datensysteme autonom analysieren, bewerten und optimieren können. Der gesamte Aufbau zeigt, wie leichtgewichtige LLMs Infrastrukturintelligenz effizient verarbeiten können, und verdeutlicht gleichzeitig, wie die agentische Orchestrierung herkömmliche Datenworkflows in adaptive, selbstoptimierende Systeme verwandelt, die für skalierbare Unternehmensanwendungen bereit sind.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.