Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menyesuaikan fungsi hadiah
<a name="reward-function"></a>

Membuat fungsi hadiah seperti merancang rencana insentif. Parameter adalah nilai yang dapat digunakan untuk mengembangkan rencana insentif Anda.

Strategi insentif yang berbeda menghasilkan perilaku kendaraan yang berbeda. Untuk mendorong kendaraan mengemudi lebih cepat, cobalah memberikan nilai negatif ketika mobil membutuhkan waktu terlalu lama untuk menyelesaikan putaran atau keluar lintasan. Untuk menghindari pola mengemudi zig-zag, coba tentukan batas rentang sudut kemudi dan beri penghargaan kepada mobil karena mengemudi kurang agresif di bagian lintasan yang lurus.

Anda dapat menggunakan titik arah, yang merupakan penanda bernomor yang ditempatkan di sepanjang garis tengah dan tepi luar dan dalam trek, untuk membantu Anda mengaitkan perilaku mengemudi tertentu dengan fitur spesifik trek, seperti jalan lurus dan kurva.

Membuat fungsi hadiah yang efektif adalah proses yang kreatif dan berulang. Cobalah strategi yang berbeda, campur dan cocokkan parameter, dan yang paling penting, bersenang-senanglah\$1

**Topics**
+ [Mengedit kode Python untuk menyesuaikan fungsi hadiah Anda](#edit-reward-function)
+ [Parameter masukan dari fungsi AWS DeepRacer hadiah](#deepracer-reward-function-input)

## Mengedit kode Python untuk menyesuaikan fungsi hadiah Anda
<a name="edit-reward-function"></a>

Di AWS DeepRacer Student, Anda dapat mengedit fungsi hadiah sampel untuk menyusun strategi balap khusus untuk model Anda. 

**Untuk menyesuaikan fungsi hadiah Anda**

1. Pada **Langkah 5: Sesuaikan halaman fungsi hadiah** dari pengalaman **model Buat AWS DeepRacer ** Siswa, pilih fungsi hadiah sampel.

1. Gunakan editor kode di bawah pemilih fungsi hadiah sampel untuk menyesuaikan parameter input fungsi hadiah menggunakan kode Python.

1. Pilih **Validasi** untuk memeriksa apakah kode Anda akan berfungsi atau tidak. Atau, pilih **Reset** untuk memulai kembali.

1. Setelah selesai membuat perubahan, pilih **Berikutnya**.

Gunakan [Parameter masukan dari fungsi AWS DeepRacer hadiah](#deepracer-reward-function-input) untuk mempelajari tentang setiap parameter. Lihat bagaimana parameter yang berbeda digunakan dalam contoh fungsi hadiah.

## Parameter masukan dari fungsi AWS DeepRacer hadiah
<a name="deepracer-reward-function-input"></a>

Fungsi AWS DeepRacer reward mengambil objek kamus yang dilewatkan sebagai variabel`params`,, sebagai input. 

```
def reward_function(params) :

    reward = ...

    return float(reward)
```

Objek kamus `params` berisi pasangan nilai kunci berikut:

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

}
```

Gunakan referensi berikut untuk mendapatkan pemahaman yang lebih baik tentang parameter AWS DeepRacer input.

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

**Tipe: ** `Boolean`

**Kisaran: ** `(True:False)`

`Boolean`Bendera untuk menunjukkan apakah agen berada di jalur atau tidak di jalur. Agen tidak berada di jalur (`False`) jika ada rodanya yang berada di luar batas lintasan. Ini di trek (`True`) jika keempat roda berada di dalam batas lintasan dalam dan luar. Ilustrasi berikut menunjukkan agen yang berada di jalurnya. 

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


Ilustrasi berikut menunjukkan agen yang tidak berada di jalur karena dua roda berada di luar batas lintasan.

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


**Contoh: ** *Sebuah fungsi penghargaan yang menggunakan 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>

**Tipe**: `[int, int]`

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

Indeks berbasis nol dari dua `waypoint` tetangga yang paling dekat dengan posisi agen saat ini dari `(x, y)`. Jarak diukur dengan jarak Euclidean dari pusat agen. Elemen pertama mengacu pada waypoint terdekat di belakang agen dan elemen kedua mengacu pada waypoint terdekat di depan agen. `Max` adalah panjang daftar titik jalan. Dalam ilustrasi yang ditunjukkan pada[titik arah](#reward-function-input-waypoints), `closest_waypoints` adalah`[16, 17]`. 

Contoh fungsi penghargaan berikut menunjukkan cara menggunakan `waypoints` dan `closest_waypoints` serta `heading` untuk menghitung penghargaan langsung.

AWS DeepRacer mendukung pustaka Python berikut:`math`,,, `random``numpy`, `scipy` dan. `shapely` Untuk menggunakannya, tambahkan pernyataan impor,`import supported library`, sebelum definisi fungsi Anda,. `def reward_function(params)`

**Contoh**: *Fungsi hadiah menggunakan `closest_waypoints` parameter.*

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

**Tipe**: `[int, int]`

**Kisaran**: `[(0:len(object_locations)-1), (0:len(object_locations)-1]`

Indeks berbasis-nol dari dua objek terdekat dengan posisi agen saat ini (x, y). Indeks pertama mengacu pada objek terdekat di belakang agen, dan indeks kedua mengacu pada objek terdekat di depan agen. Jika hanya ada satu objek, kedua indeks adalah 0.

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

**Tipe**: `float`

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

Perpindahan, dalam meter, antara pusat agen dan pusat trek. Perpindahan maksimum yang dapat diamati terjadi ketika salah satu roda agen berada di luar batas lintasan dan, tergantung pada lebar batas lintasan, dapat sedikit lebih kecil atau lebih besar dari setengah `track_width`.

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


**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `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)
```

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

**Tipe**: `float`

**Kisaran**: `-180:+180`

Arah arah, dalam derajat, dari agen sehubungan dengan sumbu x dari sistem koordinat.

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


**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `heading`*

Untuk informasi selengkapnya, lihat [`closest_waypoints`](#reward-function-input-closest_waypoints).

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

**Tipe**: `Boolean`

**Kisaran**: `(True:False)`

`Boolean`Bendera yang menunjukkan apakah agen telah menabrak objek lain (`True`) atau tidak (`False`) sebagai status penghentian. 

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

**Tipe**: `Boolean`

**Kisaran**: `[True : False]`

`Boolean`Bendera yang menunjukkan apakah agen berada di sebelah kiri track center (`True`) atau tidak meninggalkan track center (`False`). 

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

**Tipe**: `Boolean`

**Kisaran**: `(True:False)`

`Boolean`Bendera yang menunjukkan apakah keempat roda agen telah melaju di luar boarder bagian dalam atau luar trek (`True`) atau tidak (`False`). 

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

**Tipe**: `Boolean`

**Kisaran**: `[True:False]`

`Boolean`Bendera yang menunjukkan apakah agen mengemudi searah jarum jam (`True`) atau berlawanan arah jarum jam (). `False` 

Bendera ini digunakan saat Anda mengaktifkan perubahan arah untuk setiap episode. 

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

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

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

Daftar jarak antara objek di lingkungan dalam kaitannya dengan garis start. Elemen ith mengukur jarak dalam meter antara objek ith dan garis mulai di sepanjang garis tengah lintasan. 

**catatan**  
abs \$1 (var1) - (var2) \$1 = seberapa dekat mobil ke suatu objek, WHEN var1 = ["objects\$1distance"][index] and var2 = params["progress"]\$1params["track\$1length"]  
Untuk mendapatkan indeks objek terdekat di depan kendaraan dan objek terdekat di belakang kendaraan, gunakan `closest_objects` parameter.

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

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

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

Daftar judul objek dalam satuan derajat. Elemen ith mengukur heading objek ith. Judul objek stasioner adalah 0. Untuk mobil bot, nilai elemen yang sesuai adalah sudut heading mobil bot.

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

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

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

Daftar `Boolean` bendera. Nilai elemen i th menunjukkan apakah objek i ke kiri (`True`) atau kanan (`False`) dari pusat trek. 

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

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

**Kisaran**: `[(0:N,0:N), ...]`

Parameter ini menyimpan semua lokasi objek. Setiap lokasi adalah tupel ([x, y](#reward-function-input-x_y)). 

Ukuran daftar sama dengan jumlah objek di lintasan. Objek yang terdaftar termasuk rintangan stasioner dan mobil bot yang bergerak. 

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

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

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

Daftar kecepatan (meter per detik) untuk objek di lintasan. Untuk benda stasioner, kecepatannya 0. Untuk kendaraan bot, nilainya adalah kecepatan yang Anda atur dalam pelatihan. 

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

**Tipe**: `float`

**Kisaran**: `0:100`

Persentase lintasan selesai.

**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `progress`*

Untuk informasi selengkapnya, lihat [langkah-langkah](#reward-function-input-steps).

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

**Tipe**: `float`

**Kisaran**: `0.0:5.0`

Kecepatan agen yang diamati, dalam meter per detik (m/s).

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


**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `speed`*

Untuk informasi selengkapnya, lihat [all\$1wheels\$1on\$1track](#reward-function-input-all_wheels_on_track).

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

**Tipe**: `float`

**Kisaran**: `-30:30`

Sudut kemudi, dalam satuan derajat, dari roda depan garis tengah agen. Tanda negatif (-) berarti kemudi ke kanan dan tanda positif (\$1) berarti kemudi ke kiri. Garis tengah agen tidak selalu paralel dengan garis tengah trek seperti yang ditunjukkan pada ilustrasi berikut.

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


**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `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)
```

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

**Tipe**: `int`

**Kisaran**: `0:Nstep`

Jumlah langkah yang diselesaikan. Sebuah langkah sesuai dengan satu urutan tindakan pengamatan yang diselesaikan oleh agen menggunakan kebijakan saat ini.

**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `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>

**Tipe**: `float`

**Kisaran**: `[0:Lmax]`

Panjang lintasan dalam satuan meter. `Lmax is track-dependent.`

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

**Tipe**: `float`

**Kisaran**: `0:Dtrack`

Lebar lintasan dalam satuan meter.

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


**Contoh:** *Sebuah fungsi penghargaan yang menggunakan parameter `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>

**Tipe**: `float`

**Kisaran**: `0:N`

Lokasi, dalam meter, pusat agen di sepanjang sumbu x dan y dari lingkungan simulasi yang berisi trek. Asal berada di sudut kiri bawah lingkungan simulasi.

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


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

**Tipe**: `list` dari `[float, float]`

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

Daftar urutan tonggak `Max` yang bergantung pada lintasan di sepanjang pusat lintasan. Setiap tonggak digambarkan dengan koordinat (xw,i, yw,i). Untuk lintasan melingkar, waypoint pertama dan terakhir adalah sama. Untuk lintasan lurus atau tidak melingkar lainnya, waypoint pertama dan terakhir berbeda.

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


**Contoh** *Sebuah fungsi penghargaan yang menggunakan parameter `waypoints`*

Lihat informasi yang lebih lengkap di [`closest_waypoints`](#reward-function-input-closest_waypoints).