自动驾驶的驾驶员模型,自动驾驶建模

　　本文主要为大家介绍Python的自动驾驶训练模型。有需要的朋友可以借鉴一下，希望能有所帮助。祝大家进步很大，早日升职加薪。

　　00-1010一、安装环境二。配置环境三。训练模式I。数据处理II。建筑模型三。运行结果四。总结。

目录

　　Gym是一个开发和比较强化学习算法的工具包。在python中很容易安装健身房库及其子场景。

　　健身房设施：

　　pip安装健身房

　　使用Edouard Leurent在github上发布的highway-env包安装自动驾驶模块，此处为：

　　pip安装-用户git https://github.com/eleurent/highway-env

　　它包含六个场景：

　　高速公路——“高速公路-v0”连接——“合并-v0”环形交叉路口3354“绕行-v0”停车3354“停车-v0”交叉路口3354“交叉路口-v0”赛马场-v0”

一、安装环境

　　安装后可以在代码中实验(以高速公路场景为例):

　　进口健身房

　　导入公路_环境

　　%matplotlib内联

　　env=gym.make(highway-v0 )

　　env.reset()

　　for _ in范围(3):

　　action=env . action _ type . actions _ indexes[ IDLE ]

　　obs，reward，done，info=env.step(action)

　　env.render()

　　运行后，模拟器中将生成以下场景：

　　有许多参数可以为绿色ego vehicle env类配置。详情请参考原始文档。

二、配置环境

三、训练模型

　　(1)状态

　　highway-env包中没有定义传感器，车辆的所有状态(观测值)都是从底层代码中读取的，省去了大量的前期工作。根据文件介绍，state (ovservations)有三种输出模式：运动学、灰度图像和占位网格。

　　运动学

　　输出V*F的矩阵，V代表待观察车辆的数量(包括ego车辆本身)，F代表待统计特征的数量。示例：

　　数据生成后，默认情况下会归一化，取值范围为[100，100，20，20]。还可以设置除ego vehicle之外的车辆属性是地图的绝对坐标还是ego vehicle的相对坐标。

　　当定义环境时，您需要设置特性的参数：

　　配置=\

　　{

　　观察 :

　　{

　　类型 : 运动学，

　　#选择5辆车进行观察(包括ego车辆)

　　车辆_计数 : 5，

　　总共7项功能

　　特征 : [存在， x ， y ， vx ， vy ， cos_h ， sin_h]，

　　功能_范围 :

　　 {

　　 "x": [-100, 100],

　　 "y": [-100, 100],

　　 "vx": [-20, 20],

　　 "vy": [-20, 20]

　　 },

　　 "absolute": False,

　　 "order": "sorted"

　　 },

　　 "simulation_frequency": 8, # [Hz]

　　 "policy_frequency": 2, # [Hz]

　　 }

　　Grayscale Image

　　生成一张W*H的灰度图像，W代表图像宽度，H代表图像高度

　　Occupancy grid

　　生成一个WHF的三维矩阵，用W*H的表格表示ego vehicle周围的车辆情况，每个格子包含F个特征。

　　(2) action

　　highway-env包中的action分为连续和离散两种。连续型action可以直接定义throttle和steering angle的值，离散型包含5个meta actions：

ACTIONS_ALL = {
　　 0: LANE_LEFT,
　　 1: IDLE,
　　 2: LANE_RIGHT,
　　 3: FASTER,
　　 4: SLOWER
　　 }
　　

　　(3) reward

　　highway-env包中除了泊车场景外都采用同一个reward function：

　　这个function只能在其源码中更改，在外层只能调整权重。（泊车场景的reward function原文档里有，懒得打公式了……）

2、搭建模型

　　DQN网络的结构和搭建过程已经在我另一篇文章中讨论过，所以这里不再详细解释。我采用第一种state表示方式——Kinematics进行示范。

　　由于state数据量较小（5辆车*7个特征），可以不考虑使用CNN，直接把二维数据的size[5,7]转成[1,35]即可，模型的输入就是35，输出是离散action数量，共5个。

