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.
Eingabeparameter der DeepRacer AWS-Belohnungsfunktion
Die DeepRacer AWS-Belohnungsfunktion verwendet ein Wörterbuchobjekt 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 }
Es folgt eine detaillierte technische Referenz der Eingangsparameter.
all_wheels_on_track
Typ: Boolean
Bereich (True:False)
Ein Boolean-Flag, das anzeigt, ob sich der Agent auf der Strecke oder außerhalb der Strecke befindet. Es ist außerhalb der Strecke (False), wenn sich eines seiner Räder außerhalb der Streckenbegrenzungen befindet. Es ist auf der Strecke (True), wenn sich alle Räder innerhalb der beiden Streckenbegrenzungen befinden. Die folgende Abbildung zeigt, dass sich der Agent auf der Strecke befindet.
Die folgende Abbildung zeigt, dass sich der Agent außerhalb der Strecke befindet.
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 in waypoints gezeigten Abbildung wären die closest_waypoints [16, 17].
Beispiel: Eine Belohnungsfunktion mit dem Parameter closest_waypoints.
Die folgende exemplarische Belohnungsfunktion zeigt, wie man mit waypoints und closest_waypoints sowie heading direkte Belohnungen berechnet.
AWS DeepRacer unterstützt die folgenden Bibliotheken: math, random, NumPy SciPy, und Shapely. Um eine zu verwenden, fügen Sie über Ihrer Funktionsdefinition eine Importanweisung hinzudef function_name(parameters). import supported library
# 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 center line 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(objects_location)-1),
(0:len(objects_location)-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 zwischen der Mitte des Agenten und der Streckenmitte in Metern. 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
Fahrtrichtung 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 boolesches Flag, das angibt, ob der Agent als Abschlussstatus mit einem anderen Objekt kollidiert ist (True) oder nicht ist (False).
is_left_of_center
Typ: Boolean
Bereich: [True : False]
Ein Boolean-Flag, das anzeigt, ob sich der Agent auf der linken Seite (True) oder rechten Seite (False) der Streckenmitte befindet.
is_offtrack
Typ: Boolean
Bereich: (True:False)
Ein boolesches Flag, das angibt, ob sich der Agent als Abschlussstatus außerhalb der Spur (True) oder nicht (False) befindet.
is_reversed
Typ: Boolean
Bereich: [True:False]
Ein boolesches Flag, das anzeigt, ob der Agent im Uhrzeigersinn (True) oder gegen den Uhrzeigersinn (False) fährt.
Es wird verwendet, wenn Sie die Richtungsänderung für jede Episode aktivieren.
objects_distance
Typ: [float, … ]
Bereich: [(0:track_length), … ]
Eine Liste der Abstände zwischen Objekten in der Umgebung in Bezug auf die 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"]
Mit dem Parameter „closest_objects“ erhalten Sie einen Index des nächstgelegenen Objekts vor dem Fahrzeug und des nächstgelegenen Objekts hinter dem Fahrzeug.
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. Bei stationären Objekten sind ihre Fahrkurse 0. Bei einem Bot-Fahrzeug ist der Wert des entsprechenden Elements der Kurswinkel des Fahrzeugs.
objects_left_of_center
Typ: [Boolean, … ]
Bereich: [True|False, … ]
Liste der booleschen Flags. Der i-te Elementwert gibt an, ob sich das i-te Objekt links (True) oder rechts (False) von der Streckenmitte befindet.
objects_location
Typ: [(x,y), … ]
Bereich: [(0:N,0:N), … ]
Liste aller Objektpositionen, jede Position ist ein n-Tupel von (x, y).
Die Größe der Liste entspricht der Anzahl der Objekte auf der Strecke. Beachten Sie, dass das Objekt ein stationäres Hindernis oder ein sich bewegendes Bot-Fahrzeug sein könnte.
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 ist nicht unbedingt parallel zur Streckenmittellinie, 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
Anzahl der abgeschlossenen Schritte. Ein Schritt entspricht einer Aktion, die der Agent gemäß der aktuellen Richtlinie durchführt.
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 der Mitte des Agenten zur x- und y-Achse der simulierten Umgebung mit der Strecke 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.
