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.

# 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
```