Verstärkungstraining für die Kleinsten

Dieser Artikel beschreibt das Prinzip der maschinellen Lernmethode am Beispiel eines physikalischen Systems. Der optimale Strategie-Suchalgorithmus wird mithilfe der Methode in Python-Code implementiert .

Verstärktes Lernen ist eine maschinelle Lernmethode, bei der ein Modell trainiert wird, das keine Informationen über das System enthält, jedoch die Möglichkeit hat, Aktionen darin auszuführen. Aktionen versetzen das System in einen neuen Zustand und das Modell erhält eine Belohnung vom System. Betrachten Sie die Funktionsweise der Methode anhand des im Video gezeigten . Die Videobeschreibung enthält den Code für , der in implementiert ist .

Herausforderung


Bei Verwendung der Bewehrungstrainingsmethode muss dem Wagen beigebracht werden, sich bis zur maximalen Entfernung von der Wand zu entfernen. Die Auszeichnung wird als Wert der Änderung des Abstands von der Wand zum Wagen während der Bewegung vergeben. Der Abstand D von der Wand wird mit einem Entfernungsmesser gemessen. Die Bewegung in diesem Beispiel ist nur mit einem gewissen Versatz des "Antriebs" möglich, bestehend aus zwei Pfeilen S1 und S2. Pfeile sind zwei Servos mit Führungen, die in Form eines „Knies“ verbunden sind. In diesem Beispiel kann jeder Servo 6 gleiche Winkel drehen. Das Modell hat die Fähigkeit, 4 Aktionen auszuführen, die die Steuerung von zwei Servos sind. Aktion 0 und 1 drehen das erste Servo um einen bestimmten Winkel im und gegen den Uhrzeigersinn. schritt 2 und 3 drehen den zweiten servoantrieb um einen bestimmten winkel im uhrzeigersinn und gegen den uhrzeigersinn. Abbildung 1 zeigt einen funktionierenden Prototyp eines Wagens.


Abb. 1. Wagenprototyp für Experimente mit maschinellem Lernen:

In Abbildung 2 ist Pfeil S2 rot, Pfeil S1 blau und 2 Servos schwarz hervorgehoben.


Abb. 2. System-Engine Das Systemdiagramm

ist in Abbildung 3 dargestellt. Der Abstand zur Wand ist mit D gekennzeichnet, der Entfernungsmesser ist gelb dargestellt, das Systemlaufwerk ist rot und schwarz hervorgehoben.


Abb. 3. Systemdiagramm Der

Bereich der möglichen Positionen für S1 und S2 ist in Abbildung 4 dargestellt:


Abb. 4.a. Gestängebereich S1


Abb. 4.b. Gestängepositionsbereich S2

Die Endlagen des Stellantriebs sind in Abbildung 5 dargestellt:

Bei S1 = S2 = 5 der maximale Abstand zum Boden.
Mit S1 = S2 = 0 ist die minimale Reichweite zum Boden.


Abb. 5. Grenzpositionen der Pfeile S1 und S2

Der "Antrieb" hat 4 Freiheitsgrade. Eine Aktion ändert die Position der Pfeile S1 und S2 im Raum nach einem bestimmten Prinzip. Die Arten von Aktionen sind in Abbildung 6 dargestellt


. 6. Arten von Aktionen (Action) im System:

Aktion 0 erhöht den Wert von S1. Schritt 1 verringert den Wert von S1.
Schritt 2 erhöht den Wert von S2. Schritt 3 verringert den S2-Wert.

Bewegung


In unserem Problem wird der Wagen nur in 2 Fällen gefahren:
In Position S1 = 0, S2 = 1, Aktion 3 setzt den Wagen von der Wand in Bewegung, das System erhält eine positive Belohnung in Höhe der Abstandsänderung zur Wand. In unserem Beispiel ist die Belohnung 1.


Abb. 7. Bewegung des Systems mit positiver Belohnung

In Position S1 = 0, S2 = 0, Aktion 2 fährt der Wagen an die Wand, das System erhält eine negative Belohnung in Höhe der Abstandsänderung zur Wand. In unserem Beispiel ist die Belohnung -1.


Abb. 8. Bewegung des Systems mit negativer Belohnung

