Serie über Reinforcement Studying (RL), im Anschluss an Suttons und Bartos berühmtes Buch „Reinforcement Studying“ (1).

In den vorherigen Beiträgen haben wir die Analyse von Teil I dieses Buches abgeschlossen, in dem grundlegende Lösungstechniken vorgestellt werden, die die Grundlage für viele RL-Methoden bilden. Diese sind: Dynamische Programmierung (DP), Monte-Carlo-Methoden (MC) Und Zeitdifferenzlernen (TD). Was Teil I von Teil II von Suttons Buch unterscheidet und die Unterscheidung rechtfertigt, ist eine Einschränkung der Problemgröße: Während in Teil I tabellarische Lösungsmethoden behandelt wurden, wagen wir uns nun, tiefer in dieses faszinierende Thema einzutauchen und die Funktionsnäherung einzubeziehen.

Um es konkret zu machen: In Teil I haben wir angenommen, dass der Zustandsraum der untersuchten Probleme klein genug ist, damit wir ihn und auch die gefundenen Lösungen über eine einfache Tabelle darstellen können (stellen Sie sich eine Tabelle vor, die für jeden Zustand eine bestimmte „Güte“ – einen Wert – angibt). Nun geben wir in Teil II diese Annahme auf und sind somit in der Lage, beliebige Probleme anzugehen.

Und dieses modifizierte Setup ist dringend notwendig, wie wir aus erster Hand beobachten konnten: In einem früheren Beitrag gelang es uns, Tic Tac Toe zu lernen, scheiterte aber bereits an Join 4 – da die Anzahl der Staaten hier in der Größenordnung von 10²⁰ liegt. Oder stellen Sie sich ein RL-Downside vor, das eine Aufgabe basierend auf Kamerabildern lernt: Die Anzahl der möglichen Kamerabilder ist größer als die Anzahl der Atome im bekannten Universum (1).

Diese Zahlen sollten jeden davon überzeugen, dass Näherungslösungsverfahren unbedingt notwendig sind. Sie ermöglichen nicht nur die Bewältigung solcher Probleme, sondern bieten auch eine Verallgemeinerung: Bei tabellarischen Methoden wurden zwei nahe beieinander liegende, aber dennoch unterschiedliche Zustände völlig getrennt behandelt – während wir bei Näherungslösungsverfahren hoffen würden, dass unsere Funktionsnäherung solche nahe beieinander liegenden Zustände erkennen und verallgemeinern kann.

Damit fangen wir an. In den nächsten Absätzen werden wir:

• Geben Sie eine Einführung in die Funktionsnäherung
• Lösungsmethoden für solche Probleme entwickeln
• Diskutieren Sie verschiedene Möglichkeiten für Näherungsfunktionen.

Einführung in die Funktionsnäherung

Im Gegensatz zu tabellarischen Lösungsverfahren, bei denen wir beispielsweise eine Tabelle zur Darstellung von Wertfunktionen verwendet haben, verwenden wir jetzt eine parametrisierte Funktion

mit einem Gewichtsvektor

v kann alles sein, beispielsweise eine lineare Funktion der Eingabewerte oder ein tiefes neuronales Netzwerk. Später in diesem Beitrag werden wir verschiedene Möglichkeiten im Element besprechen.

Normalerweise ist die Anzahl der Gewichte viel kleiner als die Anzahl der Zustände – was zu einer Verallgemeinerung führt: Wenn wir unsere Funktion durch Anpassen einiger Gewichte aktualisieren, aktualisieren wir nicht nur einen einzelnen Eintrag in einer Tabelle – sondern dies hat Auswirkungen auf (möglicherweise) auch alle anderen Schätzungen.

Lassen Sie uns die Aktualisierungsregeln einiger der Methoden zusammenfassen, die wir in früheren Beiträgen gesehen haben.

MC-Methoden weisen die beobachtete Rendite G als Wertschätzung für einen Zustand zu:

TD(0) führt einen Bootstrapping der Wertschätzung des nächsten Zustands durch:

Während DP Folgendes verwendet:

Von nun an interpretieren wir Aktualisierungen der Type s -> u als Enter/Output-Paare einer Funktion, die wir approximieren möchten, und nutzen hierfür Techniken des maschinellen Lernens, insbesondere: Supervised Studying. Aufgaben, bei denen Zahlen (u) geschätzt werden müssen, werden als Funktionsnäherung oder Regression bezeichnet.

Um dieses Downside zu lösen, können wir theoretisch auf jede mögliche Methode für eine solche Aufgabe zurückgreifen. Wir werden dies gleich noch besprechen, sollten aber erwähnen, dass an solche Methoden bestimmte Anforderungen gestellt werden: Zum einen sollten sie in der Lage sein, inkrementelle Änderungen und Datensätze zu verarbeiten – da wir in RL normalerweise im Laufe der Zeit Erfahrungen sammeln, die sich beispielsweise von klassischen überwachten Lernaufgaben unterscheiden. Darüber hinaus sollte die gewählte Methode in der Lage sein, mit instationären Zielen umzugehen – worauf wir im nächsten Unterabschnitt eingehen werden.

Das Vorhersageziel

Im gesamten ersten Teil von Suttons Buch brauchten wir nie ein Vorhersageziel oder ähnliches – schließlich konnten wir immer auf die optimale Funktion konvergieren, die den Wert jedes Zustands perfekt beschreibt. Aus den oben genannten Gründen ist dies nicht mehr möglich und erfordert die Definition eines Ziels, einer Kostenfunktion, die wir optimieren möchten.

Wir verwenden Folgendes:

Versuchen wir, das zu verstehen. Hierbei handelt es sich um eine Erwartung hinsichtlich der Differenz zwischen vorhergesagten und tatsächlichen Werten, die intuitiv sinnvoll ist und beim überwachten Lernen üblich ist. Beachten Sie, dass wir dazu eine Verteilung µ definieren müssen, die angibt, wie wichtig uns bestimmte Zustände sind.

Oftmals handelt es sich dabei einfach um ein Maß, das proportional dazu ist, wie oft Staaten besucht werden – die On-Coverage-Verteilung, auf die wir uns in diesem Abschnitt konzentrieren werden.

Beachten Sie jedoch, dass eigentlich nicht klar ist, ob dies das richtige Ziel ist: Bei RL geht es uns darum, gute Richtlinien zu finden. Einige unserer Methoden können das oben genannte Ziel zwar sehr intestine optimieren, das vorliegende Downside aber dennoch nicht lösen – z. B. wenn die Richtlinie zu viel Zeit in unerwünschten Zuständen verbringt. Dennoch brauchen wir, wie besprochen, ein solches Ziel – und mangels anderer Möglichkeiten optimieren wir dieses einfach.

Als nächstes stellen wir eine Methode zur Minimierung dieses Ziels vor.

Minimierung des Vorhersageziels

Das von uns für diese Aufgabe ausgewählte Werkzeug ist Stochastic Gradient Descent (SGD). Im Gegensatz zu Sutton möchte ich hier nicht zu sehr ins Element gehen und mich nur auf den RL-Teil konzentrieren – daher möchte ich den interessierten Leser auf (1) oder ein anderes Tutorial zum Thema SGD/Deep Studying verweisen.

Aber im Prinzip verwendet SGD Batches (oder Mini-Batches), um den Gradienten des Ziels zu berechnen und die Gewichte einen kleinen Schritt in Richtung Minimierung dieses Ziels zu aktualisieren.

Für diesen Gradienten gilt additionally:

Nun der interessante Teil: Nehmen Sie an, dass v_π nicht das wahre Ziel ist, sondern eine (verrauschte) Annäherung daran, sagen wir U_t:

Wir können zeigen, dass, wenn U_t ein erwartungstreuer Wert von v_π ist, die über SGD erhaltene Lösung zu einem lokalen Optimum konvergiert – praktisch. Wir können jetzt einfach z. B. die MC-Rückgabe als U_t verwenden und unsere allererste Gradienten-RL-Methode erhalten:

Es ist auch möglich, andere Maße für U_t zu verwenden, insbesondere auch Bootstrapping zu verwenden, additionally frühere Schätzungen zu verwenden. Dabei verlieren wir diese Konvergenzgarantien – aber wie so oft empirisch funktioniert das trotzdem. Solche Methoden werden Semigradientenmethoden genannt, da sie nur die Auswirkung der Änderung der Gewichte auf den zu aktualisierenden Wert berücksichtigen, nicht jedoch auf das Ziel.

Auf dieser Grundlage können wir TD(0) mit Funktionsnäherung einführen:

Eine natürliche Erweiterung davon und ebenfalls eine Erweiterung der entsprechenden n-stufigen Tabellenmethode ist die n-stufige Halbgradienten-TD:

Methoden zur Funktionsnäherung

Im Relaxation von Kapitel 9 beschreibt Sutton verschiedene Arten der Darstellung der Näherungsfunktion: Ein großer Teil des Kapitels befasst sich mit der linearen Funktionsnäherung und dem Merkmalsdesign dafür, und für die nichtlineare Funktionsnäherung werden künstliche neuronale Netze eingeführt. Wir werden diese Themen nur kurz behandeln, da wir in diesem Weblog hauptsächlich mit (tiefen) neuronalen Netzen und nicht mit einfachen linearen Approximationen arbeiten und außerdem vermuten, dass der aufmerksame Leser bereits mit den Grundlagen von Deep Studying und neuronalen Netzen vertraut ist.

Lineare Funktionsnäherung

Lassen Sie uns dennoch kurz auf die lineare Approximation eingehen. Dabei wird die Zustandswertfunktion durch das innere Produkt angenähert:

Hier wird der Zustand durch den Vektor beschrieben

– und wie wir sehen können, ist dies ein linear Kombination der Gewichte.

Aufgrund der Einfachheit der Darstellung gibt es einige elegante Formeln (und Darstellungen mit geschlossenem Regelkreis) für die Lösung sowie einige Konvergenzgarantien.

Merkmalskonstruktion für lineare Methoden

Eine Einschränkung der oben eingeführten naiven linearen Funktionsnäherung besteht darin, dass jedes Merkmal separat verwendet wird und keine Kombination von Merkmalen möglich ist. Als Beispiel nennt Sutton die problematische Karrenstange: Hier können hohe Winkelgeschwindigkeiten je nach Kontext intestine oder schlecht sein. Wenn die Stange intestine zentriert ist, sollte man schnelle, ruckartige Bewegungen wahrscheinlich vermeiden. Je näher die Stange jedoch dem Umfallen kommt, desto höhere Geschwindigkeiten sind möglicherweise erforderlich.

Es gibt daher einen separaten Forschungszweig zum Entwurf effizienter Merkmalsdarstellungen (obwohl man argumentieren könnte, dass dies aufgrund des Aufkommens von Deep Studying an Bedeutung verliert).

Eine solche Darstellung ist Polynome. Stellen Sie sich als einführendes Beispiel vor, dass der Zustandsvektor aus zwei Teilen besteht, s_1 und s_2. Wir könnten den Merkmalsraum folgendermaßen definieren:

Dann könnten wir mit dieser Darstellung immer noch eine lineare Funktionsnäherung durchführen – additionally vier Gewichte für die vier neu konstruierten Merkmale verwenden und insgesamt immer noch eine lineare Funktion bezüglich der Gewichte haben.

Allgemeiner gesagt, die Polynombasismerkmale der Ordnung n+1 dargestellt werden kann durch

wobei die cs ganze Zahlen in {0 … n} sind.

