Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Referenz zur DeepRacer AWS-Prämienfunktion
<a name="deepracer-reward-function-reference"></a>

 Im Folgenden finden Sie die technische Referenz der DeepRacer AWS-Prämienfunktion. 

**Topics**
+ [Eingabeparameter der DeepRacer AWS-Belohnungsfunktion](deepracer-reward-function-input.md)
+ [Beispiele AWS DeepRacer AWS-Prämienfunktionen](deepracer-reward-function-examples.md)

# Eingabeparameter der DeepRacer AWS-Belohnungsfunktion
<a name="deepracer-reward-function-input"></a>

Die DeepRacer AWS-Belohnungsfunktion verwendet ein Wörterbuchobjekt als Eingabe. 

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

    return float(reward)
```

Das `params`-Dictionary-Objekt enthält die folgenden Schlüssel/Werte-Paare:

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

}
```

Es folgt eine detaillierte technische Referenz der Eingangsparameter. 

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

**Typ: ** `Boolean`

**Bereich ** `(True:False)`

Ein `Boolean`-Flag, das anzeigt, ob sich der Agent auf der Strecke oder außerhalb der Strecke befindet. Es ist außerhalb der Strecke (`False`), wenn sich eines seiner Räder außerhalb der Streckenbegrenzungen befindet. Es ist auf der Strecke (`True`), wenn sich alle Räder innerhalb der beiden Streckenbegrenzungen befinden. Die folgende Abbildung zeigt, dass sich der Agent auf der Strecke befindet. 

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


Die folgende Abbildung zeigt, dass sich der Agent außerhalb der Strecke befindet.

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