Unter anderen Bedingungen und bei allen Aktionen des „Antriebs“ steht das System still und die Belohnung ist 0.
Ich möchte darauf hinweisen, dass der stabile dynamische Zustand des Systems eine Folge von Aktionen 0-2-1-3 aus dem Zustand S1 = S2 = 0 ist, in dem sich der Wagen mit einer minimalen Anzahl von durchgeführten Aktionen in eine positive Richtung bewegt. Erhöht das Knie - streckt das Knie - senkt das Knie - beugt das Knie = der Wagen fährt weiter, wiederholen. Unter Verwendung des maschinellen Lernverfahrens ist es daher erforderlich, einen solchen Zustand des Systems zu finden, eine solche bestimmte Abfolge von Aktionen, deren Belohnung nicht sofort empfangen wird (Aktionen 0-2-1 - die Belohnung ist 0, die jedoch erforderlich sind, um 1 für die nächste Aktion 3 zu erhalten )

Q-Learning-Methode


Grundlage der Q-Learning-Methode ist eine Matrix von Systemzustandsgewichten. Die Matrix Q ist eine Menge aller möglichen Zustände des Systems und der Gewichte der Reaktion des Systems auf verschiedene Aktionen.
In diesem Problem sind mögliche Kombinationen der Systemparameter 36 = 6 ^ 2. In jedem der 36 Systemzustände können 4 verschiedene Aktionen ausgeführt werden (Aktion = 0,1,2,3).
Fig. 9 zeigt den Anfangszustand der Matrix Q. Die Nullspalte enthält den Zeilenindex, die erste Zeile ist der Wert von S1, die zweite ist der Wert von S2, die letzten 4 Spalten sind Gewichtungen mit Aktionen gleich 0, 1, 2 und 3. Jede Zeile repräsentiert einen eindeutigen Zustand des Systems.
Bei der Initialisierung der Tabelle werden alle Werte der Gewichte 10


gleichgesetzt. 9. Initialisierung der Matrix Q

Nach dem Trainieren des Modells (~ 15000 Iterationen) hat die Matrix Q die in Abbildung 10 gezeigte Form


. 10. Matrix Q nach 15000 Trainingsiterationen

Bitte beachten Sie, dass Aktionen mit Gewichten von 10 im System nicht möglich sind, sodass sich der Wert der Gewichte nicht geändert hat. In der Extremposition mit S1 = S2 = 0 können beispielsweise die Aktionen 1 und 3 nicht ausgeführt werden, da dies eine Einschränkung der physischen Umgebung darstellt. Diese Grenzaktionen sind in unserem Modell verboten, daher verwendet der Algorithmus keine 10k.

Betrachten Sie das Ergebnis des Algorithmus:
...
Iteration: 14991, war: S1 = 0 S2 = 0, Aktion = 0, jetzt: S1 = 1 S2 = 0, Preis: 0
Iteration: 14992, war: S1 = 1 S2 = 0, Aktion = 2, jetzt: S1 = 1 S2 = 1, Preis: 0
Iteration: 14993, war: S1 = 1 S2 = 1, Aktion = 1, jetzt: S1 = 0 S2 = 1, Preis: 0
Iteration: 14994, war: S1 = 0 S2 = 1, Aktion = 3, jetzt: S1 = 0 S2 = 0, Preis: 1
Iteration: 14995, war: S1 = 0 S2 = 0, Aktion = 0, jetzt: S1 = 1 S2 = 0, Preis: 0
Iteration: 14996, war: S1 = 1 S2 = 0, Aktion = 2, jetzt: S1 = 1 S2 = 1, Preis: 0
Iteration: 14997, war: S1 = 1 S2 = 1, Aktion = 1, jetzt: S1 = 0 S2 = 1, Preis: 0
Iteration: 14998, war: S1 = 0 S2 = 1, Aktion = 3, jetzt: S1 = 0 S2 = 0, Preis: 1
Iteration: 14999, war : S1 = 0 S2 = 0, Aktion = 0, jetzt: S1 = 1 S2 = 0, Preis: 0 Schauen