Andere häufig verwendete Basen sind die Fourier-Foundation, die Grob- und Kachelkodierung sowie radiale Basisfunktionen – aber wie bereits erwähnt, werden wir an dieser Stelle nicht näher darauf eingehen.

Abschluss

In diesem Beitrag haben wir über die vorherigen Beiträge hinaus einen wichtigen Schritt hin zur Bereitstellung von RL-Algorithmen „in freier Wildbahn“ gemacht. In den vorangegangenen Beiträgen haben wir uns auf die Einführung der wesentlichen RL-Methoden konzentriert, allerdings in Type tabellarischer Methoden. Wir haben gesehen, dass sie bei größeren Problemen schnell an ihre Grenzen stoßen und haben daher erkannt, dass Näherungslösungsmethoden erforderlich sind.

In diesem Beitrag haben wir Grundlagen dafür vorgestellt. Diese Methoden ermöglichen nicht nur die Bewältigung großer, realer Probleme, sondern führen auch die Verallgemeinerung ein – eine wichtige Notwendigkeit für jeden erfolgreichen RL-Algorithmus.

Wir begannen mit der Einführung eines geeigneten Prognoseziels und Möglichkeiten, dieses zu optimieren.

Dann haben wir unsere ersten Gradienten- und Halbgradienten-RL-Algorithmen für das Vorhersageziel eingeführt – das heißt, eine Wertfunktion für eine bestimmte Richtlinie zu lernen.

Abschließend haben wir verschiedene Möglichkeiten zur Konstruktion der Näherungsfunktion besprochen.

Wie immer vielen Dank fürs Lesen! Und wenn Sie interessiert sind, bleiben Sie gespannt auf den nächsten Beitrag, in dem wir uns mit dem entsprechenden Steuerungsproblem befassen.

Weitere Beiträge dieser Serie

Referenzen

(1) http://incompleteideas.internet/ebook/RLbook2020.pdf

(2) https://pettingzoo.farama.org/

Reinforcement Studying – Lernen aus Beobachtungen und Belohnungen – ist die Methode, die der Artwork und Weise, wie Menschen (und Tiere) lernen, am ähnlichsten ist.

Trotz dieser Ähnlichkeit bleibt es auch der komplizierteste und problematischste Bereich des modernen maschinellen Lernens. Um den berühmten Andej Karpathy zu zitieren:

Reinforcement Studying ist schrecklich. Es ist einfach so, dass alles, was wir vorher hatten, viel schlimmer struggle.

Um das Verständnis der Methode zu erleichtern, werde ich ein Schritt-für-Schritt-Beispiel eines Agenten erstellen, der mithilfe von Q-Studying lernt, in einer Umgebung zu navigieren. Der Textual content beginnt mit den ersten Prinzipien und endet mit einem voll funktionsfähigen Beispiel, das Sie in der Unity-Spiel-Engine ausführen können.

Für diesen Artikel sind Grundkenntnisse der Programmiersprache C# erforderlich. Wenn Sie mit der Unity-Spiel-Engine nicht vertraut sind, bedenken Sie einfach, dass jedes Objekt ein Agent ist, der:

• ausführt Begin() einmal zu Beginn des Programms,
• Und Replace() kontinuierlich parallel zu den anderen Agenten.

Das zugehörige Repository für diesen Artikel ist verfügbar GitHub. Alle Bilder stammen vom Autor, sofern nicht anders angegeben.

Was ist Reinforcement Studying?

Beim Reinforcement Studying (RL) haben wir einen Agenten, der in der Lage ist, Maßnahmen zu ergreifen, die Ergebnisse dieser Maßnahmen zu beobachten und aus Belohnungen/Strafen für diese Maßnahmen zu lernen.

Die Artwork und Weise, wie ein Agent in einem bestimmten Zustand über eine Aktion entscheidet, hängt von ihm ab Politik. Eine Politik π ist eine Funktion, die das Verhalten eines Agenten definiert und Zustände Aktionen zuordnet. Gegeben eine Reihe von Zuständen S und eine Reihe von Aktionen A Eine Richtlinie ist eine direkte Zuordnung: π: S → A .

Wenn wir außerdem möchten, dass der Agent mehr mögliche Optionen mit einer Auswahl hat, können wir eine erstellen Stochastische Politik. Dann bestimmt eine Richtlinie anstelle einer einzelnen Aktion die Wahrscheinlichkeit, jede Aktion in einem bestimmten Zustand zu ergreifen: π: S × A → (0, 1).

Beispiel für einen navigierenden Roboter

Um den Lernprozess zu veranschaulichen, erstellen wir ein Beispiel eines navigierenden Roboters in einer 2D-Umgebung und verwenden dabei eine von vier Aktionen: A = {Left, Proper, Up, Down} . Der Roboter muss zu jedem Zeitpunkt auf der Karte den Weg zur Auszeichnung finden, ohne ins Wasser zu fallen.

Die Belohnungen werden zusammen mit den Kacheltypen mithilfe einer Enum codiert:

public enum TileEnum { Water = -1, Grass = 0, Award = 1 }

Der Zustand wird durch seine Place im Raster angegeben, was bedeutet, dass wir 40 mögliche Zustände haben: S = (0…7) × (0…4) (ein 8 × 5-Kachelgitter), das wir mithilfe eines 2D-Arrays codieren:

_map = {
    { -1, -1, -1, -1, -1, -1, -1, -1 },   // all water border
    { -1,  0,  0,  0, -1,  0,  1, -1 },   // 1 = Award (trophy)
    { -1,  0,  0,  0, -1,  0,  0, -1 },
    { -1,  0,  0,  0,  0,  0,  0, -1 },
    { -1, -1, -1, -1, -1, -1, -1, -1 },   // all water border
}

Wir speichern die Karte in einer Kachel TileGrid das die folgenden Hilfsfunktionen hat:

// Acquire a tile at a coordinate
public T GetTileByCoords<T>(int x, int y);

// Given a tile and an motion, get hold of the following tile
public T GetTargetTile<T>(T supply, ActionEnum motion);

// Create a tile grid from the map
public void GenerateTiles();

Wir werden verschiedene Kacheltypen verwenden, daher das Allgemeine T. Jede Kachel hat eine TileType gegeben durch die TileEnum und daher auch seine Belohnung, die als erhalten werden kann (int) TileType.

Die Bellman-Gleichung

Das Downside, eine optimale Richtlinie zu finden, kann mithilfe von iterativ gelöst werden Bellman-Gleichung. Die Bellman-Gleichung postuliert, dass die langfristige Belohnung einer Aktion gleich der unmittelbaren Belohnung für diese Aktion ist Plus die erwartete Belohnung aller zukünftigen Aktionen.

Es kann iterativ für Systeme mit diskreten Zuständen und diskreten Zustandsübergängen berechnet werden. Haben:

• s— aktueller Stand,
• A— Menge aller Aktionen,
• s'— Zustand, der durch das Ergreifen einer Aktion erreicht wird a im Staat s ,
• γ— Abzinsungsfaktor (je weiter die Belohnung, desto geringer ihr Wert),
• R(s, a)— sofortige Belohnung für das Handeln a im Staat s

Die Bellman-Gleichung gibt dann den Wert an V(s) eines Staates s Ist:

Iteratives Lösen der Bellman-Gleichung

Die Berechnung der Bellman-Gleichung ist ein dynamisches Programmierproblem. Bei jeder Iteration nberechnen wir die erwartete zukünftige Belohnung, die in erreichbar ist n+1 Schritte für alle Kacheln. Für jede Kachel speichern wir dies mit a Worth Variable.

Wir vergeben eine Belohnung basierend auf dem Zielplättchen, d. h 1 wenn die Auszeichnung erreicht wird, -1 im Roboter fällt ins Wasser, und 0 ansonsten. Sobald entweder Auszeichnung oder Wasser erreicht sind, sind keine Aktionen mehr möglich, daher bleibt der Wert des Zustands auf dem Anfangswert 0 .

Wir erstellen einen Supervisor, der das Raster generiert und die Iterationen berechnet:

non-public void Begin()
{
    tileGrid.GenerateTiles();
}

non-public void Replace()
{       
    CalculateValues();
    Step();
}

Um den Überblick über die Werte zu behalten, verwenden wir a VTile Klasse, die a enthält Worth. Um zu vermeiden, dass aktualisierte Werte direkt übernommen werden, legen wir zunächst fest NextValue und stellen Sie dann alle Werte auf einmal im ein Step() Funktion.

non-public float gamma = 0.9; // Discounting issue

// The Bellman equation 
non-public double GetNewValue(VTile tile)
{
    return Agent.Actions
        .Choose(a => tileGrid.GetTargetTile(tile, a))
        .Choose(t => t.Reward + gamma * t.Worth) // Reward in (1, 0, -1)
        .Max();
}

// Get subsequent values for all tiles
non-public void CalculateValues()
{
    for (var y = 0; y < TileGrid.BOARD_HEIGHT; y++)
    {
        for (var x = 0; x < TileGrid.BOARD_WIDTH; x++)
        {
            var tile = tileGrid.GetTileByCoords<VTile>(x, y);
            if (tile.TileType == TileEnum.Grass)
            {
                tile.NextValue = GetNewValue(tile);
            }
        }
    }
}

// Copy subsequent values to present values (iteration step)
non-public void Step()
{
    for (var y = 0; y < TileGrid.BOARD_HEIGHT; y++)
    {
        for (var x = 0; x < TileGrid.BOARD_WIDTH; x++)
        {
            tileGrid.GetTileByCoords<VTile>(x, y).Step();
        }
    }
}

Bei jedem Schritt der Wert V(s) Der Wert jedes Plättchens wird über alle Aktionen hinweg auf das Most der unmittelbaren Belohnung plus dem reduzierten Wert des resultierenden Plättchens aktualisiert. Die zukünftige Belohnung breitet sich vom Auszeichnungsplättchen nach außen aus, wobei die abnehmende Rendite von gesteuert wird γ = 0.9 .

Aktionsqualität (Q-Werte)

Wir haben einen Weg gefunden, Zustände mit Werten zu verknüpfen, was für dieses Wegfindungsproblem ausreicht. Hierbei steht jedoch die Umgebung im Mittelpunkt und der Agent wird außer Acht gelassen. Für einen Agenten möchten wir normalerweise wissen, was in der Umgebung eine gute Aktion wäre.

Im Q-Studying wird dieser Wert einer Aktion als ihr bezeichnet Qualität (Q-Wert). Jede (state, motion) Dem Paar wird ein einzelner Q-Wert zugewiesen.

Wo der neue Hyperparameter α definiert eine Lernrate – wie schnell neue Informationen alte überschreiben. Dies ist analog zum standardmäßigen maschinellen Lernen und die Werte sind normalerweise ähnlich, hier verwenden wir 0.005 . Anschließend berechnen wir den Nutzen einer Maßnahme anhand der zeitlichen Differenz D(s,a):

Da wir nicht mehr alle Aktionen im aktuellen Zustand betrachten, sondern die Qualität jeder Aktion einzeln, maximieren wir nicht über alle möglichen Aktionen im aktuellen Zustand, sondern über alle möglichen Aktionen in dem Zustand, den wir erreichen werden, nachdem wir die Aktion ausgeführt haben, deren Qualität wir berechnen, kombiniert mit der Belohnung für die Durchführung dieser Aktion.

Der zeitliche Differenzterm kombiniert die unmittelbare Belohnung mit der bestmöglichen zukünftigen Belohnung und ist somit eine direkte Ableitung der Bellman-Gleichung (siehe Wiki für Particulars).

