Parametri di input della funzione di DeepRacer ricompensa AWS - AWS DeepRacer

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Parametri di input della funzione di DeepRacer ricompensa AWS

La funzione di DeepRacer ricompensa di AWS accetta un oggetto dizionario come input.

def reward_function(params) : reward = ... return float(reward)

L'oggetto dizionario params contiene le seguenti coppie chiave-valore:

{ "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 }

Il riferimento tecnico più dettagliato per i parametri di input è il seguente.

all_wheels_on_track

Type (Tipo) Boolean

Range (Intervallo): (True:False)

Un flag Boolean per indicare se l'agente è in pista o meno. È fuori pista (False) se una delle sue ruote si trova al di fuori dei bordi della pista. È in pista (True) se tutte le ruote sono all'interno dei due bordi. La figura seguente mostra l'agente in pista.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS diall_wheels_on_track = True.

La figura seguente mostra l'agente fuori pista.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS diall_wheels_on_track = False.

Esempio: una funzione di ricompensa che utilizza il parametro 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

Tipo: [int, int]

Range (Intervallo): [(0:Max-1),(1:Max-1)]

Gli indici a base zero dei due waypoint adiacenti più vicini alla posizione corrente dell'agente (x, y). La distanza è misurata in base alla distanza euclidea dal centro dell'agente. Il primo elemento si riferisce al waypoint più vicino nella parte posteriore dell'agente e il secondo elemento si riferisce al waypoint più vicino davanti l'agente. Max è la lunghezza dell'elenco dei waypoint. Nell'illustrazione mostrata in waypoint, il closest_waypoints sarebbe [16, 17].

Esempio: una funzione di ricompensa che utilizza il parametro closest_waypoints.

Il seguente esempio di funzione di ricompensa dimostra come utilizzare waypoints e closest_waypoints così come heading per calcolare le ricompense immediate.

AWS DeepRacer supporta le seguenti librerie: math NumPy SciPy, random e Shapely. Per usarne una, aggiungi un'istruzione di importazioneimport supported library, sopra la definizione della funzione. def function_name(parameters)

# 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

Tipo: [int, int]

Range (Intervallo): [(0:len(objects_location)-1), (0:len(objects_location)-1)]

Gli indici a base zero dei due oggetti più vicini alla posizione corrente dell'agente di (x, y). Il primo indice si riferisce all'oggetto più vicino dietro l'agente e il secondo indice si riferisce all'oggetto più vicino davanti all'agente. Se c'è un solo oggetto, entrambi gli indici sono 0.

distance_from_center

Tipo: float

Range (Intervallo): 0:~track_width/2

Displacement, in metri, tra il centro dell'agente e il centro della pista. Il displacement massimo osservabile si verifica quando qualsiasi ruota dell'agente si trova all'esterno di un bordo della pista e, a seconda della larghezza del bordo, può essere leggermente inferiore o superiore a metà track_width.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS didistance_from_center.

Esempio: una funzione di ricompensa che utilizza il parametro 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

Tipo: float

Range (Intervallo): -180:+180

Direzione di marcia, in gradi, dell'agente rispetto all'asse x del sistema di coordinate.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS diheading.

Esempio: una funzione di ricompensa che utilizza il parametro heading

Per ulteriori informazioni, consulta closest_waypoints.

is_crashed

Tipo: Boolean

Range (Intervallo): (True:False)

Un flag booleano per indicare se l'agente si è arrestato in modo anomalo in un altro oggetto (True) o meno (False) come stato di fine.

is_left_of_center

Tipo: Boolean

Range (Intervallo): [True : False]

Un flag Boolean per indicare se l'agente si trova sul lato sinistro rispetto al centro della pista (True) o sul lato destro (False).

is_offtrack

Tipo: Boolean

Range (Intervallo): (True:False)

Un flag booleano per indicare se l'agente è fuori pista (True) o meno (False) come stato di fine.

is_reversed

Tipo: Boolean

Range (Intervallo): [True:False]

Un flag booleano per indicare se l'agente sta guidando in senso orario (True) o antiorario (False).

Viene utilizzato quando si abilita il cambio di direzione per ogni episodio.

objects_distance

Tipo: [float, … ]

Range (Intervallo): [(0:track_length), … ]

Un elenco delle distanze tra gli oggetti nell'ambiente in relazione alla linea iniziale. L'elemento I° misura la distanza in metri tra l'oggetto I° e l'agente lungo la linea di partenza del binario.

Nota

abs | (var1) - (var2)| = how close the car is to an object, WHEN var1 = ["objects_distance"][index] and var2 = params["progress"]*params["track_length"]

Per ottenere un indice dell'oggetto più vicino davanti al veicolo e dell'oggetto più vicino dietro il veicolo, utilizzare il parametro «closest_objects».

objects_intestazione

Tipo: [float, … ]

Range (Intervallo): [(-180:180), … ]

Elenco delle intestazioni degli oggetti in gradi. L'elemento I° misura l'intestazione dell'oggetto I°. Per gli oggetti fissi, le loro intestazioni sono 0. Per un veicolo bot , il valore dell'elemento corrispondente è l'angolo di direzione del veicolo.

objects_left_of_center

Tipo: [Boolean, … ]

Range (Intervallo): [True|False, … ]

Elenco dei flag booleani. Il valore dell'elemento I° indica se l'oggetto I° si trova sul lato sinistro (True) o destro (False) del centro della pista.

objects_location

Tipo: [(x,y), … ]

Range (Intervallo): [(0:N,0:N), … ]

Elenco di tutte le posizioni degli oggetti, ogni posizione è una tupla di (x, y).

La dimensione dell'elenco è uguale al numero di oggetti presenti sulla pista. L'oggetto potrebbe essere un ostacolo stazionario, veicoli bot in movimento.

objects_speed

Tipo: [float, … ]

Range (Intervallo): [(0:12.0), … ]

Elenco delle velocità (metri al secondo) per gli oggetti in pista. Per gli oggetti fissi, le velocità sono 0. Per un veicolo bot, il valore è la velocità impostata durante l'allenamento.

progress

Tipo: float

Range (Intervallo): 0:100

Percentuale di tracciato completata.

Esempio: una funzione di ricompensa che utilizza il parametro progress

Per ulteriori informazioni, consulta steps.

speed

Tipo: float

Range (Intervallo): 0.0:5.0

La velocità dell'agente osservata, in metri al secondo (m/s).

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS dispeed.

Esempio: una funzione di ricompensa che utilizza il parametro speed

Per ulteriori informazioni, consulta all_wheels_on_track.

steering_angle

Tipo: float

Range (Intervallo): -30:30

Angolo di sterzata, in gradi, delle ruote anteriori dalla linea centrale dell'agente. Il segno negativo (-) indica una sterzata verso destra mentre il positivo (+) verso sinistra. La linea centrale dell'agente non è necessariamente parallela alla linea di mezzeria, come illustrato di seguito.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS disteering_angle.

Esempio: una funzione di ricompensa che utilizza il parametro 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

Tipo: int

Range (Intervallo): 0:Nstep

Numero di passi completati. Un passo corrisponde a un'azione intrapresa dal veicolo seguendo la policy corrente.

Esempio: una funzione di ricompensa che utilizza il parametro 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

Tipo: float

Range (Intervallo): [0:Lmax]

La lunghezza della pista in metri. Lmax is track-dependent.

track_width

Tipo: float

Range (Intervallo): 0:Dtrack

Larghezza della pista in metri.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS ditrack_width.

Esempio: una funzione di ricompensa che utilizza il parametro 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 (Tipo): float

Range (Intervallo): 0:N

Posizione, in metri, del centro dell'agente lungo gli assi x e y, dell'ambiente simulato contenente la pista. L'origine si trova nell'angolo in basso a sinistra dell'ambiente simulato.

Immagine: parametri di input della funzione di DeepRacer ricompensa AWS dix,y.

waypoint

Type (Tipo): list di [float, float]

Range (Intervallo): [[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]

Un elenco ordinato di milestone Max dipendenti dalla pista lungo il centro della pista stessa. Ogni pietra miliare è descritta da una coordinata di (xw,i, yw,i). Per una circuito circolare, il primo e l'ultimo waypoint sono identici. Per un circuito rettilineo o per un altro circuito non circolare, il primo e l'ultimo waypoint sono diversi.

Immagine: parametro di input della funzione di DeepRacer ricompensa AWS diwaypoints.

Esempio: una funzione di ricompensa che utilizza il parametro waypoints

Per ulteriori informazioni, consulta closest_waypoints.