**Beispiel: ** *Eine Belohnungsfunktion mit dem Parameter `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>

**Typ:** `[int, int]`

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

Die nullbasierten Indizes der beiden benachbarten `waypoint`s, die der aktuellen Position `(x, y)` des Agenten am nächsten liegen. Die Entfernung wird über den euklidischen Abstand von der Mitte des Fahrzeugs aus gemessen. Das erste Element bezieht sich auf den nächsten Wegpunkt hinter dem Agenten und das zweite Element bezieht sich auf den nächsten Wegpunkt vor dem Agenten. `Max` ist die Länge der Wegpunktliste. In der in [waypoints](#reward-function-input-waypoints) gezeigten Abbildung wären die `closest_waypoints` `[16, 17]`. 

**Beispiel**: Eine Belohnungsfunktion mit dem Parameter `closest_waypoints`.

Die folgende exemplarische Belohnungsfunktion zeigt, wie man mit `waypoints` und `closest_waypoints` sowie `heading` direkte Belohnungen berechnet.

AWS DeepRacer unterstützt die folgenden Bibliotheken: math, random, NumPy SciPy, und Shapely. Um eine zu verwenden, fügen Sie über Ihrer Funktionsdefinition eine Importanweisung hinzu`def function_name(parameters)`. `import supported library`

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

**Typ:** `[int, int]`

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

 Die nullbasierten Indizes der beiden Objekte, die der aktuellen Position des Agenten (x, y) am nächsten liegen. Der erste Index bezieht sich auf das nächste Objekt hinter dem Agenten und der zweite Index bezieht sich auf das nächste Objekt vor dem Agenten. Wenn nur ein Objekt vorhanden ist, sind beide Indizes 0. 

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

**Typ:** `float`

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

Verschiebung zwischen der Mitte des Agenten und der Streckenmitte in Metern. Die feststellbare maximale Verschiebung tritt auf, wenn sich eines der Räder des Agenten außerhalb einer Streckenbegrenzung befindet. Je nach Breite der Streckenbegrenzung kann sie etwas kleiner oder größer als die Hälfte von `track_width` sein.

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


**Beispiel:** *Eine Belohnungsfunktion mit dem `distance_from_center`-Parameter*.

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

**Typ:** `float`

**Bereich**: `-180:+180`

Fahrtrichtung des Agenten in Grad in Bezug auf die x-Achse des Koordinatensystems.

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


**Beispiel:** *Eine Belohnungsfunktion mit dem `heading`-Parameter*.

Weitere Informationen finden Sie unter [`closest_waypoints`](#reward-function-input-closest_waypoints).

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

**Typ:** `Boolean`

**Bereich**: `(True:False)`

Ein boolesches Flag, das angibt, ob der Agent als Abschlussstatus mit einem anderen Objekt kollidiert ist (`True`) oder nicht ist (`False`). 

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

**Typ:** `Boolean`

**Bereich**: `[True : False]`

Ein `Boolean`-Flag, das anzeigt, ob sich der Agent auf der linken Seite (`True`) oder rechten Seite (`False`) der Streckenmitte befindet. 

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

**Typ:** `Boolean`

**Bereich**: `(True:False)`

Ein boolesches Flag, das angibt, ob sich der Agent als Abschlussstatus außerhalb der Spur (True) oder nicht (False) befindet. 

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

**Typ:** `Boolean`

**Bereich**: `[True:False]`

Ein boolesches Flag, das anzeigt, ob der Agent im Uhrzeigersinn (True) oder gegen den Uhrzeigersinn (False) fährt. 

Es wird verwendet, wenn Sie die Richtungsänderung für jede Episode aktivieren. 

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

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

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

Eine Liste der Abstände zwischen Objekten in der Umgebung in Bezug auf die Startlinie. Das i-te Element misst den Abstand in Metern zwischen dem i-ten Objekt und der Startlinie entlang der Streckenmittellinie. 

**Anmerkung**  
abs \$1 (var1) - (var2) \$1 = how close the car is to an object , WENN var1 = ["objects\$1distance"] [index] und var2 = params ["progress"] \$1params ["track\$1length"]  
Mit dem Parameter „closest\$1objects“ erhalten Sie einen Index des nächstgelegenen Objekts vor dem Fahrzeug und des nächstgelegenen Objekts hinter dem Fahrzeug.

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

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

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

Liste der Fahrkurse von Objekten in Grad. Das i-te Element misst den Fahrkurs des i-ten Objekts. Bei stationären Objekten sind ihre Fahrkurse 0. Bei einem Bot-Fahrzeug ist der Wert des entsprechenden Elements der Kurswinkel des Fahrzeugs.

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

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

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

Liste der booleschen Flags. Der i-te Elementwert gibt an, ob sich das i-te Objekt links (True) oder rechts (False) von der Streckenmitte befindet. 

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

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

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

Liste aller Objektpositionen, jede Position ist ein n-Tupel von ([x, y](#reward-function-input-x_y)). 

Die Größe der Liste entspricht der Anzahl der Objekte auf der Strecke. Beachten Sie, dass das Objekt ein stationäres Hindernis oder ein sich bewegendes Bot-Fahrzeug sein könnte. 

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

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

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

Liste der Geschwindigkeiten (Meter pro Sekunde) für die Objekte auf der Strecke. Bei stationären Objekten sind ihre Geschwindigkeiten 0. Bei einem Bot-Fahrzeug entspricht der Wert der Geschwindigkeit, die Sie im Training festgelegt haben. 

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

**Typ:** `float`

**Bereich**: `0:100`

Prozentsatz der abgeschlossenen Strecke.

**Beispiel:** *Eine Belohnungsfunktion mit dem `progress`-Parameter*.

Weitere Informationen finden Sie unter [Schritte](#reward-function-input-steps).

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

**Typ:** `float`

**Bereich**: `0.0:5.0`

Die beobachtete Geschwindigkeit des Agenten in Metern pro Sekunde (m/s).

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


**Beispiel:** *Eine Belohnungsfunktion mit dem `speed`-Parameter*.

Weitere Informationen finden Sie unter [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track).

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

**Typ:** `float`

**Bereich**: `-30:30`

Lenkwinkel der Vorderräder in Grad von der Mittellinie des Agenten aus. Das negative Vorzeichen (-) steht für eine Lenkung nach rechts. Das positive (\$1) Vorzeichen steht für eine Lenkung nach links. Die Mittellinie des Agenten ist nicht unbedingt parallel zur Streckenmittellinie, wie in der folgenden Abbildung dargestellt.

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


**Beispiel:** *Eine Belohnungsfunktion mit dem `steering_angle`-Parameter*.

```
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
<a name="reward-function-input-steps"></a>

**Typ:** `int`

**Bereich**: `0:Nstep`

Anzahl der abgeschlossenen Schritte. Ein Schritt entspricht einer Aktion, die der Agent gemäß der aktuellen Richtlinie durchführt.

**Beispiel:** *Eine Belohnungsfunktion mit dem `steps`-Parameter*.

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

**Typ:** `float`

**Bereich**: `[0:Lmax]`

Die Streckenlänge in Metern. `Lmax is track-dependent.`

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

**Typ:** `float`