Um den Agenten zu trainieren, instanziieren wir erneut ein Raster, aber dieses Mal erstellen wir auch eine Instanz des Agenten, platziert unter (2,2).

non-public Agent _agent;

non-public void ResetAgentPos()
{
    _agent.State = tileGrid.GetTileByCoords<QTile>(2, 2);
}

non-public void Begin()
{
    tileGrid.GenerateTiles();
    _agent = Instantiate(agentPrefab, rework);
    ResetAgentPos();
}

non-public void Replace()
{
    Step();
}

Ein Agent Objekt hat einen aktuellen Zustand QState. Jede QStatebehält den Q-Wert für jede verfügbare Aktion bei. Bei jedem Schritt aktualisiert der Agent die Qualität jeder im Standing verfügbaren Aktion:

non-public void Step() 
{
  if (_agent.State.TileType != TileEnum.Grass)
  {
      ResetAgentPos();
  }
  else
  {
      QTile s = _agent.State;
  
      // Replace Q-values for ALL actions from present state
      foreach (var a in Agent.Actions)
      {
          double q = s.GetQValue(a);
          QTile sPrime = tileGrid.GetTargetTile(s, a);
          double r = sPrime.Reward;
          double qMax = Agent.Actions.Choose(sPrime.GetQValue).Max();
          double td = r + gamma * qMax - q;
          s.SetQValue(a, q + alpha * td);
      }
  
      // Take the most effective obtainable motion a
      ActionEnum chosen = PickAction(s); 
      _agent.State = tileGrid.GetTargetTile(s, chosen);
  }
}

Ein Agent verfügt über eine Reihe möglicher Maßnahmen in jedem Bundesstaat und wird in jedem Bundesstaat die besten Maßnahmen ergreifen.

Gibt es mehrere beste Aktionen, wird eine davon zufällig ausgewählt, da wir die Aktionen zuvor gemischt haben. Aufgrund dieser Zufälligkeit verläuft jedes Coaching anders, stabilisiert sich jedoch im Allgemeinen zwischen 500 und 1000 Schritten.

Dies ist die Grundlage von Q-Studying. Anders als die ZustandswerteDie Aktionsqualität kann in Situationen angewendet werden, in denen:

• die Beobachtung ist jeweils unvollständig (Sichtfeld des Agenten)
• die Beobachtung ändert sich (Objekte bewegen sich in der Umgebung)

Exploration vs. Ausbeutung (ε-Grasping)

Bisher hat der Agent jedes Mal die bestmögliche Aktion durchgeführt, was jedoch dazu führen kann, dass der Agent schnell in einem lokalen Optimum stecken bleibt. Eine zentrale Herausforderung beim Q-Studying ist der Kompromiss zwischen Exploration und Exploitation:

• Ausnutzen – Wählen Sie die Aktion mit dem höchsten bekannten Q-Wert (gierig).
• Erkunden – Wählen Sie eine zufällige Aktion aus, um potenziell bessere Pfade zu entdecken.

ε-Gierige Politik

Gegeben ein zufälliger Wert r ∈ (0, 1) und Parameter epsilon Es gibt zwei Möglichkeiten:

• Wenn r > epsilon Wählen Sie dann die beste Aktion aus (ausbeuten),
• andernfalls wählen Sie eine zufällige Aktion (erkunden).

Verfallendes Epsilon

Normalerweise möchten wir frühzeitig mehr erforschen und später mehr ausnutzen. Dies wird durch Zerfall erreicht epsilon im Laufe der Zeit:

epsilon = max(epsilonMin, epsilon − epsilonDecay)

Nach genügend Schritten konvergiert die Strategie des Agenten dahingehend, dass er quick immer die Aktion mit der höchsten Qualität auswählt.

non-public epsilonMin = 0.05;
non-public epsilonDecay = 0.005;

non-public ActionEnum PickAction(QTile state) {
  ActionEnum motion = Random.Vary(0f, 1f) > epsilon
      ? Agent.Actions.Shuffle().OrderBy(state.GetQValue).Final()  // exploit
      : Agent.RndAction();                                       // discover

  epsilon = Mathf.Max(epsilonMin, epsilon - epsilonDecay);
  return motion;
}

Das breitere RL-Ökosystem

Q-Studying ist ein Algorithmus innerhalb einer größeren Familie von Reinforcement Studying (RL)-Methoden. Algorithmen können entlang mehrerer Achsen kategorisiert werden:

• Zustandsraum: Diskret (z. B. Brettspiele) | Kontinuierlich (z. B. FPS-Spiele)
• Aktionsraum: Diskret (z. B. Strategiespiele) | Kontinuierlich (z. B. Autofahren)
• Richtlinientyp: Off-Coverage (Q-Studying: a’ ist immer maximiert) | Richtlinienkonform (SARSA: a’ wird durch die aktuelle Richtlinie des Agenten ausgewählt)
• Operator: Wert | Qualität | Vorteil A(s, a) = Q(s, a) − V(s)

Eine umfassende Liste der RL-Algorithmen finden Sie im Wikipedia-Seite zum Reinforcement Studying. Weitere Methoden wie das Behavioral Cloning sind dort nicht aufgeführt, kommen aber auch in der Praxis zum Einsatz. Reale Lösungen nutzen typischerweise erweiterte Varianten oder Kombinationen der oben genannten.

Q-Studying ist eine Off-Coverage-Methode mit diskretem Handeln. Die Ausweitung auf kontinuierliche Zustands-/Aktionsräume führt zu Methoden wie Deep Q-Networks (DQN), die die Q-Tabelle durch ein neuronales Netzwerk ersetzen.

Im Beispiel der Grid-Welt hat die Q-Tabelle |S| × |A| = 40 × 4 = 160 Einträge – perfekt überschaubar. Aber für ein Spiel wie Schach ist der Zustandsraum größer 10⁴⁴ Positionen, wodurch eine explizite Tabelle nicht gespeichert oder gefüllt werden kann. In solchen Fällen können neuronale Netze zur Komprimierung der Informationen eingesetzt werden.

Praktisches Verstärkungslernen in Spielen

Der obige Textual content soll eine grundlegende Einführung in das Konzept der Reinforcement Studying Brokers bieten. In der Praxis ist es natürlich unwahrscheinlich, dass Sie einen RL-Algorithmus manuell implementieren.

Die Unity-Engine stellt ein RL-Paket bereit ML-Agentendie z. B. zum Trainieren genutzt werden kann Autorennen. In den Frontier Labs wird die Erforschung von RL-Methoden in großem Maßstab unter Verwendung von Spielumgebungen durchgeführt, beispielsweise dem Versteckspiel:

Die Modelle aus diesen Labors haben in komplexen Brettspielen wie z. B. bereits den besten Spieler der Welt geschlagen Gehenschnelle Strategien wie Starcraft Und Dotaund sogar Spiele, die Kommunikation auf menschlicher Ebene erfordern, wie z Diplomatie.

Nous Analysis hat NousCoder-14B eingeführt, ein wettbewerbsorientiertes Olympia-Programmiermodell, das auf Qwen3-14B unter Verwendung von Reinforcement Studying (RL) mit überprüfbaren Belohnungen nachtrainiert wird. Beim LiveCodeBench v6-Benchmark, der Probleme vom 01.08.2024 bis 01.05.2025 abdeckt, erreicht das Modell eine Cross@1-Genauigkeit von 67,87 Prozent. Das sind 7,08 Prozentpunkte mehr als der Qwen3-14B-Basiswert von 60,79 Prozent beim gleichen Benchmark. Das Forschungsteam trainierte das Modell an 24.000 überprüfbaren Codierungsproblemen mit 48 B200-GPUs über 4 Tage und veröffentlichte die Gewichte unter der Apache 2.0-Lizenz auf Hugging Face.

Benchmark-Fokus und was Cross@1 bedeutet

LiveCodeBench v6 ist für die wettbewerbsorientierte Programmierungsbewertung konzipiert. Der hier verwendete Testsplit enthält 454 Probleme. Das Trainingsset verwendet das gleiche Rezept wie das DeepCoder-14B-Projekt von Agentica und Collectively AI. Es kombiniert Probleme von TACO Verified, PrimeIntellect SYNTHETIC 1 und LiveCodeBench-Problemen, die vor dem 31.07.2024 erstellt wurden.

Der Benchmark umfasst nur Aufgaben im kompetitiven Programmierstil. Für jedes Downside muss eine Lösung strenge Zeit- und Speicherbeschränkungen einhalten und eine große Anzahl versteckter Eingabe-Ausgabe-Assessments bestehen. Cross@1 ist der Bruchteil der Probleme, bei denen das erste generierte Programm alle Assessments besteht, einschließlich Zeit- und Speicherbeschränkungen.

Datensatzkonstruktion für ausführungsbasiertes RL

Alle für das Coaching verwendeten Datensätze bestehen aus überprüfbaren Codegenerierungsproblemen. Für jedes Downside gibt es eine Referenzimplementierung und viele Testfälle. Das Trainingsset enthält 24.000 Probleme aus:

• TACO verifiziert
• PrimeIntellect SYNTHETISCH 1
• LiveCodeBench-Probleme, die vor dem 31.07.2024 auftreten

Der Testsatz ist LiveCodeBench v6, der zwischen dem 01.08.2024 und dem 01.05.2025 454 Probleme aufweist.

Jedes Downside ist eine vollständige wettbewerbsfähige Programmieraufgabe mit einer Beschreibung, einem Eingabeformat, einem Ausgabeformat und Testfällen. Dieses Setup ist für RL wichtig, da es ein binäres Belohnungssignal liefert, das nach der Ausführung des Codes kostengünstig zu berechnen ist.

RL-Umgebung mit Atropos und Modal

Die RL-Umgebung wird mit dem Atropos-Framework erstellt. NousCoder-14B wird mithilfe des standardmäßigen LiveCodeBench-Eingabeaufforderungsformats aufgefordert und generiert Python-Code für jedes Downside. Jeder Rollout erhält eine skalare Belohnung, die von den Testfallergebnissen abhängt:

• Belohnung 1, wenn der generierte Code alle Testfälle für dieses Downside besteht
• Belohnung –1, wenn der Code eine falsche Antwort ausgibt, ein Zeitlimit von 15 Sekunden überschreitet oder in einem Testfall ein Speicherlimit von 4 GB überschreitet

Um nicht vertrauenswürdigen Code sicher und im großen Maßstab auszuführen, verwendet das Crew Modal als automatisch skalierte Sandbox. Das System startet professional Rollout einen Modal-Container im Hauptdesign, das das Forschungsteam als verwendete Einstellung beschreibt. Jeder Container führt alle Testfälle für diesen Rollout aus. Dadurch wird vermieden, dass Trainingsberechnungen mit Verifizierungsberechnungen vermischt werden, und die RL-Schleife bleibt stabil.

Das Forschungsteam leitet auch Inferenz und Verifizierung weiter. Wenn ein Inferenzarbeiter eine Generierung abschließt, sendet er den Abschluss an einen Modalprüfer und startet sofort eine neue Generierung. Mit vielen Inferenzarbeitern und einem festen Pool an modalen Containern sorgt dieses Design dafür, dass die Inferenzberechnung der Trainingsschleife und nicht die Verifizierungsgrenze gebunden bleibt.

