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à.

# Personalizzazione di una funzione di ricompensa
<a name="reward-function"></a>

Creare una funzione di ricompensa è come progettare un piano di incentivi. I parametri sono valori che possono essere utilizzati per sviluppare un piano di incentivi.

Diverse strategie di incentivazione determinano comportamenti diversi dei veicoli. Per incoraggiare il veicolo a guidare più velocemente, prova ad assegnare valori negativi quando l'auto impiega troppo tempo a finire un giro o esce di pista. Per evitare schemi di guida a zig-zag, provate a definire un limite per l'angolo di sterzata e premiate l'auto che sterza in modo meno aggressivo sui tratti rettilinei della pista.

Puoi utilizzare i waypoint, che sono indicatori numerati posizionati lungo la linea centrale e i bordi esterni e interni della pista, per aiutarti ad associare determinati comportamenti di guida a caratteristiche specifiche di un tracciato, come rettilinei e curve.

La creazione di una funzione di ricompensa efficace è un processo creativo e iterativo. Prova diverse strategie, mescola e abbina parametri e, soprattutto, divertiti\$1

**Topics**
+ [Modifica del codice Python per personalizzare la funzione di ricompensa](#edit-reward-function)
+ [Parametri di input della funzione di AWS DeepRacer ricompensa](#deepracer-reward-function-input)

## Modifica del codice Python per personalizzare la funzione di ricompensa
<a name="edit-reward-function"></a>

In AWS DeepRacer Student, puoi modificare alcuni esempi di funzioni di ricompensa per creare una strategia di corsa personalizzata per il tuo modello. 

**Per personalizzare la funzione di ricompensa**

1. Nella pagina **Step 5: Personalizza la funzione di ricompensa** dell'esperienza **modello AWS DeepRacer Student Create**, seleziona una funzione di ricompensa di esempio.

1. Usa l'editor di codice sotto il selettore di funzioni di ricompensa di esempio per personalizzare i parametri di input della funzione di ricompensa usando il codice Python.

1. Seleziona **Convalida** per verificare se il codice funzionerà o meno. In alternativa, scegli **Reimposta** per ricominciare da capo.

1. Una volta che hai finito di apportare le modifiche, seleziona **Avanti**.

[Parametri di input della funzione di AWS DeepRacer ricompensa](#deepracer-reward-function-input)Usalo per saperne di più su ogni parametro. Scopri come vengono utilizzati i diversi parametri negli esempi di funzioni di ricompensa.

## Parametri di input della funzione di AWS DeepRacer ricompensa
<a name="deepracer-reward-function-input"></a>

La funzione di AWS DeepRacer ricompensa accetta un oggetto del dizionario passato come variabile`params`, 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

}
```

Utilizzate il seguente riferimento per comprendere meglio i parametri di AWS DeepRacer input.

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

**Type (Tipo)** `Boolean`

**Range (Intervallo):** `(True:False)`

Un `Boolean` contrassegno per indicare se l'agente è sulla buona strada o meno. L'agente non è sulla buona strada (`False`) se una delle sue ruote si trova al di fuori dei bordi della pista. È sulla pista (`True`) se tutte e quattro le ruote si trovano all'interno dei bordi interni ed esterni del binario. L'illustrazione seguente mostra un agente che è sulla buona strada. 

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


L'illustrazione seguente mostra un agente che non è in pista perché due ruote si trovano al di fuori dei bordi del binario.

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


**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\$1waypoints
<a name="reward-function-input-closest_waypoints"></a>

**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](#reward-function-input-waypoints), `closest_waypoints` sono`[16, 17]`. 

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 Python:`math`,, `random` `numpy``scipy`, e. `shapely` Per usarne una, aggiungi un'istruzione di importazione`import supported library`, che precede la definizione della funzione,. `def reward_function(params)`

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

```
# 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\$1objects
<a name="reward-function-input-closest_objects"></a>

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

**Range (Intervallo)**: `[(0:len(object_locations)-1), (0:len(object_locations)-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\$1from\$1center
<a name="reward-function-input-distance_from_center"></a>

**Tipo:** `float`

**Range (Intervallo)**: `0:~track_width/2`

Spostamento, in metri, tra il centro dell'agente e il centro del binario. 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`.

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


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

**Tipo:** `float`

**Range (Intervallo)**: `-180:+180`

La direzione della rotta, in gradi, dell'agente rispetto all'asse x del sistema di coordinate.

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


**Esempio:** *una funzione di ricompensa che utilizza il parametro `heading`*

Per ulteriori informazioni, consulta [`closest_waypoints`](#reward-function-input-closest_waypoints).

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

**Tipo:** `Boolean`

**Range (Intervallo)**: `(True:False)`

Un `Boolean` flag che indica se l'agente si è schiantato contro un altro oggetto (`True`) o meno (`False`) come stato di terminazione. 

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

**Tipo:** `Boolean`

**Range (Intervallo)**: `[True : False]`

Un `Boolean` flag che indica se l'agente è a sinistra del track center (`True`) o non a sinistra del track center (`False`). 

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

**Tipo:** `Boolean`

**Range (Intervallo)**: `(True:False)`

Una `Boolean` bandiera che indica se tutte e quattro le ruote dell'agente sono uscite dai bordi interni o esterni della pista (`True`) oppure no (`False`). 

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

**Tipo:** `Boolean`

**Range (Intervallo)**: `[True:False]`

Una `Boolean` bandiera che indica 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\$1distance
<a name="reward-function-input-objects_distance"></a>

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

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

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

**Nota**  
abs \$1 (var1) - (var2)\$1 = how close the car is to an object, WHEN var1 = ["objects\$1distance"][index] and var2 = params["progress"]\$1params["track\$1length"]  
Per ottenere un indice dell'oggetto più vicino davanti al veicolo e dell'oggetto più vicino dietro il veicolo, utilizzate il `closest_objects` parametro.

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

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

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

Elenco delle intestazioni degli oggetti in gradi. L'elemento I° misura l'intestazione dell'oggetto I°. I titoli degli oggetti fissi sono 0. Per le auto bot, il valore dell'elemento corrispondente è l'angolo di rotta della bot car.

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

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

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

Elenco delle `Boolean` bandiere. Il valore i th dell'elemento indica se l'oggetto si trova a sinistra (`True`) o a destra (`False`) del centro della traccia. 

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

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

**Range (Intervallo)**: `[(0:N,0:N), ...]`

Questo parametro memorizza tutte le posizioni degli oggetti. Ogni posizione è una tupla di ([x, y).](#reward-function-input-x_y) 

La dimensione dell'elenco è uguale al numero di oggetti presenti sulla pista. Gli oggetti elencati includono sia ostacoli fissi che macchine robot in movimento. 

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

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

**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](#reward-function-input-steps).

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

**Tipo:** `float`

**Range (Intervallo)**: `0.0:5.0`

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

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


**Esempio:** *una funzione di ricompensa che utilizza il parametro `speed`*

Per ulteriori informazioni, consulta [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track).

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

**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 (\$1) verso sinistra. La linea centrale dell'agente non è necessariamente parallela alla linea centrale del binario, come illustrato nella figura seguente.

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


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

**Tipo:** `int`

**Range (Intervallo)**: `0:Nstep`

Il numero di passaggi completati. Un passaggio corrisponde a una sequenza di osservazione-azione completata dall'agente utilizzando la politica 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\$1length
<a name="reward-function-input-track_len"></a>

**Tipo:** `float`

**Range (Intervallo)**: `[0:Lmax]`

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

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

**Tipo:** `float`

**Range (Intervallo)**: `0:Dtrack`

Larghezza della pista in metri.

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


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

**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 traccia. L'origine si trova nell'angolo in basso a sinistra dell'ambiente simulato.

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


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

**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.

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


**Esempio:** *una funzione di ricompensa che utilizza il parametro `waypoints`*

Per ulteriori informazioni, consulta [`closest_waypoints`](#reward-function-input-closest_waypoints).