wir uns
das genauer an : Nehmen Sie Iteration 14991 als aktuellen Status.
1. Der aktuelle Zustand des Systems ist S1 = S2 = 0, diese Zeile entspricht einer Zeile mit Index 0. Der höchste Wert ist 0.617 (ignorieren Sie die oben beschriebenen Werte von 10), er entspricht Action = 0. Daher ist gemäß der Matrix Q, wenn der Zustand des Systems S1 = S2 ist = 0 führen wir Aktion 0 aus. Aktion 0 erhöht den Wert des Drehwinkels des Servoantriebs S1 (S1 = 1).
2. Der nächste Zustand S1 = 1, S2 = 0 entspricht der Zeile mit Index 6. Der Maximalwert des Gewichts entspricht Aktion = 2. Aktion 2 durchführen - S2 erhöhen (S2 = 1).
3. Der nächste Zustand S1 = 1, S2 = 1 entspricht der Zeile mit Index 7. Der maximale Gewichtswert entspricht Aktion = 1. Aktion 1 ausführen - S1 verringern (S1 = 0).
4. Der nächste Zustand S1 = 0, S2 = 1 entspricht der Zeile mit Index 1. Der Maximalwert des Gewichts entspricht Aktion = 3. Aktion 3 ausführen - S2 verringern (S2 = 0).
5. Als Ergebnis kehrten sie in den Zustand S1 = S2 = 0 zurück und verdienten 1 Punkt Belohnung.

Abbildung 11 zeigt das Prinzip der Auswahl der optimalen Aktion.


Abb. 11.a. Matrix Q


Abb. 11.b. Matrix F

Lassen Sie uns den Lernprozess genauer betrachten.

Q-Learning-Algorithmus
minus = 0;
plus = 0;
initializeQ();
for t in range(1,15000):
    epsilon = math.exp(-float(t)/explorationConst); 
    s01 = s1; s02 = s2
    current_action = getAction(); 
    setSPrime(current_action);  
    setPhysicalState(current_action);
    r = getDeltaDistanceRolled(); 
    lookAheadValue = getLookAhead();   
    sample = r + gamma*lookAheadValue;
    if t > 14900:    
        print 'Time: %(0)d, was: %(1)d %(2)d, action: %(3)d, now: %(4)d %(5)d, prize: %(6)d ' % \
            {"0": t, "1": s01, "2": s02, "3": current_action, "4": s1, "5": s2, "6": r}        
    Q.iloc[s, current_action] = Q.iloc[s, current_action] + alpha*(sample - Q.iloc[s, current_action] ) ;
    s = sPrime;
    if deltaDistance == 1: 
        plus += 1;
    if deltaDistance == -1: 
        minus += 1;
print( minus, plus )



Vollständiger Code auf .

Stellen Sie die Anfangsposition des Knies auf die höchste Position:

s1=s2=5.

Wir initialisieren die Matrix Q, indem wir den Anfangswert eingeben:

initializeQ();

Wir berechnen den epsilon- Parameter . Dies ist das Gewicht der "Zufälligkeit" des Algorithmus in unserer Berechnung. Je mehr Trainingsiterationen bestanden wurden, desto weniger zufällige Werte von Aktionen werden ausgewählt:

epsilon = math.exp(-float(t)/explorationConst)

Für die erste Iteration:

epsilon = 0.996672

Speichern Sie den aktuellen Status:

s01 = s1; s02 = s2

Ermitteln Sie den "besten" Wert der Aktion:

current_action = getAction();

Lassen Sie uns die Funktion genauer betrachten.

Die Funktion getAction () gibt den Wert der Aktion zurück, der der maximalen Gewichtung im aktuellen Status des Systems entspricht. Der aktuelle Status des Systems in der Q-Matrix wird ermittelt und die Aktion ausgewählt, die dem Maximalgewicht entspricht. Beachten Sie, dass diese Funktion einen Auswahlmechanismus für zufällige Aktionen implementiert. Wenn die Anzahl der Iterationen zunimmt, nimmt die zufällige Auswahl der Aktion ab. Dies geschieht, damit sich der Algorithmus nicht auf die ersten gefundenen Optionen konzentriert und einen anderen Weg einschlagen kann, der sich möglicherweise als besser herausstellt.

In der Ausgangsposition der Pfeile sind nur zwei Aktionen 1 und 3 möglich, der Algorithmus hat Aktion 1 gewählt.
Als nächstes bestimmen wir die Zeilennummer in der Q-Matrix für den nächsten Zustand des Systems, in den das System nach der im vorherigen Schritt empfangenen Aktion übergeht.

