基于CARLA的离线强化学习实战：解决自动驾驶仿真训练效率问题

1次阅读

共计 2426 个字符，预计需要花费 7 分钟才能阅读完成。

自动驾驶仿真训练中，传统的在线强化学习（Online RL）需要智能体与环境实时交互来收集数据。这种方式存在几个明显问题：

高昂的计算成本：CARLA 仿真每帧渲染需要 GPU 支持，连续交互导致硬件负载极高
样本利用率低下：在线训练时，大多数样本仅使用一次就被丢弃，数据价值未被充分挖掘
训练不稳定：实时交互引入的环境随机性会影响策略收敛

我们做过实测：在 CARLA Town05 场景中，使用 PPO 算法训练一个基本的车道保持任务，需要超过 50 万帧样本才能达到 80% 的成功率，训练耗时约 38 小时（单个 RTX 3090）。

离线强化学习（Offline RL）通过预先收集的静态数据集进行训练，其优势在 CARLA 中尤为突出：

指标	在线 RL	离线 RL（CQL）
样本效率	1x	10-15x
训练稳定性	波动较大	平滑收敛
硬件占用	持续 100%	峰值 80%
收敛时间	38 小时	4.5 小时

关键差异在于：离线 RL 通过 经验回放缓冲区 重复利用高质量轨迹，而 CQL（Conservative Q-Learning）算法通过保守 Q 值估计避免了分布偏移问题。

# 创建 CARLA 客户端
import carla
client = carla.Client('localhost', 2000)
client.set_timeout(10.0)
world = client.load_world('Town05')

# 设置传感器
blueprint_lib = world.get_blueprint_library()
camera_bp = blueprint_lib.find('sensor.camera.rgb')
camera_bp.set_attribute('image_size_x', '800')
camera_bp.set_attribute('image_size_y', '600')

def collect_episode(agent, env, max_steps=1000):
    buffer = []
    obs = env.reset()
    for _ in range(max_steps):
        action = agent.predict(obs)
        next_obs, reward, done, info = env.step(action)
        buffer.append((obs, action, reward, next_obs, done))
        if done:
            break
    return buffer

import torch
import torch.optim as optim

class CQL(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.q_net = QNetwork(state_dim, action_dim)
        self.target_q_net = QNetwork(state_dim, action_dim)
        self.optimizer = optim.Adam(self.q_net.parameters(), lr=3e-4)

    def update(self, batch):
        # 保守 Q 学习核心逻辑
        current_q = self.q_net(batch.states).gather(1, batch.actions)
        with torch.no_grad():
            target_q = batch.rewards + 0.99 * self.target_q_net(batch.next_states).max(1)[0]

        # CQL 正则项
        q_logsumexp = torch.logsumexp(self.q_net(batch.states), dim=1).mean()
        cql_loss = q_logsumexp - current_q.mean()

        # 总损失 = Bellman 误差 + 0.5*CQL 正则
        loss = F.mse_loss(current_q, target_q) + 0.5 * cql_loss
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()