Das Crew diskutiert drei Verifizierungs-Parallelisierungsstrategien. Sie untersuchen einen Container professional Downside, einen professional Rollout und einen professional Testfall. Sie vermeiden schließlich die Einstellung professional Testfall aufgrund des Mehraufwands beim Containerstart und verwenden einen Ansatz, bei dem jeder Container viele Testfälle auswertet und sich zunächst auf eine kleine Menge der schwierigsten Testfälle konzentriert. Wenn einer dieser Schritte fehlschlägt, kann das System die Überprüfung vorzeitig stoppen.

GRPO-Ziele, DAPO, GSPO und GSPO+

NousCoder-14B verwendet Group Relative Coverage Optimization (GRPO), die kein separates Wertemodell erfordert. Zusätzlich zum GRPO testet das Forschungsteam 3 Ziele: Dynamic sAmpling Coverage Optimization (DAPO), Group Sequence Coverage Optimization (GSPO) und eine modifizierte GSPO-Variante namens GSPO+.

Alle drei Ziele haben die gleiche Definition von Vorteil. Der Vorteil für jeden Rollout ist die Belohnung für diesen Rollout, normalisiert durch den Mittelwert und die Standardabweichung der Belohnungen innerhalb der Gruppe. DAPO wendet Wichtigkeitsgewichtung und Clipping auf Token-Ebene an führt drei wesentliche Änderungen gegenüber GRPO ein:

• Eine Clip-Increased-Regel, die die Exploration nach Token mit geringer Wahrscheinlichkeit erhöht
• Ein Richtliniengradientenverlust auf Token-Ebene, der jedem Token das gleiche Gewicht verleiht
• Dynamisches Sampling, bei dem Gruppen, die alle richtig oder alle falsch sind, verworfen werden, weil sie keinen Vorteil bieten

GSPO verschiebt die Wichtigkeitsgewichtung auf die Sequenzebene. Es definiert ein Sequenzwichtigkeitsverhältnis, das die Token-Verhältnisse über das gesamte Programm hinweg aggregiert. GSPO+ behält die Korrektur auf Sequenzebene bei, skaliert jedoch Farbverläufe neu, sodass Token unabhängig von der Sequenzlänge gleich gewichtet werden.

Bei LiveCodeBench v6 sind die Unterschiede zwischen diesen Zielen gering. Bei einer Kontextlänge von 81.920 Token erreicht DAPO einen Cross@1 von 67,87 Prozent, während GSPO und GSPO+ 66,26 Prozent und 66,52 Prozent erreichen. Bei 40.960 Token liegen alle drei Ziele bei rund 63 Prozent Cross@1.

Iterative Kontexterweiterung und überlange Filterung

Qwen3-14B unterstützt lange Kontexte und das Coaching folgt einem iterativen Kontexterweiterungsplan. Das Crew trainiert das Modell zunächst mit einem 32.000-Kontextfenster und setzt dann das Coaching mit dem maximalen Qwen3-14B-Kontextfenster von 40.000 fort. In jeder Part wählen sie den Prüfpunkt mit dem besten LiveCodeBench-Rating bei 40.000 Kontext aus und verwenden dann zum Zeitpunkt der Auswertung die YaRN-Kontexterweiterung, um 80.000 Token, additionally 81.920 Token, zu erreichen.

Ein wichtiger Trick ist die zu lange Filterung. Wenn ein generiertes Programm das maximale Kontextfenster überschreitet, wird sein Vorteil auf Null zurückgesetzt. Dadurch wird dieser Rollout aus dem Gradientensignal entfernt, anstatt ihn zu benachteiligen. Das Forschungsteam berichtet, dass dieser Ansatz vermeidet, das Modell aus reinen Optimierungsgründen in Richtung kürzerer Lösungen zu drängen, und dabei hilft, die Qualität aufrechtzuerhalten, wenn die Kontextlänge zum Testzeitpunkt skaliert wird.

Wichtige Erkenntnisse

• NousCoder 14B ist ein Qwen3-14B-basiertes, wettbewerbsfähiges Programmiermodell, das mit ausführungsbasiertem RL trainiert wurde. Es erreicht 67,87 Prozent Cross@1 auf LiveCodeBench v6, ein Plus von 7,08 Prozentpunkten gegenüber der Qwen3-14B-Basislinie von 60,79 Prozent auf demselben Benchmark.
• Das Modell wird auf 24.000 überprüfbare Codierungsprobleme von TACO Verified, PrimeIntellect SYNTHETIC-1 und LiveCodeBench-Aufgaben vor dem 31.07.2024 trainiert und an einem disjunkten LiveCodeBench v6-Testsatz von 454 Problemen vom 01.08.2024 bis 01.05.2025 ausgewertet.
• Das RL-Setup verwendet Atropos mit Python-Lösungen, die in Sandbox-Containern ausgeführt werden, einer einfachen Belohnung von 1 für die Lösung aller Testfälle und minus 1 für jeden Fehler oder jede Verletzung des Ressourcenlimits sowie ein Pipeline-Design, bei dem Inferenz und Überprüfung asynchron ausgeführt werden.
• Gruppenrelative Richtlinienoptimierungsziele DAPO, GSPO und GSPO+ werden für RL mit langem Kontextcode verwendet, arbeiten alle mit gruppennormalisierten Belohnungen und zeigen eine ähnliche Leistung, wobei DAPO den besten Cross@1 im längsten 81.920-Token-Kontext erreicht.
• Das Coaching verwendet eine iterative Kontexterweiterung, zunächst auf 32.000, dann auf 40.000 Token, zusammen mit einer YaRN-basierten Erweiterung zur Evaluierungszeit auf 81.920 Token, umfasst überlange Rollout-Filterung für Stabilität und wird als vollständig reproduzierbarer offener Stapel mit Apache 2.0-Gewichten und RL-Pipeline-Code geliefert.

Schauen Sie sich das an Modellgewichte Und Technische Particulars. 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.

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.

Wie können KI-Groups Verstärkungslernen im Tinker-Stil für große Sprachmodelle unter Verwendung ihrer eigenen Infrastruktur und einer einzigen einheitlichen Engine durchführen? Anyscale und NovaSky (UC Berkeley) Crew Veröffentlichungen SkyRL tx v0.1.0 Dies gibt Entwicklern die Möglichkeit, eine mit Tinker kompatible Trainings- und Inferenz-Engine direkt auf ihrer eigenen {Hardware} auszuführen und dabei die gleiche minimale API beizubehalten, die Tinker im verwalteten Dienst bereitstellt.

Das Forschungsteam beschreibt SkyRL tx als einheitliche Trainings- und Inferenz-Engine, die die Tinker-API implementiert und es Benutzern ermöglicht, einen Tinker-ähnlichen Dienst auf ihrer eigenen Infrastruktur auszuführen. Diese Model v0.1.0 ist die erste ihrer Reihe, die das Reinforcement-Studying durchgängig unterstützt und außerdem die Probenentnahme erheblich beschleunigt.

Tinker API in Kürze

Tinker von Considering Machines ist eine Trainings-API, die auf vier Kernfunktionen basiert. forward_backward führt einen Vorwärtsdurchlauf und einen Rückwärtsdurchlauf durch und sammelt Steigungen. optim_step Aktualisiert die Modellgewichte basierend auf diesen Farbverläufen. pattern generiert Token für Interaktion, Auswertung oder RL-Aktionen. save_state schreibt Kontrollpunkte für die Wiederaufnahme des Trainings.

Anstelle einer vollständigen aufgabenspezifischen Feinabstimmungsabstraktion stellt Tinker diese Grundelemente auf niedriger Ebene bereit, sodass Benutzer ihre eigenen überwachten oder verstärkenden Lernschleifen in regulärem Python-Code implementieren können, während der Dienst die GPU-Planung und die verteilte Ausführung übernimmt.

SkyRL tx zielt genau auf diese API ab und implementiert ein offenes Backend, das Benutzer lokal bereitstellen können. Es behält das Tinker-Programmiermodell bei, macht es aber überflüssig, sich nur auf die gehostete Umgebung zu verlassen.

Wo SkyRL tx in SkyRL passt

SkyRL ist eine Full-Stack-Lernbibliothek zur Verstärkung für große Sprachmodelle, die Folgendes umfasst: skyrl-agent für Agenten mit langem Horizont, skyrl-train für die Ausbildung und skyrl-gym für Werkzeugumgebungen wie Mathematik, Codierung, Suche und SQL.

Innerhalb dieses Stapels skyrl-tx ist als experimentelle plattformübergreifende Bibliothek gekennzeichnet, die eine lokale Tinker-ähnliche REST-API für das Modell-Submit-Coaching bereitstellt. SkyRL tx wird daher zur Systemschicht, die RL-Logik, Umgebungen und Trainingscode über die Tinker-Schnittstelle mit konkreten GPU-Ressourcen verbindet.

Architektur, Inferenzmaschine, die auch trainiert

Die SkyRL-TX-Architektur wird als Inferenz-Engine beschrieben, die auch Rückwärtsdurchläufe unterstützt. Es besteht aus vier Hauptkomponenten:

1. REST-API Server das eingehende Anfragen von verschiedenen Benutzern verarbeitet.
2. Datenbank das Metadaten zu Modellen, Prüfpunkten, Anfragen und Futures verfolgt und auch als Jobwarteschlange fungiert. Die aktuelle Implementierung nutzt SQLite hinter einer Schnittstelle, die auch andere SQL-Datenbanken wie Postgres unterstützt.
3. Motor das benutzerübergreifende Anfragen plant und bündelt. Jede Engine-Instanz bedient ein einzelnes Basismodell und kann viele LoRA-Adapter anhängen.
4. Arbeitnehmer das Vorwärts- und Rückwärtsdurchläufe ausführt und Modelldefinitionen und Optimiererzustände enthält. Mehrere Employee würden in kommenden Versionen ein erweitertes Multi-Node-Sharding ermöglichen

Was fügt v0.1.0 hinzu?

Die Model v0.1.0 konzentriert sich auf die Unterstützung von Reinforcement Studying und Leistungsverbesserungen. Der offizielle Veröffentlichung hebt mehrere konkrete Änderungen hervor:

• Das Sampling ist jetzt viel schneller, da es in der Engine richtig gebündelt und geshardt wird.
• Es werden jetzt unterschiedliche Sampling-Parameter professional Anfrage, professional Anfrage-Seeds und Cease-Tokens unterstützt, was nützlich ist, wenn viele Experimente ein gemeinsames Basismodell haben.
• Nach mehreren Korrekturen läuft die RL-Schleife jetzt ordnungsgemäß durch die Engine.
• Unterstützung für Gradienten-Checkpointing und Mikro-Batching für die Probenahme sind implementiert.
• Postgres wird jetzt neben SQLite als Datenbank-Backend unterstützt.

Ausführen von RL Finish-to-Finish auf 8 H100-GPUs

Die offizielle Veröffentlichung enthält ein spezifisches Coderezept für die Finish-to-Finish-Ausführung von Reinforcement Studying auf einem Cluster mit 8 H100-GPUs.

Zuerst klonen Benutzer das SkyRL-Repository und im skyrl-tx Ordner starten Sie die Engine mit:

uv run --extra gpu --extra tinker -m tx.tinker.api 
  --base-model Qwen/Qwen3-4B 
  --max-lora-adapters 3 
  --max-lora-rank 1 
  --tensor-parallel-size 8 
  --train-micro-batch-size 8 > out.log

Dann klonen sie das Tinker Cookbook vom Considering Machines-Crew und im tinker_cookbook/recipes Ordner ausführen:

export TINKER_API_KEY=dummy
export WANDB_API_KEY=<your key>
uv run --with wandb --with tinker rl_loop.py 
  base_url=http://localhost:8000 
  model_name="Qwen/Qwen3-4B" 
  lora_rank=1 
  max_length=1024 
  save_every=100

