基于强化学习A2C快速路车辆决策控制

基于强化学习A2C快速路车辆决策控制

在上一篇基于DQN强化学习的高速路决策控制中采用DQN算法进行车辆决策控制,最终并未获得奖励较高的模型,今采用A2C算法进行测试。

依赖包版本

gym == 0.21.0
stable-baselines3 == 1.6.2
highway-env == 1.5

环境配置

查看环境配置:

import gym
import highway_env
from stable_baselines3 import A2C


# Create environment
env = gym.make("highway-fast-v0")

print(env.config)

输出如下:

{
	'observation': {'type': 'Kinematics'}, 
	'action': {'type': 'DiscreteMetaAction'}, 
	'simulation_frequency': 5, 
	'policy_frequency': 1, 
	'other_vehicles_type':'highway_env.vehicle.behavior.IDMVehicle',
	'screen_width': 600, 
	'screen_height': 150, 
	'centering_position': [0.3, 0.5], 
	'scaling': 5.5, 
	'show_trajectories': False, 
	'render_agent': True, 
	'offscreen_rendering': False, 
	'manual_control': False, 
	'real_time_rendering': False, 
	'lanes_count': 3, 
	'vehicles_count': 20, 
	'controlled_vehicles': 1, 
	'initial_lane_id': None, 
	'duration': 30, 
	'ego_spacing': 1.5, 
	'vehicles_density': 1, 
	'collision_reward': -1, 
	'right_lane_reward': 0.1, 
	'high_speed_reward': 0.4, 
	'lane_change_reward': 0, 
	'reward_speed_range': [20, 30], 
	'offroad_terminal': False
}

环境动作空间为:

ACTIONS_ALL = {
        0: 'LANE_LEFT',  # 左转
        1: 'IDLE',       # 宕机(无动作)
        2: 'LANE_RIGHT', # 右转
        3: 'FASTER',     # 加速
        4: 'SLOWER'      # 减速
    }

模型训练

import gym
import highway_env
from stable_baselines3 import A2C


# Create environment
env = gym.make("highway-fast-v0")

model = A2C("MlpPolicy",
            env,
            tensorboard_log="./logs",
            verbose=1)

model.learn(total_timesteps=25000)
model.save("a2c_highway")

训练过程图为:

平均运行长度图平均奖励图由图可知,在训练至10K步左右,模型奖励值逐渐稳定。

模型测试

import gym
import highway_env
from stable_baselines3 import A2C


# Create environment
env = gym.make("highway-fast-v0")

# load model
model = A2C.load("a2c_highway", env=env)

eposides = 10
for eq in range(eposides):
    obs = env.reset()
    done = False
    rewards = 0
    actions = []
    while not done:
        action, _state = model.predict(obs, deterministic=True)
        action = action.item()
        actions.append(action)
        obs, reward, done, info = env.step(action)
        env.render()
        rewards += reward
    print('actions: {}'.format(actions))
    print('rewards: {}'.format(rewards))

模型输出:

actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 22.020221169036347
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 21.020221169036326
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 20.02022116903634
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 21.020221169036326
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 22.020221169036347
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 21.020221169036326
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 22.020221169036347
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 22.020221169036347
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 21.020221169036326
actions: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
rewards: 20.02022116903634

由输出可知,在环境默认的奖励函数条件下,获取最高的奖励动作为一直执行动作4,根据上述动作空间可知,自车一直执行“减速”动作。对应测试视频如下:highway_fast_a2c.

后记

