从零构建基于强化学习的赛车游戏AI：Car Racing强化学习入门指南

1次阅读

没有评论

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

在赛车游戏中，传统的规则式 AI 通常依赖于预先编写的固定逻辑，比如沿着赛道中心线行驶、在弯道减速等。这种方法虽然简单直接，但存在几个明显的缺点：

缺乏适应性：无法应对突发情况，比如其他车辆的突然变道
难以调优：需要手动调整大量参数来获得良好表现
上限较低：很难达到或超越高水平人类玩家的表现

相比之下，强化学习 (RL) 通过让 AI 在环境中不断试错、自主学习最优策略，能够更好地处理复杂多变的赛车场景。RL 算法可以自动发现人类可能想不到的高级驾驶技巧，最终实现超越人类的性能。

赛车游戏属于连续控制任务（方向盘、油门、刹车都是连续值），我们需要考虑算法的以下几个特性：

处理连续动作空间的能力
DQN 系列算法只能处理离散动作，不太适合
PPO、A2C 等策略梯度方法天然支持连续动作
样本效率
赛车游戏每局耗时较长，样本收集成本高
PPO 相比 A2C 有更好的样本效率
训练稳定性
赛车任务奖励稀疏（长时间无显著变化）
PPO 的 clip 机制能有效稳定训练

综合来看，PPO 算法 是最佳选择。它不仅支持连续控制，而且在样本效率和训练稳定性上都有出色表现。

我们使用 OpenAI Gym 的 CarRacing-v2 环境，安装非常简单：

import gym
env = gym.make("CarRacing-v2")

原始环境直接返回 RGB 图像(96x96x3)，我们需要进行预处理：

转换为灰度图减少计算量
下采样到 84×84 尺寸
使用帧堆叠技术（通常 4 帧）以获取速度信息

def preprocess_observation(obs):
    gray = np.dot(obs[...,:3], [0.299, 0.587, 0.114])
    resized = cv2.resize(gray, (84, 84))
    return resized

好的奖励函数是成功的关键。基础奖励包括：

速度奖励：与车辆前进速度成正比
赛道偏离惩罚：当车辆离开赛道时给予负奖励
控制惩罚：对频繁的剧烈操作给予小幅惩罚

def custom_reward(state, action):
    speed_reward = state["speed"] * 0.1
    off_track_penalty = -1 if state["off_track"] else 0
    action_penalty = -0.01 * np.sum(np.square(action))
    return speed_reward + off_track_penalty + action_penalty

以下是使用 PyTorch 实现 PPO 的关键代码：

import torch
import torch.nn as nn
import torch.optim as optim

class ActorCritic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        # 共享的特征提取网络
        self.feature = nn.Sequential(nn.Conv2d(4, 32, 8, stride=4),
            nn.ReLU(),
            nn.Conv2d(32, 64, 4, stride=2),
            nn.ReLU(),
            nn.Flatten())

        # 策略网络
        self.actor = nn.Sequential(nn.Linear(64*7*7, 256),
            nn.ReLU(),
            nn.Linear(256, action_dim)
        )

        # 价值网络
        self.critic = nn.Sequential(nn.Linear(64*7*7, 256),
            nn.ReLU(),
            nn.Linear(256, 1)
        )

    def forward(self, x):
        features = self.feature(x)
        return self.actor(features), self.critic(features)

# PPO 训练主循环
def train_ppo():
    model = ActorCritic(state_dim, action_dim)
    optimizer = optim.Adam(model.parameters(), lr=3e-4)

    for episode in range(1000):
        states, actions, rewards = [], [], []
        state = env.reset()

        # 收集经验
        for _ in range(2048):  # PPO 通常使用较大 batch
            action, log_prob = model.sample_action(state)
            next_state, reward, done, _ = env.step(action)

            states.append(state)
            actions.append(action)
            rewards.append(reward)

            state = next_state
            if done:
                break

        # 计算优势函数
        returns = compute_returns(rewards, gamma=0.99)
        values = model.critic(states)
        advantages = returns - values

        # PPO 关键更新步骤
        for _ in range(10):  # 通常执行多个 epoch
            new_log_probs = model.evaluate_actions(states, actions)
            ratio = (new_log_probs - log_probs).exp()

            # PPO clip 目标
            surr1 = ratio * advantages
            surr2 = torch.clamp(ratio, 1-0.2, 1+0.2) * advantages
            actor_loss = -torch.min(surr1, surr2).mean()

            # Critic 损失
            critic_loss = nn.MSELoss()(values, returns)

            # 总损失
            loss = actor_loss + 0.5 * critic_loss

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()