Personalizar uma função de recompensa

Criar uma função de recompensa é como criar um plano de incentivo. Os parâmetros são valores que podem ser usados para desenvolver seu plano de incentivo.

Diferentes estratégias de incentivo resultam em diferentes comportamentos do veículo. Para que o veículo dirija mais rápido, atribua valores negativos quando o carro demora muito para terminar uma volta ou sai da pista. Para evitar padrões de direção em ziguezague, defina um limite de alcance do ângulo de direção e recompense o carro por dirigir de forma menos agressiva em trechos retos da pista.

Use pontos de referência, que são marcadores numerados colocados na linha central e nas bordas externa e interna da pista, a fim de ajudá-lo a associar certos comportamentos de direção a atributos específicos de uma pista, como retas e curvas.

Criar uma função de recompensa eficaz é um processo criativo e iterativo. Experimente estratégias diferentes, misture e combine parâmetros e, o mais importante, divirta-se!

Editar o código Python para personalizar sua função de recompensa

No AWS DeepRacer Student, você edita amostras de funções de recompensa para criar uma estratégia de corrida personalizada para seu modelo.

Personalizar sua função de recompensa

1. Na página Etapa 5: Personalize a função de recompensa da experiência AWS DeepRacer Student, em Criar modelo, selecione uma amostra de função de recompensa.

2. Use o editor de código abaixo da amostra de seletor de função de recompensa para personalizar os parâmetros de entrada da função de recompensa usando o código Python.

3. Selecione Validar para conferir se o seu código funcionará. Como alternativa, escolha Redefinir para recomeçar.

4. Ao finalizar as alterações, selecione Próximo.

Use Parâmetros de entrada da função de recompensa do AWS DeepRacer para aprender sobre cada parâmetro. Veja como parâmetros diferentes são usados em exemplos de funções de recompensa.

Parâmetros de entrada da função de recompensa do AWS DeepRacer

A função de recompensa do AWS DeepRacer usa um objeto de dicionário passado como variável, params, como entrada.

def reward_function(params) :

    reward = ...

    return float(reward)

O objeto de dicionário params contém os seguintes pares de chave/valor:

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

}

Use a referência a seguir para entender melhor os parâmetros de entrada do AWS DeepRacer.

all_wheels_on_track

Tipo: Boolean

Intervalo: (True:False)

Uma bandeira Boolean para indicar se o atendente está ou não fora da pista. O atendente está fora da pista (False) se uma de suas rodas estiver fora das bordas da pista. Ele está na pista (True) se todas as rodas estiverem dentro das bordas interna e externa da pista. A ilustração a seguir mostra um atendente que está na pista.

A ilustração a seguir mostra um atendente que não está na pista porque duas rodas estão fora dos limites.

Exemplo: Uma função de recompensa usando o parâmetro 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

Digite: [int, int]

Intervalo: [(0:Max-1),(1:Max-1)]

Os índices baseados em zero dos dois waypoint vizinhos mais próximos da posição atual do atendente de (x, y). A distância é medida pela distância euclidiana do centro do atendente. O primeiro elemento refere-se ao ponto de referência mais próximo atrás do atendente, e o segundo elemento refere-se ao ponto de referência mais próximo na frente do atendente. Max é o tamanho da lista de pontos de referência. Na ilustração mostrada em pontos de referência, os closest_waypoints seriam [16, 17].

A seguinte função de recompensa de exemplo demonstra como usar waypoints e closest_waypoints bem como heading para calcular recompensas imediatas.

O AWS DeepRacer é compatível com as seguintes bibliotecas Python: math, random, numpy, scipy e shapely. Para usar uma delas, adicione uma instrução de importação, import supported library, antes da definição da função, def reward_function(params).

Exemplo: Uma função de recompensa usando o closest_waypoints parâmetro.

# 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

Digite: [int, int]

