Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Personnalisation d'une fonction de récompense
La création d'une fonction de récompense revient à concevoir un plan d'incitation. Les paramètres sont des valeurs qui peuvent être utilisées pour développer votre plan d'intéressement.
Les différentes stratégies d'incitation se traduisent par des comportements différents des véhicules. Pour encourager le véhicule à rouler plus vite, essayez d'attribuer des valeurs négatives lorsque la voiture met trop de temps à terminer un tour ou qu'elle quitte la piste. Pour éviter les schémas de conduite en zigzag, essayez de définir une limite d'angle de braquage et de récompenser la voiture qui conduit de manière moins agressive sur les sections droites de la piste.
Vous pouvez utiliser des points de cheminement, qui sont des marqueurs numérotés placés le long de l'axe central et des bords extérieurs et intérieurs de la piste, pour vous aider à associer certains comportements de conduite à des caractéristiques spécifiques d'une piste, telles que les lignes droites et les virages.
L'élaboration d'une fonction de récompense efficace est un processus créatif et itératif. Essayez différentes stratégies, mélangez les paramètres et, surtout, amusez-vous !
Rubriques
Modification du code Python pour personnaliser votre fonction de récompense
Dans AWS DeepRacer Student, vous pouvez modifier des exemples de fonctions de récompense afin d'élaborer une stratégie de course personnalisée pour votre modèle.
Pour personnaliser votre fonction de récompense
-
Sur la page Étape 5 : Personnalisation de la fonction de récompense de l'expérience AWS DeepRacer Student Create model, sélectionnez un exemple de fonction de récompense.
-
Utilisez l'éditeur de code situé sous l'exemple de sélecteur de fonctions de récompense pour personnaliser les paramètres d'entrée de la fonction de récompense à l'aide du code Python.
-
Sélectionnez Valider pour vérifier si votre code fonctionne ou non. Vous pouvez également choisir Réinitialiser pour recommencer.
-
Lorsque vous avez terminé d'apporter des modifications, sélectionnez Suivant.
Paramètres d'entrée de la fonction de AWS DeepRacer récompenseÀ utiliser pour en savoir plus sur chaque paramètre. Découvrez comment différents paramètres sont utilisés dans les exemples de fonctions de récompense.
Paramètres d'entrée de la fonction de AWS DeepRacer récompense
La fonction de AWS DeepRacer récompense prend un objet de dictionnaire passé en tant que variableparams, en entrée.
def reward_function(params) : reward = ... return float(reward)
L'objet de dictionnaire params contient les paires clé-valeur suivantes :
{ "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 }
Utilisez la référence suivante pour mieux comprendre les paramètres AWS DeepRacer d'entrée.
all_wheels_on_track
Type : Boolean
Plage : (True:False)
Un Boolean drapeau pour indiquer si l'agent est sur la bonne voie ou non. L'agent n'est pas sur la bonne voie (False) si l'une de ses roues se trouve en dehors des limites de la piste. C'est sur la piste (True) si les quatre roues se trouvent à l'intérieur des bordures intérieure et extérieure de la piste. L'illustration suivante montre un agent qui est sur la bonne voie.
L'illustration suivante montre un agent qui n'est pas sur la bonne voie car deux roues se trouvent en dehors des limites de la piste.
Exemple : Fonction de récompense utilisant le paramètre 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
Type : [int, int]
Plage : [(0:Max-1),(1:Max-1)]
Index de base zéro des deux éléments waypoints les plus proches de la position actuelle de l'agent (x, y). La distance est mesurée par la distance euclidienne par rapport au centre de l'agent. Le premier élément fait référence au point de route le plus proche à l'arrière de l'agent et le second élément fait référence au point de route le plus proche à l'avant de l'agent. Max est la longueur de la liste des points de route. Dans l'illustration présentée danswaypoints, closest_waypoints ils sont[16, 17].
L'exemple de fonction de récompense suivant illustre l'utilisation de waypoints, closest_waypoints et heading pour calculer les récompenses immédiates.
AWS DeepRacer prend en charge les bibliothèques Python suivantes : mathrandom,numpy,scipy, etshapely. Pour en utiliser une, ajoutez une instruction d'importationimport , précédant la définition de votre fonction,supported
librarydef
reward_function(params).
Exemple : une fonction de récompense utilisant le closest_waypoints paramètre.
# 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
Type : [int, int]
Plage : [(0:len(object_locations)-1),
(0:len(object_locations)-1]
Index de base zéro des deux objets les plus proches de la position actuelle de l'agent (x, y). Le premier index fait référence à l'objet le plus proche derrière l'agent, et le second index fait référence à l'objet le plus proche devant l'agent. S'il n'y a qu'un seul objet, les deux index sont 0.
distance_from_center
Type : float
Plage : 0:~track_width/2
Déplacement, en mètres, entre le centre de l'agent et le centre de la piste. L'écart maximum pouvant être observé se produit lorsque l'une des roues de l'agent est au-delà d'une limite de la piste et, en fonction de la largeur de la bordure de la piste, peut être légèrement inférieure ou supérieure à la moitié de la valeur de track_width.
Exemple : Fonction de récompense utilisant le paramètre distance_from_center
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
Type : float
Plage : -180:+180
Direction du cap, en degrés, de l'agent par rapport à l'axe X du système de coordonnées.
Exemple : Fonction de récompense utilisant le paramètre heading
Pour plus d'informations, consultez closest_waypoints.
is_crashed
Type : Boolean
Plage : (True:False)
Un Boolean indicateur qui indique si l'agent s'est écrasé sur un autre objet (True) ou non (False) en tant que statut de terminaison.
is_left_of_center
Type : Boolean
Plage : [True : False]
BooleanDrapeau qui indique si l'agent se trouve à gauche du centre de suivi (True) ou non à gauche du centre de suivi (False).
is_offtrack
Type : Boolean
Plage : (True:False)
Un Boolean drapeau qui indique si les quatre roues de l'agent ont dépassé les limites intérieures ou extérieures de la piste (True) ou non (False).
is_reversed
Type : Boolean
Plage : [True:False]
Un Boolean drapeau qui indique si l'agent conduit dans le sens des aiguilles d'une montre (True) ou dans le sens antihoraire (). False
Il est utilisé lorsque vous activez un changement de direction pour chaque épisode.
objects_distance
Type : [float, … ]
Plage : [(0:track_length), … ]
Liste des distances entre les objets de l'environnement par rapport à la ligne de départ. Le ie élément mesure la distance en mètres entre le ie objet et la ligne de départ le long de la ligne centrale de la piste.
Note
abs | (var1) - (var2) | = à quelle distance la voiture se trouve d'un objet, QUAND var1 = ["objects_distance"] [index] et var2 = params ["progress"] *params ["track_length"]
Pour obtenir un indice de l'objet le plus proche devant le véhicule et de l'objet le plus proche derrière le véhicule, utilisez le closest_objects paramètre.
objects_heading
Type : [float, … ]
Plage : [(-180:180), … ]
Liste des caps des objets en degrés. Le ie élément mesure le cap du ie objet. Les en-têtes des objets stationnaires sont 0. Pour les voitures robots, la valeur de l'élément correspondant est l'angle de cap de la voiture robot.
objects_left_of_center
Type : [Boolean, … ]
Plage : [True|False, … ]
Liste des Boolean drapeaux La valeur de l'élément i th indique si l'objet i th se trouve à gauche (True) ou à droite (False) du centre de la piste.
objects_location
Type : [(x,y), ...]
Plage : [(0:N,0:N), ...]
Ce paramètre enregistre tous les emplacements des objets. Chaque emplacement est un tuple de (x, y).
La taille de la liste est égale au nombre d'objets sur la piste. Les objets répertoriés incluent à la fois des obstacles stationnaires et des voitures robotisées en mouvement.
objects_speed
Type : [float, … ]
Plage : [(0:12.0), … ]
Liste de vitesses (mètres par seconde) pour les objets sur la piste. Pour les objets immobiles, les vitesses sont égales à 0. Pour un véhicule robot, la valeur est la vitesse que vous avez définie lors de l'entraînement.
progress
Type : float
Plage : 0:100
Pourcentage de piste parcouru.
Exemple : Fonction de récompense utilisant le paramètre progress
Pour de plus amples informations, veuillez consulter steps.
speed
Type : float
Plage : 0.0:5.0
Vitesse observée de l'agent, en mètres par seconde (m/s).
Exemple : Fonction de récompense utilisant le paramètre speed
Pour de plus amples informations, veuillez consulter all_wheels_on_track.
steering_angle
Type : float
Plage : -30:30
Angle de direction, en degrés, des roues avant par rapport à l'axe central de l'agent. Le signe moins (-) indique une direction vers la droite et le signe plus (+) indique une direction vers la gauche. L'axe médian de l'agent n'est pas nécessairement parallèle à l'axe médian de la piste, comme le montre l'illustration suivante.
Exemple : Fonction de récompense utilisant le paramètre steering_angle
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
Type : int
Plage : 0:Nstep
Le nombre d'étapes effectuées. Une étape correspond à une séquence d'observation-action réalisée par l'agent à l'aide de la politique actuelle.
Exemple : Fonction de récompense utilisant le paramètre steps
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
Type : float
Plage : [0:Lmax]
La longueur de la piste en mètres. Lmax is track-dependent.
track_width
Type : float
Plage : 0:Dtrack
Largeur de la piste, en mètres.
Exemple : Fonction de récompense utilisant le paramètre track_width
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
Type : float
Plage : 0:N
Emplacement, en mètres, du centre de l'agent le long des axes x et y de l'environnement simulé contenant la trace. L'origine se trouve dans l'angle inférieur gauche de l'environnement simulé.
waypoints
Type : list de [float, float]
Plage : [[xw,0,yw,0] …
[xw,Max-1,
yw,Max-1]]
Liste ordonnée des jalons Max dépendants des pistes le long du centre de la piste. Chaque jalon est décrit par une coordonnée de (xw,i, yw,i). Pour une piste en anneau, le premier et le dernier points de route sont identiques. Pour une piste rectiligne ou autre piste sans anneau, le premier et le dernier points de route sont différents.
Exemple : Fonction de récompense utilisant le paramètre waypoints
Pour plus d'informations, consultez closest_waypoints.
