{
  "video_id": "UDTr9yUnLUI",
  "channel_slug": "sequoiacapital",
  "channel_handle": "sequoiacapital",
  "title": "How Cursor Trained Composer on Fireworks: Distributed Infrastructure for High-Performance RL",
  "duration_seconds": 2734.0,
  "url": "https://www.youtube.com/watch?v=UDTr9yUnLUI",
  "upload_date": "",
  "transcript": "Und Sie benötigen die gesamte Infrastruktur, um\ndiese Umgebungen zu betreiben, die\nso genau wie möglich dem entsprechen müssen, wie ein\nBenutzercomputer aussieht.  Und\nes ist sehr wichtig, so genau wie\nmöglich vorzugehen, denn manchmal kann das Modell\ntatsächlich erkennen, wann es in\neiner simulierten und wann in einer realen Umgebung ausgeführt wird,\nund es zeigt dann während des Reinforcement Learnings ein anderes Verhalten\nals im Produktionsbetrieb.\nMerkst du, dass es sich\nin der künstlichen Umgebung\nanders verhält?   Ja\n.  Ja.\nInteressant.   Es ist so, als ob\nich mich in einer künstlichen\nUmgebung befände.  Ich habe ein paar Tricks gelernt, um\nin diesem Umfeld eine bessere Belohnung zu bekommen,\nund lasst mich sie ausprobieren.\nModels lieben es, zu betrügen.  Es ist wirklich gut darin, zum Schummeln zu animieren\n.\nIch freue mich sehr, heute Federico von\nCursor und Dimma von Fireworks im\nPodcast begrüßen zu dürfen.  Feder Rico, Sie sind der\nForschungsleiter für Composer 2 bei Cursor,\nCursors neues agentenbasiertes Codierungsmodell und\nDimma. Wie viele der letzten\nMonate haben Sie nebenbei bei Cursor gearbeitet, um\neinen Großteil der\nInfrastruktur zu unterstützen, die für die Durchführung dieser\ngigantischen Trainingsaufgabe erforderlich ist?  Und so freue\nich mich darauf, heute mit Ihnen beiden\ndarüber zu sprechen, wie das Training von Composer 2\nzustande kam, welche schwierigen Probleme Sie\ngemeinsam gelöst haben und was dies Ihrer Meinung nach\nfür die Zukunft von KI- und\nFoundation-Model-Unternehmen bedeutet.\nSpannend.  Ja, aufregend.  Vielen Dank für die Einladung\n.\nDanke fürs Mitmachen.  Okay, legen wir gleich los\n. Für diejenigen, die\nuns nicht so genau verfolgt haben: Cursor\nhat kürzlich Composer 2 angekündigt, ein\nagentenbasiertes Codierungsmodell, das für\nlangfristige Codierungsaufgaben gedacht ist.  Fed Rico, äh\nbis jetzt, ähm Cursor hat hauptsächlich äh die\nCodierungsagenten anderer Leute ermöglicht\n.  Was war der Anstoß für\nCursor, sich so stark auf Composer\n2 zu konzentrieren, und wie existenziell ist es für Sie,\nnicht nur ein Anwendungsunternehmen,\nsondern auch ein Unternehmen für grundlegende Modelle zu werden?\nDer Grund, warum wir angefangen haben, uns mit dem\nTraining unserer eigenen Modelle zu beschäftigen, ist folgender: Man kann sich\ndas Modell wie eine Art\nSpeichermedium vorstellen; es verfügt über eine bestimmte\nAnzahl von Bits, die es in seinen Gewichten speichern kann,\nund die Idee ist sehr einfach: Wir\nkümmern uns nur um eine Aufgabe, wir\nkümmern uns nicht einmal unbedingt um Codierung oder\nProgrammierung.  Uns interessiert\nSoftwareentwicklung innerhalb des Cursors und\nnur innerhalb des Cursors.  Und was wäre, wenn wir\nalle\nInformationsbits, die in einem\nModellgewicht gespeichert werden können, dieser einen bestimmten\nAufgabe zuordnen würden?  Außerdem ist Composer, wie manche vielleicht schon bemerkt haben, um\nGrößenordnungen\ngünstiger als Opus und ähnliche\nCodierungsmodelle, weil wir einfach\nalle Modellgewichte auf\ndiese spezielle Aufgabe spezialisieren können und so\nein kleineres Modell oder Ähnliches bereitstellen können\n.  Ja.   Es geht also darum,\nsicherzustellen, dass jedes\neinzelne Quäntchen Gewicht und Information, das wir\nhaben, dem jeweiligen Problem gewidmet ist, vor dem\nwir stehen.\nGenau.\nHabe es.  Ähm, das scheint ein\nnahezu verallgemeinerbares Problem zu sein.  Ähm, DM, ich bin\nneugierig auf Ihre Sichtweise.  Sind Sie der Meinung,\ndass jedes Softwareunternehmen\nCursor als Vorboten zukünftiger Entwicklungen betrachten sollte\n?  Sollten sie alle dasselbe anstreben\n?   Ja\n, absolut.  Ich meine, wir\nsehen es im Allgemeinen als ein Muster einer Art\nEvolution von Anwendungen.  Vielleicht sollten Sie mit der Entwicklung eines\nPrototyps beginnen.  Möglicherweise verwenden Sie ein\nStandardmodell, um überhaupt\netwas zum Laufen zu bringen.  Vielleicht solltest du mal ein bisschen tüfteln und\nherausfinden, wie dein Kabelbaum\nfunktioniert.  Das wichtigste\nNutzungsmerkmal Ihrer Anwendung ist jedoch die tatsächliche\nVerwendung von Benutzerdaten oder bestimmter\nAspekte der Funktionsweise der Anwendung\n.  Vielleicht einige Aspekte Ihres\nAngebots, welche Tools Sie bereitstellen, wie\ndie Anwendung funktioniert, also wirklich\nwichtige Details, die für\nIhre Anwendung wichtig sind.  Und um das richtig zu\nerfassen, kann man das teilweise\ndurch gezielte Hinweise erreichen, aber der\nrichtige Weg besteht darin, das Modell so zu gestalten, dass es\nin der jeweiligen Umgebung agiert.  Ja,\nabsolut.  Es gibt bestimmte Tools, die\nder Agent verwendet, deren\nVerhalten sich dem Modell nur schwer präzise beschreiben lässt. Nach dem\nTraining können wir die\noptimale Nutzung dieser Tools, wie beispielsweise des\nComposers, implementieren. Wir geben dem Composer zwar einen Befehl,\naber ich denke, durch unsere\nTrainingsmethode würde es auch ohne\nBefehl funktionieren und wüsste, was zu tun ist, da\nwir\ndas Modell während des gesamten Trainings intrinsisch in die richtige Richtung lenken. Es gibt eine Art\nObergrenze für die Möglichkeiten des\nPrompt Engineerings. Um\nwirklich großartige KI-Produkte zu entwickeln, ist eine\nFeinabstimmung und die\nBeeinflussung des Modellverhaltens notwendig. Das ist der erste Grund. Der zweite Grund\nist die empfohlene Abwägung zwischen\nKosten und Geschwindigkeit. Bei\nFireworks betrachten wir die\nOptimierung als einen\ndreidimensionalen Kompromiss zwischen\nQualität, Geschwindigkeit und Kosten. Man kann damit\nsehr weit kommen, und wir wenden diese Methode bei allen\nKunden an. Anfangs kann man damit sehr weit kommen.  Es geht\nnur um die Optimierung der Infrastruktur, aber\nwenn man sich mit dem\nModelltraining beschäftigt, kann man diesen\nKompromiss noch viel weiter ausreizen und ein\nbesseres Modell zu einem Bruchteil der Kosten erhalten, das\nviel schneller läuft.\nComposer ist ein gutes Beispiel dafür. Darf\nich das noch etwas ausführen? Ich möchte\nfragen, ob dieser Ansatz weniger effektiv oder\nweniger effektiv ist. Wir\nsprachen ja alle über Tab 9 im\nWalk-in. Ich erinnere mich, dass es vor der LLM-\nÄra diese kleinen,\nspezialisierten Codierungsmodelle gab. Und was viele\nLeute überrascht hat, war, dass\ndie Modelle selbst mit der Skalierung – also dem Training im Internet mit vielen englischen Texten und anderen Sprachen –\nauch im Codieren selbst besser wurden.  Der\nTrend, den ich bisher beobachtet habe, zeigt also, dass\ngrößere Modelle in allen Bereichen besser abschneiden,\nauch beim Codieren.\nSagt ihr damit, dass das im Widerspruch zu\nder bitteren Erkenntnis steht?\nIch glaube nicht.  Eine ähnliche\nBeobachtung ist jedoch, dass die großen\nModelle, die von den Laboren trainiert werden,\nebenfalls mit einer Menge Code trainiert werden.  Das Programmieren ist eine der\nHauptaufgaben, die die Labore\nvorantreiben wollen, und deshalb verallgemeinern sie nicht einfach\ndarauf.  Sie sind auch ein bisschen\nspezialisiert.  Ich denke, in unserem\nFall – wenn wir\ndie bittere Lektion beherzigen –\nkonzentrieren wir uns sehr stark auf die Datendimension,\nund wir wissen, dass die Modelle naturgemäß eine\nbegrenzte Kapazität haben. Wenn wir\ndiese Kapazität voll ausschöpfen wollen, müssen wir die\nDaten skalieren, und um mehr\nDaten aufnehmen zu können, müssen wir die\nGewichte von Ablenkungen befreien, die das Modell möglicherweise\nhat.\nOkay, verstanden, super interessant. Okay, schauen wir uns\ndas Training von Composer 2 genauer an, das Sie\nvor ein paar Wochen veröffentlicht haben und das sofort\nAufmerksamkeit erregte.  Starke Benchmark-\nErgebnisse, deutlich geringere Kosten für die Durchführung von\nAbdrücken.\nWie funktioniert Composer 2 in Kurzform und was habt ihr getan, um\nes so performant zu machen?\nWir begannen mit einer sehr starken Basis, nämlich\nKimmy 2.5.  Das ist wie ein\nParameter mit einer Billion Anzahl an Elementen, von denen 30 Milliarden aktiv sind.  So sehr, so\nspärlich.  Eigentlich haben wir uns\nden Stapel mal genauer angesehen und festgestellt, dass es da so\nzwei Achsen gibt.  Composer\n1 konzentrierte sich hauptsächlich auf eine dieser\nAchsen, nämlich das Reinforcement Learning, während\nComposer 2 auf zwei verschiedenen Achsen agierte.   Das\neine ist kontinuierliches Vortraining, das\nandere bestärkendes Lernen.  Das\nBesondere an Composer 2 ist also, dass er\nin beide Richtungen gleichermaßen zielführend ist.\nWir begannen den Trainingslauf also damit,\nviele Zwischenläufe mit Code-Tokens durchzuführen,\nquasi im Rahmen des Vortrainings,\nund nach diesem\nZwischenlauf nahmen wir die Kontrollpunkte und führten dann\nsehr umfangreiches Reinforcement Learning mit sehr vielen\nAufgaben durch.\nOkay.  Die Grundannahme hierbei wäre, dass\nman aufgrund der Tatsache, dass sich der Cursor inmitten so vieler interessanter Codierungs-Token befindet, auf einzigartige Weise\nZugriff auf\nDaten hat, um in nahezu\nVor-Trainings-Maßstab trainieren zu können.   Ja\n.  Warum nicht ein eigenes Modell vortrainieren?\nDann\ndenken wir einfach von\noben nach unten statt von unten nach oben über unseren Ansatz nach.\nWie können wir also in kürzester Zeit ein Modell entwickeln, das für die\nBenutzer nützlich ist? Wenn wir ganz von vorne\nanfangen und\nherausfinden, wie wir das Vortraining durchführen,\nund es dann bis zum mittleren Trainingsstadium skalieren, und\ndann, okay, jetzt haben wir das mittlere\nTrainingsstadium herausgefunden, oder wir wenden Reinforcement\nLearning an.  Das würde sehr lange dauern, bis wir\nein Modell für unsere Nutzer entwickeln könnten.  Indem wir den umgekehrten Weg gingen,\nkonnten wir unseren Nutzern in kürzester Zeit ein nützliches Modell zur Verfügung stellen\n.  Hoffentlich\nwissen Sie also bereits, dass die nächsten Composer-Versionen\nunser eigenes Modell sein werden, anstatt auf\neiner Open-Source-Basis zu beruhen.\nWas lernt das Modell ungefähr\nwährend des mittleren Trainingsschritts und\nwas lernt es\nanschließend?  Ja.  Mitten im\nTraining geht es also im Grunde darum, etwas über\nCodebibliotheken\nund über spezifische, sehr verbreitete Codemuster zu lernen – quasi auch um allgemeines\nAllgemeinwissen.\nDort gibt es auch Webdaten.  Dadurch wird im Grunde\neine breitere Verteilung geschaffen, auf der das\nbestärkende Lernen dann\nschärfen kann.  Und so\nweiß man beim Reinforcement Learning, dass das Modell\ndirekt mit der Cursor-Arness interagieren kann.  Und so lernt es\ndie Welt kennen, in der das\nModell den Rest\nseines Lebens verbringen wird, richtig?  In gewisser Weise.  Und so\nlernt es während des Reinforcement Learnings, wie man\nWerkzeuge richtig aufruft, wie man sich in seiner\nUmgebung zurechtfindet und wie man korrekten Code schreibt.\nDenn mitten im Training\nlernt es, Code zu schreiben.  Das\nbedeutet nicht zwangsläufig, dass es lernt,\nkorrekten Code zu schreiben.  Wir versuchen, mit\nweitgehend korrektem Code zu trainieren, aber das Modell kann\ntatsächlich nicht\nzwischen den beiden unterscheiden.  Beim Reinforcement Learning (\nRL) besteht eine der wichtigsten Maßnahmen darin,\ndie\nEigenschaften des Modells so anzupassen, dass es\nstets korrekten Code enthält\n.  Genau.\nInteressant.  Und ist das Modell\nnach der Mitte des Trainings ähnlich\ndem Modell, das ihr für die Tab-\nAutovervollständigung verwendet, oder handelt es sich dabei um eine andere\nKernkompetenz?  Ja, ich meine, äh ja,\nich würde es so ausdrücken, denn\nmitten im Training machen wir ja nur\nVorhersagen über das nächste Token, wissen Sie,\nwie gut man das nächste Token\nund dann das Token danach vorhersagen kann.  Also ja,\nwarum nicht einfach ein Trainingsmodell für die Tab-\nAutovervollständigung hinzufügen?  Warum\ndie verschiedenen Modelle bei mittleren Regenfällen?\nJa, ich meine, das Tablet ist ein sehr kleines Modell,\nweil es ein Modell mit extrem niedriger Latenz ist, da\nman es sehr schnell haben möchte.\nDie beiden wichtigsten Unterschiede zwischen\nden Basismodellen sind also, dass Tab\nklein ist und Composer ziemlich\ngroß.\nIch verstehe.  Ich verstehe.  Okay.  Es scheint also, als ob ein\nGroßteil eurer Arbeit\nan Composer 2 auf diesem groß angelegten\nReinforcement-Learning-Lauf beruhte.  Können Sie\nuns das genauer erklären?  Was genau gehört dazu\nund welche schwierigen\nProbleme müssen Sie dabei lösen?\nWenn Sie a durchführen, ist das etwas ganz anderes als beispielsweise beim\nVortraining oder beim m-\nTraining, weil Sie nicht nur versuchen, das\nnächste Token vorherzusagen.  Du\nbetreibst im Grunde den gesamten Messaufbau wie das\ngesamte Experiment.  Sie lassen das\nModell in der Umgebung agieren.  Sehen Sie, wie\nes sich bei einer bestimmten Einführung verhält.\nDas ist die Bezeichnung, die als\nRollout bezeichnet wird.  und es wird eine Art Belohnung zugewiesen, je nachdem, ob\netwas korrekt ausgeführt wurde oder\nnicht. Dies kann mithilfe eines Sprachmodells als\nBewertungskriterium erfolgen oder durch etwas Verifizierbares wie die\nKompilierung des Codes. Im\nVergleich zum\nregulären Training benötigt man also eine Reihe\nweiterer Komponenten. Man benötigt weiterhin ein\ngroß angelegtes Training und muss\nZehntausende von GPUs orchestrieren, um\nVorwärts- und Rückwärtspropagation durchzuführen sowie alle Schritte des Vor-\nund\nZwischentrainings zu erledigen. Zusätzlich muss man nun aber auch\neine Vielzahl von Umgebungen orchestrieren und die\nModellinferenz ausführen. Denn bei diesem\nRollout wird im Prinzip eine\nechte Cursor-Sitzung ausgeführt.\nNotizen sind wie ein Vorwärtsdurchlauf, aber der\nRollout umfasst im Grunde die gesamte\nAgentensitzung vom Cursor aus. Das\nbedeutet, dass das\nModell etwa 50 Durchläufe benötigt. Es nimmt eine\nerste Eingabe entgegen, entscheidet dann, welche\nTools aufgerufen und ausgeführt werden sollen, und\ngeneriert anschließend weiteren\nCode – quasi die gesamte Sitzung.\nWenn man mit Agent und Cursor interagiert,\nsimuliert man diese\ngesamte Sitzung als Teil des\nTrainingslaufs. Man erhält die finale Belohnung und\nnutzt dieses Signal, um\nzum Trainer zurückzukehren.  und die Art und Weise, wie es verwendet wird, berücksichtigt\nes im Modellgewicht.  Sie haben also diese\nArt von sehr großer Aktualisierungsschleife, die\nsehr heterogen ist, richtig? Denn\nall diese verschiedenen\nKomponenten arbeiten zusammen, und jetzt\nversuchen Sie, das alles so zu orchestrieren, dass es\neffizient und mit hohem\nDurchsatz funktioniert, denn GPUs sind teuer,\nund Sie möchten Ihr Modell\nschnell und wirtschaftlich trainieren.  Das ist an\nsich schon eine sehr\ninteressante Problemstellung und ein\nSchnittpunkt von Algorithmen und\nInfrastruktur, denn es gibt viele\nKompromisse, wie man\ndas System sozusagen gemeinsam optimieren und gestalten kann.\nEin Aspekt ist, dass die Leute so etwas wie\neine Pipeline-Synchronisierung nennen.  Die Idee ist im\nGrunde, dass Sie versuchen,\ndieses Modell schrittweise zu aktualisieren, also haben Sie\nIhre aktuelle Modellversion und\nversuchen, damit eine Reihe von Rollouts durchzuführen\n.  Was macht dein Trainer, während\ndu diese Rollouts durchführst?  Rechts?  So wie ein\nAnsatz sagen würde: Okay, jetzt höre ich mit\nmeinem Trainer auf.  Ich werde\neine Reihe von Sitzungen abhalten, und diese\nSitzungen können etwa 5 bis 10 Minuten dauern,\noder sogar länger, wenn es sich um\nAufgaben mit längerem Zeithorizont handelt.  Ich werde mir diese\nErgebnisse ansehen und dann meine\nSchlussfolgerung unterbrechen.  Ich werde wieder mit dem\nTraining beginnen und versuchen, Updates durchzuführen.  Das ist zwar\ntheoretisch algorithmisch sehr\nrobust, weil man nicht\nalles exakt simuliert, aber es ist\nsystemtechnisch sehr ineffizient, weil die Hälfte der\nKapazität ständig ungenutzt bleibt.\nSo können Sie äh all die cleveren\nalgorithmischen Tricks anwenden, die Ihnen stattdessen ermöglichen.   Ja\n.   Ja\n.  Man kann das alles so in eine Art\nPipeline umwandeln.  Stellen Sie sich das also wie\neine gigantische Fabrik vor, richtig?  Es gibt so etwas\nwie Trainergebäude und\nRollout-Gebäude.  Sie\ndrehen sich ja ständig, nicht wahr?  Bei Rollouts wird immer die\nneueste Modellversion verwendet, um\nneue Sitzungen durchzuführen und neue\nAgentensitzungen zu simulieren. Der Trainer nimmt die\nneuen Ergebnisse immer entgegen und versucht,\nAktualisierungen zu berechnen.  Alles bewegt sich also ständig\n.  Der Nachteil ist, dass es\nalgorithmisch\nanders ist, denn bis man einen\nTestlauf in der\nsimulierten Umgebung abgeschlossen hat, sind die\nModellgewichte möglicherweise bereits anhand\nanderer Daten aktualisiert worden.  Es entsteht also eine Art\nVerzögerung zwischen der Geschwindigkeit, mit der das\nModell Aktualisierungen lernen kann, denn bis man eine\nInteraktionssitzung mit einer simulierten\nUmgebung durchführt, hat sich das Modell bereits verändert.\nDies führt zu interessanten\nTrainingsdynamiken, und es gibt clevere Möglichkeiten, dem\nentgegenzuwirken. Die Kehrseite der Medaille\nist jedoch, dass alle GPUs und\nComputer ständig ausgelastet sind,\nwas tatsächlich zu einem\nhöheren Flops-Verbrauch und – zu Ihrem Leidwesen – zu einem geringeren Ressourcenverbrauch führt\n.  Ja, du\nhast quasi eine höhere Recheneffizienz.\nSie können in kürzerer Zeit zu einem besseren Modell gelangen\n.  Ja.  Vielleicht\nverliert man ein paar Prozentpunkte durch die asynchrone Arbeitsweise\nund die nicht ganz exakten mathematischen\nAktualisierungen,\naber das lässt sich dadurch ausgleichen, dass man\neffektiv nicht die Hälfte seiner\nKapazität ungenutzt lässt. Und genau\nin diesem Bereich gibt es viele interessante Aspekte und Interaktionen.  Und wir nehmen die\nLeistung bei Cursor sehr ernst,\ndenn im Gegensatz zu den großen Laboren verfügen\nwir über Zehntausende von GPUs, nicht über\nMillionen.  Und ja, wir wenden alle möglichen\nTricks an, um das Beste aus der\nGPU herauszuholen, z. B. trainieren wir in der Produktion mit FP4 und\narbeiten sogar mit Fireworks, um die\nInferenz zu beschleunigen, denn die\nInfrastruktur ist einfach von\nNatur aus komplexer als das\nVortraining, da man die gesamte\nVortrainingsinfrastruktur benötigt.  Das ist genau\neine der Voraussetzungen.  Dann\nbenötigen Sie die gesamte Infrastruktur, um diese\nUmgebungen zu betreiben, die so\ngenau wie möglich dem entsprechen müssen, wie ein\nBenutzercomputer aussieht.  Und es ist sehr\nwichtig, so genau wie möglich vorzugehen, denn\nmanchmal kann das Modell tatsächlich\nerkennen, wann es in einer simulierten\nund wann in einer realen Umgebung ausgeführt wird, und es zeigt dann\nwährend des Reinforcement Learnings ein anderes Verhalten als\nim Produktionsbetrieb.\nMerkst du, dass es sich bewusst ist, dass es sich\nin einer künstlichen Umgebung befindet und sich deshalb\nanders verhält?   Ja\n.  Ja.\nInteressant.  Es ist so, als ob ich mich in einer\ndichten Umgebung befände.  Ich habe ein paar\nTricks gelernt, um in diesem Umfeld eine bessere Belohnung zu bekommen,\nund lasst mich sie ausprobieren\n.\nModels lieben es, zu betrügen.  Es ist wirklich gut darin, zum Schummeln zu animieren\n.   Ja\n.  Und dann brauchen wir eine wirklich\neffiziente Inferenz.  Das ist also wirklich\nwichtig.  Es gibt also tatsächlich diesen\nMythos, dass man während des Trainings\nviel mehr Inferenz-Flops als\nTrainings-Flops verbringt.  Das ist so ähnlich wie bei\nOpen-Source-\nInferenzmaschinen, die einfach nur sehr unoptimiert sind, anstatt dass es sich\ntatsächlich um eine allgemeine Eigenschaft handelt.\nDas Verhältnis ist im Großen und Ganzen dasselbe\n.  Theoretisch sollte bei maximaler Auslastung der GPUs\nein Drittel der\nTrainings-GPUs für die\nInferenz reserviert sein, richtig?  Weil das Training im\nGrunde aus drei Vorwärtspässen besteht.  Sie\nhaben den Vorwärtsdurchlauf, Sie haben den\nDatengradienten, den Gewichtsgradienten.  Wenn\nSie bei der Inferenz tatsächlich die kritische Batchgröße erreichen\n, sollten Sie nur noch einen\neinzigen Forward-Passwort-Flop benötigen.   Deshalb\nverwendet ihr also Feuerwerkskörper\nanstelle einer offenen\nInferenzmaschine.\nJa, ich meine, die andere Alternative wäre, dass wir selbst\neinen bauen, aber wir\nhaben ja bekanntlich auch nur eine begrenzte Anzahl an Ingenieuren wie alle\nanderen.  Wir würden es vorziehen, wenn die\nIngenieure das Training effizienter\nund präziser gestalten würden, anstatt etwas wie\neinen Inferenzprozess in Gang zu setzen.  Ja.\nOkay.  Das ist echt krass.\nIch glaube, Sie erwähnten in Ihrem technischen Papier,\ndass Sie\ndies auf eine Art und Weise global verteilt umsetzen\n.  Warum global verteilt und\nwas macht das so schwierig?   Ja\n.  Ja.  Nun, dafür gibt es verschiedene\nGründe.  Solche\ngroßen, zusammenhängenden Cluster sind\nauf dem Markt schwer zu finden.  Deshalb können wir\nstattdessen einen Cluster verwenden, der das\ngesamte Training durchführt.  Wissen Sie,\nwir können kein globales Trainingscluster durchführen.\nDie Inferenzkomponente des\nReinforcement Learnings können wir hingegen global auf\nkleine Cluster auf der ganzen\nWelt verteilen.  Ich glaube, dass wir für den\nComposer insgesamt vier Cluster verwendet haben,\ndie über die ganze Welt verteilt und sehr weit voneinander entfernt waren,\nund wir haben sogar\neinen Teil unseres Produktionsdatenverkehrs genutzt, als\ndieser am wenigsten ausgelastet war.  Wir hatten also\nComposer 1.5, das Vorgängermodell,\nund als es am wenigsten genutzt wurde, haben wir\neinfach ein paar Inferenz-GPUs hinzugefügt, um das\nTraining zu beschleunigen. So\nkönnen wir solche Dinge tun und\nunsere Trainingsumgebung relativ einfach skalieren,\nohne einen großen, zusammenhängenden\nCluster zu benötigen. Was dies ermöglicht –\nvielleicht kann Dimma das genauer erläutern –\nist, dass unser Training\nsehr heterogen ist. Indem wir diese\nHeterogenität nutzen, können wir die unterschiedlichen\nInfrastrukturen der verschiedenen Komponenten besser steuern\n.  Man kann die Effizienz tatsächlich steigern,\nund dieses Muster sieht man quasi überall\n.\nSpeziell für Schulungszwecke benötigt man\nall dies, wie zum Beispiel hochgradig vernetzte\nCluster, man braucht ein Hochgeschwindigkeitsnetzwerk und\nmuss quasi synchron arbeiten.\nDiese Cluster sind also teuer, richtig? Und\nes ist tatsächlich sehr schwer, große Cluster zu finden, denn in\ndem Umfang, in dem\nComposer trainiert wurde,\nist es deutlich schwieriger, einen doppelt so großen Cluster zu finden\nals einen Cluster der aktuellen Größe\n.  Und deshalb ist es so, dass man, wenn man\ndiese Komponenten aufteilen und\nan verschiedenen Orten platzieren kann, keinen\nso großen Cluster mehr benötigt.  Zweitens\nkann man\nbei der Hardware tatsächlich unterschiedliche Kompromisse eingehen, da man für\nInferenz keine so\nweitreichenden Verbindungen benötigt.  Man kann kleinere\nGruppen von GPUs miteinander verbinden.\nEs können unterschiedliche\nGPU-Typen verwendet werden.  Es können verschiedene\nGPU-Generationen verwendet werden.  Man kann im Prinzip alle diese\nSpiele spielen, Spieleoptimierung.  Und schließlich\nwie Schlussfolgerungen.  Es ist viel einfacher, die Größe nach\nund nach anzupassen.  Und\nja, es ist eine sehr konventionelle Vorgehensweise, zum Beispiel wenn man\naußerhalb der Spitzenzeiten Abdeckungen hat. Man kann\nseinen gesamten Inferenzpool als einen Satz\nvon GPUs betrachten, die den\nProduktionsdatenverkehr für echte\nBenutzer bedienen oder simulierte Umgebungen\nfür RL-Zwecke bedienen, und eine Art Gleichgewicht\nzwischen diesen beiden Aspekten herstellen.  Natürlich handelt es sich um ein sehr\ninteressantes Systemproblem.  Der\nempfohlene\nTrainingsschritt mit einem Terabyte dauert\netwa 5 bis 15 Minuten.\nDas bedeutet im Grunde, dass etwa alle\n5 bis 10 Minuten eine\nneue Momentaufnahme der\nGewichte im Terabyte-Bereich erstellt wird.  Die Frage ist also, wie\nman es auf effiziente Weise zu einem anderen\nCluster auf der anderen Seite der Welt transportiert,\nund zwar\nschnell, denn man will ja\nnicht, dass diese Daten veralten\n.  Ich denke, das war\nwahrscheinlich der\nlustigste Teil, den wir\ngemeinsam herausgefunden haben: Obwohl das vollständige\nModell etwa ein Terabyte groß ist,\nändern sich nicht alle Gewichte bei jedem Schritt, richtig?\nDenn RL nimmt viele sehr\npräzise Anpassungen vor, insbesondere während des\nTrainings.  Es\ngibt also tatsächlich recht regelmäßige Muster darin,\nwelche Teilmenge der Gewichte\ngeändert wird; vielleicht ändern sich nicht jedes Mal alle\n.  Wenn man sich also anschaut,\nwie sich mein Modell innerhalb eines\nTrainingsschritts, beispielsweise nach 10 Minuten, verändert, so\nist der Unterschied zwischen diesen Schritten relativ gering\n.  Man kann einen Komprimierungsalgorithmus schreiben,\nder diese Eigenschaft im Grunde ausnutzt,\nund dann steht man vor einem ähnlichen\nProblem wie bei Datenbanksystemen:\nOkay, ich habe mein Delta und ich möchte\nes einfach nur um die ganze Welt schicken.  Mein\nDelta ist vielleicht etwa 20 Mal kleiner\nals das, mit dem das vollständige Modell ausgeliefert wurde,\nund das macht es praktisch, aber\nnatürlich muss man jetzt all diese\nArt von Maschinen aus dem Lagersystem bauen.\nAlso vollständige Snapshots, Deltas,\nWiederherstellung, Abgleich usw. Wir\nkonnten das Ganze quasi verlustfrei realisieren, was im\nGrunde bedeutet, dass man am Ende\nimmer ein bitgenaues Modell\nauf der anderen Seite erhält.  Sie müssen sich also keine\nGedanken über irgendwelche Unordnungsaspekte machen und es geht\nwirklich schnell.  Das schaffst du in\nwenigen\nMinuten, selbst unter den schlechtesten Bedingungen.\nNormalerweise dauert es weniger als eine Minute, und vor\nallem pausiert man nur etwa\n30 Sekunden, um die Gewichte in der\neigentlichen Inferenz zu ändern.  Außerdem wurde\ndas Bandbreitenvolumen des\nClusters vollständig ausgelastet, indem sowohl Upload\nals auch Download aufgeteilt wurden.\nMan kann also all diese Systemtricks anwenden,\num den Stand zu Fall zu bringen.  Es ist zwar ziemlich\nkomplex, aber man kann\nes abstrahieren und es so gestalten, dass es den\nTrainingsalgorithmus nicht beeinträchtigt.\nAndererseits hat man die Möglichkeit, die Daten zu\nverteilen und andere Cluster dafür zu nutzen. Das widerspricht der gängigen\nMeinung zur\nInfrastruktur für Reinforcement Learning. Bisher ging man davon aus, dass man einen\nriesigen\nCluster mit RDMA verbindet, was sehr\nteuer ist.\nMan würde wahrscheinlich einen Server für das\nTraining und zwei für die Inferenz verwenden. Sicher, bei einem\nsehr teuren Netzwerk ist\nes einfacher, ein\nTerabyte schnell zu kopieren. Aber jetzt haben wir einen\ndreimal so großen Cluster. Wenn die\nInferenz-Engine optimiert ist,\nspart man ohnehin ein Drittel der\nGPUs, weil man\neffizienter arbeitet. Man kann die\nHälfte des Clusters auf\ngünstigerer\nHardware in einer anderen Region betreiben, wodurch die\nKosten deutlich sinken.\nIch finde es toll, dass ihr beim\nBeschreiben so grinst, denn es ist einfach genial.\nDas ist so schwierig, und das ist doch wie der\nTraum eines jeden Systemingenieurs, oder?  Und deshalb ist es einfach so, als ob\nihr da ein wirklich fantastisches System hättet.\nWir haben viele Nächte daran gearbeitet\n.\nJa, ihr seht so aus, als hättet ihr sehr viel\nZeit miteinander verbracht.  Wie wäre es damit, dass\nSie am Anfang erwähnt haben,\ndass Kimmy ein sehr großes, spärlich bestücktes Model ist?\nMacht das den RL-Lauf in irgendeiner\nWeise komplizierter?\nMhm.  Ja.\nWie so?\nNun, wenn man Inferenz betreibt, macht man im\nWesentlichen so etwas wie einen Vorwärtsdurchlauf, der im Prinzip wie eine\nautoregressive Methode funktioniert.  Und\nin diesem Vorwärtsdurchlauf werden die\nLogarithmen der Wahrscheinlichkeiten der Tokens, die es\nabgetastet hat, erzeugt.  Wenn wir die\nGenerationen des Modells an den\nTrainer zurücksenden, müssen wir diesen Vorwärtsdurchlauf erneut durchführen,\nda wir, wie bereits erwähnt, ein\nasynchrones Training durchführen.  Das\nModell, das den Pass erzeugt hat,\nwar möglicherweise einige Schritte\nhinter dem aktuellen Stand des Trainers zurück, daher\nmüssen wir diesen Vorwärtspass erneut ausführen und die\nLog-Wahrscheinlichkeiten reproduzieren.  Das\nProblem besteht nun darin, dass diese Log-\nWahrscheinlichkeit theoretisch genau gleich sein sollte,\nwenn es sich um dieselbe Modellversion handelt, aber selbst\nbei gleicher Modellversion erhält man\nleicht oder manchmal sehr unterschiedliche Log-\nWahrscheinlichkeitswerte für dieselben Token.\nDies wird daher oft als eine Art\nnumerische Diskrepanz für Schlussfolgerungen bezeichnet.\nDas hört man heutzutage ständig beim Thema\nMixing.\nUnd warum ist das so?  Warum passiert das?  Ich\nmeine vor allem deshalb, weil die\nGleitkommaarithmetik,\ndie hier angewendet wird, grundsätzlich nichtdeterministisch ist.\nAlso, falls Sie es\nbedauern: Gleitkommaarithmetik ist\nnichtdeterministisch.\nWir haben also diesen Code gelernt, der besagt, dass,\nwenn man a + b + c nimmt,\nund auch c + b + a, das\nErgebnis dasselbe ist.\nWenn man das mit\nganzen Zahlen auf dem Computer macht, dann trifft das\nimmer zu.\nWenn Sie mit\nGleitkommazahlen arbeiten, die eigentlich nur Näherungszahlen sind, dann\nhaben Sie so etwas wie Mantis und Exponent usw.\na plus b plus c und c plus b plus a werden\nIhnen unterschiedliche Ergebnisse liefern,\noder sogar a plus b und b.  Im Grunde geht es also um die\nReihenfolge der Akkumulation aller\nOperationen, die Modelle durchführen, also im Grunde\nMultiplikationen und Additionen, und die\nReihenfolge der Additionen ist für das\nEndergebnis wichtig.  Es sind alles nur kleine\nUnterschiede, die sich aber\ndurch Millionen und Milliarden von\nOperationen enorm verstärken.  Wenn man also Inferenz von\nModellen durchführt, spielt das normalerweise keine so große Rolle,\nda man sein Modell vortrainiert und es dadurch\neigentlich ziemlich robust ist.  Wenn du\nein paar Teile umdrehst, wirst\ndu trotzdem gute Ergebnisse erzielen.  Ihr\nMaßstab wird sich nicht ändern.  Aber\ngerade bei ARL, weil man\ndieses sehr, sehr schwache Signal verwendet, um\ndas Modell zu trainieren, kann das Rauschen aufgrund dieser numerischen\nUnterschiede über Erfolg oder Misserfolg des\nTrainings entscheiden.  Und das ist besonders\nwichtig.  Und auch hier handelt es sich wieder um eine\ninteressante Schnittstelle zwischen\nalgorithmischem und systemtechnischem Bereich, denn\nman kann zwar ein wunderschönes Durcheinander programmieren, aber\nin der Praxis funktioniert es einfach nicht.  Es\ngibt Möglichkeiten, diesen\nUnterschied nahezu auf null zu reduzieren.  Es\ngibt immer Batch-invariante Wege, im\nGrunde kann man sehr, sehr sorgfältig vorgehen\nund alle GPU-Kernel so schreiben, dass sie die\nZahlen immer in der gleichen Reihenfolge addieren.\nMan rechnet also immer a + b + c, und\nzwar in der gleichen Reihenfolge.  Äh, das ist möglich,\naber es hat immer seine Schattenseiten, richtig?\nIm Grunde wird Ihr System dadurch etwa\n2- bis 3-mal langsamer.  Es\nentsteht erneut ein interessanter Kompromiss, etwa die Frage:\nWelche 10 % Verlangsamung\nkönnen wir in Kauf nehmen, oder in der Praxis tatsächlich welche wenigen %\nVerlangsamung können wir hinnehmen, um 90 %\ndieser Differenz auszugleichen?  Das ist der\nrichtige Kompromiss, den wir\ngemeinsam durch Iteration finden. Sie\nerwähnten, dass\nSparity besonders schwierig ist. Der Grund dafür ist, dass man die\nAktivierungen jeder Ebene nimmt und sie durch eine\nGating-Ebene leitet.\nMan entscheidet dann: „Okay, für dieses\nToken wähle ich von 384\nExperten acht aus.“ Das führt zu einer Art Durcheinander,\nund die acht besten Ergebnisse – diese acht\nExperten werden\naktiviert, die anderen nicht.\nDiese Operation verstärkt\nkleine numerische Unterschiede erheblich,\ndenn vielleicht unterscheiden sich die Hidden States nur um die\nfünfte Stelle\nnach dem Punkt. Das ist eigentlich egal, aber dieser\nUnterschied führt dazu, dass man Experte Nummer\nsieben anstelle von Experte Nummer neun\nals eine Art Trennlinie auswählt und plötzlich einen völlig\nanderen Teil des Modells aktiviert. Dadurch wird der\nUnterschied stark verstärkt, und\nmeine Modelle reagieren definitionsgemäß sehr\nempfindlich auf solche Diskrepanzen, insbesondere bei der\nInferenz. Bei\nnormalen Berechnungen spielt das\nim Durchschnitt normalerweise keine Rolle, aber wenn man …  Der\nVersuch, das Basismodell zu lernen,\nist enorm, da Ihre\nInferenz Expertennummer sieben aktiviert hat und\nSie nun während des Trainings versuchen,\nExpertennummer neun zu aktualisieren, die\nwährend der Inferenz gar nicht dazu beigetragen hat\n.\nHabt ihr also die GPU-Kernel selbst geschrieben, um\ndieses Problem zu umgehen?   Ja\n.  Man kann also einen\nGroßteil dieses Durchsatzes angehen, wobei es immer einen\nKompromiss gibt. Speziell für mich gibt es\ndiesen interessanten Trick, den man\nRouter Replay nennt. Im Grunde\nkann die Inferenz\nzusätzliche Informationen an das Training weitergeben und sagen: „\nHey, ich habe Experte 7 für dieses\nToken aktiviert.“ Diese winzige\nInformation ist nur eine Ganzzahl, die besagt: „\nOkay, das ist der Experte, den\ndu aktiviert hast.“ Der Trainer kann sich daran anpassen.\nDiese numerische\nAusrichtung besteht im Wesentlichen aus\nTricks wie dem Anpassen von Quantisierungsstufen,\nKernels usw., um\ndie Divergenz zwischen Trainings- und\nInferenzimplementierung zu verringern. Das\nmacht einen großen Unterschied: Der\nLauf kann entweder komplett divergent sein\noder weniger\nrecheneffizient, da man viel mehr\nDaten benötigt, um diese Diskrepanz auszugleichen.\nIch würde gerne etwas mehr\nüber die RL-Methode sprechen. Können Sie\netwas über das von Ihnen\nverwendete Belohnungssignal sagen? Oder können Sie es nicht sagen? Okay, ich kann es nicht\nsagen, verstanden, streng geheim.\nOkay, das ergibt Sinn. Es scheint so etwas wie\ndas\nÄquivalent zum Lernen in der Simulation zu geben.\nSimulierte Rollouts im Vergleich zu der Tatsache, dass man über\nso viele tatsächliche Nutzerdaten verfügt, aus denen man\nlernen könnte, warum nicht einfach RL mit den\ntatsächlichen Nutzerdaten und dem\ntatsächlichen Nutzer-Harness durchführen, anstatt dies in einer\nSimulation zu tun?\nJa, das machen wir auch, das\nnennen wir Echtzeit-RL.\nOkay,\nund wir verwenden dieselbe Technologie, um\ndie Inferenzgewichtung mit\nFireworks zu synchronisieren. Dazu finden wir\nNutzersignale, die zeigen, ob der Nutzer mit einer bestimmten Modellgeneration zufrieden oder unzufrieden war,\nund wir können dieses Modell\nlive aktualisieren und so\nalle paar Stunden kontinuierlich eine neue Version des Modells ausliefern.\nWir arbeiten daran, diese Zeit zu verkürzen.\nTatsächlich müssen wir\ndiese Zeitspanne irgendwann verlängern, da der\nZeithorizont des Modells immer\nlänger wird.  Wir müssen diese Frist erneut verlängern\n.  Es ist wie ein interessantes Theaterstück:\nMomentan versuchen wir, die\nZeit bis zur Stabilität zu verkürzen, weil wir\ndie richtigen Hyperparameter ermitteln mussten,\nund nachdem wir sie ermittelt haben,\nmüssen wir das Ganze wieder verlängern, nur weil\nwir den Zeithorizont dieser Modelle ausdehnen wollen\n.  Ja.\nMüssen Sie so etwas wie ein\nVortraining mit simuliertem Reinforcement Learning durchführen? Sie haben doch\nso viele tatsächliche Benutzerdaten, die doch viel\nwertvoller für das\nTraining und die Feinabstimmung sind.  Warum nicht gleich\nzum Online-RL-Schritt übergehen?  Warum,\nwarum muss man das Offline-\nRL machen?\nDas Online-RL ist derzeit ziemlich\nineffizient.  Wir leiden unter dem Problem,\ndass die GPUs im Wesentlichen für lange Zeit offline sind,\nund darüber hinaus gibt es auch\nverschiedene Kompromisse sowohl in Bezug auf die\nEffizienz als auch auf die Benutzererfahrung.  Ja,\nwenn man eine Simulation durchführt, macht man tatsächlich\nmehrere Rollouts von derselben Eingabeaufforderung aus,\nrichtig?  Man nimmt einem Modell eine Aufgabe und\nbittet es, 16 Versuche für diese Aufgabe zu unternehmen\noder beispielsweise 128 Versuche für verschiedene\nRollouts derselben Aufgabe.  Manche werden\ngut laufen, manche\nnicht.  Durch die Durchführung\nmehrerer paralleler Rollouts\nerhält man ein wesentlich präziseres\nSignal.  Vielleicht ist das Modell, wie Sie wissen,\nsehr gut und funktioniert in 90 %\nder Fälle einwandfrei, vielleicht ist es aber auch nicht sehr gut.\nVerluste wie GRPO, wie Gruppenrichtlinien-\nGradienten, die durch die\ngleichzeitige Durchführung mehrerer Rollouts entstehen.  Wenn\ndu online vorgehst, gibt es nur einen\nRollout, und daher musst du verschiedene Abwägungen treffen, z. B.\nwie du es algorithmisch umsetzt.\nUnd vor allem: Wenn ein\nsimulierter Rollout fehlschlägt, ist das nicht\närgerlich. Du musst dann\nvielleicht etwas Zeit auf die GPU verwenden. Wenn\nes sich um einen echten Nutzer handelt, sind die Anforderungen viel\nhöher, da du im\nPrinzip einen A/B-Test durchführst.\nWenn das Modell also etwas Ungewöhnliches produziert,\nist das eine schlechte Nutzererfahrung.\nOkay, bei simulierten Nutzern kannst du\nhäufiger von den Richtlinien abweichen, weil du\nmit\nungewöhnlichen Dingen experimentieren kannst, ohne die Nutzererfahrung zu beeinträchtigen.\nDu kannst viel mehr Rollouts durchführen,\nGPO nutzen\nund so quasi ein gewisses\nLeistungsniveau erreichen,\ndas gut genug ist, um es\nNutzern zu präsentieren.\nWir trainieren das logische Denken im Offline-Modus, der\neigentlich\nOnline-Offline genannt wird. Es ist eher eine DPO-\nTechnik, die die\nOnline-Verhaltenssteuerung verstärkt. Dort bringen wir\ndem Modell das logische Denken bei und geben ihm\nInput für das erwartete Verhalten\n.  Wir versuchen, dem System neue\nInformationen über die Welt zu vermitteln und ihm den\nUmgang mit Tools beizubringen, bevor wir es dann\nfür die Benutzer freigeben. Denn man kann sich vorstellen:\nWenn das Modell schlecht ist, wollen die Benutzer\nes nicht benutzen und werden uns auch kein\nFeedback geben, richtig?  Das Modell muss also\ngewisse Anforderungen erfüllen, um überhaupt\nin den Online-Schienenverkehr aufgenommen zu werden.  Wir möchten, dass\ndas Modell wirklich zufriedenstellend ist, und genau dieses\nModell liefern wir aus.  Das ist gewissermaßen das\nParadoxon des Online-Eisenbahnverkehrs, oder wie wir\nes gerne nennen: Echtzeit. Wir können damit\ndas\nModell nicht von Grund auf neu erstellen, denn die Benutzer müssen\ndas Modell ja bereits nutzen, es muss also schon\ngut sein, und wir können es nur noch\nverbessern.  Ja.   Ja\n.  Das ist sozusagen das i-Tüpfelchen, um\ndiese überaus angenehme\nErfahrung bei den Sitzungen zu machen.  Hoffentlich wird\nes eines Tages so groß wie eine riesige Kirsche sein, wissen Sie?   Ja\n.   Ja\n.  den Dan Roberts\nletztes Jahr auf unserer Konferenz vorgestellt hat.  Ich glaube, du warst\ndabei.  Es ist wie früher, als es den\ngroßen Kuchen und die kleine Kirsche gab.\nKirsche.  Ja.\nKleiner Kuchen.  Große Kirsche.   Ja.   Mich\ninteressiert die Aussage von Andre Karpathy, dass\nRL im Moment immer noch\nextrem ineffizient ist.  Man macht einen langen, ausgiebigen\nInformationsaustausch und bekommt dann\nam Ende nur noch ein paar wenige Informationen – es ist immer noch so, als würde man nur\nBruchstücke durch einen Strohhalm schlürfen.   Was\ndenken Sie?  Und haben Sie\nherausgefunden, wie man auf\ndiesem Weg noch mehr Bits gewinnen kann?  Äh, darüber kann ich nicht sprechen\n.\nOkay.  Okay.  Habe es.  Wir sind wieder bei\nden geheimen Angelegenheiten.  Gut.  Daran\nerkenne ich, dass ich die richtigen\nFragen stelle.\nSie erwähnten, dass die Rollouts jeweils einige\nMinuten dauern.  Es scheint, als ob die\ngesamte Branche darauf abzielt,\nLangzeitagenten zu entwickeln, Agenten, die\nüber einen langen Zeitraum\nununterbrochen und im Allgemeinen\nausfallsicher arbeiten können.  Ich liebe diese Skala für Meter\n.  Welche Maßnahmen werden im RL-\nProzess ergriffen, um die Laufzeit des Agenten zu\nverlängern?\nMehrere Dinge.  Ein Problem beim\nReinforcement Learning ist also,\ndass die Zuordnung von Punkten umso schwieriger wird, je länger die Trajektorie ist\n.\nMan kann sich das so vorstellen, als würden wir\ndem Bundle am\nEnde seiner Arbeit einen Daumen hoch oder Daumen runter geben, und um\ndas Problem etwas zu vereinfachen,\nfragt sich das Modell quasi selbst: „Okay, wo habe ich es\nrichtig gemacht und wo habe ich es falsch gemacht?“ Das ist im\nGrunde das Problem, das man Cray-\nZuweisung nennt.  Je\nlänger das dauert, desto schwieriger wird es.  Man muss also eine ganze Reihe von\nTricks anwenden.  Das andere Problem ist, dass\neinem einfach der Platz ausgeht, richtig?\nDiese Modelle haben beispielsweise ein begrenztes\nKontextfenster und werden dieses irgendwann\nerreichen.  Um das Problem\nam Cursor zu lösen, fügen wir die\nKomprimierung innerhalb der Schleife ein.  Wir\nnennen dies also Selbstzusammenfassung.  Beim\nReinforcement Learning lernt der Agent also\ntatsächlich, wie er fortfährt und\nimmer weitermacht.  In der Praxis ist unser Modell also\nwie ein\nKontextfenstermodell mit 200.000 Elementen, aber in Wirklichkeit\nkann es Millionen von Token verarbeiten.\nGenau wegen dieser Fähigkeit kann es\nseine Arbeit zusammenfassen und diese Zusammenfassung dann nutzen, um\nsein Kontextfenster neu zu starten,\nwährend es weiterhin versucht, die Aufgabe zu erfüllen.\nDadurch wird das\nModell dazu angehalten, die Dinge gleichzeitig korrekt in Richtung\ndes Ziels zu tun. Wir\ntrainieren das Modell also gleichzeitig darauf, eine gute Zusammenfassung zu erstellen,\nund wir trainieren das\nModell gleichzeitig darauf, diese Zusammenfassung sehr gut zu verstehen\n.  Ähm, und das\nist also gewissermaßen eine Fortsetzung der\nArgumentation.  Ich finde es\nfaszinierend, denn äh, ich meine, normalerweise wird\nKontextmanagement als Teil\nder Schwierigkeit betrachtet, richtig?  In diesem Fall\noptimieren Sie effektiv gemeinsam, indem Sie\nbeispielsweise die Härte und das Modell\nselbst miteinander verknüpfen und all das\nin den Optimierungsprozess einbeziehen.  Und das haben wir\nbei KI immer wieder gesehen: Je\nmehr Probleme man Computern stellt\n, desto besser lassen sie sich von\nAnfang bis Ende lösen.  Die Magie, aus\nbitteren Lektionen zu lernen, funktioniert und man\nerhält ein viel besseres System, das zusammenarbeiten kann\n.\nVöllig.  Völlig.  Glauben Sie, dass jedes\nUnternehmen seine\neigenen Gurte herstellen wird?  Glaubst du zum Beispiel, dass\njedes Unternehmen das gleiche\nProblem wie der Cursor hat?\nWenn sie KI einsetzen und beispielsweise\nviele Token produzieren und ein\nProdukt haben, das sie optimieren können, dann denke ich, dass es der\nrichtige Schritt und die\nrichtige Richtung ist, Modelle zu trainieren.   Ja\n.  Ja.  Interessant.  Interessant.\nÄhm, und so scheint es, als ob der größte Teil des\nReinforcement Learnings, das ihr damals durchgeführt habt, eher auf die\nVerwendung des Harness-Tools ausgerichtet war als darauf, gut darin zu werden,\ndas nächste Token für den\nCode zu vervollständigen.  Ist das in etwa das Muster, das\nandere Gründer im Hinterkopf behalten sollten, wenn\nsie darüber nachdenken, wo sie\nReinforcement Learning einsetzen sollten?\nWenn Sie also beispielsweise einen Agenten dazu bringen wollen,\nAufgaben mit Tools über einen längeren\nZeitraum auszuführen, benötigen Sie Reinforcement Learning.  Wenn Sie\nein Modell erstellen möchten, das gut in\nZusammenfassung, nächstem Token oder\nÄhnlichem ist, benötigen Sie wahrscheinlich kein Reinforcement Learning.  Ist\ndas ein guter Rahmen für Situationen, in denen\nReinforcement Learning benötigt wird?\nIch glaube, RL passt überall hin.  Also, selbst bei\nTabs verwenden wir persönlich dies nur als\nmeine Theorie und sie ist durch\nnichts untermauert.  Wenn man ein Modell vortrainiert, befinden sich\ndie Modelle gerade erst dabei,\ndas gesamte menschliche\nWissen aufzunehmen.  Nehmen wir an, Sie trainieren ein\nModell für Mathematik.  Das Modell\nlernt sozusagen die gesamte Mathematik der Börse.\nWenn das Modell mit einem\nmathematischen Problem konfrontiert wird – und dieses Modell hat noch\nkeine reale Erfahrung gemacht –,\nmuss es sich fragen, was für eine Art Mensch es eigentlich\nist.  Ist es der Experte oder der\nSchüler, der lernen will?  Und\nich glaube, dass\ndabei unter anderem Folgendes passiert: Wir justieren diesen Regler und\nsignalisieren dem Modell damit: „Hey, du bist der\nExperte, du musst die Dinge richtig machen.“\nEine Sache, die dabei passiert, ist, dass\nwir diese Verteilung gewissermaßen schärfen, wobei es sich um eine Verteilung mit mehreren\nPhasen handelt.  Es\ngibt also die allererste Phase, in der das\nModell lernt und sehr schnell sehr gut wird,\nund dann gibt es eine zweite\nPhase, in der viel\nRechenleistung benötigt wird, um das Modell kontinuierlich zu verbessern,\nund wie Sie sehen, beginnt das Modell zu\nschlussfolgern und dieses Muster zu erkennen.  In\nder ersten Phase der Kurve geht es also darum,\ndem Modell die richtigen Parameter zuzuweisen und ihm mitzuteilen, dass es bestimmte\nDinge korrekt ausführen soll. Gerade bei\nkleinen Rechenressourcen ist es sehr hilfreich,\ndem Modell zu signalisieren, dass es\nkorrekt arbeiten muss. Das ist in etwa\nmein Fall.\nZweitens\nsehen wir dieses Muster in vielen Anwendungsfällen.\nWir haben beispielsweise das RL-Feintuning\nfür viele Kunden optimiert. Dabei kommt in der Regel ein\nkontinuierliches\nVortraining zum Einsatz. Das\nreguläre überwachte Feintuning\nvereinfacht die\nWissensübertragung auf abstrakte Weise, während\nRL das\nVerhalten oder bestimmte gewünschte Eigenschaften\ndes\nModells verfeinert. Meistens benötigt man\nbeides. Auch bei Ihrem Beispiel der\nZusammenfassung kann RL\nsehr nützlich sein, da es manchmal darum geht, einen\nbestimmten Stil der\nZusammenfassung zu erzielen. Es ist schwierig,\nBeispiele für gute\nund schlechte Zusammenfassungen zu finden und\ndiese präzise zu beschreiben. Wenn\nman beispielsweise ein Sprachmodell als Kriterium verwendet, …\nMan kann tatsächlich sehr präzise Rubriken festlegen, sozusagen vorgeben, wie man eine\ngute Zusammenfassung bewertet. Dann gibt man das in eine RL-Schleife ein und\nlässt das Modell mit\nverschiedenen Zusammenfassungsstilen experimentieren, um\nherauszufinden, was man eigentlich will. Gleichzeitig\nbewertet vielleicht ein anderes LLM,\nob die Zusammenfassung einer bestimmten Rubrik entspricht\noder nicht. Das ist ein\nMuster, das man häufig sieht, nicht nur beim\nProgrammieren.\nOkay, ich werde diese Frage\nDimma stellen, weil Fed Rico sich auf\nden fünften Verfassungszusatz berufen wird.  Ähm, Sie haben\nLLM schon ein paar Mal als Richter erwähnt.\nGlauben Sie, dass Unternehmen letztendlich\nerfolgreicher sein werden, wenn Experten die\nEinführung von RL manuell prüfen und\ndas Modellverhalten in gewisser Weise manuell coachen,\noder glauben Sie, dass LLM oder andere\nautomatisierte Bewertungskriterien uns eher\ndorthin bringen werden?\nSie möchten doch nicht wirklich Experten\ndirekt in die Beurteilung von Produkteinführungen einbeziehen.  Ich\nmeine, das wäre so etwas wie\nEchtzeit-RL, wenn es tatsächlich Nutzer wären,\noder so etwas wie\nRLF für DPR. Generell gilt: Je\nüberprüfbarer die Belohnung ist, desto besser,\nweil man dadurch die\nRechenleistung skalieren und in manchen Fällen bessere Ergebnisse erzielen kann. Überprüfbar\nbedeutet im Grunde, ob man\nes automatisch ohne menschliches Zutun erzeugen kann.\nWenn es sich um Massenproduktion oder Programmierung handelt und\nman etwas sehr Deterministisches erstellen kann, ist das natürlich\noptimal. Der Grund,\nwarum LMZ als Judge funktioniert, ist, dass es eine\nArt\nGenerator-Diskriminator-Unterscheidung ist, wodurch die\nBeurteilung viel einfacher wird.  Ich meine, das Gleiche gilt doch auch\nfür Menschen, oder?  Es ist einfacher, ein Venture Capital zu\nbeurteilen, als eines zu gründen\n.   Ja\n.  Nein, das hat keinerlei Implikation.  Aber\nja, es ist viel einfacher zu beurteilen, und man\nkann genau die verschiedenen\nKriterien festlegen, nach denen man eine Antwort bewerten möchte,\nund man sieht dann dieses Muster, wo man möglicherweise eine\nsehr komplizierte Bewertung aus\nmehreren Blickwinkeln hat, richtig?  Denn wenn man zu\nviele Aspekte auf ein einziges LM überträgt,\nkönnte es schwierig werden, die richtige Beurteilung zu finden,\nrichtig?  Vielleicht könntest du es ja auch aufschlüsseln.\nOkay, Sie werden die Bewertungskriterien anhand des\nStils und\nverschiedener Aspekte wie der\nFaktentreue anpassen, um die\nBelohnungen optimal zu gestalten.  Einige davon sind die\nGenies, einige basieren auf BLM, und das\nbestimmt das Verhalten Ihres Modells. Dann\nschalten Sie einfach weitere Berechnungen ein und\nsehen zu, wie der Graph nach oben geht.\nGlauben Sie, dass RL\nin den schwieriger zu\nverifizierenden Bereichen effektiver sein wird?  Sind Sie der Meinung, dass ein LLM-Abschluss für\nRichter ausreichend ist?  Das ist eine der\nTechniken, mit denen man\nidealerweise anfängt, herauszufinden,\nwas das tatsächliche Ergebnis ist, welche\nKennzahl man erreichen möchte. Eine Möglichkeit ist,\ndies zu approximieren, eine andere,\ngrößere simulierte\nUmgebungen zu erstellen.\nWenn man mehr vom Produkt oder der\nUmgebung simulieren kann, hat man in der Regel die finale\nKennzahl, die einem wichtig ist. Sie ist nur\nschwieriger zu erfassen. Wenn man herausfindet,\nwie man sie erfasst, ist das großartig. Und was\nIhre Anmerkung zu Experten betrifft:\nExperten werden nach wie vor benötigt,\ndenn die Gestaltung dieser Aufgabe kann\ndas gewünschte Produkterlebnis tatsächlich kodieren, und genau darauf kommt es an.\nWir haben die\nSoftware-Versionen 1.0, 2.0 und 3.0 durchlaufen, richtig?\nWeil die Software direkt entwickelt wird.\nWir begannen mit der Erstellung von Trainingsdaten.\nRechts?  Jetzt erstellen Sie im Grunde\ndie Bewertungsregeln.  Aber das ist trotzdem\nsehr wichtig.  Du musst dir\nBeispiele ansehen.  Sie müssen sich die Daten ansehen.\nSie müssen analysieren, wo Ihr\nProdukt Schwächen aufweist und wie Sie das Modell\nin die richtige Richtung lenken können, um das gewünschte Verhalten zu erzielen.\nIch möchte eine Frage zu RL-Umgebungen stellen,\ndie vielleicht mit dem zusammenhängt, worüber Sie\ngesprochen haben.  Es scheint, als hätte es\neine regelrechte Explosion gegeben, und zwar hinsichtlich der\nUmsatzzahlen, die einige dieser RL-\nUmgebungsunternehmen erreichen.\nWas bieten sie an, das tatsächlich\nnützlich ist?  Denn ich denke, bei Cursor zum\nBeispiel hat man so viele Daten darüber,\nwie die Kunden die Umgebungen tatsächlich nutzen\n.  Was\nbieten Ihnen die Anbieter von RL-Umgebungen zusätzlich\nzu dem, was Sie bereits haben?\nJa, wir nutzen tatsächlich keinen der\nAnbieter von Umgebungssoftware.  Ich denke schon, es ist\nsehr schwierig, Arbeitsumgebungen zu schaffen\n.  Es ist ein wertvolles Produkt\nfür Menschen, die keinen Zugang dazu haben\n.  Allerdings gibt es,\ninsbesondere im Bereich des Programmierens, eine sehr große\nAnzahl an Arbeitsumgebungen, die\njedem zur Verfügung stehen.  Das ist GitHub,\nrichtig?  Man kann da reingehen und vielleicht so\nein Modell haben, bei dem man einfach alle\nAbhängigkeiten für ein Repository installiert, und\ndas ist dann so eine Art Arbeitsumgebung.  Ich\nglaube, ein Großteil der Schwierigkeiten rührt\nauch von der Infrastruktur her.  Man kann sich also\nvorstellen, dass eine Umgebung, die\nfür eine bestimmte Aufgabe gut funktioniert,\nmöglicherweise bestimmte Dienste benötigt.  Wenn Sie beispielsweise\neine Änderung vornehmen, etwa eine\nDatenbankmigration, um zu testen, ob diese\ntatsächlich funktioniert, benötigen Sie die\nDatenbankanwendung. Solche Dinge\nsind sehr knifflig. Ich denke, diese\nEntwicklungsumgebungen sind dabei sehr\nhilfreich.\nEs gibt im Grunde zwei Aspekte: Erstens,\nwenn man sich\nFrontier Labs ansieht, versuchen sie, ein\ngenerisches Modell zu entwickeln, das für alles gut ist.\nSie müssen also\nall diese verschiedenen Aufgaben\nin einem einzigen Modell zusammenfassen und dessen\nGeneralisierung fördern.\nÄh, das ist also ein\nTeilaspekt, und der ist sehr hilfreich,\nrichtig? In Fällen wie Composer\nhaben Sie Ihr eigentliches Produkt, richtig?\nUnd ich denke, das ist auch die\nÜberzeugung von Fireworks: Wenn Sie\nIhr eigentliches Produkt haben, sollten Sie damit gut zurechtkommen.\nDie leistungsstärkste Umgebung ist Ihr\neigenes Produkt,\ngenau weil dort Ihr\nModell tatsächlich verwendet wird. Und\nnatürlich, wenn Sie Frontier Lab haben, werden\nSie das nicht für alle\nProdukte tun, richtig? Aber wenn Sie\nversuchen, das beste Modell für Ihr\nProdukt zu erstellen, es zu spezialisieren und anzupassen,\nsollten Sie einfach Ihre Produktionsumgebung verwenden.\nNatürlich möchten Sie\ndiese ordnungsgemäß isolieren, richtig?  Sie\nwollen ja nicht, dass Ihr Modell durch einen Wreck-Vorfall Ihre\nProduktionsdatenbank beschädigt.  Sie möchten\nes klonen usw. Und es gibt einige\nTools von IT-Unternehmen, die sich mit IT-Umgebungen und\nallgemeiner Infrastruktur befassen und\ndies erleichtern.  Generell ist es aber wünschenswert, dass\nIhre RL-Umgebung so nah wie\nmöglich an der realen Produktion ist.\nUnd genau das wissen Sie ja, zum Beispiel\nsehen wir es so: Wenn man sich so einfache\nRL-Beispiele, so einfache Frameworks ansieht, dann fängt es immer so an: „\nOh, da ist diese Art von\nSpielzeugumgebung.“  Und ich werde einen\nDocker-Container starten und alles\ndarin ausführen, was sich hervorragend für einfache Beispiele eignet,\nwenn man einem Modell beibringen möchte, wie man\nAtario spielt oder so, richtig?  Wenn\nSie aber tatsächlich in den\nProduktionsbetrieb übergehen, können Sie\nIhre echte Produktionsanwendung nicht einfach in\nden Docker-Container packen.  Und wir haben das\nselbst ziemlich früh herausgefunden, zum Beispiel durch die Zusammenarbeit mit\nManifox, wie im Fall des Corser-Trainers\nauf deren Seite.  Bei einigen anderen Kunden\nbetreiben wir den Trainer auf unserer Trainingsplattform, aber\nin Umgebungen führen wir\nihn standardmäßig auf Kundenseite aus,\nda dort die eigentliche\nImplementierung stattfindet und man im\nGrunde die gleiche Trainerkonfiguration hat,\negal ob sie Teil der Fireworks-\nPlattform ist oder auf Kundenseite stattfindet und\ndie eigentliche Produktionsumgebung aufruft, anstatt\nsie zu verpacken und zu\nkomponentisieren.   Ja\n.\nAuf der gehosteten Plattform, weil\ndas wirklich schwierig ist und dadurch\nUnterschiede entstehen.   Ja\n.  Ich meine, das, was wir als\nUmgebung bezeichnen, besteht eigentlich aus drei Komponenten.   Das\neine ist der Gurt.  Das Harness ist also so etwas wie der Ort, an dem\ndas Modell Werkzeuge übermitteln kann, die dann\nausgeführt werden, und das\nzweite ist, nennen wir es mal eine Art\nBetriebssystem, richtig?\nWas ist also die eigentliche Welt, der\nZustand, mit dem das Modell\ninteragiert? Und dann gibt es noch\ndie Belohnungskomponente, die wir benötigen, um am\nEnde zu überprüfen, ob die Arbeit\nkorrekt ausgeführt wurde. Im Allgemeinen ist das Harness\nziemlich portabel.  Das\nGeschirr kann in vielen verschiedenen\nUmgebungen eingesetzt werden.  Entscheidend ist\ndas Betriebssystem, und um\ndies nachzubilden, reichen normale Container nicht wirklich aus\n.  Bei Cursor haben wir also einen\nkompletten Virtual-Machine-Stack entwickelt,\nsodass wir virtuelle\nMaschinen extrem schnell starten können. Das muss\nextrem schnell gehen, denn stellen Sie sich vor:\nWir bitten das System,\njetzt 100.000 virtuelle Maschinen bereitzustellen, und\nsie müssen alle sofort verfügbar sein.\nJa,\nfantastisch! Ich habe das heutige\nGespräch sehr genossen. Ich finde, Cursor ist eine große\nInspiration für das, was Sie\nals Unternehmen tun, um sich von einem\nAnwendungsunternehmen zu einem wirklich zukunftsweisenden\nLabor zu entwickeln. Und ich denke, Ihre Arbeit\nmit Composer 2 ist dabei wegweisend\n.  Es ist wirklich etwas Besonderes, davon zu hören\n.  Und dann Dimma, es war wirklich toll,\nvon den kniffligen Infrastrukturproblemen zu hören, die\nihr beide\ngemeinsam in den Schützengräben über\nviele, viele späte Nächte hinweg gelöst habt, um das alles\nmöglich zu machen.  Vielen Dank.  Vielen Dank, dass ihr\nheute dabei wart.   Vielen\nDank, dass wir bei Ihnen sein durften.\nDanke schön.",
  "transcript_chars": 54913,
  "ingested_at": "2026-05-26T16:30:59.367500+00:00",
  "source": "channel",
  "yt_meta": {
    "view_count": 719,
    "like_count": 35,
    "channel_id": "UCWrF0oN6unbXrWsTN7RctTw",
    "categories": [
      "Science & Technology"
    ],
    "tags": []
  }
}