Dadurch wird eine Belohnungskurve erstellt, die bestätigt, dass die RL-Schleife korrekt durch das lokale SkyRL-TX-Backend läuft.

Wichtige Erkenntnisse

• SkyRL tx v0.1.0 implementiert eine lokale, Tinker-kompatible Engine, die Coaching und Inferenz für das LLM-Submit-Coaching vereinheitlicht.
• Das System stellt die Tinker-Grundelemente „forward_backward“, „optim_step“, „pattern“ und „save_state“ über REST bereit, während es intern Batchverarbeitung, LoRA-Adapter und Geräteplatzierung übernimmt.
• Die Architektur ist in API-Server, SQL-Datenbank, Planungs-Engine und Employee unterteilt, die Vorwärts- und Rückwärtsdurchgänge für ein einzelnes Basismodell mit mehreren LoRA-Adaptern ausführen.
• v0.1.0 bietet Finish-to-Finish-Unterstützung für verstärktes Lernen, schnelleres Jitted- und Sharded-Sampling, Sampling-Parameter professional Anfrage, Gradient Checkpointing, Micro Batching und Postgres-Unterstützung.

SkyRL tx v0.1.0 ist ein praktischer Schritt für Entwicklerteams, die Verstärkungslernen im Tinker-Stil auf ihren eigenen Clustern mit einer konsistenten Tinker-API-Oberfläche wünschen. Das Design, das das System als Inferenzmaschine behandelt, die auch Rückwärtsdurchläufe ausführt, ist sauber und reduziert Stapeldivergenz. Die Unterstützung für LoRA, Gradient Checkpointing, Micro Batching und Postgres ist ein konkretes System-Improve. Insgesamt verwandelt diese Model die Tinker-Kompatibilität in ein umsetzbares lokales RL-Backend für LLM

Schauen Sie sich das an Repo Und Offizielle Veröffentlichung. 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.

Wie wandeln Sie echte Agentenverfolgungen in Reinforcement Studying RL-Übergänge um, um Richtlinien-LLMs zu verbessern, ohne Ihren bestehenden Agentenstapel zu ändern? Veröffentlichungen des Microsoft AI-Groups Agent Lightning zur Optimierung von Multiagentensystemen. Agent Lightning ist ein Open-Supply-Framework, das Reinforcement Studying für jeden KI-Agenten ohne Umschreibungen ermöglicht. Es trennt Coaching und Ausführung, definiert ein einheitliches Hint-Format und führt LightningRL ein, eine hierarchische Methode, die komplexe Agentenläufe in Übergänge umwandelt, die standardmäßige Single-Flip-RL-Coach optimieren können.

Was Agent Lightning macht?

Das Framework modelliert einen Agenten als Entscheidungsprozess. Es formalisiert den Agenten als einen teilweise beobachtbaren Markov-Entscheidungsprozess, bei dem die Beobachtung die aktuelle Eingabe in das Richtlinien-LLM ist, die Aktion der Modellaufruf ist und die Belohnung terminaler oder intermediärer Natur sein kann. Aus jedem Lauf werden nur die vom Richtlinienmodell getätigten Aufrufe sowie Eingaben, Ausgaben und Belohnungen extrahiert. Dadurch werden andere Rahmengeräusche entfernt und saubere Übergänge für das Coaching erzielt.

LightningRL führt die Kreditzuweisung über mehrstufige Episoden hinweg durch und optimiert dann die Richtlinie mit einem einzigen RL-Ziel. Das Forschungsteam beschreibt die Kompatibilität mit Single-Flip-RL-Methoden. In der Praxis nutzen Groups häufig Coach, die PPO oder GRPO implementieren, wie z. B. VeRL, das zu dieser Schnittstelle passt.

Systemarchitektur

Agent Lightning verwendet Coaching Agent Disaggregation. Ein Blitz Server führt Coaching und Bereitstellung durch und stellt eine OpenAI-ähnliche API für das aktualisierte Modell bereit. Ein Lightning-Consumer führt die Agentenlaufzeit dort aus, wo sie sich bereits befindet, erfasst Spuren von Eingabeaufforderungen, Toolaufrufen und Belohnungen und streamt sie zurück an den Server. Dadurch bleiben Instruments, Browser, Shells und andere Abhängigkeiten nah an der Produktion, während das GPU-Coaching auf der Serverebene verbleibt.

Die Laufzeit unterstützt zwei Ablaufverfolgungspfade. Ein Standardpfad verwendet OpenTelemetry-Spans, sodass Sie Agententelemetrie über Standardkollektoren weiterleiten können. Es gibt auch einen leichtgewichtigen eingebetteten Tracer für Groups, die OpenTelemetry nicht einsetzen möchten. Beide Wege enden zum Coaching im selben Laden.

Einheitliche Datenschnittstelle

Agent Lightning zeichnet jeden Modellaufruf und jeden Toolaufruf als Spanne mit Eingaben, Ausgaben und Metadaten auf. Die Algorithmusschicht passt Spannen in geordnete Tripletts aus Aufforderung, Antwort und Belohnung an. Durch diese selektive Extraktion können Sie einen Agenten in einem Multi-Agenten-Workflow oder mehrere Agenten gleichzeitig optimieren, ohne den Orchestrierungscode zu berühren. Dieselben Spuren können auch eine automatische Immediate-Optimierung oder eine überwachte Feinabstimmung vorantreiben.

Experimente und Datensätze

Das Forschungsteam meldet drei Aufgaben. Für Textual content-to-SQL verwendet das Group den Spider-Benchmark. Spider enthält mehr als 10.000 Fragen in 200 Datenbanken, die 138 Bereiche umfassen. Das Richtlinienmodell ist Llama 3.2 3B Instruct. Die Implementierung verwendet LangChain mit einem Author-Agenten, einem Rewriter-Agenten und einem Checker. Der Author und der Rewriter werden optimiert und der Checker bleibt unverändert. Die Belohnungen verbessern sich während des Trainings und zur Prüfungszeit stetig.

Für die Retrieval-Augmented-Generierung verwendet das Setup den MuSiQue-Benchmark und einen Wikipedia-Skalenindex mit etwa 21 Millionen Dokumenten. Der Retriever verwendet BGE-Einbettungen mit Kosinusähnlichkeit. Der Agent wird mit dem OpenAI Brokers SDK erstellt. Die Belohnung ist eine gewichtete Summe aus einem Format-Rating und einem F1-Korrektheits-Rating. Belohnungskurven zeigen stabile Zuwächse während des Trainings und der Bewertung mit demselben Basismodell.

Für die Beantwortung mathematischer Fragen mithilfe eines Instruments wird der Agent mit AutoGen implementiert und ruft ein Taschenrechnertool auf. Der Datensatz ist Calc X. Das Basismodell ist wiederum Llama 3.2 3B Instruct. Das Coaching verbessert die Fähigkeit, Instruments korrekt aufzurufen und Ergebnisse in endgültige Antworten zu integrieren.

Wichtige Erkenntnisse

1. Agent Lightning nutzt Coaching Agent Disaggregation und eine einheitliche Hint-Schnittstelle, sodass bestehende Agenten in LangChain, OpenAI Brokers SDK, AutoGen oder CrewAI nahezu ohne Codeänderungen verbunden werden können.
2. LightningRL wandelt Flugbahnen in Übergänge um. Es wendet die Kreditzuweisung auf mehrstufige Läufe an und optimiert dann die Richtlinie mit Single-Flip-RL-Methoden wie PPO oder GRPO in Standardtrainern.
3. Automated Intermediate Rewarding, AIR, liefert dichtes Suggestions. AIR wandelt Systemsignale wie den Standing der Werkzeugrückgabe in Zwischenbelohnungen um, um Probleme mit spärlichen Belohnungen in langen Arbeitsabläufen zu reduzieren.
4. Die Forschung wertet Textual content nach SQL auf Spider, RAG auf MuSiQue mit einem Wikipedia-Skalenindex unter Verwendung von BGE-Einbettungen und Kosinusähnlichkeit sowie die Verwendung von Mathematiktools auf Calc X aus, alles mit Llama 3.2 3B Instruct als Basismodell.
5. Die Laufzeit zeichnet Traces über OpenTelemetry auf, streamt sie an den Trainingsserver und stellt einen OpenAI-kompatiblen Endpunkt für aktualisierte Modelle bereit, wodurch skalierbare Rollouts ohne das Verschieben von Instruments ermöglicht werden.

Agent Lightning ist eine praktische Brücke zwischen der Agentenausführung und dem verstärkenden Lernen und nicht eine weitere Neufassung des Frameworks. Es formalisiert Agentenläufe als Markov-Entscheidungsprozess (MDP), führt LightningRL für die Kreditzuweisung ein und extrahiert Übergänge, die in Single-Flip-RL-Coach eingefügt werden. Das Coaching Agent Disaggregation-Design trennt einen Consumer, der den Agent ausführt, von einem Server, der einen OpenAI-kompatiblen Endpunkt trainiert und bedient, sodass Groups vorhandene Stacks behalten. Die automatische Zwischenbelohnung wandelt Laufzeitsignale in dichtes Suggestions um und reduziert so spärliche Belohnungen in langen Arbeitsabläufen. Insgesamt ist Agent Lightning ein sauberer Weg mit minimaler Integration, der es Agenten ermöglicht, aus ihren eigenen Spuren zu lernen.

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 E-newsletter. 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.

Reinforcement Studying RL nach dem Coaching ist heute ein wichtiger Hebel für auf das Denken ausgerichtete LLMs, aber anders als vor dem Coaching conflict dies nicht der Fall prädiktiv Skalierungsregeln. Groups investieren Zehntausende GPU-Stunden in Läufe, ohne eine prinzipielle Möglichkeit zu haben, abzuschätzen, ob sich ein Rezept mit mehr Rechenleistung weiter verbessern wird. Eine neue Studie von Meta, UT Austin, UCL, Berkeley, Harvard und Periodic Labs liefert a Rechenleistungs-Framework–überprüft >400.000 GPU-Stunden– das modelliert den RL-Fortschritt mit a Sigmoidale Kurve und liefert ein erprobtes Rezept, ScaleRLdas den vorhergesagten Kurven bis folgt 100.000 GPU-Stunden.

Passen Sie ein Sigmoid an, kein Potenzgesetz

Das Vortraining entspricht häufig den Potenzgesetzen (Verlust vs. Rechenleistung). RL-Feinabstimmungsziele begrenzte Metriken (z. B. Erfolgsquote/durchschnittliche Belohnung). Das Forschungsteam zeigt sigmoidale Anfälle Zu Erfolgsquote vs. Trainingsberechnung sind empirisch robuster und stabiler als das Potenzgesetz passt, besonders wenn Sie es wollen aus kleineren Läufen extrapolieren zu größeren Budgets. Sie schließen das sehr frühe, laute Regime aus (~first 1,5.000 GPU-Stunden) und passen Sie den folgenden vorhersehbaren Teil an. Die sigmoidalen Parameter haben intuitive Rollen: Man legt die fest asymptotische Leistung (Obergrenze)ein anderer der Effizienz/Exponentund noch eins Mittelpunkt wo die Gewinne am schnellsten sind.

Warum das wichtig ist: Nach ca. 1–2.000 GPU-Stunden können Sie die Kurve anpassen und vorhersagen, ob sich der Anstieg auf 10.000–100.000 GPU-Stunden lohnt –vor Du verbrennst das Price range. Die Forschung zeigt auch, dass Potenzgesetzanpassungen zu irreführenden Obergrenzen führen können, es sei denn, Sie passen nur mit sehr hohem Rechenaufwand an, was dem Zweck einer frühen Prognose zuwiderläuft.

