Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Referencia de funciones de DeepRacer recompensas de AWS
<a name="deepracer-reward-function-reference"></a>

 La siguiente es la referencia técnica de la función de DeepRacer recompensas de AWS. 

**Topics**
+ [

# Parámetros de entrada de la función de DeepRacer recompensas de AWS
](deepracer-reward-function-input.md)
+ [

# Ejemplos de funciones de DeepRacer recompensa de AWS
](deepracer-reward-function-examples.md)

# Parámetros de entrada de la función de DeepRacer recompensas de AWS
<a name="deepracer-reward-function-input"></a>

La función de DeepRacer recompensa de AWS toma un objeto de diccionario como entrada. 

```
def reward_function(params) :
    
    reward = ...

    return float(reward)
```

El objeto del diccionario `params` contiene los siguientes pares de clave-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

}
```

A continuación, se incluye una referencia técnica más detallada de los parámetros de entrada. 

## all\$1wheels\$1on\$1track
<a name="reward-function-input-all_wheels_on_track"></a>

**Tipo: ** `Boolean`

**Rango: ** `(True:False)`

Una marca `Boolean` para indicar si el agente está en la pista o fuera de la pista. Está fuera de la pista (`False`) si cualquiera de sus ruedas están fuera de los límites de la pista. Está en la pista (`True`) si todas las ruedas están dentro de los dos límites de la pista. La siguiente ilustración muestra que el vehículo está dentro de la pista. 

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-true.png)


La siguiente ilustración muestra que el agente está fuera de la pista.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-false.png)


**Ejemplo:** *una función de recompensa utilizando el 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\$1waypoints
<a name="reward-function-input-closest_waypoints"></a>

**Tipo:** `[int, int]`

**Rango**: `[(0:Max-1),(1:Max-1)]`

Los índices de base cero de los dos `waypoint` más cercanos a la posición actual `(x, y)` del agente. La distancia se mide por la distancia euclidiana desde el centro del agente. El primer elemento se refiere al punto de ruta más cercano detrás del agente y el segundo elemento hace referencia al punto de ruta más cercano delante del agente. `Max` es la longitud de la lista de puntos de ruta. En la ilustración que se muestra en [waypoints](#reward-function-input-waypoints), los `closest_waypoints` serían `[16, 17]`. 

**Ejemplo**: una función de recompensa utilizando el parámetro `closest_waypoints`.

En el siguiente ejemplo, se muestra cómo utilizar la función de recompensa `waypoints` y `closest_waypoints`, así como `heading` para calcular las recompensas inmediatas.

AWS DeepRacer admite las siguientes bibliotecas: math NumPy SciPy, random y Shapely. Para utilizarlas, añada una declaración de importación, `import supported library`, sobre la definición de la función, `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\$1objects
<a name="reward-function-input-closest_objects"></a>

**Tipo:** `[int, int]`

**Rango**: `[(0:len(objects_location)-1), (0:len(objects_location)-1)]`

 Índices basados en cero de los dos objetos más cercanos a la posición actual (x,y) del agente. El primer índice hace referencia al objeto más cercano situado detrás del agente, mientas que el segundo índice hace referencia al objeto más cercano situado delante. Si solo hay un objeto, ambos índices serán 0. 

## distance\$1from\$1center
<a name="reward-function-input-distance_from_center"></a>

**Tipo:** `float`

**Rango**: `0:~track_width/2`

Desplazamiento, en metros, entre el centro del agente y el centro de la pista. El desplazamiento máximo observable se produce cuando cualquiera de las ruedas del agente están fuera del límite de la pista y, en función de la anchura de la pista, puede ser ligeramente más pequeña o más grande que la mitad de `track_width`.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-distance_from_center.png)


**Ejemplo:** *una función de recompensa utilizando el 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
<a name="reward-function-input-heading"></a>

**Tipo:** `float`

**Rango**: `-180:+180`

La dirección hacia la que se dirige, en grados, del agente con respecto al eje x del sistema de coordenadas.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-heading.png)


**Ejemplo:** *una función de recompensa utilizando el parámetro `heading`.*

