分类 AWS Deepracer Developer Guide 下的文章

https://student.deepracer.com/raceToken/XU-8IQzqQoOVWn0Wxz3TJw

AWS上面创建一个学生虚拟比赛

有student.deepracer.com账号的都可以接受邀请参与其中..

    Welcome to Deepracer-SHXW-2023, an AWS DeepRacer student community race!

You're invited to Deepracer-SHXW-2023, a time trial race on May 1 12:00 AM GMT+8. This race is hosted by <Educator/School>. 

To Race:
1. Log in to your AWS DeepRacer student account.
2. Submit your AWS DeepRacer model to enter the race https://student.deepracer.com/raceToken/XU-8IQzqQoOVWn0Wxz3TJw. Model

submissions open on May 1 12:00 AM GMT+8 and ends on December 31 11:59
PM GMT+8. Note that this displayed race time may not reflect your
current time zone. You can submit multiple models, but only the model
with the best lap time is entered in the race.


Participation checklist
* Sign up for an AWS DeepRacer student account and create a profile.
* Train a model.
* Submit your model to enter the race.

AWS DeepRacer 奖励函数示例

以下列出了 AWS DeepRacer 奖励函数的一些示例。

主题

  • 示例 1:在计时赛中遵循中心线
  • 示例 2:在计时赛中待在两个边界内
  • 示例 3:防止计时赛出现曲折现象
  • 示例 4:在不撞上静止的障碍物或行驶中的车辆的情况下保持在一条车道上

示例 1:在计时赛中遵循中心线

此示例确定代理距中心线的距离,如果代理靠近赛道的中心,则提供更高的奖励,鼓励代理紧贴中心线行驶。

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

示例 2:在计时赛中待在两个边界内

如果代理人待在边界内,这个例子只会给出高额奖励,让特工找出完成一圈的最佳路径。它易于编程和理解,但可能需要更长的时间才能融合。

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

示例 3:防止计时赛出现曲折现象

此示例奖励代理紧贴中心线行驶,但如果转向角太大,则会受到惩罚(减少奖励),这有助于防止之字形行驶。特工在模拟器中学会平稳驾驶,部署到实体车辆时可能会保持相同的行为。

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)

示例 4:在不撞上静止的障碍物或行驶中的车辆的情况下保持在一条车道上

此奖励功能奖励特工停留在赛道边界内,并惩罚特工离赛道前方物体太近。代理可变道以避免撞车。总奖励是奖励和惩罚的加权总和。为了避免碰撞,该示例更加重视处罚。尝试不同的平均权重,针对不同的行为结果进行训练。

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

AWS DeepRacer 奖励函数参考

以下是 AWS DeepRacer 奖励函数的技术参考。

主题

  • AWS DeepRacer 奖励函数的输入参数
  • AWS DeepRacer 奖励函数示例

AWS DeepRacer 奖励函数的输入参数

AWS DeepRacer 奖励函数的输入参数
PDF
AWS DeepRacer 奖励函数将字典对象作为输入。

def reward_function(params) :
    
    reward = ...

    return float(reward)

params 词典对象包含以下键/值对:

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

}

输入参数的更多详细技术参考如下所示。


all_wheels_on_track
类型:Boolean

范围:(True:False)

一个 Boolean 标记,指示代理是在赛道上还是偏离赛道。如果车辆的任一车轮位于赛道边界外,则将车辆视为偏离赛道 (False)。如果车辆的所有车轮都在两个赛道边界内,则将车辆视为在赛道上 (True)。下图显示了代理在赛道上。

deepracer-reward-function-input-all_wheels_on_track-true.png

下图显示了代理偏离赛道。
deepracer-reward-function-input-all_wheels_on_track-false.png

示例:使用 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_waypoints
类型: [int, int]

范围:[(0:Max-1),(1:Max-1)]

最接近代理当前位置 (x, y) 的两个相邻 waypoint 的从零开始的索引。距离是根据与代理中心的欧氏距离来测量的。第一个元素指代理后面最近的路点,第二个元素指代理前面最近的路点。Max 是路点列表的长度。在waypoints的图示中,closest_waypoints 将为 [16, 17]。

示例:使用 closest_waypoints 参数的奖励函数。

以下示例奖励函数演示如何使用 waypoints、closest_waypoints 和 heading 来计算即时奖励。

AWS DeepRacer 支持以下库:数学、随机 NumPy SciPy、和 Shapely。要使用一个,请在函数定义的上方添加一个 import 语句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_objects
类型: [int, int]

范围:[(0:len(object_locations)-1), (0:len(object_locations)-1]

最接近代理当前位置 (x, y) 的两个物体的从零开始的索引。第一个索引指代理后面最近的物体,第二个索引指代理前面最近的物体。如果只有一个物体,则两个索引都为 0。

distance_from_center
类型: float

范围:0:~track_width/2

代理中心和赛道中心之间的位移(以米为单位)。当代理的任一车轮位于赛道边界外时可观察到的最大位移,并且根据赛道边界的宽度,它可以略小于或大于 track_width 的一半。

deepracer-reward-function-input-distance_from_center.png

示例:使用 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
类型: float

范围:-180:+180

代理相对于坐标系 x 轴的前进方向(以度为单位)。

deepracer-reward-function-input-heading.png

示例:使用 heading 参数的奖励函数

有关更多信息,请参阅closest_waypoints:


is_crashed
类型: Boolean

范围:(True:False)

一个布尔标记,用于指示代理的最终状态是否为撞向另一个物体(True 或 False)

is_left_of_center
类型: Boolean

范围:[True : False]

一个 Boolean 标记,用于指示代理是位于赛道中心的左侧 (True) 还是右侧 (False)。

is_offtrack
类型: Boolean

范围:(True:False)

一个布尔标记,用于指示代理的最终状态是否为脱离赛道(True 或 False)。

is_reversed
类型: Boolean

范围:[True:False]

一个布尔标记,用于指示代理是顺时针行驶 (True) 还是逆时针行驶 (False)。

此参数在您针对每个过程改变方向时使用。

objects_distance
类型: [float, … ]

范围:[(0:track_length), … ]

环境中物体之间相对于起始线的距离列表。第 i 个元素测量沿赛道中心线第 i 个物体与起始线之间的距离。

注意 abs | (var1) - (var2)| = 汽车与物体的接近程度, WHEN var1 =
"objects_distance" and var2 =
params["progress"]*params["track_length"]
要获取车辆前方最近物体和车辆后方最近物体的索引,请使用“closest_objects”参数。

objects_heading
类型: [float, … ]

范围:[(-180:180), … ]

物体前进方向(以度为单位)列表。第 i 个元素测量第 i 个物体的前进方向。对于静止物体,其前进方向为 0。对于自动程序车辆,相应元素的值是车辆的前进角度。

objects_left_of_center
类型: [Boolean, … ]

范围:[True|False, … ]

布尔标记列表。第 i 个元素值指示第 i 个物体位于赛道中心的左侧 (True) 还是右侧 (False)。

objects_location
类型: [(x,y), ...]

范围:[(0:N,0:N), ...]

所有物体位置的列表,每个位置都是 (x, y) 的元组。

列表的大小等于赛道上的物体数。注意,物体可能是静止的障碍物,移动的自动程序车辆。

objects_speed
类型: [float, … ]

范围:[(0:12.0), … ]

赛道上物体的速度(米/秒)列表。对于静止物体,其速度为 0。对于机器人载具,该值是您在训练中设置的速度。

progress
类型: float

范围:0:100

赛道完成百分比。

示例:使用 progress 参数的奖励函数

有关更多信息,请参阅步骤。

speed
类型: float

范围:0.0:5.0

观察到的代理速度,以米/秒 (m/s) 为单位。

deepracer-reward-function-input-speed.png

示例:使用 speed 参数的奖励函数

有关更多信息,请参阅 all_wheels_on_track。

steering_angle
类型: float

范围:-30:30

前轮与代理中心线之间的转向角(以度为单位)。负号 (-) 表示向右转向,正号 (+) 表示向左转向。代理中心线不一定与赛道中心线平行,如下图所示。

deepracer-reward-function-steering.png

示例:使用 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
类型: int

范围:0:Nstep

完成的步骤数。步骤对应于代理按照当前策略所采取的操作。

示例:使用 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_length
类型: float

范围:[0:Lmax]

赛道长度(以米为单位)。Lmax is track-dependent.

track_width
类型: float

范围:0:Dtrack

赛道宽度(以米为单位)。

deepracer-reward-function-input-track_width.png


示例:使用 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
类型: float

范围:0:N

包含赛道的模拟环境的沿 x 和 y 轴的代理中心位置(以米为单位)。原点位于模拟环境的左下角。

deepracer-reward-function-input-x-y.png


waypoints
类型:[float, float] 的 list

范围:[[xw,0,yw,0] … [xw,Max-1, yw,Max-1]]

沿赛道中心排列、取决于赛道的 Max 里程的有序列表。每个里程碑都用 (xw,i, yw,i) 坐标来描述。对于环形赛道,第一个路径点与最后一个路径点相同。对于直道和其他非环形赛道,第一个路径点与最后一个路径点不同。

deepracer-reward-function-input-waypoints.png


示例:使用 waypoints 参数的奖励函数

有关更多信息,请参阅 closest_waypoints。

使用 AWS DeepRacer 控制台训练和评估 AWS DeepRacer 模型

请输入图片描述
要训练强化学习模型,您可以使用 AWS DeepRacer 控制台。在控制台中,创建一个训练任务,选择支持的框架以及可用的算法,添加新的奖励函数,然后配置训练设置。您也可以继续在模拟器中观看训练。您可以在中找到 step-by-step 相关说明训练您的第一个 AWS DeepRacer 模型 。

本节介绍如何训练和评估 AWS DeepRacer 模型,请登录。其中还演示了如何创建和改进奖励函数、操作空间如何影响模型的性能以及超级参数如何影响训练成绩。您还可以了解如何克隆模型来扩展训练会话,如何使用模拟器来评估训练成绩,以及如何解决在从模拟转向真实环境时面临的一些挑战。

主题

  • 创建您的奖励函数
  • 探索动作空间来训练一个强大的模型
  • 系统地调整超参数
  • 检查 AWS DeepRacer 培训任务进度
  • 克隆经过训练的模型以开始新的训练通行证
  • 在模拟中评估 AWS DeepRacer 模型
  • 将 AWS DeepRacer 事件 CloudWatch 记录到日志
  • 针对真实环境优化训练 AWS DeepRacer 模型

创建您的奖励函数

奖励函数描述了当您的 AWS DeepRacer 车辆从赛道上的一个位置移动到新位置时的即时反馈(奖励或惩罚分数)。该函数的目的是鼓励车辆沿赛道快速行驶到目的地,避免事故或违规。理想的驾驶过程会由于其操作或其目标状态赢得较高的分数。非法或绕路的驾驶过程得到的分数较低。训练 AWS DeepRacer 模型时,奖励函数是唯一特定于应用程序的部分。

通常,您设计奖励函数来用作激励计划。不同的激励策略会导致不同的车辆行为。要使车辆驾驶速度更快,函数应为车辆沿赛道行驶提供奖励。该函数应对车辆完成一圈用时过长或者偏离赛道进行罚分。为了避免之字形驾驶模式,可以为在赛道的直道部分转向更少的车辆进行奖分。奖励函数可在车辆通过特定里程时给出正分数,这一里程通过 waypoints 来测量。这可以减少等待或者在错误方向上驾驶的情况。您也可以更改奖励函数以将赛道情况考虑在内。但是,在奖励函数中越多地考虑特定于环境的信息,您训练的模型过度拟合的可能性就越高,通用性就越低。要使您的模型适用性更强,您可以探索操作空间。

如果激励计划未周详考虑,它可能导致负面效应这样的意外后果。出现这种情况是因为即时反馈是必要的,但没有足够的条件用于强化学习。单独的即时奖励本身也无法确定驾驶路线是否理想。在特定位置,一个驾驶路线可以获得较高的奖励。随后的驾驶路线可能会偏离赛道,得到较低的分数。在这种情况下,车辆在该位置应该按高分驾驶路线行驶。只有当平均而言,从给定位置往后的所有移动会得到高分时,才认为前往下一个位置的驾驶路线是理想的。未来的反馈按一定比例折扣,使得在平均奖励计算中,只包含少量以后的驾驶路线或位置。

创建奖励函数的一个良好做法是先创建一个涵盖基本场景的简单函数。您可以增强函数来处理更多操作。现在我们来看一些简单的奖励函数。

主题

  • 简单的奖励函数示例
  • 增强您的奖励函数

简单的奖励函数示例
我们可以通过首先考虑最基本的情况来构建奖励函数。也就是在直道上从起点行驶到终点且不偏离赛道的情况。在这种情况下,奖励函数逻辑仅依赖于 on_track 和 progress。作为试验,您可以从以下逻辑开始:

def reward_function(params):
    if not params["all_wheels_on_track"]:
        reward = -1
    else if params["progress"] == 1 :
        reward = 10
    return reward


此逻辑在代理行驶偏离赛道时进行罚分。在代理行驶到终点线时奖分。这对实现既定目标是合理的。但是,代理会在起点线和终点线之间自由行驶,包括在赛道上向后行驶。训练不仅可能需要很长时间才能完成,并且训练模型在部署到实际车辆中时会导致驾驶效率低下。

实际上,如果代理能够在 bit-by-bit整个训练过程中学习,则可以更有效地学习。这意味着奖励函数应该随着车辆在赛道上的行进逐渐加大给予的奖励。为了让代理在直线赛道上驾驶车辆,我们可以按下面所示改进奖励函数:

def reward_function(params):
    if not params["all_wheels_on_track"]:
        reward = -1
    else:
        reward = params["progress"]
    return reward

利用此函数,代理可以在越接近终点线时获得更多奖励。这应该减少或消除向后驾驶的非生产性试验。通常,我们希望奖励函数在操作空间上更均匀地分配奖励。创建有效的奖励函数可能是一项颇具挑战性的任务。您应该从一个简单的函数开始,并逐步增强或改进该函数。对于系统性试验,函数可能会更稳健和高效。

增强您的奖励功能
在您成功地将 AWS DeepRacer 模型训练成简单的直道后,AWS DeepRacer 车辆(虚拟或物理)可以在不偏离赛道的情况下自行行驶。如果您让车辆在环形赛道上行驶,它将不会保持在赛道上。奖励函数忽略了通过转弯来保持在赛道上的操作。

要使车辆处理这些操作,您必须增强奖励函数。在代理进行允许的转弯时,函数应该予以奖励,如果代理做出了非法转弯,则应给予罚分。然后,您便可以开始另一轮训练。要利用以前的训练,您可以通过克隆以前训练的模型并传递以前学习的知识来开始新的训练。您可以按照这种模式逐步向奖励功能添加更多功能,训练您的 AWS DeepRacer 车辆在越来越复杂的环境中行驶。

有关更高级的奖励函数,请参阅以下示例:

  • 示例 1:在计时赛中遵循中心线
  • 示例 2:在计时赛中待在两个边界内
  • 示例 3:防止计时赛出现曲折现象
  • 示例 4:在不撞上静止的障碍物或行驶中的车辆的情况下保持在一条车道上

探索动作空间来训练一个强大的模型

作为通则,您训练的模型应该尽可能稳健,这样就可以将其应用到尽可能多的环境。稳健的模型是可以应用到广泛赛道形状和条件的模型。一般而言,一个稳健的模型不够“智能”,因为其奖励函数没有包含特定于环境的具体知识的能力。否则,您的模型更可能仅适用于类似于训练环境的环境。

在奖励函数中明确包含特定于环境的信息会导致特征工程。特征工程有助于减少训练时间,在针对特定环境定制解决方案时会很有用。但是,要训练具有一般适用性的模型,您应该避免尝试大量特征工程。

例如,在圆形赛道上训练模型时,如果您在奖励函数中明确包含了这种集合属性,就不能预期得到适合任何非圆形赛道的训练模型。

如何才能在训练出尽可能稳健的模型的同时,确保奖励函数尽可能简单? 探索操作空间的一种方法是生成您的代理可以采取的操作。另一种是通过基础训练算法的超级参数进行实验。通常,您同时使用这两种方法。在这里,我们将重点介绍如何探索行动空间,为您的 AWS DeepRacer 车辆训练一个强大的模型。

在训练 AWS DeepRacer 模型时,动作 (a) 是速度(t米每秒)和转向角度(s以度为单位)的组合。代理的操作空间定义了代理可以使用的速度和转向角度范围。对于具有 m 个速度、(v1, .., vn) 和 n 个转向角度的不连续操作空间 (s1, .., sm),操作空间中有 m*n 个可能的操作。

a1: (v1, s1)
...
an: (v1, sn)

...
a(i-1)*n+j: (vi, sj)
...

a(m-1)*n+1: (vm, s1)
...
am*n: (vm, sn)
(vi, sj) 的实际值取决于 vmax 和 |smax| 的范围,不均匀分布。

每次开始训练或迭代 AWS DeepRacer 模型时,都必须先指定nm、vmax和/|smax| 或同意使用它们的默认值。根据您的选择,AWS DeepRacer 服务会生成您的代理可以在培训中选择的可用操作。生成的操作并非均匀分布在操作空间上。

一般情况下,操作数越多、操作范围越大就会向您的代理提供更多的空间或选项,从而根据赛道情况做出更为多变的选择,例如具有不规则转弯角度或方向的弯曲赛道。对代理可用的选项越多,就越能处理赛道情况变化。因此,您即使使用简单奖励函数,训练模型也可以有广泛的应用范围。

例如,您的代理可以使用粗粒度的操作空间,其中只有少量速度和转弯角度,快速学习如何处理直线赛道。在弯曲赛道上,此粗粒度的操作空间可能会导致代理转过头,在转弯时偏离赛道。这是因为没有足够的选项供其处理来调整速度或转弯。增加速度数量和/或转弯角度数量,代理应该具备更好的能力来处理转弯,保持在赛道上。同样,如果您的代理以之字形移动,您可以尝试增加转向范围的数量,从而减少在任意给定步骤中的突然转向。

当操作空间太大时,训练性能可能会受到负面影响,因为探索操作空间用时更长。请确保在模型的一般适用性与训练性能要求之间实现效益平衡。这种优化涉及系统性实验。


系统地调整超参数

提升模型性能的一种方法是制订更好或更高效的训练过程。例如,为获取稳健的模型,在代理的操作空间中,训练必须向代理提供或多或少的均匀分布采样。这需要充分权衡探索和开发。影响这些情况的变量包括所用的训练数据量(number of episodes between each training 和 batch size)、代理学习的速度 (learning rate) 以及探索部分 (entropy)。要使训练切实可行,您可能需要加快学习过程。影响这一情况的变量包括 learning rate、batch size、number of epochs 和 discount factor。

影响训练过程的变量称为超级参数。这些算法特性并非基础模型的属性。遗憾的是,超级参数本质上是经验性的。其最佳值对于所有实际用途未知,需要通过系统性实验来得出。

在讨论可以调整以调整 AWS DeepRacer 模型训练性能的超参数之前,让我们定义以下术语。

数据点
数据点也称为经验,它是 (s,a,r,s’) 的元组,其中 s 表示摄像头捕捉到的观察(或者状态),a 表示车辆采取的操作,r 表示所述操作带来的预期奖励,以及 s’ 表示在采取之后的新观察。

情节
情节是一段时间,在这段时间中,车辆从给定起点启动,然后到达终点完成赛道,或者跑出赛道。它是一系列经验的具体表达。不同的情节可以有不同的长度。

经验缓冲区
经验缓冲区包含多个已排序的数据点,在训练过程中,从不同长度的固定数量情节上收集这些数据点。对于 AWS DeepRacer,它对应于安装在您的 AWS DeepRacer 车辆上的摄像头捕获的图像以及车辆采取的操作,并且是从中提取输入以更新底层(策略和价值)神经网络的来源。

Batch
批次是排序的经验列表,表示一段时间中的一部分模拟,用于更新策略网络权重。它是经验缓冲区的子集。

训练数据
训练数据是从经验缓冲区中随机采样的批次组,用于训练策略网络权重。

算法超级参数及其效果
超参数描述
Gradient descent batch size (梯度下降批大小)从经验缓冲区中随机采样的最近车辆经验数,用于更新基础深度学习神经网络权重。随机采样有助于减少输入数据中内在的关联。使用较大的批大小可以推动对神经网络更稳定和更平滑的更新,但需要注意训练时间较长或者速度较慢的可能性。
必填 是
有效值 正整数 (32, 64, 128, 256, 512)
默认值 64
Number of epochs (纪元数)在梯度下降期间,遍历训练数据以更新神经网络权重的次数。训练数据对应于来自经验缓冲区的随机样本。使用较大的纪元数可以推动更稳定的更新,但预计训练速度较慢。当批大小较小时,您可以使用较少的纪元数
必填 否
有效值 介于 [3 - 10] 的正整数
默认值 3
Learning rate (学习速率)在每次更新期间,新权重的一部分可以来自梯度下降(或上升)的贡献,其余部分来自现有权重值。学习速率控制控制梯度下降(或上升)更新对网络权重的贡献度。使用较高的学习速率可以包括更多的梯度下降贡献,从而加快训练,但请注意,如果学习速率太高,预期奖励可能不会收敛。
必填 否
有效值 介于 0.00000001(或 10-8)和 0.001(或 10-3)之间的实数
默认值 0.0003
Entropy用于确定何时向策略分布添加随机性的不确定性程度。增加的不确定性有助于 AWS DeepRacer 飞行器更广泛地探索行动空间。较大的熵值会推动车辆更彻底地探索操作空间。
必填 否
有效值 介于 0 和 1 之间的实数。
默认值 0.01
Discount factor (折扣系数)系数指定了未来奖励对预期奖励的影响程度。折扣系数值越大,行驶过程中考虑贡献时需要考虑的距离就越远,训练就越慢。使用折扣系数 0.9,车辆根据行驶过程的接下来 10 个步骤提供奖励。使用折扣系数 0.9999,车辆根据行驶过程的接下来 10000 个步骤提供奖励。建议的折扣系数值是 0.99、0,999 和 0.9999。
必填 否
有效值 介于 0 和 1 之间的实数。
默认值 0.999
Loss type (损耗类型)用于更新网络权重的目标函数的类型。一个良好的训练算法应该对代理的策略进行渐进式改变,使它逐渐从采取随机行动转变为采取战略性行动以增加奖励。但是,如果算法进行了过大的更改,训练将变得不稳定,代理最终也不会学习。Huber loss (Huber 损耗) 和 Mean squared error loss (均方误差损耗) 类型针对小型更新的行为方式相似。但是,随着更新变得越来越大,Huber loss (Huber 损耗) 相比 Mean squared error loss (均方误差损耗) 占用的增量较小。当您遇到收敛问题时,请使用 Huber loss (Huber 损耗) 类型。当收敛正常并且您希望提高训练速度时,请使用 Mean squared error loss (均方误差损耗) 类型。
必填 否
有效值 (Huber loss (Huber 损耗)、Mean squared error loss (均方误差损耗))
默认值 Huber loss (Huber 损耗)
Number of experience episodes between each policy-updating iteration (每次策略更新迭代之间的经验情节数)从中提取训练数据的经验缓冲区的大小,这些数据用于学习策略网络权重。经验情节是一段时间,在这段时间中,代理从给定起点启动,然后到达终点完成赛道,或者跑出赛道。它由一系列经验组成。不同的情节可以有不同的长度。对于简单强化学习问题,较小的缓冲区可能已足够,学习速度较快。对于具有更多局部最大值的更复杂问题,需要更大的经验缓冲区来提供更多不相关的数据点。在这种情况下,训练更慢但更稳定。
建议的值为 10、20 和 40。
必填 否
有效值 介于 5 和 100 之间的整数。
默认值 20

检查 AWS DeepRacer 培训任务进度

启动训练作业之后,您可以检查各个情节的奖励和赛道完成情况等训练指标,以便确定模型在训练作业中的性能。在 AWS DeepRacer 控制台上,指标显示在奖励图表中,如下图所示。

best-model-bar-reward-graph2.png
您可以选择查看在各个情节中赢得的奖励、每次迭代的平均奖励、每个情节的进度、每次迭代的平均进度或这些指标的任意组合。为此,请切换奖励图表底部的奖励(剧集、平均值)或进度(剧集、平均值)开关。每个情节的奖励和进度以不同颜色的散点图显示。平均奖励和赛道完成情况以线形图显示,从第一次迭代之后开始。

奖励范围显示在图形的左侧,进度范围 (0-100) 显示在右侧。要读取某个训练指标的精确值,请将鼠标移动到图形上靠近数据点的位置。

当训练仍在进行时,图形每 10 秒自动更新一次。您可以选择刷新按钮以手动更新指标显示。

如果平均奖励和赛道完成情况表现出收敛的趋势,则训练任务良好。特别是,如果每个情节的进度持续达到 100%,并且奖励呈平稳状态,则表示模型可能已收敛。如果不是,请克隆模型并重新训练。


克隆经过训练的模型以开始新的训练通

如果您克隆之前的训练模型作为新一轮训练的起点,就可以提升训练效率。要执行此操作,请修改超级参数以利用已经学习的知识。

在本节中,您将学习如何使用 AWS DeepRacer 控制台克隆经过训练的模型。

使用 AWS DeepRacer 控制台迭代训练强化学习模型

  1. 如果您尚未登录 AWS DeepRacer Gateway 控制台,请登录
  2. 在模型页面上,选择经过训练的模型,然后从操作下拉菜单列表中选择克隆。
  3. 对于 Model details (模型详细信息),执行以下操作:

    • a. 如果您不想为克隆的模型生成名称,请键入RL_model_1模型名称。
    • b. (可选)在 to-be-cloned 模型描述 -可选中为模型提供描述。
  4. 对于环境模拟,请选择其他轨道选项。
  5. 对于 Reward function (奖励函数),请选择可用奖励函数示例之一。修改奖励函数。例如,请考虑转向。
  6. 展开 Algorithm settings (算法设置) 并尝试不同的选项。例如,将 Gradient descent batch
    size (梯度下降批大小) 值从 32 更改为 64,或者增加 Learning rate (学习速率) 以加快学习速度。
  7. 使用选择的不同 Stop conditions (停止条件) 进行实验。
  8. 选择 Start training (开始训练) 以开始新一轮的训练。

与平时训练稳健的机器学习模型一样,您务必进行系统的实验以找到最佳解决方案。


在模拟中评估 AWS DeepRacer 模型
评估模型是为了测试已训练模型的性能。在 AWS 中 DeepRacer,标准性能指标是连续完成三圈的平均时间。使用此指标,对于任何两个模型,如果一个模型可以使代理在同一轨道上更快地行驶,则该模型优于另一个模型。

一般而言,评估模型涉及以下任务:

  1. 配置并启动评估作业。
  2. 在任务运行时观察正在进行的评估。这可以在 AWS DeepRacer 模拟器中完成。
  3. 在评估任务完成后检查评估摘要。您可以随时终止正在进行的评估任务。
注意 评估时间取决于您选择的标准。如果您的模型不符合评估标准,则评估将持续运行,直到达到 20 分钟上限。
  1. (可选)将评估结果提交给符合条件的 AWS DeepRacer 排行榜。排行榜上的排名让您可以了解您的模型相对于其他参赛者的表现如何。

使用 AWS DeepRacer 车辆在物理赛道上行驶来测试 AWS DeepRacer 模型,请参阅操作您的 AWS DeepRacer 车辆 。


将 AWS DeepRacer 事件 CloudWatch 记录到日志

出于诊断目的,AWS DeepRacer 会在训练和评估期间向 CloudWatch Logs 报告某些运行时事件。

这些事件记录到特定于作业的任务流中。对于训练作业,日志流显示在 /aws/sagemaker/TrainingJobs 日志组下。对于模拟作业,日志流显示在 /aws/robomaker/SimulationJobs 日志组下。对于提交到 AWS Le DeepRacer ague 虚拟巡回赛排行榜的评估任务,日志流显示在/aws/deepracer/leaderboard/SimulationJobs日志组下方。对于奖励函数执行,日志流显示在 /aws/lambda/AWS-DeepRacer-Test-Reward-Function 日志组下。

除了以 SIM_TRACE_LOG 开头的日志条目之外,大部分日志条目是自说明的。此日志条目的示例如下所示:

SIM_TRACE_LOG:0,14,3.1729,0.6200,-0.2606,-0.26,0.50,2,0.5000,False,True,1.4878,1,17.67,1563406790.240018

事件项分别对应于以下数据值:

SIM_TRACE_LOG: episode, step, x-coordinate, y-coordinate, heading, steering_angle, speed, action_taken, reward, job_completed, all_wheels_on_track, progress,  closest_waypoint_index, track_length, time.time()

要访问 AWS DeepRacer 日志,您可以使用CloudWatch控制台、AWS CLI或 SAWS DK。

要使用 AWS DeepRacer 日志,请使用AWS CLI

  1. 打开终端窗口。
  2. 键入以下命令:

    aws logs get-log-events \

    --log-group-name a-deepracer-log-group-name \
    --log-stream-name a-deepracer-log-stream-name
    

该命令将返回与以下输出类似的结果:

{
    "events": [
        {
            "timestamp": 1563406819300,
            "message": "SIM_TRACE_LOG:2,155,7.3941,1.0048,0.0182,-0.52,1.00,1,0.0010,False,False,14.7310,16,1
7.67,1563406818.939216",
            "ingestionTime": 1563406819310
        },
        
        ...
        
        {
            "timestamp": 1563407217100,
            "message": "SIM_TRACE_LOG:39,218,5.6879,0.3078,-0.1135,0.52,1.00,9,0.0000,True,False,20.7185,9,17.67,1563407216.694622",
            "ingestionTime": 1563407217108
        },
        {
            "timestamp": 1563407218143,
            "message": "Training> Name=main_level/agent, Worker=0, Episode=40, Total reward=61.93, Steps=4315, Training iteration=0",
            "ingestionTime": 1563407218150
        }
    ],
    "nextForwardToken": "f/34865146013350625778794700014105997464971505654143647744",
    "nextBackwardToken": "b/34865137118854508561245373892407536877673471318173089813"
}

要在 DeepRacer 日志控制台中查看 AWS CloudWatch 日志,请执行以下操作:

  1. 登录到 CloudWatch 控制台。
  2. 从主导航窗格中选择 Logs (日志)。
  3. 选择合适的日志组。

    为了帮助快速查找 AWS DeepRacer 特定的事件日志,请在筛选框中键入上述日志组名称之一。

  4. 选择日志流以打开日志文件。

    要快速查找指定日志组中的最新日志流,请按照 Last Event Time (上次事件时间) 排序列表。


针对真实环境优化训练 AWS DeepRacer 模型

许多因素会影响训练模型的真实表现,包括操作空间的选择、奖励函数、训练中使用的超级参数以及车辆校准和真实赛道条件。此外,模拟仅仅是(通常很粗糙)真实世界的近似。这些情况使得将在模拟中训练的模型在应用到真实世界时,取得满意的成绩成为了一项挑战。

训练模型以提供稳定的真实性能通常需要在模拟环境中多次迭代对奖励函数、操作空间、超级参数和评估的探索,然后在真实环境中测试。最后一步涉及所谓的simulation-to-real 世界(sim2real)传输,可能会感觉不灵活。

为了帮助应对 sim2real 挑战,请注意以下几点:

  • 确保良好校准了您的车辆。

    这非常重要,因为模拟环境很可能是部分代表了真实环境。此外,代理在每一步中根据当前赛道情况采取操作,而赛道情况是摄像头捕获的图像。它看得不够远,无法快速规划路线。为了适应这种情况,模拟对速度和转向施加了限制。要确保训练模型在真实世界中正常工作,车辆必须经过正确的校准以匹配这些和其他模拟设置。有关校准车辆的更多信息,请参阅校准您的
    AWS DeepRacer 车辆。

  • 首先使用默认模型测试您的车辆。

    您的 AWS DeepRacer
    车辆在其推理引擎中加载了预训练的模型。在真实环境中测试自己的模型之前,请确保车辆在默认模型中可以良好地运行。如果不行,请检查物理赛道设置。在修建不正确的物理赛道中测试模型可能会导致性能欠佳。在这种情况下,请重新配置或修理您的赛道,然后再启动或恢复测试。

注意 在运行 AWS DeepRacer 车辆时,无需调用奖励函数,即可根据经过训练的策略网络推断操作。
  • 确保模型在模拟中正常工作。

如果您的模型不能正常工作,可能是整个模型或赛道有缺陷。要找出根本原因,您应首先在模拟中评估模型,检查模拟的代理是否可以至少完成一圈而不偏离赛道。您可以通过检查奖励的收敛并观察代理在模拟器中的轨迹,来查找原因。如果奖励在模拟的代理完成一圈达到最大值而没有衰退时,这可能是一个良好的模型。

  • 不要过度训练模型。

模型在模拟中稳定地完成赛道后继续训练会导致模型中的过度拟合。过度拟合的模型无法在真实环境中良好运行,因为它无法处理哪怕是模拟赛道与真实环境中很小的差别。

  • 使用来自不同迭代的多个模型。

典型的训练会话会生成一系列模型,这些模型介于拟合不足与过度拟合之间。因为没有先验标准来确定正好合适的模型,所以您应该从代理在模拟器中完成一圈开始,到其能稳定跑圈之间,选择几个模型候选。

  • 在测试中,从低速开始,逐步增加驾驶速度。

测试部署到车辆上的模型时,首先从较小的最高速度值开始。例如,您可以将测试速度限制设置为小于训练速度限制 10%。然后,逐渐增加测试速度限制,直到车辆开始正常行驶。您可以在校准车辆时使用设备控制台设置测试速度限制。如果车辆行驶得太快,例如,如果速度超过了在模拟器中训练期间看到的速度,则模型不太可能在真实赛道上表现良好。

  • 使用车辆在不同开始位置测试模型。

模型学习在模拟中采用了特定路线,可能会对其在赛道上的位置比较敏感。您应在赛道边界内的不同位置开始车辆测试(从左边到中间到右边),以查看模型是否在特定位置表现良好。大多数模型倾向于让车辆靠近白线的某一边。为了帮助分析车辆的路径,逐个步骤绘制模拟中车辆的位置 (x, y),确定您的车辆在真实环境中可能采取的路线。

  • 在直道上开始测试。

在直道上导航比在弯道上要容易得多。在直道上开始测试有助于快速排除欠佳的模型。如果车辆大部分时间无法按照直道行驶,模型在外道上的表现也不会好。

  • 注意车辆仅采取一种类型操作的行为。

当您的车辆只能采取一种动作时,例如,仅向左转向车辆,则该模型可能过度装配或不合适。对于给定模型参数,训练中过多迭代会导致模型过度拟合。迭代太少会导致拟合不足。

  • 注意车辆沿赛道边界纠正其路径的能力。

良好的模型在车辆靠近赛道边界时会纠正自身。大多数良好训练的模型具有此功能。如果车辆可以在赛道两端边界纠正自己,可以认为这是一个稳健的高质量模型。

  • 注意车辆表现出的不一致行为。

策略模型表示在给定状态下采取行动的概率分布。将训练模型加载到其推理引擎后,车辆可以根据模型的执行选择最可能的操作,一次一个步骤。如果操作概率均匀分步,则车辆采取概率相等或相近的任意一个操作。这将导致不稳定的驾驶行为。例如,当车辆有时沿着直线路行驶(例如,一半的时间),而在其他时间进行不必要的转弯,则模型要么不合适,要么过配。

  • 注意车辆只能转向一种类型(向左或向右)。

如果车辆左转非常好但在尝试右转时出现问题,或者,如果车辆只能很好地右转但左转则不行,您需要仔细校准或重新校准车辆的转向。或者,您可以尝试使用其训练设置接近实际测试环境设置的模型。

  • 当心车辆突然转弯并偏离轨道。

如果车辆大部分时间按照正确路线行驶,但突然偏离赛道,则可能是由于环境的干扰。大多数常见干扰包括意外或无意识的反光。在这种情况下,在赛道周围使用隔离或者其他方式来减少眩光。

了解赛车类型并启用 AWS 支持的传感器 DeepRacer

在 AWS Le DeepRacer ague 中,您可以参加以下类型的赛车赛事:

  • 计时赛:在畅通无阻的赛道上争分夺秒,争取尽可能快的单圈时间。
  • 避物:在有固定障碍物的赛道上争分夺秒,并以尽可能快的单圈时间为目标。
  • Head-to-bot 赛车:在同一赛道上与其他一辆或多辆车竞赛,目标是先于其他车辆越过终点线。

AWS DeepRacer 社区竞赛目前仅支持计时赛。

您应该在您的 AWS DeepRacer 车辆上尝试不同的传感器,使其具有足够的能力来观察给定比赛类型的周围环境。下一节介绍了 AWS DeepRacer 支持的传感器,这些传感器可以启用支持的自动赛车赛事类型。

主题

  • 为 AWS DeepRacer 赛车类型选择传感器
  • 配置用于训练 AWS DeepRacer 模型的代理
  • 为计时赛量身定制 AWS DeepRacer 培训
  • 为避物竞赛量身定制 AWS DeepRacer 训练
  • 为 head-to-bot 比赛量身定制 AWS DeepRacer 训练

为 AWS DeepRacer 赛车类型选择传感器

您的 AWS DeepRacer 车辆配有前置单目摄像头作为默认传感器。您可以添加另一个前置单目摄像头来制作前置立体摄像头,或者使用 LiDAR 单元补充单目摄像头或立体摄像头。

以下列表总结了 AWS DeepRacer 支持的传感器的功能以及简要 cost-and-benefit 分析:

前置摄像头
单镜头前置摄像头可以捕捉主车辆前方环境的图像,包括轨道边界和形状。它是最便宜的传感器,适用于处理更简单的自动驾驶任务,例如在标记明确的赛道上进行无障碍计时赛。通过适当的训练,它可以避开赛道上固定位置的固定障碍物。但是,障碍物位置信息已内置在经过训练的模型中,因此,该模型可能过度拟合,可能无法推广到其他障碍物放置位置。如果将静止物体放置在随机位置或轨道上的其他移动车辆,模型不太可能趋于一致。

在现实世界中,AWS DeepRacer 车辆带有单镜头前置摄像头作为默认传感器。相机配备 120 度广角镜头,可捕获 RGB 图像,然后以每秒 15 帧 (fps) 的速度转换为 160 x 120 像素的灰度图像。这些传感器属性保留在模拟器中,以最大限度地提高训练后的模型从仿真到现实世界的良好转化机会。

前置立体摄像头
立体相机有两个或多个镜头,可以捕获具有相同分辨率和频率的图像。来自两个镜头的图像用于确定观测物体的深度。来自立体摄像头的深度信息对于主机车辆非常有价值,可以避免撞上前方的障碍物或其他车辆,尤其是在更具动态性的环境下。但是,增加深度信息会使训练融合得更慢。

在 AWS DeepRacer 物理车辆上,双镜头立体摄像头是通过添加另一个单镜头摄像机并将每个摄像头安装在车辆的左侧和右侧来构建的。AWS DeepRacer 软件同步从两个摄像机捕获的图像。捕获的图像被转换为灰度,堆叠,然后输入到神经网络进行推理。在模拟器中复制了相同的机制,以便训练模型很好地推广到现实环境。

LiDAR 传感器
LiDAR 传感器使用旋转的激光器发出可见光谱之外的光脉冲,并确定每个脉冲返回需要多长时间。特定脉冲击中物体的方向和距离以LiDAR 单元为中心的大型 3D 地图中记录为一个点。

例如,LiDAR 可帮助检测主机车辆的盲点,以避免车辆变道时发生碰撞。通过将LiDAR 与mono 声道或立体摄像头相结合,可以使主机车辆捕获足够的信息以采取适当的行动。但是,与相机相比,LiDAR 传感器的成本更高。神经网络必须学习如何解释 LiDAR 数据。因此,培训需要更长的时间才能趋于一致。

在 AWS DeepRacer 物理车辆上,LiDAR 传感器安装在后部,向下倾斜 6 度。它以每秒 10 次旋转的角速度旋转,范围为 15 厘米到 2m。它可以检测主车辆后面和旁边的物体,以及不受前方车辆部件阻挡的高大物体。选择角度和范围是为了使LiDAR 单元不易受到环境噪声的影响。

您可以使用以下支持的传感器组合配置 AWS DeepRacer 车辆:

  • 仅限前置单镜头摄像头。

这种配置非常适合计时赛,也适合在固定位置使用物体避障。

  • 仅限前置立体摄像头。

这种配置非常适合在固定或随机位置使用物体避障。

  • 带LiDAR 的前置单镜头相机。

这种配置非常适合避障或 head-to-bot赛车。

  • 带LiDAR 的前置立体摄像头。

这种配置适合避障或 head-to-bot 赛车,但对于计时赛来说可能不是最经济的。

当您添加更多传感器使您的 AWS DeepRacer 车辆从计时赛到物体避开再到 head-to-bot 赛车时,车辆会收集更多有关环境的数据,以便在训练中输入到底层神经网络中。这使得训练更具挑战性,因为需要模型来处理日益增加的复杂性。最后,学习训练模型的任务变得更加艰巨。

要逐步学习,你应该先开始计时赛训练,然后才开始避开物体,然后再开始 head-to-bot 比赛。您将在下一节中找到更多详细建议。


配置用于训练 AWS DeepRacer 模型的代理

要训练强化学习模型,让 AWS DeepRacer 车辆参加避障或 head-to-bot 竞速比赛,您需要使用适当的传感器配置代理。对于简单的计时赛,您可以使用配置了单镜头摄像头的默认代理。在配置代理时,您可以自定义操作空间并选择神经网络拓扑,以便它们能够更好地与所选传感器配合使用,满足预期的行驶要求。此外,您还可以在训练期间更改代理的外观以在视觉上帮助识别。

配置后,代理配置将记录为模型元数据的一部分,用于训练和评估。为了进行评估,代理会自动检索记录的配置,以使用指定的传感器、操作空间和神经网络技术。

本节将指导您在 AWS Blc DeepRacer er。

在 AWS DeepRacer 控制台中配置 AWS DeepRacer 代理

  1. 登录 AW S DeepRacer 控制台。
  2. 在主导航窗格中选择 Garage (车库)。
  3. 首次使用 Garage (车库) 时,您会看到 WELCOME TO THE GARAGE (欢迎使用车库) 对话框。选择 > 或 <
    浏览 AWS DeepRacer 车辆支持的各种传感器的简介,或选择 X 关闭对话框。您可以在 Garage (车库)
    的帮助面板中找到此介绍性信息。
  4. 在 Garage (车库) 页面上,选择 Build new vehicle (构建新车辆)。
  5. 在 Mod your own vehicle (改装自己的车辆) 页面上,在 Mod specifications (改装规范)
    下,选择一个或多个传感器,尝试了解能够满足预期赛车类型的最佳组合。

    要为您的 AWS DeepRacer 车辆计时赛进行训练,请选择 C amera。为了避障或 head-to-bot
    赛车,你想使用其他类型的传感器。要选择立体摄像头,请确保您已购买了额外的单镜头相机。AWS 用两个单镜头摄像机 DeepRacer
    制造了立体摄像头。您可以在一辆车上使用单镜头摄像头或双镜头立体摄像头。无论哪种情况,如果您只想让经过训练的模型能够检测和避开避障碍物或
    head-to-bot 赛车中的盲点,则可以向代理添加LiDAR 传感器。

  6. 在 Garage (车库) 页面的 Neural network topologies (神经网络拓扑) 下,选择支持的网络拓扑。

    一般来说,更深的神经网络(层次较多)更适合在具有复杂曲线和急转弯的更复杂赛道上行驶、规避静止障碍物的比赛或与其他移动车辆的比赛。但是,更深的神经网络的训练成本更高,模型需要更长的时间才能融合。另一方面,更浅的网络(层次较少)成本更低,需要的训练时间更短。训练后的模型能够处理较简单的赛道条件或行驶要求,例如在没有竞争对手的无障碍赛道上进行的计时赛。

    具体而言,AWS DeepRacer 支持 3 层 CNN 或 5 层 CNN。

  7. 在 Garage (车库) 页面上,选择 Next (下一步) 以继续设置代理的操作空间。
  8. 在 Action space (操作空间)

    页面上,保留第一次训练的默认设置。对于后续训练,请尝试不同的转向角度、最高速度及其粒度设置。然后选择下一步。
    
  9. 在 “为车辆着色以在人群中脱颖而出” 页面上,在 “命名你的名字” 中输入一个名字,

    DeepRacer然后从车辆颜色列表中为特工选择一种颜色。然后,选择 Submit (提交)。
  10. 在 Garage (车库) 页面上,检查新代理的设置。要进行其他修改,请选择 Mod vehicle (改装车辆),然后从步骤 4
    开始重复上述步骤。

现在,您的代理已准备好进行训练了。


为计时赛量身定制 AWS DeepRacer 培训

如果这是您第一次使用 AWS DeepRacer,则应从简单的计时赛开始,熟悉如何训练 AWS DeepRacer 模型来驾驶您的车辆。这样,你就可以更温和地介绍奖励功能、代理、环境等基本概念。你的目标是训练一个模型,让车辆保持在赛道上,并尽可能快地完成一圈。然后,您可以将经过训练的模型部署到您的 AWS DeepRacer 车辆上,在物理赛道上测试驾驶,无需任何其他传感器。

要针对此场景训练模型,您可以从 AWS DeepRacer 控制台的 Garag e 中选择默认代理。默认代理已配置为单个前置摄像头、默认操作空间和默认神经网络拓扑。在转向更复杂的代理之前,开始使用默认代理训练 AWS DeepRacer 模型会很有帮助。

要使用默认代理训练模型,请遵循以下建议。

  1. 用一条形状更规则和不那么急转弯的简单轨迹开始训练模型。使用默认奖励功能。然后训练模型 30
    分钟。训练作业完成后,在同一条赛道上评估您的模型,以观察代理能否完成一圈。
  2. 阅读有关奖励函数参数的信息。通过不同的激励措施继续训练,以奖励代理人走得更快。将下一个模型的训练时间延长到 1-2
    小时。比较第一次训练和第二次训练之间的奖励图。继续试验,直到奖励图停止改善。
  3. 阅读有关行动空间的更多信息。通过提高最高速度(例如 1 m/s)对模型进行第三次训练。要修改操作空间,当你有机会进行修改时,你必须在
    Garage 中建造一个新的代理人。更新代理的最高速度时,请注意,最高速度越高,代理完成评估中赛道的速度就越快,您的 AWS
    DeepRacer
    车辆在物理赛道上完成一圈的速度也就越快。但是,更高的最高速度通常意味着训练聚合的时间更长,因为代理更有可能在弯道上超速,从而偏离正轨。你可能需要降低粒度,为特工提供更多空间来加速或减速,并通过其他方式进一步调整奖励功能,以帮助训练更快地融合。训练结束后,评估第三个模型,看看单圈时间是否有所改善。继续探索,直到没有更多改进。
  4. 选择更复杂的曲目,然后重复步骤 1 到步骤
    3。在与您过去训练的轨道不同的轨道上评估您的模型,以了解该模型如何推广到不同的虚拟轨道并推广到现实环境。
  5. (可选)使用不同的超参数值进行实验以改进训练过程,然后重复步骤 1 到步骤 3。
  6. (可选)检查和分析 AWS DeepRacer 日志。有关可用于分析日志的示例代码,请参阅
    https://github.com/aws-samples/aws-deepracer-workshops
    /tree/master/log- analysis。

为避物竞赛量身定制 AWS DeepRacer 训练
在你熟悉了计时赛并训练了几个融合模型之后,接下来是下一个要求更高的挑战——避障。在这里,你的目标是训练一个可以在不偏离轨道的情况下尽快完成一圈的模型,同时避免撞上放置在轨道上的物体。对于代理来说,这显然是一个更难学习的问题,而且训练需要更长的时间才能趋于一致。

AWS DeepRacer 控制台支持两种类型的避障训练:可以在赛道上的固定或随机位置放置障碍物。在固定位置下,在整个训练任务中,障碍物会保持固定在同一位置。使用随机位置,障碍物在不同剧集之间随机改变各自的位置。

由于系统的自由度较小,因此训练更容易汇聚在一起以避开固定位置的障碍物。但是,在训练的模型中内置位置信息时,模型可能会过度拟合。因此,模型可能过度拟合,可能无法很好地概括。对于随机定位的避障,训练更难融合,因为特工必须不断学习,以避免在以前从未见过的位置撞上障碍物。但是,使用此选项训练的模型往往可以更好地进行概括,并且可以很好地转移到现实世界中。首先,在固定位置放置障碍物,熟悉行为,然后应对随机地点。

在 AWS DeepRacer 模拟器中,障碍物是长方体盒子,其尺寸(9.5 英寸(长)x 15.25 英寸(宽)x 10/5 英寸(高))与 AWS DeepRacer 车辆的包装箱相同。如果您将包装盒作为障碍物放在物理轨道上,则可以更轻松地将经过训练的模型从模拟器转移到现实世界。

要尝试避障,请遵循以下步骤中概述的推荐做法:

  1. 使用默认代理或通过自定义现有代理或构建新代理来尝试新的传感器和操作空间。应将最高速度限制在 0.8 m/s 以下,将速度粒度限制为 1
    或 2 级。

    首先在固定位置放置 2 个物体,训练模型约 3 小时。使用示例奖励函数,在你将要参加比赛的赛道或与该赛道非常相似的赛道上训练模型。AWS
    S DeepRacer mile
    Speedway(中级)赛道是一条简单的赛道,因此是准备峰会比赛的好选择。使用相同数量的障碍物对同一轨道上的模型进行评估。观察预期的奖励融合数(如果有)。

  2. 阅读有关奖励函数参数的信息。尝试不同的奖励功能。将障碍物数增加到
    4。训练代理以查看训练是否在相同的训练时间内趋于一致。如果没有,请再次调整你的奖励功能,降低最高速度或减少障碍物数量,然后再次训练特工。重复试验,直到没有更明显的改善。
  3. 现在,继续训练,避开随机位置的障碍物。您需要为代理配置额外的传感器,这些传感器可从 AWS DeepRacer 控制台的 Garag e
    获得。你可以使用立体摄像头。或者,你可以将LiDAR
    单元与单镜头相机或立体相机组合使用,但预计训练时间会更长。将动作空间设置为相对较低的最高速度(例如 2
    m/s),以使训练更快地收敛。对于网络架构,使用浅层神经网络,已发现该网络足以避障。
  4. 在简单的轨道上随机放置 4 个物体,开始训练 4
    个小时的避障新代理人。然后在同一条赛道上评估你的模型,看看它能否在障碍物随机放置的情况下完成圈速。如果不是,你可能需要调整奖励功能,尝试不同的传感器并延长训练时间。另一个提示是,你可以尝试克隆现有模型以继续训练,以利用以前学到的经验。
  5. (可选)为动作空间选择更高的最高速度,或者在轨道上随机放置更多障碍物。尝试不同的传感器组合,调整奖励函数和超参数值。试验 5 层 CNN
    网络拓扑。然后,重新训练模型以确定它们如何影响训练的收敛。

为 head-to-bot 比赛量身定制 AWS DeepRacer 训练

完成避障训练后,你现在已经准备好迎接下一个级别的挑战: head-to-bot 比赛训练模型。与避障赛事不同, head-to-bot 赛车的环境充满活力,车辆在移动。您的目标是为您的 AWS DeepRacer 车辆训练模型,使其与其他移动车辆竞争,以便在不偏离轨道或撞上任何其他车辆的情况下先到达终点线。在 AWS DeepRacer 控制台中,您可以让代理与 1-4 辆机器人车辆竞争,从而训练 head-to-bot 赛车模型。一般来说,你应该在更长的赛道上设置更多的障碍物。

每辆机器人车辆都以恒定速度沿着预定义的路径行驶。你可以让它改变车道或留在起跑道上。与避障训练类似,你可以让机器人车辆在两条车道上均匀分布在赛道上。控制台限制你在赛道上最多有 4 辆机器人载具。在赛道上放置更多的竞争车辆可以让学习者有更多机会与其他车辆面对更多不同的情况。这样,它可以在一次训练工作中学到更多,并且代理可以更快地接受培训。但是,每次训练可能需要更长的时间才能趋于一致。

要使用机器人载具训练特工,你应该将代理行动空间的最高速度设置为高于机器人载具的(恒定)速度,这样特工在训练期间有更多的通过机会。作为一个很好的起点,你应该将代理的最高速度设置为 0.8 m/s,将机器人车辆的移动速度设置为 0.4 m/s。如果你让机器人改变车道,训练就会变得更具挑战性,因为特工不仅要学会如何避免在同一车道上撞上前方行驶中的车辆,还要学会如何避免在另一条车道上撞上前方的另一辆行驶中的车辆。你可以设置机器人以随机间隔改变车道。间隔的长度是在开始训练作业之前从您指定的时间范围(例如 1 秒到 5 秒)中随机选择的。这种变道行为更类似于现实世界中的 head-to-bot 赛车行为,训练有素的特工应该会产生更好的效果。但是,训练模型使其趋同需要更长的时间。

按照以下建议的步骤反复进行 head-to-bot 赛车训练:

  1. 在 AWS DeepRacer 控制台的 Garag e 中,构建一个配置有立体摄像头和 LiDAR
    单元的新训练代理。仅使用立体摄像头对抗机器人车辆就可以训练一个相对较好的模型。LiDAR
    有助于减少代理人变道时的盲点。不要将最高速度设置得太高。1 m/s 是一个好起点。
  2. 要为 head-to-bot 赛车训练,从两辆机器人车辆开始。将机器人的移动速度设置为低于代理的最高速度(例如,如果代理的最高速度为 1
    m/s,则为 0.5 m/s)。禁用换道选项,然后选择您刚创建的训练代理。使用其中一个奖励函数示例或进行最少的必要修改,然后训练 3
    小时。使用你将要参加比赛的赛道,或者与该赛道非常相似的赛道。AWS S DeepRacer mile
    Speedway(中级)赛道是一条简单的赛道,因此是准备峰会比赛的好选择。训练完成后,在同一赛道上评估训练后的模型。
  3. 对于更具挑战性的任务,可以克隆你的训练模型来制作第二个
    head-to-bot赛车模型。继续尝试使用更多机器人载具或启用换道选项。从慢速变道操作开始,随机间隔超过 2
    秒。你可能还想尝试自定义奖励功能。通常,如果你不考虑超越其他车辆和保持正轨之间的平衡,你的自定义奖励函数逻辑可能与避障函数逻辑类似。根据你之前的模型有多好,你可能需要再训练
    3 到 6 个小时。评估您的模型并查看模型的性能。