ScaleRL: ein Rezept, das vorhersehbar skaliert

ScaleRL ist nicht nur ein neuer Algorithmus; es ist ein Zusammensetzung der Wahlmöglichkeiten Dies führte zu einer stabilen, extrapolierbaren Skalierung in der Studie:

• Asynchrone Pipeline RL (Generator-Coach-Aufteilung auf GPUs) für Durchsatz außerhalb der Richtlinien.
• CISPO (abgeschnittene Wichtigkeitsstichprobe REINFORCE) als RL-Verlust.
• FP32-Präzision an den Logits um eine numerische Nichtübereinstimmung zwischen Generator und Coach zu vermeiden.
• Sofortige Schadensdurchschnittsermittlung Und Vorteilsnormalisierung auf Chargenebene.
• Erzwungene Längenunterbrechungen um außer Kontrolle geratene Spuren zu verschließen.
• Null-Varianz-Filterung (Drop-Eingabeaufforderungen, die kein Gradientensignal liefern).
• Kein positives Resampling (Entfernen Sie Eingabeaufforderungen mit hoher Erfolgsquote ≥0,9 aus späteren Epochen).

Das Forschungsteam validierte jede Komponente mit Go away-one-out (LOO)-Ablationen bei 16.000 GPU-Stunden und zeigen Sie, dass die angepassten Kurven von ScaleRL zuverlässig sind extrapolieren aus 8k → 16kdann in viel größeren Maßstäben halten – einschließlich eines einzelnen Laufs, der auf erweitert wird 100.000 GPU-Stunden.

Ergebnisse und Verallgemeinerung

Zwei wichtige Demonstrationen:

1. Vorhersehbarkeit im großen Maßstab: Für ein 8B dicht Modell und a Lama-4 17B×16 MoE („Scout“)Die erweiterte Ausbildung aufmerksam verfolgt Sigmoid-Extrapolationen abgeleitet von kleineren Rechensegmenten.
2. Downstream-Übertragung: Verbesserungen der Erfolgsquote bei einem iid-Validierungssatz Schiene Nachgelagerte Bewertung (z. B. AIME-24), was darauf hindeutet, dass die Rechenleistungskurve kein Datensatzartefakt ist.

Die Studie vergleicht auch angepasste Kurven für gängige Rezepte (z. B. DeepSeek (GRPO), Qwen-2.5 (DAPO), Magistral, MiniMax-M1) und Berichte höhere asymptotische Leistung und bessere Recheneffizienz für ScaleRL in ihrem Setup.

Welche Knöpfe bewegen die Decke im Vergleich zur Effizienz?

Mit dem Framework können Sie Designentscheidungen klassifizieren:

• Deckenbeweger (Asymptote): Skalierung Modellgröße (z. B. MoE) und längere Generationslängen (bis zu 32.768 Token) erhöhen die asymptotisch zwar die Leistung, kann jedoch den frühen Fortschritt verlangsamen. Größer globale Batchgröße kann auch die endgültige Asymptote anheben und das Coaching stabilisieren.
• Effizienzformer: Verlustaggregation, Vorteilsnormalisierung, Datenlehrplanund die Off-Coverage-Pipeline hauptsächlich ändern wie schnell Sie nähern sich der Decke, nicht der Decke selbst.

Operativ berät das Forschungsteam Kurven frühzeitig anpassen und Priorisierung von Interventionen, die das erhöhen Deckedann stimmen Sie das ab Effizienz Knöpfe, um es bei fester Rechenleistung schneller zu erreichen.

Wichtige Erkenntnisse

• Das Forschungsteam modelliert den RL-Fortschritt nach dem Coaching mit Sigmoidale Rechenleistungskurven (Erfolgsquote vs. Log-Compute) und ermöglicht eine zuverlässige Extrapolation – im Gegensatz zu Potenzgesetz-Anpassungen bei begrenzten Metriken.
• Ein Greatest-Observe-Rezept, ScaleRLvereint PipelineRL-k (Asynchrongenerator-Coach), CISPO Verlust, FP32-ProtokolleAggregation auf Eingabeaufforderungsebene, Vorteilsnormalisierung, unterbrechungsbasierte Längenkontrolle, Nullvarianzfilterung und No-Optimistic-Resampling.
• Anhand dieser Passungen hat das Forschungsteam vorhergesagt und abgestimmt längere Läufe bis zu 100.000 GPU-Stunden (8B dicht) und ~50.000 GPU-Stunden (17B×16 MoE „Scout“) auf Validierungskurven.
• Ablationen Zeige einige Auswahlmöglichkeiten, verschiebe die asymptotische Decke (A) (z. B. Modellmaßstab, längere Generationslängen, größere globale Cost), während andere sich hauptsächlich verbessern Recheneffizienz (B) (z. B. Aggregation/Normalisierung, Lehrplan, Off-Coverage-Pipeline).
• Das Framework bietet frühe Prognose um zu entscheiden, ob ein Lauf skaliert werden soll, und Verbesserungen bei der verteilungsinternen Validierung Verfolgen Sie Downstream-Metriken (z. B. AIME-24) zur Unterstützung der externen Validität.

Diese Arbeit verwandelt die RL-Nachschulung vom Versuch-und-Irrtum-Prinzip in ein vorhersehbares Engineering. Es passt sigmoidale Rechenleistungskurven (Erfolgsrate vs. Log-Berechnung) an, um Renditen vorherzusagen und zu entscheiden, wann gestoppt oder skaliert werden soll. Es bietet auch ein konkretes Rezept, ScaleRL, das asynchrone Generierung/Coaching im PipelineRL-Stil, den CISPO-Verlust und FP32-Logits für Stabilität verwendet. Die Studie berichtet über mehr als 400.000 GPU-Stunden an Experimenten und eine einmalige Erweiterung auf 100.000 GPU-Stunden. Die Ergebnisse unterstützen eine saubere Aufteilung: Einige Entscheidungen erhöhen die Asymptote; andere verbessern hauptsächlich die Recheneffizienz. Diese Trennung hilft Groups dabei, bahnbrechende Änderungen zu priorisieren, bevor sie die Durchsatzregler anpassen.

Schauen Sie sich das an PAPIER. 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.

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.

Arbeiten mit ODEs

Physikalische Systeme können typischerweise durch Differentialgleichungen oder Gleichungen, die Ableitungen enthalten, modelliert werden. Kräfte, daher Newtons Gesetze, können als Ableitungen ausgedrückt werden, ebenso wie Maxwells Gleichungen, sodass Differentialgleichungen die meisten physikalischen Probleme beschreiben können. Eine Differentialgleichung beschreibt, wie sich ein System basierend auf dem aktuellen Zustand des Methods ändert, und definiert so faktisch den Zustandsübergang. Differentialgleichungssysteme können in Matrix-/Vektorform geschrieben werden:

Dabei ist x der Zustandsvektor, A die aus der physikalischen Dynamik ermittelte Zustandsübergangsmatrix und x dot (oder dx/dt) die Zustandsänderung bei zeitlicher Änderung. Im Wesentlichen wirkt Matrix A auf den Zustand x ein, um ihn um einen kleinen Zeitschritt voranzutreiben. Diese Formulierung wird typischerweise für lineare Gleichungen verwendet (wobei Elemente von A keinen Zustandsvektor enthalten), kann aber für nichtlineare Gleichungen verwendet werden, bei denen die Elemente von A Zustandsvektoren haben können, die zu dem oben beschriebenen komplexen Verhalten führen können. Diese Gleichung beschreibt, wie sich eine Umgebung oder ein System ausgehend von einem bestimmten Ausgangszustand im Laufe der Zeit entwickelt. In der Mathematik werden diese als Anfangswertprobleme bezeichnet, da zur Beurteilung der Entwicklung des Methods die Angabe eines Ausgangszustands erforderlich ist.

Der obige Ausdruck beschreibt eine bestimmte Klasse von Differentialgleichungen, gewöhnliche Differentialgleichungen (ODE), bei denen die Ableitungen alle von einer Variablen stammen, normalerweise von der Zeit, gelegentlich aber auch vom Raum. Der Punkt bezeichnet dx/dt oder eine Zustandsänderung mit inkrementeller zeitlicher Änderung. ODEs sind intestine untersucht und für lineare ODE-Systeme steht eine breite Palette analytischer Lösungsansätze zur Verfügung. Analytische Lösungen ermöglichen es, Lösungen in Type von Variablen auszudrücken, was sie für die Untersuchung des gesamten Systemverhaltens flexibler macht. Für nichtlineare Systeme gibt es weniger Ansätze, für bestimmte Systemklassen stehen jedoch analytische Lösungen zur Verfügung. Zum größten Teil lassen sich nichtlineare (und einige lineare) ODEs jedoch am besten durch Simulation lösen, wobei die Lösung in jedem Zeitschritt als numerische Werte ermittelt wird.

Bei der Simulation geht es darum, eine Annäherung an die Differentialgleichung zu finden, oft durch Transformation in eine algebraische Gleichungdas über eine kleine Zeitänderung bis zu einem bekannten Grad genau ist. Laptop können dann im Laufe der Zeit viele kleine Änderungen durchlaufen, um zu zeigen, wie sich das System entwickelt. Zur Berechnung dieses Willens stehen zahlreiche Algorithmen zur Verfügung, beispielsweise ODE45 von Matlab oder die Funktionsolve_ivp von Python SciPy. Diese Algorithmen nehmen eine ODE und einen Startpunkt/Anfangszustand an, bestimmen automatisch die optimale Schrittgröße und durchlaufen das System bis zur angegebenen Endzeit.

Wenn wir die richtigen Steuereingaben an ein ODE-System anwenden können, können wir es oft in einen gewünschten Zustand bringen. Wie beim letzten Mal besprochen, bietet RL einen Ansatz zur Bestimmung der richtigen Eingaben für nichtlineare Systeme. Um RLs zu entwickeln, werden wir erneut die Turnhallenumgebung verwenden, dieses Mal werden wir jedoch eine benutzerdefinierte Turnhallenumgebung basierend auf unserem eigenen ODE erstellen. Nachfolgend GymnasialdokumentationWir schaffen einen Beobachtungsraum, der unseren Zustandsraum abdeckt, und einen Aktionsraum für den Kontrollraum. Wir initialisieren/setzen das Gymnasium auf einen beliebigen Punkt innerhalb des Zustandsraums (wobei wir hier vorsichtig sein müssen, nicht alle gewünschten Endzustände). sind immer erreichbar von jedem Ausgangszustand für einige Systeme). In der Schrittfunktion des Gymnasiums machen wir einen Schritt über einen kurzen Zeithorizont in unserem ODE, indem wir die vom Algorithmus geschätzte Eingabe mithilfe der Python SciPy-Funktion „solve_ivp“ anwenden. Solve_ivp ruft eine Funktion auf, die die jeweilige ODE enthält, mit der wir arbeiten. Der Code ist verfügbar unter Fool. Die Init- und Reset-Funktionen sind unkompliziert; Init erstellt einen Beobachtungsraum für jeden Zustand im System und Reset legt einen zufälligen Startpunkt für jede dieser Variablen innerhalb der Domäne in einem Mindestabstand vom Ursprung fest. Beachten Sie in der Schrittfunktion die Zeile „solve_ivp“, die die eigentliche Dynamik aufruft, die Dynamik-ODE über einen kurzen Zeitschritt löst und dabei die angewendete Steuerung Okay übergibt.