Intervalo: [(0:len(object_locations)-1), (0:len(object_locations)-1]

Os índices baseados em zero dos dois objetos mais próximos da posição atual do atendente de (x, y). O primeiro índice refere-se ao objeto mais próximo atrás do veículo, e o segundo índice refere-se ao objeto mais próximo na frente do atendente. Se houver apenas um objeto, os dois índices serão 0.

distance_from_center

Digite: float

Intervalo: 0:~track_width/2

Deslocamento, em metros, entre o centro do atendente e o centro da pista. O deslocamento máximo observável ocorre quando qualquer uma das rodas do atendente está fora de uma borda da pista e, dependendo da largura da borda da pista, pode ser ligeiramente menor ou maior que a metade da track_width.

Exemplo: Uma função de recompensa usando o parâmetro 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

Digite: float

Intervalo: -180:+180

A condução da direção, em graus, do atendente em relação ao eixo x do sistema de coordenadas.

Exemplo: Uma função de recompensa usando o parâmetro heading

Para obter mais informações, consulte closest_waypoints.

is_crashed

Digite: Boolean

Intervalo: (True:False)

Uma bandeira Boolean para indicar se o atendente bateu em outro objeto (True) ou não (False), como um status de encerramento.

is_left_of_center

Digite: Boolean

Intervalo: [True : False]

Uma bandeira Boolean que indica se o atendente está à esquerda do centro da pista (True) ou não (False).

is_offtrack

Digite: Boolean

Intervalo: (True:False)

Uma bandeira Boolean que indica se todas as quatro rodas do atendente foram para fora das bordas interna ou externa da pista (True) ou não (False).

is_reversed

Digite: Boolean

Intervalo: [True:False]

Uma bandeira Boolean que indica se o atendente está dirigindo no sentido horário (True) ou anti-horário (False).

Ela é usada quando você habilita a mudança de condução para cada episódio.

objects_distance

Digite: [float, … ]

Intervalo: [(0:track_length), … ]

Uma lista das distâncias entre objetos no ambiente em relação à linha de largada. O i^o elemento mede a distância em metros entre o i^o objeto e a linha de largada ao longo da linha central da pista.

nota

abs | (var1) - (var2) | = a proximidade do carro em relação a um objeto, WHEN var1 = ["objects_distance"][index] e var2 = params["progress"]*params["track_length"]

Para obter um índice do objeto mais próximo na frente e atrás do veículo, use o parâmetro closest_objects.

objects_heading

Digite: [float, … ]

Intervalo: [(-180:180), … ]

Lista das direções dos objetos em graus. O i^o elemento mede a direção do i^o objeto. As direções dos objetos estacionários são 0. Para carros bot, o valor do elemento correspondente é o ângulo de direção do carro bot.

objects_left_of_center

Digite: [Boolean, … ]

Intervalo: [True|False, … ]

Lista de bandeiras Boolean. O i^o valor do elemento indica se o i^o objeto está no lado esquerdo (True) ou direito (False) do centro da pista.

objects_location

Digite: [(x,y), ...]

Intervalo: [(0:N,0:N), ...]

Esse parâmetro armazena todas as localizações dos objetos. Cada local é uma tupla de (x, y).

O tamanho da lista é igual ao número de objetos na pista. Os objetos listados incluem obstáculos estacionários e carros bot em movimento.

objects_speed

Digite: [float, … ]

Intervalo: [(0:12.0), … ]

Lista de velocidades (metros por segundo) dos objetos na pista. Para objetos estacionários, suas velocidades são 0. Para um veículo bot, o valor é a velocidade definida no treinamento.

progresso

Digite: float

Intervalo: 0:100

Porcentagem da pista concluída.

Exemplo: Uma função de recompensa usando o parâmetro progress

Para mais informações, consulte etapas.

velocidade

Digite: float

Intervalo: 0.0:5.0

A velocidade observada do atendente, em metros por segundo (m/s).

Exemplo: Uma função de recompensa usando o parâmetro speed

Para mais informações, consulte all_wheels_on_track.

steering_angle

Digite: float

Intervalo: -30:30

Ângulo da direção, em graus, das rodas dianteiras a partir da linha central do atendente. O sinal negativo (-) significa curva para a direita e o sinal positivo (+) significa curva para a esquerda. A linha central do atendente não é necessariamente paralela à linha central da pista, conforme mostrado na ilustração a seguir.

Exemplo: Uma função de recompensa usando o parâmetro 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)

etapas

Digite: int

Intervalo: 0:Nstep

Número de etapas concluídas. Uma etapa corresponde a uma sequência de observação e ação concluída pelo atendente usando a diretriz atual.

Exemplo: Uma função de recompensa usando o parâmetro 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

Digite: float

Intervalo: [0:Lmax]

O comprimento da pista em metros. Lmax is track-dependent.

track_width

Digite: float

Intervalo: 0:Dtrack

Largura da pista em metros.

Exemplo: Uma função de recompensa usando o parâmetro 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

Digite: float

Intervalo: 0:N

Localização, em metros, do centro do atendente ao longo dos eixos x e y do ambiente simulado da pista. A origem está no canto inferior esquerdo do ambiente simulado.

pontos de referência

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

Intervalo: [[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]

Uma lista ordenada dos marcos Max dependentes da pista ao longo do centro da pista. Cada marco é descrito por uma coordenada de (x_w,i, y_w,i). Para um circuito, o primeiro e o último ponto de referência são os mesmos. Para uma pista reta ou que não seja um circuito, o primeiro e o último ponto de referência são diferentes.

Example (Exemplo) Uma função de recompensa usando o parâmetro waypoints

Para obter mais informações, consulte closest_waypoints.