**Bereich**: `0:Dtrack`

Streckenbreite in Metern.

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


**Beispiel**: *Eine Belohnungsfunktion mit dem `track_width`-Parameter*.

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

**Typ:** `float`

**Bereich**: `0:N`

Position der Mitte des Agenten zur x- und y-Achse der simulierten Umgebung mit der Strecke in Metern. Der Nullpunkt liegt in der unteren linken Ecke der simulierten Umgebung.

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


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

**Typ**: `list` mit `[float, float]`

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

Eine sortierte Liste von streckenabhängigen `Max`-Meilensteinen entlang der Streckenmitte. Jeder Meilenstein wird durch eine Koordinate von (xw,i, yw,i) beschrieben. Bei einer Schleife sind die ersten und die letzte Zwischenposition identisch. Bei einer geraden Strecke oder einer Strecke, die keine Schleife bildet, unterscheiden sich die erste und die letzte Zwischenposition.

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


**Beispiel** *Eine Belohnungsfunktion mit dem Parameter `waypoints`*.

Weitere Informationen finden Sie unter [`closest_waypoints`](#reward-function-input-closest_waypoints).

# Beispiele AWS DeepRacer AWS-Prämienfunktionen
<a name="deepracer-reward-function-examples"></a>

Im Folgenden sind einige Beispiele für die DeepRacer AWS-Prämienfunktion aufgeführt.

**Topics**
+ [Beispiel 1: Folgen Sie beim Zeitfahren der Mittellinie](#deepracer-reward-function-example-0)
+ [Beispiel 2: Bleiben Sie beim Zeitfahren innerhalb der beiden Grenzen](#deepracer-reward-function-example-1)
+ [Beispiel 3: Vermeiden Sie Zick-Zack-Bewegungen bei Zeitfahren](#deepracer-reward-function-example-2)
+ [Beispiel 4: Bleiben Sie auf einer Spur, ohne gegen stehende Hindernisse oder fahrende Fahrzeuge zu stoßen](#deepracer-reward-function-example-3)

## Beispiel 1: Folgen Sie beim Zeitfahren der Mittellinie
<a name="deepracer-reward-function-example-0"></a>

 In diesem Beispiel wird festgestellt, wie weit der Agent von der Mittellinie entfernt ist, und er erhält eine höhere Belohnung, wenn er näher an der Mitte der Spur liegt; dadurch wird er veranlasst, der Mittellinie möglichst genau zu folgen. 

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

## Beispiel 2: Bleiben Sie beim Zeitfahren innerhalb der beiden Grenzen
<a name="deepracer-reward-function-example-1"></a>

 Dieses Beispiel bietet einfach hohe Belohnungen, wenn der Agent innerhalb der Grenzen bleibt, und lässt den Agenten herausfinden, wie er eine Runde am besten beenden kann. Es ist einfach zu programmieren und zu verstehen, aber die Konvergenz dauert wahrscheinlich länger. 

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

## Beispiel 3: Vermeiden Sie Zick-Zack-Bewegungen bei Zeitfahren
<a name="deepracer-reward-function-example-2"></a>

 In diesem Beispiel wird der Agent belohnt, wenn er der Mittellinie folgt, bei zu vielen Lenkbewegungen wird er jedoch bestraft, wodurch Zick-Zack-Bewegungen vermieden werden sollen. Der Agent lernt, im Simulator reibungslos zu fahren, und behält wahrscheinlich dasselbe Verhalten bei, wenn er auf dem physischen Fahrzeug eingesetzt wird. 

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

## Beispiel 4: Bleiben Sie auf einer Spur, ohne gegen stehende Hindernisse oder fahrende Fahrzeuge zu stoßen
<a name="deepracer-reward-function-example-3"></a>

 

Diese Belohnungsfunktion belohnt den Agenten dafür, dass er sich innerhalb der Streckengrenzen aufhält, und bestraft den Agenten, wenn er Objekten vor der Strecke zu nahe kommt. Der Agent kann sich von Spur zu Spur bewegen, um Kollisionen zu vermeiden. Die Gesamtbelohnung ist eine gewichtete Summe aus den Belohnungen und Bestrafungen. In diesem Beispiel wird der Strafe mehr Gewicht beigemessen, um Abstürze zu vermeiden. Experimentieren Sie mit unterschiedlichen Gewichten zur Mittelwertbildung, um für unterschiedliche Verhaltensergebnisse zu trainieren.

 

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