#taken from https://www.gymlibrary.dev/content material/environment_creation/
#create fitness center for Moore-Greitzer Mannequin
#motion area: steady  +/- 10.0 float , possibly make scale to mu 
#commentary area:  -30,30 x2 float for x,y,zand
#reward:  -1*(x^2+y^2+z^2)^1/2 (attempt to drive to 0)
#Moore-Grietzer mannequin:
from os import path
from typing import Elective
import numpy as np
import math
import scipy
from scipy.combine import solve_ivp
import gymnasium as fitness center
from gymnasium import areas
from gymnasium.envs.classic_control import utils
from gymnasium.error import DependencyNotInstalled
import dynamics  #native library containing formulation for solve_ivp
from dynamics import MGM
class MGMEnv(fitness center.Env):
#no render modes
def __init__(self, render_mode=None, dimension=30):
self.observation_space =areas.Field(low=-size+1, excessive=size-1, form=(2,), dtype=float)
self.action_space = areas.Field(-10, 10, form=(1,), dtype=float) 
#must replace motion to regular distribution
def _get_obs(self):
return self.state
def reset(self, seed: Elective(int) = None, choices=None):
#want under to seed self.np_random
tremendous().reset(seed=seed)
#begin random x1, x2 origin
np.random.seed(seed)
x=np.random.uniform(-8.,8.)
whereas (x>-2.5 and x<2.5):
np.random.seed()
x=np.random.uniform(-8.,8.)
np.random.seed(seed)
y=np.random.uniform(-8.,8.)
whereas (y>-2.5 and y<2.5):
np.random.seed()
y=np.random.uniform(-8.,8.)
self.state = np.array((x,y))
commentary = self._get_obs()
return commentary, {}
def step(self,motion):
u=motion.merchandise()
outcome=solve_ivp(MGM, (0, 0.05), self.state, args=(u))
x1=outcome.y(0,-1)
x2=outcome.y(1,-1)
self.state=np.array((x1.merchandise(),x2.merchandise()))
finished=False
commentary=self._get_obs()
information=x1
reward = -math.sqrt(x1.merchandise()**2)#+x2.merchandise()**2)
truncated = False #placeholder for future expnasion/limits if answer diverges
information = x1
return commentary, reward, finished, truncated, {}

Nachfolgend finden Sie die Dynamik der Moore-Greitzer-Modus-Funktion (MGM). Diese Implementierung basiert auf der Solve_ivp-Dokumentation. Es werden Grenzen gesetzt, um Lösungsdivergenzen zu vermeiden. Wenn das System die Grenzwerte erreicht, ist die Belohnung gering, was den Algorithmus dazu veranlasst, den Kontrollansatz zu überarbeiten. Das Erstellen von ODE-Turnhallen auf der Grundlage der hier besprochenen Vorlage sollte unkompliziert sein: Ändern Sie die Größe des Beobachtungsraums, um sie an die Abmessungen des ODE-Methods anzupassen, und aktualisieren Sie die Dynamikgleichung nach Bedarf.

def MGM(t, A, Okay):
#non-linear approximation of surge/stall dynamics of a fuel turbine engine per Moore-Greitzer mannequin from
#"Output-Feedbak Cotnrol on Nonlinear techniques utilizing Management Contraction Metrics and Convex Optimization"
#by Machester and Slotine
#2D system, x1 is mass circulation, x2 is strain improve
x1, x2 = A
if x1>20:  x1=20.
elif x1<-20:  x1=-20.
if x2>20:  x2=20.
elif x2<-20:  x2=-20.
dx1= -x2-1.5*x1**2-0.5*x1**3
dx2=x1+Okay
return np.array((dx1, dx2))

Für dieses Beispiel verwenden wir eine ODE, die auf dem Moore-Greitzer-Modell (MGM) basiert, um die Pump-Stall-Dynamik von Gasturbinentriebwerken zu beschreiben¹. Diese Gleichung beschreibt gekoppelte gedämpfte Schwingungen zwischen Motormassenstrom und -druck. Das Ziel des Reglers besteht darin, Schwingungen schnell auf Null zu dämpfen, indem er den Druck auf den Motor steuert. MGM hat „eine wesentliche Entwicklung des nichtlinearen Steuerungsdesigns motiviert“ und es zu einem interessanten Testfall für die SAC- und GP-Ansätze gemacht. Code, der die Gleichung beschreibt, finden Sie unter Github. Außerdem sind drei weitere nichtlineare ODEs aufgeführt. Der Van-Der-Pol-Oszillator ist ein klassisches nichtlineares Schwingsystem, das auf der Dynamik elektronischer Systeme basiert. Der Lorenz-Attraktor ist ein scheinbar einfaches System von ODEs, das chaotisches Verhalten oder Ergebnisse hervorrufen kann, die sehr empfindlich auf Anfangsbedingungen reagieren, sodass jede unendlich kleine Abweichung im Ausgangspunkt in einem unkontrollierten System bald zu stark divergierenden Zuständen führt. Das dritte ist ein Imply-Discipline-ODE-System von Duriez/Brunton/Noack, das die Entwicklung komplexer Wechselwirkungen stabiler und instabiler Wellen als Annäherung an turbulente Flüssigkeitsströmungen beschreibt.

Um eine Wiederholung der Analyse des letzten Artikels zu vermeiden, präsentieren wir hier lediglich die Ergebnisse und weisen darauf hin, dass der GP-Ansatz wiederum einen besseren Controller in kürzerer Rechenzeit lieferte als der SAC/neuronale Netzwerk-Ansatz. Die folgenden Abbildungen zeigen die Schwingungen eines ungeregelten Methods unter dem GP-Regler und unter dem SAC-Regler.

Beide Algorithmen verbessern die unkontrollierte Dynamik. Wir sehen, dass der SAC-Controller zwar schneller arbeitet (ca. 20 Zeitschritte), aber eine geringe Genauigkeit aufweist. Der GP-Controller braucht etwas länger, um zu reagieren, sorgt aber für ein reibungsloses Verhalten in beiden Zuständen. Auch als vorGP konvergierte in weniger Iterationen als SAC.

Wir haben gesehen, dass Turnhallen leicht übernommen werden können, um das Coaching von RL-Algorithmen auf ODE-Systemen zu ermöglichen, haben kurz besprochen, wie leistungsfähig ODEs für die Beschreibung und damit Erforschung der RL-Steuerung der physikalischen Dynamik sein können, und haben erneut gesehen, dass der GP bessere Ergebnisse liefert. Allerdings haben wir noch nicht versucht, einen der beiden Algorithmen zu optimieren, sondern haben uns bei der Einrichtung im Wesentlichen auf eine Schätzung der grundlegenden Algorithmusparameter gestützt. Wir werden dieses Manko jetzt beheben, indem wir die MGM-Studie erweitern.

Wiederholung

Diffusionsmodelle haben sich in letzter Zeit als De-facto-Customary für die Generierung komplexer, hochdimensionaler Ergebnisse herauskristallisiert. Sie kennen sie vielleicht für ihre Fähigkeit, atemberaubende KI-Kunst und hyperrealistische synthetische Bilderaber sie sind auch in anderen Anwendungen erfolgreich, wie zum Beispiel Arzneimitteldesign Und kontinuierliche Kontrolle. Die Kernidee hinter Diffusionsmodellen ist die iterative Umwandlung von zufälligem Rauschen in eine Probe, wie z. B. ein Bild oder eine Proteinstruktur. Dies wird typischerweise als Most-Probability-Schätzung Downside, bei dem das Modell trainiert wird, um Stichproben zu generieren, die möglichst genau mit den Trainingsdaten übereinstimmen.

Die meisten Anwendungsfälle von Diffusionsmodellen befassen sich jedoch nicht direkt mit der Anpassung der Trainingsdaten, sondern mit einem nachgelagerten Ziel. Wir wollen nicht nur ein Bild, das wie vorhandene Bilder aussieht, sondern eines, das eine bestimmte Artwork von Erscheinungsbild hat; wir wollen nicht nur ein Arzneimittelmolekül, das physikalisch plausibel ist, sondern eines, das so wirksam wie möglich ist. In diesem Beitrag zeigen wir, wie Diffusionsmodelle mithilfe von Reinforcement Studying (RL) direkt auf diese nachgelagerten Ziele trainiert werden können. Dazu optimieren wir Stabile Diffusion auf eine Vielzahl von Zielen, darunter Bildkomprimierbarkeit, vom Menschen wahrgenommene ästhetische Qualität und schnelle Bildausrichtung. Das letzte dieser Ziele nutzt Suggestions von ein großes Imaginative and prescient-Language-Modell um die Leistung des Modells bei ungewöhnlichen Eingabeaufforderungen zu verbessern und zu zeigen, wie Leistungsstarke KI-Modelle können zur gegenseitigen Verbesserung genutzt werden ohne dass ein Mensch involviert ist.

Ein Diagramm, das das Ziel der Immediate-Picture-Ausrichtung veranschaulicht. Es verwendet LLaVAein großes Bildsprachenmodell, um generierte Bilder auszuwerten.

Rauschunterdrückung, Diffusionspolitikoptimierung

Wenn wir Diffusion in ein RL-Downside umwandeln, machen wir nur die grundlegendste Annahme: Bei einer gegebenen Probe (z. B. einem Bild) haben wir Zugriff auf eine Belohnungsfunktion, die wir auswerten können, um zu erfahren, wie „intestine“ diese Probe ist. Unser Ziel ist es, dass das Diffusionsmodell Proben generiert, die diese Belohnungsfunktion maximieren.

Diffusionsmodelle werden typischerweise mit einer Verlustfunktion trainiert, die aus der Most-Probability-Schätzung (MLE) abgeleitet wird. Das bedeutet, dass sie dazu angehalten werden, Stichproben zu generieren, die die Trainingsdaten wahrscheinlicher erscheinen lassen. In der RL-Einstellung haben wir keine Trainingsdaten mehr, sondern nur Stichproben aus dem Diffusionsmodell und die damit verbundenen Belohnungen. Eine Möglichkeit, die gleiche MLE-motivierte Verlustfunktion weiterhin zu verwenden, besteht darin, die Stichproben als Trainingsdaten zu behandeln und die Belohnungen einzubeziehen, indem der Verlust für jede Stichprobe mit ihrer Belohnung gewichtet wird. Dies gibt uns einen Algorithmus, den wir belohnungsgewichtete Regression (RWR) nennen, nach Bestehende Algorithmen aus der RL-Literatur.

Dieser Ansatz bringt jedoch einige Probleme mit sich. Einer davon ist, dass RWR kein besonders exakter Algorithmus ist – er maximiert die Belohnung nur ungefähr (siehe Nair et al.Anhang A). Der MLE-inspirierte Verlust für Diffusion ist ebenfalls nicht exakt und wird stattdessen mithilfe eines Variationsgrenze von der tatsächlichen Wahrscheinlichkeit jeder Stichprobe. Das bedeutet, dass RWR die Belohnung durch zwei Näherungsebenen maximiert, was unserer Ansicht nach die Leistung erheblich beeinträchtigt.

Wir bewerten zwei Varianten von DDPO und zwei Varianten von RWR anhand von drei Belohnungsfunktionen und stellen fest, dass DDPO durchweg die beste Leistung erzielt.