Para obtener más información, consulte [`closest_waypoints`](#reward-function-input-closest_waypoints).

## is\$1crashed
<a name="reward-function-input-crashed"></a>

**Tipo:** `Boolean`

**Rango**: `(True:False)`

Indicador booleano para indicar si el agente ha chocado contra otro objeto (`True`) o no (`False`) como estado de terminación. 

## is\$1left\$1of\$1center
<a name="reward-function-input-is_left_of_center"></a>

**Tipo:** `Boolean`

**Rango**: `[True : False]`

Una marca `Boolean` para indicar si el agente se encuentra en el lado izquierdo con respecto al centro de la pista (`True`) o en el lado derecho (`False`). 

## is\$1offtrack
<a name="reward-function-input-offtrack"></a>

**Tipo:** `Boolean`

**Rango**: `(True:False)`

Indicador booleano para indicar si el agente tiene un estado de fuera de la pista (Verdadero) o no (False) como estado de terminación. 

## is\$1reversed
<a name="reward-function-input-is_reversed"></a>

**Tipo:** `Boolean`

**Rango**: `[True:False]`

Un indicador booleano para indicar si el agente está conduciendo en sentido horario (True) o antihorario (False). 

Se utiliza cuando se habilita el cambio de dirección para cada episodio. 

## objects\$1distance
<a name="reward-function-input-objects_distance"></a>

**Tipo:** `[float, … ]`

**Rango**: `[(0:track_length), … ]`

Lista de las distancias entre objetos del entorno en relación con la línea de salida. El elemento ith mide la distancia en metros entre el objeto ith y la línea de salida a lo largo de la línea central de la pista. 

**nota**  
abs \$1 (var1) - (var2)\$1 = a qué distancia está el coche de un objeto, WHEN var1 = ["objects\$1distance"][index] y var2 = params["progress"]\$1params["track\$1length"]  
Para obtener el índice del objeto más cercano que hay delante del vehículo y del objeto más cercano que hay detrás del vehículo, utilice el parámetro «closest\$1objects».

## objects\$1heading
<a name="reward-function-input-objects_heading"></a>

**Tipo:** `[float, … ]`

**Rango**: `[(-180:180), … ]`

Lista de los encabezados de los objetos en grados. El elemento ith mide el encabezado del objeto ith. Para los objetos estacionarios, los encabezados son 0. Para un vehículo robot, el valor del elemento correspondiente es el ángulo de rumbo del vehículo.

## objects\$1left\$1of\$1center
<a name="reward-function-input-objects_left_of_center"></a>

**Tipo:** `[Boolean, … ]`

**Rango**: `[True|False, … ]`

Lista de banderas booleanas. El valor del elemento ith indica si el objeto ith está en el lado izquierdo (True) o derecho (False) del centro de la pista. 

## objects\$1location
<a name="reward-function-input-objects_location"></a>

**Tipo:** `[(x,y), … ]`

**Rango**: `[(0:N,0:N), … ]`

Lista de todas las ubicaciones de objetos, cada ubicación es una tupla de ([x, y](#reward-function-input-x_y)). 

El tamaño de la lista es igual al número de objetos en la pista. Tenga en cuenta que el objeto podría ser los obstáculos estacionarios, vehículos robot en movimiento. 

## objects\$1speed
<a name="reward-function-input-objects_speed"></a>

**Tipo:** `[float, … ]`

**Rango**: `[(0:12.0), … ]`

Lista de velocidades (metros por segundo) para los objetos en la pista. En objetos estacionarios, las velocidades son 0. En un vehículo robot, el valor es la velocidad que se establece en el entrenamiento. 

## avance
<a name="reward-function-input-progress"></a>

**Tipo:** `float`

**Rango**: `0:100`

Porcentaje de pista completado.

**Ejemplo:** *una función de recompensa utilizando el parámetro `progress`.*

Para obtener más información, consulte [pasos](#reward-function-input-steps).

## speed
<a name="reward-function-input-speed"></a>

**Tipo:** `float`

**Rango**: `0.0:5.0`

La velocidad observada del agente, en metros por segundo (m/s).

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-speed.png)


**Ejemplo:** *una función de recompensa utilizando el parámetro `speed`.*

Para obtener más información, consulte la sección [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track).

## steering\$1angle
<a name="reward-function-input-steering_angle"></a>

**Tipo:** `float`

**Rango**: `-30:30`

Ángulo de dirección, en grados, de las ruedas delanteras desde la línea central del agente. El signo negativo (-) significa maniobrar hacia la derecha y el signo positivo (\$1) significa maniobrar hacia la izquierda. La línea central del agente no tiene que estar necesariamente paralela a la línea central paralela tal y como se muestra en la siguiente ilustración.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-steering.png)


**Ejemplo:** *una función de recompensa utilizando el 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)
```

## pasos
<a name="reward-function-input-steps"></a>

**Tipo:** `int`

**Rango**: `0:Nstep`

Número de pasos completados. Un paso corresponde a una acción realizada por el agente siguiendo la política actual.

**Ejemplo:** *una función de recompensa utilizando el 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\$1length
<a name="reward-function-input-track_len"></a>

**Type (Tipo)**: `float`

**Rango**: `[0:Lmax]`

La longitud de la pista en metros. `Lmax is track-dependent.`

## track\$1width
<a name="reward-function-input-track_width"></a>

**Tipo:** `float`

**Rango**: `0:Dtrack`

Ancho de la pista en metros.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-track_width.png)


**Ejemplo:** *una función de recompensa utilizando el 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
<a name="reward-function-input-x_y"></a>

**Tipo:** `float`

**Rango**: `0:N`

Ubicación, en metros, del centro del agente a lo largo de los ejes x e y, del entorno simulado que contiene la pista. El origen se encuentra en el ángulo inferior izquierdo del entorno simulado.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-x-y.png)


## waypoints
<a name="reward-function-input-waypoints"></a>

**Tipo**: `list` de `[float, float]`

**Rango**: `[[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]`

Una lista ordenada de hitos `Max` dependientes de la pista a lo largo del centro de la pista. Cada hito se describe mediante una coordenada de (xw,i, yw,i). Para una pista en bucle, el primer y el último señalador son los mismos. Para una pista recta u otra pista no en bucle, el primer y el último señalador son distintos.

![\[\]](http://docs.aws.amazon.com/es_es/deepracer/latest/developerguide/images/deepracer-reward-function-input-waypoints.png)


**Ejemplo:** *una función de recompensa utilizando el parámetro `waypoints`.*

Para obtener más información, consulte [`closest_waypoints`](#reward-function-input-closest_waypoints).

# Ejemplos de funciones de DeepRacer recompensa de AWS
<a name="deepracer-reward-function-examples"></a>

A continuación se enumeran algunos ejemplos de la función de DeepRacer recompensas de AWS.

**Topics**
+ [

## Ejemplo 1: seguir la línea central en contrarreloj
](#deepracer-reward-function-example-0)
+ [

## Ejemplo 2: permanecer dentro de los límites en contrarreloj
](#deepracer-reward-function-example-1)
+ [

## Ejemplo 3: evitar zigzaguear en las contrarreloj
](#deepracer-reward-function-example-2)
+ [

## Ejemplo 4: permanecer en un carril sin chocar con obstáculos estacionarios ni vehículos en movimiento
](#deepracer-reward-function-example-3)

## Ejemplo 1: seguir la línea central en contrarreloj
<a name="deepracer-reward-function-example-0"></a>

 En este ejemplo se determina a qué distancia está el agente de la línea central y se otorga una mayor recompensa si está más cerca del centro de la pista, animando al agente a seguir de cerca la línea central. 

```
def reward_function(params):
    '''
    Example of rewarding the agent to follow center line
    '''
    
    # Read input parameters
    track_width = params['track_width']
    distance_from_center = params['distance_from_center']

    # Calculate 3 markers that are increasingly further away from the center line
    marker_1 = 0.1 * track_width
    marker_2 = 0.25 * track_width
    marker_3 = 0.5 * track_width

    # Give higher reward if the car is closer to center line and vice versa
    if distance_from_center <= marker_1:
        reward = 1
    elif distance_from_center <= marker_2:
        reward = 0.5
    elif distance_from_center <= marker_3:
        reward = 0.1
    else:
        reward = 1e-3  # likely crashed/ close to off track

    return reward
```

## Ejemplo 2: permanecer dentro de los límites en contrarreloj
<a name="deepracer-reward-function-example-1"></a>

 Este ejemplo simplemente da grandes recompensas si el agente permanece dentro de los límites, y deja que el agente descubra cuál es el mejor camino para terminar una vuelta. Es fácil de programar y entender, pero probablemente tarde más en converger. 

```
def reward_function(params):
    '''
    Example of rewarding the agent to stay inside the two borders of the track
    '''
    
    # Read input parameters
    all_wheels_on_track = params['all_wheels_on_track']
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    
    # Give a very low reward by default
    reward = 1e-3

    # Give a high reward if no wheels go off the track and 
    # the car is somewhere in between the track borders 
    if all_wheels_on_track and (0.5*track_width - distance_from_center) >= 0.05:
        reward = 1.0

    # Always return a float value
    return reward
```

## Ejemplo 3: evitar zigzaguear en las contrarreloj
<a name="deepracer-reward-function-example-2"></a>

 Este ejemplo incentiva al agente a seguir la línea central, pero le penaliza con una recompensa menor si vira demasiado, lo que ayuda a prevenir el zigzagueo. El agente aprende a conducir sin zigzaguear en el simulador y probablemente mantendrá el mismo comportamiento cuando se implemente al vehículo físico. 

```
def reward_function(params):
    '''
    Example of penalize steering, which helps mitigate zig-zag behaviors
    '''
    
    # Read input parameters
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    abs_steering = abs(params['steering_angle']) # Only need the absolute steering angle

    # Calculate 3 marks that are farther and father away from the center line
    marker_1 = 0.1 * track_width
    marker_2 = 0.25 * track_width
    marker_3 = 0.5 * track_width

    # Give higher reward if the car is closer to center line and vice versa
    if distance_from_center <= marker_1:
        reward = 1.0
    elif distance_from_center <= marker_2:
        reward = 0.5
    elif distance_from_center <= marker_3:
        reward = 0.1
    else:
        reward = 1e-3  # likely crashed/ close to off track

    # Steering penality threshold, change the number based on your action space setting
    ABS_STEERING_THRESHOLD = 15 

    # Penalize reward if the car is steering too much
    if abs_steering > ABS_STEERING_THRESHOLD:
        reward *= 0.8

    return float(reward)
```

## Ejemplo 4: permanecer en un carril sin chocar con obstáculos estacionarios ni vehículos en movimiento
<a name="deepracer-reward-function-example-3"></a>

 

Esta función de recompensa premia al agente por permanecer dentro de los límites de la pista y penaliza al agente por acercarse demasiado al objeto que tiene delante. El agente puede moverse de carril en carril para evitar accidentes. La recompensa total es una suma ponderada de la recompensa y la penalización. El ejemplo da más peso a la penalización para centrarse más en la seguridad evitando accidentes. Experimente con diferentes pesos promedios para entrenarse y obtener diferentes resultados de comportamiento.

 

```
import math
def reward_function(params):
    '''
    Example of rewarding the agent to stay inside two borders
    and penalizing getting too close to the objects in front
    '''
    all_wheels_on_track = params['all_wheels_on_track']
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    objects_location = params['objects_location']
    agent_x = params['x']
    agent_y = params['y']
    _, next_object_index = params['closest_objects']
    objects_left_of_center = params['objects_left_of_center']
    is_left_of_center = params['is_left_of_center']
    # Initialize reward with a small number but not zero
    # because zero means off-track or crashed
    reward = 1e-3
    # Reward if the agent stays inside the two borders of the track
    if all_wheels_on_track and (0.5 * track_width - distance_from_center) >= 0.05:
        reward_lane = 1.0
    else:
        reward_lane = 1e-3
    # Penalize if the agent is too close to the next object
    reward_avoid = 1.0
    # Distance to the next object
    next_object_loc = objects_location[next_object_index]
    distance_closest_object = math.sqrt((agent_x - next_object_loc[0])**2 + (agent_y - next_object_loc[1])**2)
    # Decide if the agent and the next object is on the same lane
    is_same_lane = objects_left_of_center[next_object_index] == is_left_of_center
    if is_same_lane:
        if 0.5 <= distance_closest_object < 0.8:
            reward_avoid *= 0.5
        elif 0.3 <= distance_closest_object < 0.5:
            reward_avoid *= 0.2
        elif distance_closest_object < 0.3:
            reward_avoid = 1e-3  # Likely crashed
    # Calculate reward by putting different weights on
    # the two aspects above
    reward += 1.0 * reward_lane + 4.0 * reward_avoid
    return reward
```