stable-baseline3: 手册
gym: 手册
highway-env: 手册

  • 0
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
### 回答1: A2C(Advantage Actor-Critic)是一种深度强化学习算法,它结合了Actor-Critic和Advantage学习的优点,可以用于解决连续动作空间的问题。以下是一个使用Python实现A2C算法的简单示例: ```python import gym import torch import torch.nn as nn import torch.optim as optim # 定义Actor-Critic网络 class ActorCritic(nn.Module): def __init__(self, input_size, output_size): super(ActorCritic, self).__init__() self.common = nn.Sequential( nn.Linear(input_size, 128), nn.ReLU() ) self.actor = nn.Linear(128, output_size) self.critic = nn.Linear(128, 1) def forward(self, x): x = self.common(x) policy = nn.functional.softmax(self.actor(x), dim=-1) value = self.critic(x) return policy, value # 定义A2C算法 def a2c(env, model, optimizer, gamma=0.99, num_steps=5): rewards = [] values = [] log_probs = [] entropys = [] obs = env.reset() done = False while not done: for _ in range(num_steps): obs = torch.FloatTensor(obs) policy, value = model(obs) action = torch.multinomial(policy, 1).item() log_prob = torch.log(policy[action]) entropy = -torch.sum(policy * torch.log(policy)) obs, reward, done, _ = env.step(action) rewards.append(reward) values.append(value) log_probs.append(log_prob) entropys.append(entropy) if done: break _, next_value = model(torch.FloatTensor(obs)) returns = [] advantages = [] R = next_value for r in reversed(rewards): returns.insert(0, R) R = r + gamma * R for v, R in zip(values, returns): advantages.append(R - v) policy_loss = 0 value_loss = 0 entropy_loss = 0 for log_prob, advantage, value, entropy in zip(log_probs, advantages, values, entropys): policy_loss -= log_prob * advantage value_loss += nn.functional.mse_loss(value, torch.FloatTensor([R])) entropy_loss -= entropy loss = policy_loss + 0.5 * value_loss + 0.01 * entropy_loss optimizer.zero_grad() loss.backward() optimizer.step() return sum(rewards) # 使用A2C算法训练CartPole-v1游戏 env = gym.make('CartPole-v1') model = ActorCritic(env.observation_space.shape[0], env.action_space.n) optimizer = optim.Adam(model.parameters(), lr=0.001) for i in range(1000): reward = a2c(env, model, optimizer) print(f"Episode {i}: reward {reward}") ``` 这是一个简单的A2C实现,其中Actor-Critic网络使用了一个共享的中间层,输入是状态,输出是动作策略和状态值。在训练过程中,先通过Actor-Critic网络选择动作和计算状态值,然后使用这些信息计算Advantage和Policy梯度,最后通过Adam优化器更新网络参数。在训练过程中,每个episode的奖励都会被记录下来,可以用来评估算法的性能。 ### 回答2: 深度强化学习(Deep Reinforcement Learning)是一种机器学习的方法,结合了深度学习强化学习的技术。A2C(Advantage Actor-Critic)是深度强化学习中的一种算法模型,它可以用Python语言进行实现。 A2C是一种基于策略梯度的强化学习算法,其核心思想是通过增强代理(Agent)的策略,来最大化其在环境中获得的累积奖励。A2C的优势在于其可以充分利用计算资源,实现多个代理的并行运行,加快训练速度。 在Python中实现A2C,我们首先需要定义神经网络模型,用于估计代理的动作策略。这个模型可以是一个深度神经网络,接收环境状态作为输入,输出各个动作的概率分布。然后,我们可以使用强化学习的基本原理,在代理与环境之间进行交互,采样得到经验轨迹(experience trajectory)。接着,利用这些经验轨迹,我们可以计算代理执行动作的预期回报,并使用策略梯度方法来更新神经网络模型的参数,提高代理的策略。A2C算法使用Actor-Critic结构,其中Actor用于执行动作,Critic用于估计预期回报并提供策略改进的信号。 实际编程中,可以使用Python中的强化学习框架,如TensorFlow、PyTorch等,来实现A2C算法。例如,可以定义一个神经网络模型的类,利用框架的API构建网络结构,然后编写A2C算法的训练循环,在每个时间步更新网络参数,并与环境进行交互。 总而言之,深度强化学习A2C算法的实现需要定义神经网络模型、构建训练循环、利用策略梯度方法更新网络参数,并结合强化学习的基本原理进行代理与环境的交互。Python语言为如此复杂的任务提供了灵活和高效的开发环境和工具。 ### 回答3: 深度强化学习中的A2C指的是Advantage Actor-Critic的缩写,它是一种使用深度神经网络进行策略优化的算法。这种算法结合了Actor-Critic方法和优势函数(Advantage)的概念,旨在通过优势函数的估计来引导智能体的学习过程。 在A2C中,智能体被建模为一个 Actor(策略网络)和 Critic(值函数网络) 的组合。Actor负责产生动作的策略,而Critic则通过估计状态-动作值函数(或者优势函数)来评估当前策略的优劣。这两个网络共同协作,不断通过与环境进行交互来更新参数,使得策略不断得到优化。 具体来说,A2C使用了基于梯度的优化方法,通过最大化 Critic 网络预测的累积回报来更新 Actor 网络的参数。同时,Actor网络还会通过 Policy Gradient算法来进行更新,使得策略能够更好地适应环境的变化。此外,A2C还使用了经验回放机制,即将智能体的经历存储在一个回放缓冲区中,用于提高采样数据的效率。 在Python中实现A2C算法时,可以使用深度学习框架如PyTorch或TensorFlow来构建Actor和Critic网络,以及定义损失函数和优化器。此外,还需要设计一个与环境进行交互的循环,不断地采样、更新网络参数,并进行策略评估和改进。 总的来说,A2C 是一种深度强化学习算法,通过 Actor-Critic 结构和优势函数的引导,能够在与环境交互的过程中不断优化智能体的策略。在Python中实现A2C算法时,需要使用深度学习框架,定义网络架构、损失函数和优化器,并设计交互循环来进行参数更新和策略改进。
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值