Die wichtigste Erkenntnis unseres Algorithmus, den wir als Denoising Diffusion Coverage Optimization (DDPO) bezeichnen, besteht darin, dass wir die Belohnung der endgültigen Probe besser maximieren können, wenn wir auf die gesamte Abfolge der Denoising-Schritte achten, die uns dorthin geführt haben. Zu diesem Zweck definieren wir den Diffusionsprozess als mehrstufigen Markow-Entscheidungsprozess (MDP). In der MDP-Terminologie: Jeder Entrauschungsschritt ist eine Aktion, und der Agent erhält nur im letzten Schritt jeder Entrauschungstrajektorie eine Belohnung, wenn die endgültige Probe erstellt wird. Dieses Framework ermöglicht es uns, viele leistungsstarke Algorithmen aus der RL-Literatur anzuwenden, die speziell für mehrstufige MDPs entwickelt wurden. Anstatt die ungefähre Wahrscheinlichkeit der endgültigen Probe zu verwenden, verwenden diese Algorithmen die genaue Wahrscheinlichkeit jedes Entrauschungsschritts, die äußerst einfach zu berechnen ist.

Wir haben uns für die Anwendung von Coverage-Gradient-Algorithmen entschieden, da diese einfach zu implementieren sind und bisherige Erfolge bei der Feinabstimmung von SprachmodellenDies führte zu zwei Varianten von DDPO: DDPO_SFdas den einfachen Rating-Funktionsschätzer des Coverage-Gradienten verwendet, auch bekannt als VERSTÄRKEN; und DDPO_ISTdas einen leistungsfähigeren Significance-Sampling-Schätzer verwendet. DDPO_IST ist unser Algorithmus mit der besten Leistung und seine Implementierung folgt eng der von proximale Richtlinienoptimierung (PPO).

Feinabstimmung der stabilen Diffusion mit DDPO

Für unsere Hauptergebnisse optimieren wir Stabile Diffusion v1-4 mit DDPO_IST. Wir haben vier Aufgaben, jede von ihnen wird durch eine andere Belohnungsfunktion definiert:

• Komprimierbarkeit: Wie einfach lässt sich das Bild mit dem JPEG-Algorithmus komprimieren? Als Belohnung erhält man die unfavorable Dateigröße des Bildes (in kB), wenn es als JPEG gespeichert wird.
• Inkompressibilität: Wie schwer ist das Bild mit dem JPEG-Algorithmus zu komprimieren? Die Belohnung ist die constructive Dateigröße des Bildes (in kB), wenn es als JPEG gespeichert wird.
• Ästhetische Qualität: Wie ästhetisch ansprechend ist das Bild für das menschliche Auge? Die Belohnung ist die Ausgabe des LAION Ästhetik-Prädiktorein neuronales Netzwerk, das auf menschliche Vorlieben trainiert ist.
• Immediate-Bild-Ausrichtung: Wie intestine stellt das Bild dar, was in der Eingabeaufforderung gefragt wurde? Das ist etwas komplizierter: Wir geben das Bild in LLaVAbitten Sie es, das Bild zu beschreiben, und berechnen Sie dann die Ähnlichkeit zwischen dieser Beschreibung und der ursprünglichen Eingabeaufforderung mithilfe von BERTScore.

Da Secure Diffusion ein Textual content-zu-Bild-Modell ist, müssen wir auch eine Reihe von Eingabeaufforderungen auswählen, die wir ihm während der Feinabstimmung geben. Für die ersten drei Aufgaben verwenden wir einfache Eingabeaufforderungen der Type „ein Tier)“Für die Ausrichtung von Eingabeaufforderung und Bild verwenden wir Eingabeaufforderungen der Type „eine (tierische) (Tätigkeit)“wo die Aktivitäten „Geschirr spülen“, „Schach spielen“Und „Fahrrad fahren“. Wir haben festgestellt, dass Secure Diffusion bei diesen ungewöhnlichen Szenarien oft Probleme hatte, Bilder zu produzieren, die der Eingabeaufforderung entsprachen, sodass durch RL-Feinabstimmung viel Raum für Verbesserungen blieb.

Zunächst veranschaulichen wir die Leistung von DDPO bei den einfachen Belohnungen (Kompressibilität, Inkompressibilität und ästhetische Qualität). Alle Bilder werden mit demselben Zufallsstartwert generiert. Im oberen linken Quadranten veranschaulichen wir, was die „normale“ stabile Diffusion für neun verschiedene Tiere generiert; alle RL-fein abgestimmten Modelle zeigen einen klaren qualitativen Unterschied. Interessanterweise tendiert das Modell der ästhetischen Qualität (oben rechts) zu minimalistischen schwarz-weißen Strichzeichnungen und zeigt die Arten von Bildern, die der ästhetische Prädiktor von LAION als „ästhetischer“ betrachtet.

Als Nächstes demonstrieren wir DDPO anhand der komplexeren Aufgabe der Immediate-Picture-Ausrichtung. Hier zeigen wir mehrere Schnappschüsse aus dem Trainingsprozess: Jede Serie von drei Bildern zeigt Beispiele für denselben Immediate und denselben Zufallsstartwert im Zeitverlauf, wobei das erste Beispiel aus der Standardversion von Secure Diffusion stammt. Interessanterweise verschiebt sich das Modell in Richtung eines eher cartoonartigen Stils, was nicht beabsichtigt battle. Wir vermuten, dass dies daran liegt, dass Tiere, die menschenähnliche Aktivitäten ausführen, in den Vortrainingsdaten eher in einem cartoonartigen Stil erscheinen, sodass das Modell in Richtung dieses Stils verschiebt, um sich leichter an den Immediate anzupassen, indem es das nutzt, was es bereits weiß.

Unerwartete Verallgemeinerung

Es hat sich gezeigt, dass bei der Feinabstimmung großer Sprachmodelle mit RL überraschende Verallgemeinerungen auftreten: Beispielsweise wurden Modelle, die nur auf die Befolgung von Anweisungen in Englisch abgestimmt sind, verbessern sich oft in anderen Sprachen. Wir stellen fest, dass das gleiche Phänomen bei Textual content-Bild-Diffusionsmodellen auftritt. Beispielsweise wurde unser Modell der ästhetischen Qualität mithilfe von Eingabeaufforderungen verfeinert, die aus einer Liste von 45 häufig vorkommenden Tieren ausgewählt wurden. Wir stellen fest, dass es nicht nur auf unbekannte Tiere, sondern auch auf Alltagsgegenstände verallgemeinert werden kann.

Unser Immediate-Picture-Alignment-Modell verwendete während des Trainings dieselbe Liste mit 45 häufig vorkommenden Tieren und nur drei Aktivitäten. Wir stellen fest, dass es nicht nur auf unbekannte Tiere, sondern auch auf unbekannte Aktivitäten und sogar auf neuartige Kombinationen aus beidem verallgemeinert werden kann.

Überoptimierung

Es ist bekannt, dass die Feinabstimmung einer Belohnungsfunktion, insbesondere einer erlernten, zu Folgendem führen kann: Überoptimierung der Belohnung wo das Modell die Belohnungsfunktion ausnutzt, um auf nicht nützliche Weise eine hohe Belohnung zu erzielen. Unsere Einstellung ist keine Ausnahme: Bei allen Aufgaben zerstört das Modell schließlich jeden sinnvollen Bildinhalt, um die Belohnung zu maximieren.

Wir haben auch festgestellt, dass LLaVA anfällig für typografische Angriffe ist: bei der Optimierung der Ausrichtung in Bezug auf Eingabeaufforderungen der Type „(n) Tiere“DDPO konnte LLaVA erfolgreich täuschen, indem es stattdessen einen Textual content generierte, der der richtigen Nummer grob ähnelte.

Derzeit gibt es keine allgemeingültige Methode zur Vermeidung einer Überoptimierung und wir heben dieses Downside als einen wichtigen Bereich für künftige Arbeiten hervor.

Abschluss

Wenn es darum geht, komplexe, hochdimensionale Ergebnisse zu erzeugen, sind Diffusionsmodelle kaum zu übertreffen. Bisher waren sie jedoch vor allem bei Anwendungen erfolgreich, bei denen es darum ging, Muster aus sehr großen Datenmengen zu lernen (beispielsweise Bildunterschriftenpaare). Wir haben eine Methode gefunden, Diffusionsmodelle effektiv zu trainieren, die über das Mustervergleichen hinausgeht – und ohne dass unbedingt Trainingsdaten erforderlich sind. Die Möglichkeiten werden nur durch die Qualität und Kreativität Ihrer Belohnungsfunktion begrenzt.

Die Artwork und Weise, wie wir DDPO in dieser Arbeit verwendet haben, ist von den jüngsten Erfolgen bei der Feinabstimmung von Sprachmodellen inspiriert. Die GPT-Modelle von OpenAI, wie Secure Diffusion, werden zunächst mit riesigen Mengen an Internetdaten trainiert; sie werden dann mit RL feinabgestimmt, um nützliche Instruments wie ChatGPT zu erstellen. Normalerweise wird ihre Belohnungsfunktion aus menschlichen Vorlieben gelernt, aber Andere Greif zu kürzlich haben herausgefunden, wie man leistungsstarke Chatbots mit Belohnungsfunktionen auf Foundation von KI-Suggestions erstellen kann. Im Vergleich zum Chatbot-Regime sind unsere Experimente klein und in ihrem Umfang begrenzt. Aber angesichts des enormen Erfolgs dieses Paradigmas „Vortrainieren + Feinabstimmen“ in der Sprachmodellierung scheint es sich durchaus zu lohnen, es in der Welt der Diffusionsmodelle weiter zu verfolgen. Wir hoffen, dass andere auf unserer Arbeit aufbauen können, um große Diffusionsmodelle zu verbessern, nicht nur für die Textual content-zu-Bild-Generierung, sondern für viele spannende Anwendungen wie Videogenerierung, Musikgeneration, Bildbearbeitung, Proteinsynthese, Robotikund mehr.

Darüber hinaus ist das Paradigma „Vortrainieren + Feinabstimmen“ nicht die einzige Möglichkeit, DDPO zu verwenden. Solange Sie eine gute Belohnungsfunktion haben, hindert Sie nichts daran, von Anfang an mit RL zu trainieren. Obwohl dieser Ansatz noch unerforscht ist, ist dies ein Ort, an dem die Stärken von DDPO wirklich zum Tragen kommen könnten. Reines RL wird seit langem in einer Vielzahl von Bereichen eingesetzt, von Spiele spielen Zu Robotermanipulation Zu Kernfusion Zu Chipdesign. Wenn man die leistungsstarke Ausdruckskraft von Diffusionsmodellen hinzufügt, hat man das Potenzial, bestehende RL-Anwendungen auf die nächste Ebene zu heben – oder sogar neue zu entdecken.

Dieser Beitrag basiert auf dem folgenden Dokument:

Wenn Sie mehr über DDPO erfahren möchten, können Sie sich die Papier, Webseite, ursprünglicher Codeoder holen Sie sich die Modellgewichte auf Hugging FaceWenn Sie DDPO in Ihrem eigenen Projekt verwenden möchten, lesen Sie meine PyTorch + LoRA-Implementierung wo Sie Secure Diffusion mit weniger als 10 GB GPU-Speicher feinabstimmen können!

Wenn DDPO Ihre Arbeit inspiriert, zitieren Sie es bitte mit:

@misc{black2023ddpo,
      title={Coaching Diffusion Fashions with Reinforcement Studying}, 
      creator={Kevin Black and Michael Janner and Yilun Du and Ilya Kostrikov and Sergey Levine},
      12 months={2023},
      eprint={2305.13301},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}