import torch
　　import torch.nn as nn
　　from torch.autograd import Variable
　　import torch.nn.functional as F
　　import torch.optim as optim
　　import torchvision.transforms as T
　　from torch import FloatTensor, LongTensor, ByteTensor
　　from collections import namedtuple
　　import random 
　　Tensor = FloatTensor
　　EPSILON = 0 # epsilon used for epsilon greedy approach
　　GAMMA = 0.9
　　TARGET_NETWORK_REPLACE_FREQ = 40 # How frequently target netowrk updates
　　MEMORY_CAPACITY = 100
　　BATCH_SIZE = 80
　　LR = 0.01 # learning rate
　　class DQNNet(nn.Module):
　　 def __init__(self):
　　 super(DQNNet,self).__init__() 
　　 self.linear1 = nn.Linear(35,35)
　　 self.linear2 = nn.Linear(35,5) 
　　 def forward(self,s):
　　 s=torch.FloatTensor(s) 
　　 s = s.view(s.size(0),1,35) 
　　 s = self.linear1(s)
　　 s = self.linear2(s)
　　 return s 
　　class DQN(object):
　　 def __init__(self):
　　 self.net,self.target_net = DQNNet(),DQNNet() 
　　 self.learn_step_counter = 0 
　　 self.memory = []
　　 self.position = 0 
　　 self.capacity = MEMORY_CAPACITY 
　　 self.optimizer = torch.optim.Adam(self.net.parameters(), lr=LR)
　　 self.loss_func = nn.MSELoss()
　　 def choose_action(self,s,e):
　　 x=np.expand_dims(s, axis=0)
　　 if np.random.uniform() < 1-e: 
　　 actions_value = self.net.forward(x) 
　　 action = torch.max(actions_value,-1)[1].data.numpy()
　　 action = action.max() 
　　 else: 
　　 action = np.random.randint(0, 5)
　　 return action
　　 def push_memory(self, s, a, r, s_):
　　 if len(self.memory) < self.capacity:
　　 self.memory.append(None)
　　 self.memory[self.position] = Transition(torch.unsqueeze(torch.FloatTensor(s), 0),torch.unsqueeze(torch.FloatTensor(s_), 0),\
　　 torch.from_numpy(np.array([a])),torch.from_numpy(np.array([r],dtype=float32)))#
　　 self.position = (self.position + 1) % self.capacity
　　 def get_sample(self,batch_size):
　　 sample = random.sample(self.memory,batch_size)
　　 return sample
　　 def learn(self):
　　 if self.learn_step_counter % TARGET_NETWORK_REPLACE_FREQ == 0:
　　 self.target_net.load_state_dict(self.net.state_dict())
　　 self.learn_step_counter += 1
　　 transitions = self.get_sample(BATCH_SIZE)
　　 batch = Transition(*zip(*transitions))
　　 b_s = Variable(torch.cat(batch.state))
　　 b_s_ = Variable(torch.cat(batch.next_state))
　　 b_a = Variable(torch.cat(batch.action))
　　 b_r = Variable(torch.cat(batch.reward)) 
　　 q_eval = self.net.forward(b_s).squeeze(1).gather(1,b_a.unsqueeze(1).to(torch.int64)) 
　　 q_next = self.target_net.forward(b_s_).detach() #
　　 q_target = b_r + GAMMA * q_next.squeeze(1).max(1)[0].view(BATCH_SIZE, 1).t() 
　　 loss = self.loss_func(q_eval, q_target.t()) 
　　 self.optimizer.zero_grad() # reset the gradient to zero 
　　 loss.backward()
　　 self.optimizer.step() # execute back propagation for one step 
　　 return loss
　　Transition = namedtuple(Transition,(state, next_state,action, reward))
　　

3、运行结果

　　各个部分都完成之后就可以组合在一起训练模型了，流程和用CARLA差不多，就不细说了。

　　初始化环境（DQN的类加进去就行了）：

import gym
　　import highway_env
　　from matplotlib import pyplot as plt
　　import numpy as np
　　import time
　　config = \
　　 {
　　 "observation": 
　　 {
　　 "type": "Kinematics",
　　 "vehicles_count": 5,
　　 "features": ["presence", "x", "y", "vx", "vy", "cos_h", "sin_h"],
　　 "features_range": 
　　 {
　　 "x": [-100, 100],
　　 "y": [-100, 100],
　　 "vx": [-20, 20],
　　 "vy": [-20, 20]
　　 },
　　 "absolute": False,
　　 "order": "sorted"
　　 },
　　 "simulation_frequency": 8, # [Hz]
　　 "policy_frequency": 2, # [Hz]
　　 }
　　env = gym.make("highway-v0")
　　env.configure(config)
　　

　　训练模型：

dqn=DQN()
　　count=0
　　reward=[]
　　avg_reward=0
　　all_reward=[]
　　time_=[]
　　all_time=[]
　　collision_his=[]
　　all_collision=[]
　　while True:
　　 done = False 
　　 start_time=time.time()
　　 s = env.reset()
　　 while not done:
　　 e = np.exp(-count/300) #随机选择action的概率，随着训练次数增多逐渐降低
　　 a = dqn.choose_action(s,e)
　　 s_, r, done, info = env.step(a)
　　 env.render()
　　 dqn.push_memory(s, a, r, s_)
　　 if ((dqn.position !=0)&(dqn.position % 99==0)):
　　 loss_=dqn.learn()
　　 count+=1
　　 print(trained times:,count)
　　 if (count%40==0):
　　 avg_reward=np.mean(reward)
　　 avg_time=np.mean(time_)
　　 collision_rate=np.mean(collision_his)
　　 all_reward.append(avg_reward)
　　 all_time.append(avg_time)
　　 all_collision.append(collision_rate)
　　 plt.plot(all_reward)
　　 plt.show()
　　 plt.plot(all_time)
　　 plt.show()
　　 plt.plot(all_collision)
　　 plt.show()
　　 reward=[]
　　 time_=[]
　　 collision_his=[]
　　 s = s_
　　 reward.append(r) 
　　 end_time=time.time()
　　 episode_time=end_time-start_time
　　 time_.append(episode_time)
　　 is_collision=1 if info[crashed]==True else 0
　　 collision_his.append(is_collision)
　　

　　我在代码中添加了一些画图的函数，在运行过程中就可以掌握一些关键的指标，每训练40次统计一次平均值。

　　平均碰撞发生率：

　　epoch平均时长(s)：

　　平均reward：

　　可以看出平均碰撞发生率会随训练次数增多逐渐降低，每个epoch持续的时间会逐渐延长（如果发生碰撞epoch会立刻结束）

四、总结

　　相比于我在之前文章中使用过的模拟器CARLA，highway-env环境包明显更加抽象化，用类似游戏的表示方式，使得算法可以在一个理想的虚拟环境中得到训练，而不用考虑数据获取方式、传感器精度、运算时长等现实问题。

　　对于端到端的算法设计和测试非常友好，但从自动控制的角度来看，可以入手的方面较少，研究起来不太灵活。

　　以上就是Python实现自动驾驶训练模型的详细内容，更多关于Python自动驾驶训练模型的资料请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。