setSPrime(current_action);

In einer realen physischen Umgebung würden wir nach dem Ausführen einer Aktion eine Belohnung erhalten, wenn es eine Bewegung gäbe, aber da die Bewegung des Wagens modelliert ist, ist es notwendig, Hilfsfunktionen einzuführen, um die Reaktion des physischen Mediums auf Aktionen zu emulieren. (setPhysicalState und getDeltaDistanceRolled ()) Führen
wir die Funktionen aus:

setPhysicalState(current_action);
- Wir simulieren die Reaktion des Mediums auf unsere gewählte Aktion. Wir ändern die Position der Servos, wir verschieben den Wagen.

r = getDeltaDistanceRolled();
- Berechnen Sie die Belohnung - die vom Wagen zurückgelegte Strecke.

Nach Abschluss der Aktion müssen wir den Koeffizienten dieser Aktion in der Matrix Q für den entsprechenden Status des Systems aktualisieren. Es ist logisch, dass der Koeffizient in unserem Algorithmus um einen niedrigeren Wert als bei einer negativen Belohnung abnehmen sollte, wenn die Aktion zu einer positiven Belohnung führte.
Jetzt ist es am interessantesten, in die Zukunft zu schauen, um das Gewicht des aktuellen Schritts zu berechnen.
Bei der Bestimmung der optimalen Aktion, die im aktuellen Status ausgeführt werden muss, wählen wir das größte Gewicht in der Matrix Q aus. Da wir den neuen Status des Systems kennen, zu dem wir gewechselt haben, können wir den maximalen Gewichtswert aus Tabelle Q für diesen Status ermitteln:

lookAheadValue = getLookAhead();

Ganz am Anfang ist es 10. Und wir verwenden den Gewichtswert der Aktion, die noch nicht abgeschlossen wurde, um das aktuelle Gewicht zu berechnen.

sample = r + gamma*lookAheadValue;
sample = 7.5
Q.iloc[s, current_action] = Q.iloc[s, current_action] + alpha*(sample - Q.iloc[s, current_action] ) ;
Q.iloc[s, current_action] = 9.75

Das heißt Wir haben den Gewichtswert des nächsten Schritts verwendet, um das Gewicht des aktuellen Schritts zu berechnen. Je größer das Gewicht des nächsten Schritts ist, desto geringer ist das Gewicht des Stroms (gemäß der Formel), und der aktuelle Schritt ist beim nächsten Mal vorzuziehen.
Dieser einfache Trick liefert gute Konvergenzergebnisse für den Algorithmus.

Algorithmus-Skalierung


Dieser Algorithmus kann auf eine größere Anzahl von Freiheitsgraden des Systems (s_features) und eine größere Anzahl von Werten erweitert werden, die der Freiheitsgrad (s_states) annimmt, jedoch in kleinen Grenzen. Die Q-Matrix nimmt schnell genug den gesamten RAM ein. Unten finden Sie ein Beispiel für den Code zum Erstellen einer zusammenfassenden Matrix von Zuständen und Modellgewichten. Mit der Anzahl der "Pfeile" s_features = 5 und der Anzahl der verschiedenen Positionen des Pfeils s_states = 10 hat die Matrix Q Dimensionen (100000, 9).

Zunehmende Freiheitsgrade des Systems
import numpy as np
s_features = 5
s_states = 10
numActions = 4
data = np.empty((s_states**s_features, s_features + numActions), dtype='int')
for h in range(0, s_features):
    k = 0
    N = s_states**(s_features-1-1*h)
    for q in range(0, s_states**h):
        for i in range(0, s_states):
            for j in range(0, N):
                data[k, h] = i        
                k += 1
for i in range(s_states**s_features):
        for j in range(numActions):
            data[i,j+s_features] = 10.0;
data.shape
# (100000L, 9L)


Fazit


Diese einfache Methode zeigt die „Wunder“ des maschinellen Lernens, wenn ein Modell, ohne etwas über die Umgebung zu wissen, den optimalen Zustand lernt und findet, in dem die Belohnung für Aktionen maximal ist, und die Belohnung nicht sofort für eine Aktion, sondern für eine Abfolge von Aktionen vergeben wird.

Vielen Dank für Ihre Aufmerksamkeit!

Jetzt auch beliebt: