1. 从零开始:为什么选择Gazebo与TD3来教机器人“认路”?
大家好,我是老张,在机器人圈子里摸爬滚打了十来年,从最早的轮式小车到现在的复杂人形机器人,没少跟各种算法和仿真平台打交道。今天想跟大家聊聊一个特别有意思、也特别有挑战性的话题:怎么让机器人自己学会在复杂环境里导航。你可能会说,这不就是路径规划吗,用A*、DWA这些传统算法不就行了?没错,传统算法在已知地图、规则明确的环境里确实很稳。但现实世界是充满不确定性的——办公室的椅子可能被挪开,走廊可能临时放了障碍物,这些“意外”对传统算法来说是巨大的挑战。
这时候,强化学习就派上用场了。你可以把它想象成教一个小孩学走路:我们不给他写死每一步该怎么迈,而是设定规则(比如别摔倒、朝着目标走),让他自己通过大量尝试和犯错,最终学会一套在各种地形下都能走好的策略。而TD3算法,就是目前教机器人“走路”这个领域里,公认的“优等生”之一。它属于深度确定性策略梯度算法家族,最大的特点就是稳定和高效,能有效解决训练过程中常见的过度估计问题,让学习过程不那么容易“跑偏”。
那训练场选在哪呢?总不能在真实机器人上磕磕碰碰吧,成本太高,效率也低。这就是Gazebo仿真平台登场的时候了。它就像一个高保真的“机器人元宇宙”,能模拟出非常接近真实的物理环境(摩擦力、碰撞、传感器噪声等),让我们可以安全、快速、低成本地进行海量训练。我自己的经验是,在Gazebo里训练好的模型,迁移到真实机器人上,往往只需要做一些参数微调就能跑起来,省时省力。
所以,Gazebo + TD3这个组合,可以理解为:我们在一个高度逼真的虚拟世界(Gazebo)里,用一个高效且稳定的教学方法(TD3),让机器人通过反复试错,学会一套自主导航的“生存本能”。这篇文章,我就手把手带你走一遍这个完整的实践流程,从环境搭建、代码解读到调参技巧,把我踩过的坑和总结的经验都分享给你。即使你之前没怎么接触过强化学习或者ROS,跟着步骤来,也能让你的机器人在仿真里“跑”起来。
2. 搭建你的第一个训练场:Gazebo与ROS环境配置详解
工欲善其事,必先利其器。第一步就是把我们的训练场——Gazebo仿真环境给搭起来。这里会涉及到ROS(机器人操作系统),它是连接Gazebo和我们的强化学习算法的“桥梁”。别担心,我会把每一步都拆解清楚。
2.1 基础软件安装:ROS与Gazebo
首先,确保你有一个Ubuntu系统(推荐18.04或20.04,ROS的兼容性最好)。ROS的安装虽然步骤固定,但网络环境不好时容易出问题。我习惯用清华或中科大的源来加速。
# 设置软件源(以Ubuntu 20.04和ROS Noetic为例)
sudo sh -c 'echo "deb http://mirrors.tuna.tsinghua.edu.cn/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654
sudo apt update
# 安装ROS完整版,包含了Gazebo
sudo apt install ros-noetic-desktop-full
# 初始化rosdep,这一步经常因为网络问题卡住,多试几次或者用手机热点
sudo rosdep init
rosdep update
# 设置环境变量,让终端知道ROS命令在哪
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc
安装完成后,验证一下Gazebo是否能正常启动:
roscore &
gazebo
你应该能看到一个空的世界窗口弹出来。如果Gazebo启动后是黑屏或者模型加载不出来,大概率是模型库没下载完整。可以单独下载Gazebo模型:
# 创建一个目录存放模型
mkdir -p ~/.gazebo/models
# 使用wget下载官方模型库(这是一个比较全的集合)
cd ~/.gazebo/models
wget -q https://github.com/osrf/gazebo_models/archive/refs/heads/master.zip
unzip master.zip
mv gazebo_models-master/* .
rm -rf gazebo_models-master master.zip
2.2 创建你的机器人训练世界
空荡荡的世界可没法训练。我们需要一个有障碍物、有通道、类似真实场景的环境。Gazebo支持用SDF或World文件描述世界。这里我分享一个自己常用的简单办公室走廊环境,你可以把它保存为 corridor.world。
<?xml version="1.0"?>
<sdf version="1.6">
<world name="default">
<!-- 光照 -->
<include>
<uri>model://sun</uri>
</include>
<!-- 地面 -->
<include>
<uri>model://ground_plane</uri>
</include>
<!-- 墙壁和障碍物 -->
<model name="wall1">
<pose>4 0 0.5 0 0 0</pose>
<static>true</static>
<link name="link">
<collision name="collision">
<geometry>
<box>
<size>8 0.1 1</size>
</box>
</geometry>
</collision>
<visual name="visual">
<geometry>
<box>
<size>8 0.1 1</size>
</box>
</geometry>
<material>
<ambient>0.8 0.2 0.2 1</ambient>
</material>
</visual>
</link>
</model>
<!-- 更多障碍物定义... -->
<!-- 在这里放置你的机器人模型 -->
</world>
</sdf>
这个世界文件定义了一个长条形的墙壁。更复杂的迷宫或动态障碍物也可以通过类似方式添加。接下来,我们需要一个机器人模型。Gazebo社区有很多现成的,比如TurtleBot3,非常适合初学者。我们安装它:
sudo apt install ros-noetic-turtlebot3-simulations ros-noetic-turtlebot3-gazebo
然后,在启动仿真前,记得设置一下机器人型号:
echo "export TURTLEBOT3_MODEL=burger" >> ~/.bashrc
source ~/.bashrc
现在,我们可以用一个launch文件把世界和机器人一起启动。创建一个 train_world.launch 文件:
<launch>
<!-- 启动Gazebo世界 -->
<include file="$(find gazebo_ros)/launch/empty_world.launch">
<arg name="world_name" value="$(find your_package)/worlds/corridor.world"/>
<arg name="paused" value="false"/>
<arg name="use_sim_time" value="true"/>
<arg name="gui" value="true"/>
<arg name="headless" value="false"/>
<arg name="debug" value="false"/>
</include>
<!-- 生成TurtleBot3机器人 -->
<include file="$(find turtlebot3_gazebo)/launch/spawn_turtlebot3.launch">
<arg name="model" value="burger" />
<arg name="x_pos" value="0.0"/>
<arg name="y_pos" value="0.0"/>
<arg name="z_pos" value="0.0"/>
</include>
</launch>
这个launch文件做了两件事:1. 加载我们刚才创建的走廊世界;2. 在原点位置生成一个TurtleBot3 Burger机器人。现在,运行 roslaunch your_package train_world.launch,你应该能看到机器人生成在世界里了。环境搭建这一步就完成了,我们的虚拟训练场准备就绪。
3. 定义机器人的“感官”与“行为”:状态、动作与奖励设计
环境有了,接下来要定义我们的小机器人“学生”在这个世界里如何感知、如何行动,以及什么是“好”,什么是“坏”。这就是强化学习最核心的三个要素:状态空间、动作空间和奖励函数。设计得好不好,直接决定了机器人能不能学会,以及学得快不快。
3.1 状态空间:给机器人装上“眼睛”和“定位器”
状态是机器人对环境的观测。对于导航任务,我们需要告诉机器人两件事:我在哪?周围有什么?
- 自身状态(定位):通常来自里程计(Odometry)。它提供了机器人的位置(x, y)和朝向(theta)。在ROS中,我们订阅
/odom话题就能拿到这些信息。但要注意,里程计有累积误差,在长距离导航中会漂移,不过在仿真中我们暂时可以认为它是准确的。 - 环境感知(避障):最常用的是激光雷达(Lidar)数据。它返回机器人在不同角度上到最近障碍物的距离。原始数据维度很高(例如TurtleBot3的激光是360个点),直接扔给神经网络效率太低。一个经典的处理方法是扇形划分。比如,把机器人前方180度的视野等分成20个扇形区域,每个区域取最小的激光测距值作为代表。这样,我们就把高维数据压缩成了一个20维的向量,每个值代表那个方向上最近的障碍物距离。这个处理非常关键,既保留了避障所需的关键信息,又大大降低了学习难度。
- 目标信息:机器人要知道目标在哪。通常用目标点相对于机器人自身的极坐标来表示:
distance_to_goal(距离)和angle_to_goal(角度差)。这样,无论机器人在世界哪个角落,它都知道目标在它的哪个方向、有多远。
所以,最终的状态向量可能就是这24维:20维的激光数据 + 2维的目标信息(距离和角度差)+ 2维的自身速度信息(当前线速度和角速度)。速度信息有助于让策略学习到运动的惯性。代码上,状态获取的核心回调函数大概是这样的:
def get_state(self):
# 获取激光数据并处理成20维
laser_data = self.process_laser_scan(self.laser_ranges) # 假设返回20维数组
# 获取里程计和目标信息
distance_to_goal, angle_to_goal = self.calculate_goal_relative_pose()
# 获取当前速度(可以从cmd_vel或odom中计算)
current_linear_vel = self.current_vel.linear.x
current_angular_vel = self.current_vel.angular.z
# 拼接成最终状态向量
state = np.concatenate([
laser_data,
[distance_to_goal, angle_to_goal],
[current_linear_vel, current_angular_vel]
])
return state
3.2 动作空间:机器人能怎么“动”?
动作就是机器人可以执行的操作。对于差速驱动的机器人(像TurtleBot),动作空间通常很简单,就是两个连续值:线速度(v) 和 角速度(w)。我们需要为这两个值设定合理的范围,比如线速度在 [0, 0.5] 米/秒,角速度在 [-1, 1] 弧度/秒。神经网络输出的动作值通常在 [-1, 1] 之间,我们需要将其线性映射到实际的速度范围。
def scale_action(self, network_output):
# network_output 是一个包含两个值的数组,范围在 [-1, 1]
linear_range = [0.0, 0.5]
angular_range = [-1.0, 1.0]
scaled_linear = self._scale_value(network_output[0], -1, 1, linear_range[0], linear_range[1])
scaled_angular = self._scale_value(network_output[1], -1, 1, angular_range[0], angular_range[1])
return [scaled_linear, scaled_angular]
def _scale_value(self, value, in_min, in_max, out_min, out_max):
return (value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
3.3 奖励函数:告诉机器人什么是“好”的
奖励函数是强化学习的“指挥棒”,设计它是门艺术。我们的目标是让机器人高效、安全地到达目标。一个直观的奖励函数可以这样设计:
- 稀疏奖励:到达目标点,给一个很大的正奖励(比如+200);发生碰撞,给一个很大的负奖励(比如-100)。这种奖励清晰明确,但问题在于“稀疏”——在到达目标前,机器人可能很长时间都得不到任何反馈,导致学习非常慢,甚至学不会。
- 稠密奖励:为了加速学习,我们需要在每一步都给机器人一些“提示”。可以结合距离、速度和安全来设计:
- 距离奖励:每一步,根据机器人到目标距离的减少量给予奖励。离目标越近,奖励越高。这能引导机器人向目标移动。
- 速度奖励:给予一个与线速度正相关的奖励,鼓励机器人快速移动,但也要避免无脑冲撞。
- 安全惩罚:当激光雷达检测到很近的障碍物时,给予一个负奖励。这迫使机器人学会避障。
- 平稳性惩罚:对过大的角速度给予轻微惩罚,鼓励机器人走直线,减少原地打转。
一个结合了以上思想的奖励函数示例:
def calculate_reward(self, state, action, done, collision, min_laser_distance):
if done and self._is_goal_reached(state):
return 200.0 # 成功到达目标
if collision:
return -100.0 # 碰撞惩罚
# 稠密奖励部分
distance_reward = -0.1 * state[-4] # 状态中存储了到目标的距离,越小越好,所以加负号
speed_reward = 0.5 * action[0] # 鼓励一定的线速度
safety_penalty = 0.0
if min_laser_distance < 0.3: # 如果离障碍物太近
safety_penalty = -1.0 * (0.3 - min_laser_distance)
angular_penalty = -0.1 * abs(action[1]) # 轻微惩罚大角速度
total_reward = distance_reward + speed_reward + safety_penalty + angular_penalty
return total_reward
这个函数会在每一步都计算一个奖励值。通过调整这些奖励项的系数(比如0.1, 0.5, 1.0这些数字),你可以极大地影响机器人的学习行为。我刚开始调的时候,因为给速度奖励的权重太高,结果训练出来的机器人就是个“莽夫”,到处乱撞。后来把安全惩罚的权重调高,它才慢慢学会了“瞻前顾后”。
4. TD3算法核心:让机器人学会稳健决策的“大脑”
现在,环境、感官、行为准则都定义好了,就差一个“大脑”来学习决策了。这就是TD3算法。它属于Actor-Critic架构,你可以理解为有两个“部门”在协同工作:Actor(演员) 负责根据当前状态做出动作决策;Critic(评论家) 负责评价Actor做出的这个动作在当下状态有多好。TD3在它的前辈DDPG基础上做了几项关键改进,让训练更稳定。
4.1 网络结构:双Critic与延迟更新
TD3的核心思想是“保守”和“平滑”。它主要用了三招:
- 双Critic网络(Twin Critic):它维护两个独立的Critic网络(Q1和Q2)。在计算目标Q值时,取两个网络输出的最小值。这能有效防止Q值被高估,因为高估会导致策略利用这个虚高的值去选择一些实际并不好的动作。
- 目标策略平滑正则化(Target Policy Smoothing):在更新Critic时,会给目标Actor网络输出的动作添加一点随机噪声,然后裁剪到一个范围内。这相当于给目标动作“模糊”一下,让Critic学会对动作的小扰动不那么敏感,从而学出一个更平滑、更稳健的Q函数。
- 延迟策略更新(Delayed Policy Update):Actor网络(策略网络)更新的频率比Critic网络低。通常是Critic更新多次(比如2次),Actor才更新1次。这给了Critic网络更多的时间来收敛到一个相对准确的价值估计,再用这个更准确的估计去指导Actor更新,避免了策略在价值函数还不准的时候“瞎改”。
来看看代码里是怎么体现的。首先是Actor网络,它就是一个输入状态、输出动作的神经网络:
import torch.nn as nn
import torch.nn.functional as F
class Actor(nn.Module):
def __init__(self, state_dim, action_dim):
super(Actor, self).__init__()
# 三层全连接层
self.l1 = nn.Linear(state_dim, 256)
self.l2 = nn.Linear(256, 256)
self.l3 = nn.Linear(256, action_dim)
# 输出层用tanh激活,将动作约束在[-1, 1]范围
self.tanh = nn.Tanh()
def forward(self, state):
a = F.relu(self.l1(state))
a = F.relu(self.l2(a))
return self.tanh(self.l3(a))
Critic网络则复杂一些,因为它要同时接收状态和动作作为输入。TD3用了两个结构相同但参数独立的Critic网络:
class Critic(nn.Module):
def __init__(self, state_dim, action_dim):
super(Critic, self).__init__()
# Q1 网络
self.l1 = nn.Linear(state_dim + action_dim, 256)
self.l2 = nn.Linear(256, 256)
self.l3 = nn.Linear(256, 1)
# Q2 网络
self.l4 = nn.Linear(state_dim + action_dim, 256)
self.l5 = nn.Linear(256, 256)
self.l6 = nn.Linear(256, 1)
def forward(self, state, action):
sa = torch.cat([state, action], 1) # 拼接状态和动作
# 计算Q1值
q1 = F.relu(self.l1(sa))
q1 = F.relu(self.l2(q1))
q1 = self.l3(q1)
# 计算Q2值
q2 = F.relu(self.l4(sa))
q2 = F.relu(self.l5(q2))
q2 = self.l6(q2)
return q1, q2
4.2 训练循环:经验回放与软更新
训练过程就是不断重复“交互-存储-学习”的循环。这里有两个关键组件:
- 经验回放缓冲区(Replay Buffer):机器人每一步与环境交互得到的(状态,动作,奖励,下一个状态,是否结束)这个五元组,会被存储到一个大的缓冲区里。训练时,随机从里面采样一小批(batch)数据。这样做打破了数据之间的时间关联性,让训练更稳定,也提高了数据利用率。
- 软更新(Soft Update):TD3维护了两套Actor和Critic网络:一套是正在训练更新的“当前网络”,另一套是更新缓慢的“目标网络”。每次更新时,目标网络的参数不是直接被替换,而是按照一个很小的比例(比如 τ=0.005)向当前网络参数靠近:
θ_target = τ * θ_current + (1-τ) * θ_target。这种平滑的更新方式进一步稳定了训练。
训练一步的核心代码逻辑如下:
def train_one_step(self, replay_buffer, batch_size=100):
# 1. 从缓冲区采样一批经验
state, action, reward, next_state, done = replay_buffer.sample(batch_size)
# 2. 用目标Actor网络为下一个状态选择动作,并添加平滑噪声
with torch.no_grad():
noise = (torch.randn_like(action) * self.policy_noise).clamp(-self.noise_clip, self.noise_clip)
next_action = (self.actor_target(next_state) + noise).clamp(-self.max_action, self.max_action)
# 计算目标Q值(取两个目标Critic的最小值)
target_Q1, target_Q2 = self.critic_target(next_state, next_action)
target_Q = torch.min(target_Q1, target_Q2)
target_Q = reward + (1 - done) * self.discount * target_Q
# 3. 更新两个Critic网络
current_Q1, current_Q2 = self.critic(state, action)
critic_loss = F.mse_loss(current_Q1, target_Q) + F.mse_loss(current_Q2, target_Q)
self.critic_optimizer.zero_grad()
critic_loss.backward()
self.critic_optimizer.step()
# 4. 延迟更新:每隔policy_freq步,更新一次Actor网络
if self.total_it % self.policy_freq == 0:
actor_loss = -self.critic.Q1(state, self.actor(state)).mean() # 最大化Q值
self.actor_optimizer.zero_grad()
actor_loss.backward()
self.actor_optimizer.step()
# 软更新目标网络
soft_update(self.critic_target, self.critic, self.tau)
soft_update(self.actor_target, self.actor, self.tau)
理解了这个循环,你就掌握了TD3训练的核心。在实际操作中,你需要让机器人在Gazebo环境里跑几十万甚至几百万步,不断积累经验、更新网络参数,最终才能得到一个可靠的导航策略。
5. 实战演练:代码整合与训练调参全记录
理论说再多,不如动手跑一遍。这一部分,我们把前面所有的模块像拼乐高一样组合起来,形成一个完整的、可运行的训练流程。我会基于原始文章提供的代码骨架,填充更多细节和实操中会遇到的问题。
5.1 主训练循环搭建
首先,我们需要一个主文件来统筹一切。这个文件负责初始化环境、创建网络、管理训练循环和评估。下面是一个简化但完整的主循环框架:
import os
import time
import numpy as np
import torch
from torch.utils.tensorboard import SummaryWriter
from gazebo_env import GazeboEnv # 这是我们自己写的Gazebo环境接口
from td3 import TD3 # TD3算法实现类
from replay_buffer import ReplayBuffer
# 超参数设置(这里的水很深,调参主要就是调它们)
MAX_TIMESTEPS = 1e6 # 总训练步数,100万步起步
EVAL_FREQ = 5000 # 每5000步评估一次策略
BATCH_SIZE = 100 # 从经验池采样的大小
GAMMA = 0.99 # 折扣因子,未来奖励的重要性
TAU = 0.005 # 目标网络软更新系数
POLICY_NOISE = 0.2 # 添加到目标策略的噪声标准差
NOISE_CLIP = 0.5 # 噪声裁剪范围
POLICY_FREQ = 2 # 策略网络更新频率(Critic更新2次,Actor更新1次)
BUFFER_SIZE = int(1e6) # 经验回放池大小
EXPL_NOISE = 0.1 # 探索开始时添加到动作的噪声
SEED = 0 # 随机种子,保证可复现性
# 设置随机种子
torch.manual_seed(SEED)
np.random.seed(SEED)
# 初始化环境
env = GazeboEnv(launch_file='train_world.launch', state_dim=24)
time.sleep(5) # 等待Gazebo和ROS节点完全启动
# 获取状态和动作维度
state_dim = env.state_dim
action_dim = env.action_dim
max_action = float(env.action_high[0]) # 假设动作上限对称
# 创建TD3智能体
agent = TD3(state_dim, action_dim, max_action)
# 创建经验回放池
replay_buffer = ReplayBuffer(BUFFER_SIZE, SEED)
# 创建日志记录器(用于TensorBoard可视化)
writer = SummaryWriter(log_dir='./runs/exp1')
# 训练前评估一次初始随机策略
evaluation_rewards = []
state = env.reset()
total_timesteps = 0
episode_num = 0
episode_reward = 0
episode_timesteps = 0
print("============== 开始训练 ==============")
while total_timesteps < MAX_TIMESTEPS:
# 选择动作并加入探索噪声
if total_timesteps < 10000: # 最初1万步完全随机探索,快速填充经验池
action = env.action_space.sample()
else:
action = agent.select_action(np.array(state))
# 添加随时间衰减的探索噪声
noise = np.random.normal(0, EXPL_NOISE, size=action_dim)
action = (action + noise).clip(-max_action, max_action)
# 在环境中执行动作
next_state, reward, done, info = env.step(action)
episode_reward += reward
episode_timesteps += 1
total_timesteps += 1
# 将经验存入回放池(注意:done需要处理成0/1标志)
done_bool = float(done) if episode_timesteps < env._max_episode_steps else 0
replay_buffer.add(state, action, next_state, reward, done_bool)
# 状态转移
state = next_state
# 如果回合结束,重置环境
if done or episode_timesteps >= env._max_episode_steps:
print(f"回合 {episode_num+1} 结束,步数:{episode_timesteps}, 累计奖励:{episode_reward:.2f}")
writer.add_scalar('train/episode_reward', episode_reward, total_timesteps)
writer.add_scalar('train/episode_length', episode_timesteps, total_timesteps)
state = env.reset()
episode_reward = 0
episode_timesteps = 0
episode_num += 1
# 当经验池有足够数据后,开始训练
if total_timesteps > 1000: # 至少积累1000条经验
agent.train(replay_buffer, BATCH_SIZE, GAMMA, TAU, POLICY_NOISE, NOISE_CLIP, POLICY_FREQ)
# 定期评估策略
if total_timesteps % EVAL_FREQ == 0:
avg_reward = evaluate_policy(agent, env, eval_episodes=5)
evaluation_rewards.append(avg_reward)
writer.add_scalar('eval/avg_reward', avg_reward, total_timesteps)
print(f"评估步数 {total_timesteps}: 平均奖励 = {avg_reward:.2f}")
# 保存模型
agent.save(f"td3_model_step_{total_timesteps}", './models')
print("============== 训练完成 ==============")
writer.close()
env.close()
5.2 关键调参经验与“避坑”指南
代码跑起来只是第一步,要让机器人真正学会,调参是关键。下面这个表格是我在多个项目中总结的一些核心参数的影响和调参建议:
| 参数 | 典型值范围 | 作用与影响 | 调参建议与“坑” |
|---|---|---|---|
| 学习率 (LR) | Actor: 3e-4, Critic: 3e-4 | 控制网络参数更新的步长。太大容易震荡不收敛,太小学习太慢。 | Critic的学习率通常等于或略小于Actor。如果训练曲线剧烈抖动,尝试调小学习率。我一般从3e-4开始。 |
| 折扣因子 (GAMMA) | 0.99 | 衡量未来奖励的重要性。越接近1,智能体越“有远见”。 | 导航任务中,未来几步的奖励很重要,建议设置在0.99-0.999。设太低(如0.9)会导致机器人非常“短视”。 |
| 回放缓冲区大小 (BUFFER_SIZE) | 1e5 - 1e6 | 存储经验的数量。太小会导致过拟合旧经验,太大会占用大量内存且学习初期效率低。 | 对于中等复杂任务,1e6是个安全的起点。如果发现学习停滞,可以尝试清空或部分替换缓冲区。 |
| 批次大小 (BATCH_SIZE) | 64 - 256 | 每次从缓冲区采样用于训练的数据量。 | 通常设为64或128。GPU内存充足可以尝试256。太小噪声大,太大计算慢且容易陷入局部最优。 |
| 目标网络更新率 (TAU) | 0.001 - 0.01 | 控制目标网络参数向当前网络参数靠近的速度。 | TD3论文推荐0.005。这是一个非常敏感的参数,调大(如0.01)可能不稳定,调小(如0.001)学习会变慢。 |
| 探索噪声 (EXPL_NOISE) | 0.1 | 训练时添加到动作上的随机噪声,用于探索。 | 初期可以设大一点(如0.2),随着训练进行可以线性衰减到0.05。完全不加噪声会导致探索不足。 |
| 策略噪声 (POLICY_NOISE) | 0.2 | TD3特有的,用于平滑目标动作的噪声。 | 按论文用0.2即可,配合NOISE_CLIP=0.5。这是TD3稳定性的关键之一,不要随意改动。 |
除了调参,还有几个常见的“坑”:
- 奖励不收敛:最常见的原因是奖励函数设计不合理。检查你的稠密奖励是否相互冲突(比如速度奖励和安全惩罚)。多用TensorBoard可视化奖励曲线,看看是哪个环节出了问题。
- 训练初期崩溃:机器人一开始就疯狂碰撞,导致经验池里全是负奖励。可以在训练初期增加一个“安全启动”阶段,比如前N步让人工规则控制(如沿着墙走),或者大幅提高碰撞惩罚的权重。
- Gazebo仿真不同步:ROS和Gazebo通信有时会出现延迟或消息丢失,导致状态获取不准。一定要在环境类里加入健壮的异常处理和等待机制,比如用
rospy.wait_for_service确保服务可用,用消息时间戳检查数据是否过期。 - 过拟合仿真环境:在某个特定仿真环境里学得很好,换一个稍微不同的环境就失效了。解决办法是在训练时引入环境随机化,比如改变障碍物位置、目标点位置、机器人初始位姿,甚至改变激光雷达的噪声模型,让策略学会泛化。
训练过程通常很漫长,在CPU上可能需要数天。一定要有耐心,并善用可视化工具(如TensorBoard)来监控训练进度。当你看到评估奖励曲线稳步上升,最终稳定在一个较高水平时,那种成就感是无与伦比的。
326



被折叠的 条评论
为什么被折叠?



