Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Eine Belohnungsfunktion anpassen
Das Erstellen einer Belohnungsfunktion ist wie das Entwerfen eines Anreizplans. Parameter sind Werte, die zur Entwicklung Ihres Prämienplans verwendet werden können.
Verschiedene Anreizstrategien führen zu unterschiedlichem Fahrzeugverhalten. Um das Fahrzeug zu einer schnelleren Fahrt anzuregen, sollten Sie versuchen, negative Werte zu vergeben, wenn das Auto zu lange braucht, um eine Runde zu beenden, oder wenn es von der Strecke abkommt. Um Zick-Zack-Fahrmuster zu vermeiden, versuchen Sie, eine Begrenzung des Lenkwinkelbereichs zu definieren und das Fahrzeug dafür zu belohnen, dass es auf geraden Streckenabschnitten weniger aggressiv lenkt.
Sie können Wegpunkte verwenden, bei denen es sich um nummerierte Markierungen handelt, die entlang der Mittellinie sowie an den äußeren und inneren Rändern der Strecke angebracht sind. Sie helfen Ihnen dabei, ein bestimmtes Fahrverhalten bestimmten Merkmalen einer Strecke zuzuordnen, z. B. Geraden und Kurven.
Die Entwicklung einer effektiven Belohnungsfunktion ist ein kreativer und iterativer Prozess. Probieren Sie verschiedene Strategien aus, kombinieren Sie Parameter und haben Sie vor allem Spaß!
Themen
Python-Code bearbeiten, um Ihre Belohnungsfunktion anzupassen
In AWS DeepRacer Student können Sie Beispiele für Belohnungsfunktionen bearbeiten, um eine benutzerdefinierte Rennstrategie für Ihr Modell zu erstellen.
So passen Sie Ihre Belohnungsfunktion an
-
Wählen Sie auf der Seite „Schritt 5: Prämienfunktion anpassen“ der Modelloberfläche AWS DeepRacer Student Create ein Beispiel für eine Prämienfunktion aus.
-
Verwenden Sie den Code-Editor unter dem Beispiel für die Auswahl von Belohnungsfunktionen, um die Eingabeparameter der Belohnungsfunktion mithilfe von Python-Code anzupassen.
-
Wählen Sie Validieren aus, um zu überprüfen, ob Ihr Code funktioniert oder nicht. Wählen Sie alternativ Zurücksetzen, um von vorne zu beginnen.
-
Wenn Sie mit den Änderungen fertig sind, wählen Sie Weiter.
Verwenden SieEingabeparameter der AWS DeepRacer Belohnungsfunktion, um mehr über die einzelnen Parameter zu erfahren. Sehen Sie sich in Beispielen für Belohnungsfunktionen an, wie verschiedene Parameter verwendet werden.
Eingabeparameter der AWS DeepRacer Belohnungsfunktion
Die AWS DeepRacer Belohnungsfunktion verwendet ein Wörterbuchobjekt, das als Variable,, übergeben params wird, als Eingabe.
def reward_function(params) : reward = ... return float(reward)
Das params-Dictionary-Objekt enthält die folgenden Schlüssel/Werte-Paare:
{ "all_wheels_on_track": Boolean, # flag to indicate if the agent is on the track "x": float, # agent's x-coordinate in meters "y": float, # agent's y-coordinate in meters "closest_objects": [int, int], # zero-based indices of the two closest objects to the agent's current position of (x, y). "closest_waypoints": [int, int], # indices of the two nearest waypoints. "distance_from_center": float, # distance in meters from the track center "is_crashed": Boolean, # Boolean flag to indicate whether the agent has crashed. "is_left_of_center": Boolean, # Flag to indicate if the agent is on the left side to the track center or not. "is_offtrack": Boolean, # Boolean flag to indicate whether the agent has gone off track. "is_reversed": Boolean, # flag to indicate if the agent is driving clockwise (True) or counter clockwise (False). "heading": float, # agent's yaw in degrees "objects_distance": [float, ], # list of the objects' distances in meters between 0 and track_length in relation to the starting line. "objects_heading": [float, ], # list of the objects' headings in degrees between -180 and 180. "objects_left_of_center": [Boolean, ], # list of Boolean flags indicating whether elements' objects are left of the center (True) or not (False). "objects_location": [(float, float),], # list of object locations [(x,y), ...]. "objects_speed": [float, ], # list of the objects' speeds in meters per second. "progress": float, # percentage of track completed "speed": float, # agent's speed in meters per second (m/s) "steering_angle": float, # agent's steering angle in degrees "steps": int, # number steps completed "track_length": float, # track length in meters. "track_width": float, # width of the track "waypoints": [(float, float), ] # list of (x,y) as milestones along the track center }
Verwenden Sie die folgende Referenz, um die AWS DeepRacer Eingabeparameter besser zu verstehen.
all_wheels_on_track
Typ: Boolean
Bereich (True:False)
Eine Boolean Markierung, die anzeigt, ob der Agent auf dem richtigen Weg ist oder nicht. Der Agent ist nicht auf Kurs (False), wenn sich eines seiner Räder außerhalb der Streckengrenzen befindet. Er ist auf Kurs (True), wenn sich alle vier Räder innerhalb der inneren und äußeren Spurgrenzen befinden. Die folgende Abbildung zeigt einen Agenten, der auf dem richtigen Weg ist.
Die folgende Abbildung zeigt einen Agenten, der nicht auf dem richtigen Weg ist, weil sich zwei Räder außerhalb der Streckengrenzen befinden.
Beispiel: Eine Belohnungsfunktion mit dem Parameter all_wheels_on_track.
def reward_function(params): ############################################################################# ''' Example of using all_wheels_on_track and speed ''' # Read input variables all_wheels_on_track = params['all_wheels_on_track'] speed = params['speed'] # Set the speed threshold based your action space SPEED_THRESHOLD = 1.0 if not all_wheels_on_track: # Penalize if the car goes off track reward = 1e-3 elif speed < SPEED_THRESHOLD: # Penalize if the car goes too slow reward = 0.5 else: # High reward if the car stays on track and goes fast reward = 1.0 return float(reward)
closest_waypoints
Typ: [int, int]
Bereich: [(0:Max-1),(1:Max-1)]
Die nullbasierten Indizes der beiden benachbarten waypoints, die der aktuellen Position (x, y) des Agenten am nächsten liegen. Die Entfernung wird über den euklidischen Abstand von der Mitte des Fahrzeugs aus gemessen. Das erste Element bezieht sich auf den nächsten Wegpunkt hinter dem Agenten und das zweite Element bezieht sich auf den nächsten Wegpunkt vor dem Agenten. Max ist die Länge der Wegpunktliste. In der Abbildung in waypoints closest_waypoints sind dies[16, 17].
Die folgende exemplarische Belohnungsfunktion zeigt, wie man mit waypoints und closest_waypoints sowie heading direkte Belohnungen berechnet.
AWS DeepRacer unterstützt die folgenden Python-Bibliotheken: mathrandom,numpy,scipy, undshapely. Um eine zu verwenden, fügen Sie vor Ihrer Funktionsdefinition eine Import-Anweisung hinzudef
reward_function(params). import supported
library
Beispiel: Eine Belohnungsfunktion, die den closest_waypoints Parameter verwendet.
# Place import statement outside of function (supported libraries: math, random, numpy, scipy, and shapely) # Example imports of available libraries # # import math # import random # import numpy # import scipy # import shapely import math def reward_function(params): ############################################################################### ''' Example of using waypoints and heading to make the car point in the right direction ''' # Read input variables waypoints = params['waypoints'] closest_waypoints = params['closest_waypoints'] heading = params['heading'] # Initialize the reward with typical value reward = 1.0 # Calculate the direction of the centerline based on the closest waypoints next_point = waypoints[closest_waypoints[1]] prev_point = waypoints[closest_waypoints[0]] # Calculate the direction in radius, arctan2(dy, dx), the result is (-pi, pi) in radians track_direction = math.atan2(next_point[1] - prev_point[1], next_point[0] - prev_point[0]) # Convert to degree track_direction = math.degrees(track_direction) # Calculate the difference between the track direction and the heading direction of the car direction_diff = abs(track_direction - heading) if direction_diff > 180: direction_diff = 360 - direction_diff # Penalize the reward if the difference is too large DIRECTION_THRESHOLD = 10.0 if direction_diff > DIRECTION_THRESHOLD: reward *= 0.5 return float(reward)
closest_objects
Typ: [int, int]
Bereich: [(0:len(object_locations)-1),
(0:len(object_locations)-1]
Die nullbasierten Indizes der beiden Objekte, die der aktuellen Position des Agenten (x, y) am nächsten liegen. Der erste Index bezieht sich auf das nächste Objekt hinter dem Agenten und der zweite Index bezieht sich auf das nächste Objekt vor dem Agenten. Wenn nur ein Objekt vorhanden ist, sind beide Indizes 0.
distanz_from_center
Typ: float
Bereich: 0:~track_width/2
Verschiebung in Metern zwischen der Mitte des Agenten und der Mitte der Spur. Die feststellbare maximale Verschiebung tritt auf, wenn sich eines der Räder des Agenten außerhalb einer Streckenbegrenzung befindet. Je nach Breite der Streckenbegrenzung kann sie etwas kleiner oder größer als die Hälfte von track_width sein.
Beispiel: Eine Belohnungsfunktion mit dem distance_from_center-Parameter.
def reward_function(params): ################################################################################# ''' Example of using distance from the center ''' # Read input variable track_width = params['track_width'] distance_from_center = params['distance_from_center'] # Penalize if the car is too far away from the center marker_1 = 0.1 * track_width marker_2 = 0.5 * track_width if distance_from_center <= marker_1: reward = 1.0 elif distance_from_center <= marker_2: reward = 0.5 else: reward = 1e-3 # likely crashed/ close to off track return float(reward)
heading
Typ: float
Bereich: -180:+180
Die Kursrichtung des Agenten in Grad in Bezug auf die X-Achse des Koordinatensystems.
Beispiel: Eine Belohnungsfunktion mit dem heading-Parameter.
Weitere Informationen finden Sie unter closest_waypoints.
is_crashed
Typ: Boolean
Bereich: (True:False)
Ein Boolean Kennzeichen, das angibt, ob der Agent gegen ein anderes Objekt (True) gestürzt ist oder nicht (False).
is_left_of_center
Typ: Boolean
Bereich: [True : False]
Eine Boolean Markierung, die angibt, ob sich der Agent links von der Track-Mitte (True) oder nicht links von der Track-Mitte (False) befindet.
is_offtrack
Typ: Boolean
Bereich: (True:False)
Eine Boolean Markierung, die angibt, ob alle vier Räder des Agenten außerhalb der inneren oder äußeren Grenzen der Strecke gefahren sind (True) oder nicht (False).
is_reversed
Typ: Boolean
Bereich: [True:False]
Eine Boolean Markierung, die angibt, ob der Agent im Uhrzeigersinn (True) oder gegen den Uhrzeigersinn () fährt. False
Es wird verwendet, wenn Sie die Richtungsänderung für jede Episode aktivieren.
objects_distance
Typ: [float, … ]
Bereich: [(0:track_length), … ]
Eine Liste der Entfernungen zwischen Objekten in der Umgebung im Verhältnis zur Startlinie. Das i-te Element misst den Abstand in Metern zwischen dem i-ten Objekt und der Startlinie entlang der Streckenmittellinie.
Anmerkung
abs | (var1) - (var2) | = how close the car is to an object , WENN var1 = ["objects_distance"] [index] und var2 = params ["progress"] *params ["track_length"]
Verwenden Sie den closest_objects Parameter, um einen Index des nächstgelegenen Objekts vor dem Fahrzeug und des nächstgelegenen Objekts hinter dem Fahrzeug zu erhalten.
objects_heading
Typ: [float, … ]
Bereich: [(-180:180), … ]
Liste der Fahrkurse von Objekten in Grad. Das i-te Element misst den Fahrkurs des i-ten Objekts. Die Überschriften stationärer Objekte sind 0. Bei Bot-Autos entspricht der Wert des entsprechenden Elements dem Richtungswinkel des Bot-Autos.
objects_left_of_center
Typ: [Boolean, … ]
Bereich: [True|False, … ]
Liste der Boolean Flaggen. Der Wert des i-ten Elements gibt an, ob sich das Objekt links (True) oder rechts (False) von der Spurmitte befindet.
objects_location
Typ: [(x,y), ...]
Bereich: [(0:N,0:N), ...]
Dieser Parameter speichert alle Objektpositionen. Jede Position ist ein Tupel von (x, y).
Die Größe der Liste entspricht der Anzahl der Objekte auf der Strecke. Zu den aufgelisteten Objekten gehören sowohl stationäre Hindernisse als auch fahrende Bot-Autos.
objects_speed
Typ: [float, … ]
Bereich: [(0:12.0), … ]
Liste der Geschwindigkeiten (Meter pro Sekunde) für die Objekte auf der Strecke. Bei stationären Objekten sind ihre Geschwindigkeiten 0. Bei einem Bot-Fahrzeug entspricht der Wert der Geschwindigkeit, die Sie im Training festgelegt haben.
progress
Typ: float
Bereich: 0:100
Prozentsatz der abgeschlossenen Strecke.
Beispiel: Eine Belohnungsfunktion mit dem progress-Parameter.
Weitere Informationen finden Sie unter Schritte.
speed
Typ: float
Bereich: 0.0:5.0
Die beobachtete Geschwindigkeit des Agenten in Metern pro Sekunde (m/s).
Beispiel: Eine Belohnungsfunktion mit dem speed-Parameter.
Weitere Informationen finden Sie unter all_wheels_on_track.
steering_angle
Typ: float
Bereich: -30:30
Lenkwinkel der Vorderräder in Grad von der Mittellinie des Agenten aus. Das negative Vorzeichen (-) steht für eine Lenkung nach rechts. Das positive (+) Vorzeichen steht für eine Lenkung nach links. Die Mittellinie des Agenten verläuft nicht unbedingt parallel zur Spurmittellinie, wie in der folgenden Abbildung dargestellt.
Beispiel: Eine Belohnungsfunktion mit dem steering_angle-Parameter.
def reward_function(params): ''' Example of using steering angle ''' # Read input variable abs_steering = abs(params['steering_angle']) # We don't care whether it is left or right steering # Initialize the reward with typical value reward = 1.0 # Penalize if car steer too much to prevent zigzag ABS_STEERING_THRESHOLD = 20.0 if abs_steering > ABS_STEERING_THRESHOLD: reward *= 0.8 return float(reward)
steps
Typ: int
Bereich: 0:Nstep
Die Anzahl der abgeschlossenen Schritte. Ein Schritt entspricht einer Beobachtungs- und Aktionssequenz, die der Agent unter Verwendung der aktuellen Richtlinie abgeschlossen hat.
Beispiel: Eine Belohnungsfunktion mit dem steps-Parameter.
def reward_function(params): ############################################################################# ''' Example of using steps and progress ''' # Read input variable steps = params['steps'] progress = params['progress'] # Total num of steps we want the car to finish the lap, it will vary depends on the track length TOTAL_NUM_STEPS = 300 # Initialize the reward with typical value reward = 1.0 # Give additional reward if the car pass every 100 steps faster than expected if (steps % 100) == 0 and progress > (steps / TOTAL_NUM_STEPS) * 100 : reward += 10.0 return float(reward)
track_length
Typ: float
Bereich: [0:Lmax]
Die Streckenlänge in Metern. Lmax is track-dependent.
track_width
Typ: float
Bereich: 0:Dtrack
Streckenbreite in Metern.
Beispiel: Eine Belohnungsfunktion mit dem track_width-Parameter.
def reward_function(params): ############################################################################# ''' Example of using track width ''' # Read input variable track_width = params['track_width'] distance_from_center = params['distance_from_center'] # Calculate the distance from each border distance_from_border = 0.5 * track_width - distance_from_center # Reward higher if the car stays inside the track borders if distance_from_border >= 0.05: reward = 1.0 else: reward = 1e-3 # Low reward if too close to the border or goes off the track return float(reward)
x, y
Typ: float
Bereich: 0:N
Position des Agentenmittelpunkts auf der X- und Y-Achse der simulierten Umgebung, in der sich der Track befindet, in Metern. Der Nullpunkt liegt in der unteren linken Ecke der simulierten Umgebung.
waypoints
Typ: list mit [float, float]
Bereich: [[xw,0,yw,0] …
[xw,Max-1,
yw,Max-1]]
Eine sortierte Liste von streckenabhängigen Max-Meilensteinen entlang der Streckenmitte. Jeder Meilenstein wird durch eine Koordinate von (xw,i, yw,i) beschrieben. Bei einer Schleife sind die ersten und die letzte Zwischenposition identisch. Bei einer geraden Strecke oder einer Strecke, die keine Schleife bildet, unterscheiden sich die erste und die letzte Zwischenposition.
Beispiel Eine Belohnungsfunktion mit dem Parameter waypoints.
Weitere Informationen finden Sie unter closest_waypoints.
