Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Referensi fungsi DeepRacer penghargaan AWS Referensi fungsi hadiah Berikut ini adalah referensi teknis dari fungsi DeepRacer reward AWS. **Topics** + [ # Parameter masukan fungsi DeepRacer reward AWS ](deepracer-reward-function-input.md) + [ # Contoh fungsi DeepRacer penghargaan AWS ](deepracer-reward-function-examples.md) # Parameter masukan fungsi DeepRacer reward AWS Parameter input fungsi hadiah Fungsi AWS DeepRacer reward mengambil objek kamus 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 } ``` Referensi teknis yang lebih detail dari parameter input adalah sebagai berikut. ## all\$1wheels\$1on\$1track **Tipe: ** `Boolean` **Kisaran: ** `(True:False)` Bendera `Boolean` menunjukkan apakah agen berada di lintasan atau di luar lintasan. Bendera keluar lintasan (`False`) jika salah satu roda agen berada di luar batas lintasan. Bendera berada di lintasan (`True`) jika semua roda berada di dalam dua batas lintasan. Ilustrasi berikut menunjukkan bahwa agen berada di lintasan. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/deepracer-reward-function-input-all_wheels_on_track-true.png) Ilustrasi berikut menunjukkan bahwa agen keluar lintasan. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/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 **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 dalam [titik arah](#reward-function-input-waypoints), `closest_waypoints` akan menjadi `[16, 17]`. **Contoh**: Sebuah fungsi penghargaan menggunakan parameter `closest_waypoints`. Contoh fungsi penghargaan berikut menunjukkan cara menggunakan `waypoints` dan `closest_waypoints` serta `heading` untuk menghitung penghargaan langsung. AWS DeepRacer mendukung pustaka berikut: matematika, acak,, NumPy SciPy, dan Shapely. Untuk menggunakannya, tambahkan pernyataan impor, `import supported library`, di atas definisi fungsi Anda, `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 **Tipe**: `[int, int]` **Kisaran**: `[(0:len(objects_location)-1), (0:len(objects_location)-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 **Tipe**: `float` **Kisaran**: `0:~track_width/2` Perpindahan, dalam satuan meter, antara pusat agen dan pusat lintasan. 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/developerguide/images/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 **Tipe**: `float` **Kisaran**: `-180:+180` Arah tujuan, dalam satuan derajat, dari agen yang sehubungan dengan sumbu x dari sistem koordinat. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/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 **Tipe**: `Boolean` **Kisaran**: `(True:False)` Bendera Boolean untuk menunjukkan apakah agen telah menabrak objek lain (`True`) atau tidak (`False`) sebagai status pengakhiran. ## is\$1left\$1of\$1center **Tipe**: `Boolean` **Kisaran**: `[True : False]` Bendera `Boolean` untuk menunjukkan jika agen berada di sisi kiri pusat lintasan (`True`) atau di sisi kanan (`False`). ## is\$1offtrack **Tipe**: `Boolean` **Kisaran**: `(True:False)` Bendera Boolean untuk menunjukkan apakah agen memiliki off track (Betul) atau tidak (Salah) sebagai status pengakhiran. ## is\$1reversed **Tipe**: `Boolean` **Kisaran**: `[True:False]` Bendera Boolean untuk menunjukkan jika agen mengemudi searah jarum jam (Betul) atau tidak searah jarum jam (Salah). Bendera ini digunakan saat Anda mengaktifkan perubahan arah untuk setiap episode. ## objects\$1distance **Tipe**: `[float, … ]` **Kisaran**: `[(0:track_length), … ]` Daftar jarak antara objek di lingkungan dalam kaitannya dengan garis mulai. 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 di belakang kendaraan, gunakan parameter "closest\$1objects". ## objects\$1heading **Tipe**: `[float, … ]` **Kisaran**: `[(-180:180), … ]` Daftar judul objek dalam satuan derajat. Elemen ith mengukur heading objek ith. Untuk benda stasioner, judulnya adalah 0. Untuk kendaraan bot, nilai elemen yang sesuai adalah sudut judul kendaraan. ## objects\$1left\$1of\$1center **Tipe**: `[Boolean, … ]` **Kisaran**: `[True|False, … ]` Daftar bendera Boolean. Nilai elemen ith menunjukkan apakah objek ith berada di sisi kiri (Betul) atau kanan (Salah) pusat lintasan. ## objects\$1location **Tipe**: `[(x,y), … ]` **Kisaran**: `[(0:N,0:N), … ]` Daftar semua lokasi objek, setiap lokasi adalah tupel dari ([x, y](#reward-function-input-x_y)). Ukuran daftar sama dengan jumlah objek di lintasan. Perhatikan, objeknya bisa berupa rintangan stasioner, kendaraan bot yang bergerak. ## objects\$1speed **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 **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 **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/developerguide/images/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 **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 harus sejajar dengan garis tengah lintasan seperti yang ditunjukkan pada ilustrasi berikut. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/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 **Tipe**: `int` **Kisaran**: `0:Nstep` Jumlah langkah selesai. Sebuah langkah sesuai dengan tindakan yang diambil oleh agen mengikuti 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 **Tipe**: `float` **Kisaran**: `[0:Lmax]` Panjang lintasan dalam satuan meter. `Lmax is track-dependent.` ## track\$1width **Tipe**: `float` **Kisaran**: `0:Dtrack` Lebar lintasan dalam satuan meter. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/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 **Tipe**: `float` **Kisaran**: `0:N` Lokasi, dalam satuan meter, dari pusat agen di sepanjang sumbu x dan y, dari lingkungan simulasi yang berisi lintasan. Asal berada di sudut kiri bawah lingkungan simulasi. ![\[\]](http://docs.aws.amazon.com/id_id/deepracer/latest/developerguide/images/deepracer-reward-function-input-x-y.png) ## titik arah **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/developerguide/images/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). # Contoh fungsi DeepRacer penghargaan AWS Contoh fungsi hadiah Berikut ini mencantumkan beberapa contoh fungsi DeepRacer reward AWS. **Topics** + [ ## Contoh 1: Ikuti garis tengah dalam uji waktu ](#deepracer-reward-function-example-0) + [ ## Contoh 2: Tetap di dalam dua batas dalam uji waktu ](#deepracer-reward-function-example-1) + [ ## Contoh 3: Cegah zig-zag dalam uji waktu ](#deepracer-reward-function-example-2) + [ ## Contoh 4: Tetap di satu jalur tanpa menabrak rintangan stasioner atau kendaraan yang bergerak ](#deepracer-reward-function-example-3) ## Contoh 1: Ikuti garis tengah dalam uji waktu Contoh ini menentukan seberapa jauh agen dari garis tengah, dan memberikan penghargaan yang lebih tinggi jika lebih dekat ke pusat lintasan, mendorong agen untuk mengikuti garis tengah dengan cermat. ``` 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 ``` ## Contoh 2: Tetap di dalam dua batas dalam uji waktu Contoh ini hanya memberikan imbalan tinggi jika agen tetap berada di dalam perbatasan, dan memungkinkan agen mencari jalan terbaik untuk menyelesaikan putaran. Sangat mudah untuk memprogram dan memahami, tetapi mungkin membutuhkan waktu lebih lama untuk bertemu. ``` 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 ``` ## Contoh 3: Cegah zig-zag dalam uji waktu Contoh ini mendorong agen untuk mengikuti garis tengah tetapi menghukum dengan penghargaan yang lebih rendah jika mengarahkan terlalu banyak yang membantu mencegah perilaku zig-zag. Agen belajar mengemudi dengan lancar di simulator dan kemungkinan menjaga perilaku yang sama ketika dikerahkan ke kendaraan fisik. ``` 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) ``` ## Contoh 4: Tetap di satu jalur tanpa menabrak rintangan stasioner atau kendaraan yang bergerak Fungsi hadiah ini memberi penghargaan kepada agen karena tetap berada di dalam batas lintasan dan menghukum agen karena terlalu dekat dengan objek di depannya. Agen dapat berpindah dari satu jalur ke jalur lainnya untuk menghindari tabrakan. Total penghargaan adalah penjumlahan tertimbang dari penghargaan dan penalti. Contoh tersebut memberikan bobot lebih pada penalti dalam upaya menghindari tabrakan. Bereksperimenlah dengan bobot rata-rata yang berbeda untuk melatih hasil perilaku yang berbeda. ``` 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 ```