Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)

    作为一个刚接触webots数日的新手,来着手使用webots搭建一个二轮小车并实现避障的任务,以及使用webots进行强化学习的尝试。该文章主要有如下的内容:

大概内容:

    1.Webots简要介绍
    2.Webots搭建双轮小車
    3.Webots双轮小车避障简单的控制逻辑
    4.Pycharm编写控制程序连接并控制Webots中实体的方法
    5.Tensorflow编写DQN强化学习算法用于小车的避障
    6.Webots搭建八自由度四足机器狗子尝试(多有不足,刚接触webots,只是控制尝试)
1.Webots简要介绍

    既然是简要介绍,好像也没什么好说的。比如webots是 一款开源的机器人仿真软件。主要功能是机器人的建模、控制与仿真,用于开发、测试和验证机器人算法。
    下面给一个小例子,可以用webots来组建温馨的港湾。


    里面也有许多现成的实体可供使用。

    然后很关键的一点,就是可以根据需求自行搭建模型。下面就开始搭建双轮小车。

2.Webots搭建双轮小車

    从最基本的开始:
    2.1 新建一个项目:

        向导→新项目目录
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第1张图片
        然后根据提示下一步→选择文件存储的路径→勾选Add a rectangle arena→完成创建,大概就是这个样子:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第2张图片
        完成创建之后的样子如下:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第3张图片
        左侧用来添加节点,中间是仿真的显示区域,右侧用来编写控制器程序。下方显示输出信息。

    2.2 创建二轮小车实体:
        按照下图中图示的顺序创建一个机器人节点
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第4张图片
        然后在创建的机器人节点中的孩子节点(children node)下,添加一个transform节点。这个是为后续添加boundingObject做准备的,操作过程如下(注意添加transform之后将translation中y坐标的值设置为0.1或者其他的正值,将robot节点的坐标系抬高,要不然创建出来的实体会一半嵌进地里):
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第5张图片
        修改transform节点的坐标 translation,将y值设置为0.1,上移坐标的位置
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第6张图片

        然后在创建的transform节点下的children节点添加一个Shape,后面并通过这个shape选择一个形状,将会选一个圆柱,操作如下:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第7张图片
        添加圆柱并设置圆柱的外观显示。单纯添加圆柱为白色,添加外观设置之后可视化效果更好
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第8张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第9张图片
        外观设置中,2,3,4步骤为对应的选项,操作2中颜色自选,操作3中Value可以设置为1,操作4设置为0,就可以得到下面这个粉柱子

        然后修改圆柱的大小,将高度设置为2cm,对应里面的坐标为0.02,圆柱的半径设置为0.01,即1cm。

        然后添加边界属性与物理属性。不加边界掉地里就找不着了。为了更方便的区分,将transform节点改一个名字,比如Body。方法如下,单击Transform节点,然后在Node DEF下面输入Body
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第10张图片
        完成上一步之后,就可以添加上文提到的两个属性,分别是boundingObject与physics。boundingObject我们使用刚才改名的Body,然后physics属性点击弹出后直接添加即可,如下
        需要注意的是,在添加physics属性之前,可以先将仿真的按钮关闭。否则添加physics属性之后,实体就会直接掉在地上。按钮的位置如下:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第11张图片

Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第12张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第13张图片
        添加完成后,如果出现围绕实体的白色的边界线,就说明设置成功。如果边界线跟添加实体的边界有偏差,就说明坐标等细节有问题。可能是Transform(改名后为Body)节点下的坐标设置有问题,如果出现问题可以自查。弄完后大概就是这个样子:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第14张图片
        然后就可以进行下一步,添加一个轮子。单击Transform(改名后为Body)节点,选择Add(就那个“+”号),打开节点目录,选择一个HingeJoint节点。这个HingeJoint节点先不展开说,大概上可以理解为添加一个转轴,转轴的两端连接两个节点,一端是主体(Body),另一端需要连接一个Solid节点,下面会使用这个Solid节点制作一个轮子
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第15张图片
        然后打开新增的HingeJoint节点,里面有三个属性,第一个是针对主节点的,第二个Device用来添加一个Motor,第三个终端节点就是要添加轮子的节点。下面两张图对应着前两个节点的修改
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第16张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第17张图片
        然后打开添加的Motor节点,给Motor改改名字。这里就改为motorRight。修改名字方便后续对于Motor的调用

        然后创建一个轮子出来。点击endPoint,添加一个Solid节点。然后单击Solid节点,同样的方法添加一个Shape节点。然后用上文相同的方法,在Shape节点下添加一个圆柱
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第18张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第19张图片
        单击Shape节点,添加一个圆柱。然后请各位自行修改颜色属性,就不过多赘述了,添加好大概样子如下(后面会修改Solid的坐标以及圆柱的大小,来让endPoint变成一个合格的轮子)
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第20张图片
        修改圆柱的大小,并修改Solid节点的translation与rotation属性,将轮子放在指定的位置上。修改的数值如下(这个可以根据各位的喜好自行定义),可以按照图示的位置与数值修改
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第21张图片
        然后给新添加的Shape节点改个名字。这个修改操作是为了给endPoint节点添加边界属性准备的。在添加boundingObject之后,添加物理属性,同时也给physics属性也改一个名字。操作如下:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第22张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第23张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第24张图片
        下面给物理属性改个名字,同上操作
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第25张图片
        下面就是很关键的一步,这一步确保轮子能绕轴转动。打开HingeJoint节点下的endPoint节点,把translation的数值,直接复制到HingeJoint的第一个属性下面的anchor属性中,保持二者相同。然后点击position观察轮子是否按照指定转轴转动。如果转轴异常,可以修改axis的数值为 “0 1 0”或“0 0 1”,然后变动position的数值继续测试
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第26张图片
        这样第一个轮子就创建成功了,记得保存各位,要不然辛苦白费了。第二个轮子会很轻松,因为是对称的,只需修改少量数据即可。点击刚创建的HingeJoint节点,复制,粘贴,出现一个相同的HingeJoint节点。然后打开新节点,按照图示修改数值。这样小車的主体部分就设计好了。
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第27张图片
    2.3 运动测试:
        先保存最后的结果,很重要,很重要。然后点开仿真按钮,小車就掉下来了。双击小車的主体,在左侧会出现两个电机的控制台。然后就可以进行简单的运动测试了

Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第28张图片
    2.4 编写控制器:
        向导→新机器人控制器→下一步→Python→…可劲点就行了,点到结束。这里使用Python语言来创建控制器程序。若只用C/C++什么的看到这里就可以了,就不要浪费时间向下看了。

Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第29张图片
        先简单写一个包含前进/后退/转向/静止的代码逻辑,通过键盘输入进行控制。按键就是你键盘上最光亮的几个按键。代码如下:

from controller import Robot

robot = Robot()

timestep = int(robot.getBasicTimeStep())

#获取键盘输入
key = robot.getKeyboard()
key.enable(timestep)

#获取电机
motor_right = robot.getMotor("motorRight")
motor_left = robot.getMotor("motorLeft")

#设置电机模式与电机初始速度
motor_right.setPosition(float("inf"))
motor_right.setVelocity(0.0)

motor_left.setPosition(float("inf"))
motor_left.setVelocity(0.0)

while robot.step(timestep) != -1:
    
    key_ = key.getKey()
    
    if key_ == ord('W'):
        motor_right.setVelocity(-7.0)
        motor_left.setVelocity(-7.0)
    if key_ == ord('S'):
        motor_right.setVelocity(7.0)
        motor_left.setVelocity(7.0)
    if key_ == ord('A'):
        motor_right.setVelocity(4.0)
        motor_left.setVelocity(-4.0)
    if key_ == ord('D'):
        motor_right.setVelocity(-4.0)
        motor_left.setVelocity(4.0)
    if key_ == ord(' '):
        motor_right.setVelocity(0.0)
        motor_left.setVelocity(0.0)

        下面是效果图:
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第30张图片

    2.5 添加距离传感器
        我也是第一次做这个,接触了没几天,包括避障什么的。所以可能写的代码里多有逻辑不严谨或者是错误,还请加以分辨,请自行修正,抱歉。
        我是在小車的大脑门上加了三个距离传感器。方法类似于上文中的步骤。在Tramsform(Body)节点的基础上,添加一个Solid节点,是和前面添加的HingeJoint并列的节点。然后在Solid节点的children属性里添加Shape,并在Shape下添加一个圆柱,并调节尺寸,坐标,边界与物理属性。这些所有的步骤上文都有详细的介绍。还请上翻查看。
        按照图中标记的顺序。第一步:单击Transform节点,添加Solid。第二步:单击Solid节点,添加Shape。
            第一步:单击Transform节点,添加Solid。
            第二步:单击Solid节点,添加Shape。
            第三步:单击Shape节点,添加圆柱(Cylinder)。
            第四步:修改Cylinder属性值,修改Solid下的translation属性值。
            第五步:修改Shape的名称为sensor,然后保存保存保存。

Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第31张图片
        然后添加Solid节点下的boundingObject属性与physics属性。boundingObject属性用刚才修改的 sensor 。physics正常添加即可。可以通过白色的边界线来确定边界添加的准确与否。
        在刚才添加的Solid节点上单击,选择Add,添加一个距离传感器。
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第32张图片
        然后把Solid节点的translation的数值直接复制到距离传感器的translation中。这时就可以看到坐标的移动了。然后点击查看→可选显示→显示距离传感器射线。这个时候可以看到距离传感器的射线,不过应该不太明显。
        接着修改距离传感器的rotation,使得距离传感器的射线朝向小車的前方,并保存。如下图:

        然后复制粘贴再添加两个距离传感器,修改rotation的angle数值使得距离传感器的射线朝向两个轮子,与原来前向垂直。然后修改距离传感器的名字,打开距离传感器节点,里面有name选项,直接修改名字即可。最后添加控制器程序,我直接写在原来的控制器里,如下图:

        修改之后的代码如下(这个时候可以运行仿真,控制小车运动,然后可以观察传感器的输出,print()还没写,请自行添加):

from controller import Robot

robot = Robot()

timestep = int(robot.getBasicTimeStep())

#获取三个距离传感器的数值
ds_forward = robot.getDistanceSensor("sensor_forward")
ds_forward.enable(timestep)
ds_right = robot.getDistanceSensor("sensor_right")
ds_right.enable(timestep)
ds_left = robot.getDistanceSensor("sensor_left")
ds_left.enable(timestep)

#获取键盘输入
key = robot.getKeyboard()
key.enable(timestep)

#获取电机
motor_right = robot.getMotor("motorRight")
motor_left = robot.getMotor("motorLeft")

#设置电机模式与电机初始速度
motor_right.setPosition(float("inf"))
motor_right.setVelocity(0.0)

motor_left.setPosition(float("inf"))
motor_left.setVelocity(0.0)

while robot.step(timestep) != -1:
    
    distance_f = ds_forward.getValue()
    distance_l = ds_left.getValue()
    distance_r = ds_right.getValue()

    key_ = key.getKey()
    
    if key_ == ord('W'):
        motor_right.setVelocity(-7.0)
        motor_left.setVelocity(-7.0)
    if key_ == ord('S'):
        motor_right.setVelocity(7.0)
        motor_left.setVelocity(7.0)
    if key_ == ord('A'):
        motor_right.setVelocity(4.0)
        motor_left.setVelocity(-4.0)
    if key_ == ord('D'):
        motor_right.setVelocity(-4.0)
        motor_left.setVelocity(4.0)
    if key_ == ord(' '):
        motor_right.setVelocity(0.0)
        motor_left.setVelocity(0.0)         
3.Webots双轮小车避障简单的控制逻辑

    3.1 下面是避障大橙子的效果图
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第33张图片
    3.2 避障的基本逻辑
        小車有三个距离传感器,前/左/右各有一个。小车在循环中处于直行状态,当检测到前方有障碍物时,判断左右两侧的距离传感器的数值,进而转向距离传感器大的方向。在直行的同时,也会检测两侧的距离,当两侧距离障碍物过于接近的时候,也会启动转向的判定逻辑。控制代码如下:

from controller import Robot
import time

robot = Robot()

timestep = int(robot.getBasicTimeStep())

speed = 6.0

lm = robot.getMotor('motorLeft')
rm = robot.getMotor('motorRight')

lm.setPosition(float('inf'))
lm.setVelocity(0.0)

rm.setPosition(float('inf'))
rm.setVelocity(0.0)

dist = robot.getDistanceSensor("sensor_forward")
dist.enable(timestep)

distance_left = robot.getDistanceSensor("sensor_left")
distance_left.enable(timestep)

distance_right = robot.getDistanceSensor("sensor_right")
distance_right.enable(timestep)

def Left():
    for i in range(5):
        if robot.step(timestep) != -1:
            ls = -speed
            rs = speed
                
            lm.setVelocity(ls)
            rm.setVelocity(rs)

def Right():
    for i in range(5):
        if robot.step(timestep) != -1:
            ls = speed
            rs = -speed
                
            lm.setVelocity(ls)
            rm.setVelocity(rs)

def Forward():
    while True:
        if robot.step(timestep) != -1:
            ls = -speed
            rs = -speed
                
            lm.setVelocity(ls)
            rm.setVelocity(rs)
            
            ds = dist.getValue()
            ds_left = distance_left.getValue()
            ds_right = distance_right.getValue()  
            
        if float(ds)<700.0 or float(ds_left)<200.0 or float(ds_right)<200.0:# or float(ds_left)<1000.0 or float(ds_right)<1000.0:
            break
    
    if ds_left>ds_right:
        return "L"
    return "R"
  
while True:
    direction = Forward()
    if direction == "L":
        Left()
    else:
        Right()
4.Pycharm编写控制程序连接并控制Webots中实体的方法

    特别注意的是,这一步可能会有许多问题。也有很多的方法。如果下面的方法不能帮您解决,请自行百度,有很多方法可以选择并能解决问题,请保持耐心。
    特别注意的是,这一步可能会有许多问题。也有很多的方法。如果下面的方法不能帮您解决,请自行百度,有很多方法可以选择并能解决问题,请保持耐心。
    如果说要做强化学习,基本上离不开Tensorflow,Pytorch之类的库,但这些玩意想在Webots里运行是不现实的。所以说可以使用Pycharm来运行控制程序,然后调用Webots提供的接口来控制机器人的运动。下面介绍Pycharm连接Webots的方法。
    这个其实可以搜到很多的方法,大概上可以这样做:
    找到该项目的文件集合,找到controllers目录,使用Pycharm打开。
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第34张图片
    然后设置Pycharm。打开File→选择Settings→打开Project :controllers→打开Project :Structure→选择Add,然后添加Webots下的目录,根据自己安装的Webots来定。我的是“D:\Webots\lib\controller\python37”
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第35张图片
    然后设置Configurations,在环境变量里添加:;Path=D:\Webots\lib\controller\;D:\Webots\msys64\mingw64\bin\;D:\Webots\msys64\mingw64\bin\cpp 也是根据自己的Webots目录来定(注意一开始的 “;”)。然后点击Apply应用。如果正常的话,现在打开Webots仿真,在controller里选择 “extern”。然后在Pycharm运行程序,就可以实现控制。
    如果问题没有解决,请考虑修改主机的环境变量。百度上可以搜到文章,关于环境变量的修改。
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第36张图片
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第37张图片

    5.Tensorflow编写DQN强化学习算法用于小车的避障(这个会用到两种方式来编写代码,一种是直接拿我其他文章中提到的DQN代码,另一种会改写DQN的代码逻辑)

    这里先弄第一种,第二种后续测试完了会补上。
    5.0 我承认我忘了,这是刚添加上的第零项
        我们需要在刚才的小車的基础上修改一下坐标。意思就是让小车整体向下移动。下面我会给出图示,将Robot节点的children下的所有节点中的translation中的y值都减少0.08。使得小車的整体向下移动。

        然后很关键的一点,我们需要使用Supervisor来重置机器人的状态。只需要把Supervisor对应的节点选择为True即可。
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第38张图片
    5.1 思路:
        这个算是为了后续的强化学习任务做铺垫,案例以及算法逻辑多有不足,还请理解。
        设置了一个圈子,并设置围栏的高度。DQN算法的Observation仅仅包含三个距离传感器数据。其实这个数据偏少,各位可以给小車自行添加GPS,陀螺仪等,也可以使用激光雷达代替距离传感器,以此来丰富Observation的数据量。然后因为DQN算法只适用于离散值,所以会预先编写一个控制器,将动作离散化,即小車只有三个动作:前进 / 左转+前进 / 右转+前进。当然也可以通过DDPG算法来控制连续的动作,DDPG算法的文章过一阵子也会发。
        这里先说个小点子,如果动作只有前进/ 左转 / 右转,且Reward不加特殊设定的话,训练出来的小車很容易原地自转,避了个好障。
    5.2 控制器程序:
        如果接触过强化学习,应该对Gym不陌生。这个控制器的作用就是将小車改造成类似于Gym中的强化学习环境。因此,需要编写Reset()与Step()函数。Reset()函数用于重置系统的状态。Step()函数用于驱动小車运动,这个项目的运动输入是 [0,1,2]。因为小车没有安装陀螺仪等传感器,无法获得小车的姿态数据。因此在驱动小车进行转向(转向均为旋转90度)时默认为开环控制,不对旋转角度进行修正。各位有实际需求的,可以自行加装闭环控制程序,像是典型的PID之类。然后下面是控制器类的代码:

from controller import Supervisor
import time
import numpy as np

class Env():

    def __init__(self):
    
        self.name = "car"
        self.version = 1.0
        self.action_space = 3
        self.obs_space = 4
        self.terminal = False
        self.robot = Supervisor()
        self.timestep = 32
        
        self.max_speed = 6.28
        
        self.motor_1 = self.robot.getMotor("motorLeft")
        self.motor_2 = self.robot.getMotor("motorRight")
       
        self.motor_1.setVelocity(0.0)
        self.motor_2.setVelocity(0.0)
        
        self.motor_1.setPosition(float("inf"))
        
        self.motor_2.setPosition(float("inf"))
        
        self.ds_front = self.robot.getDistanceSensor("sensor_forward")
        self.ds_left = self.robot.getDistanceSensor("sensor_left")
        self.ds_right = self.robot.getDistanceSensor("sensor_right")
        
        self.ds_front.enable(self.timestep)
        self.ds_left.enable(self.timestep)
        self.ds_right.enable(self.timestep)

    def step(self,action):
        
        df = dr = dl = 0
        
        if action == 0:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)
                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()
                
        elif  action == 1:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(6.0)
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)  
                
                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()
        else:
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(6.0)
                self.motor_2.setVelocity(-6.0)
            for i in range(11):
                self.robot.step(self.timestep)
                self.motor_1.setVelocity(-6.0)
                self.motor_2.setVelocity(-6.0)  
                
                df = self.ds_front.getValue()
                dl = self.ds_left.getValue()
                dr = self.ds_right.getValue()
        
        self.motor_1.setVelocity(0)
        self.motor_2.setVelocity(0)
        
        terminal = False
        reward = -1
        
        if df<400.0 or dr<400.0 or dl<400.0:
            terminal = True
            reward = -15.0
        
        return [np.array([df,dl,dr]).reshape(1,1,3),reward,terminal]
    
    def reset(self):
        
        self.robot.simulationResetPhysics()
    
        Name = self.robot.getFromDef("car")
        trans= Name.getField("translation")
        rotation = Name.getField("rotation")
        trans.setSFVec3f([0,-0.01,0])

        return np.array([1000.0,1000.0,1000.0]).reshape(1,1,3)
  

    5.3 DQN Algorithm

from tensorflow.keras import Sequential, layers
from tensorflow.keras.models import load_model
from collections import deque
from Env import Env
import numpy as np
import random
import time

class Agent(object):

    def __init__(self, ):

        self.steps = 0
        self.var = 1e-1/2
        self.e = 1e-5
        self.Model = self.model_()
        self.Target = self.model_()
        self.replay_memory = deque(maxlen=1000)

    def model_(self):

        model = Sequential(name="DQN")
        model.add(layers.Dense(100, "relu",input_shape=(None,3)))
        model.add(layers.Dense(100, "relu"))
        model.add(layers.Dense(3, None))
        model.compile("adam", "mse")
        return model

    def add(self, obs, action, reward, n_s, done):

        if action == 0 and not done:
            reward += 2.0
        self.replay_memory.append((obs, action, reward, n_s, done))

    def sample(self, obs):

        self.var -= self.e
        if np.random.uniform() <= self.var:
            return np.random.randint(3)
        return np.argmax(self.Model.predict(obs))

    def data(self):

        batch = random.sample(self.replay_memory, 64)
        Obs, Action, Reward, N_s, Done = [], [], [], [], []
        for (obs, action, reward, n_s, done) in batch:
            Obs.append(obs)
            Action.append(action)
            Reward.append(reward)
            N_s.append(n_s)
            Done.append(done)
        return np.array(Obs).astype("float32"), np.array(Action).astype("int64"), np.array(Reward).astype("float32"), \
               np.array(N_s).astype("float32"), np.array(Done).astype("float32")

    def learn(self):

        if self.steps % 50 == 0:
            self.Target.set_weights(self.Model.get_weights())

        if self.steps % 2 == 0 and len(self.replay_memory) >= 80:

            Obs, Action, Reward, N_s, Done = self.data()
            Q = self.Model.predict(Obs.reshape(64, 1, 3))
            Q_ = self.Target.predict(N_s.reshape(64, 1, 3))

            for i in range(64):
                if Done[i]:
 
                    Q[i][0][Action[i]] = 0.01 * Reward[i]
                Q[i][0][Action[i]] = 0.01 * (Reward[i] + 0.9 * np.argmax(Q_[i][0]))

            self.Model.fit(Obs.reshape(64, 1, 3), Q, verbose=0)


env = Env()
agent = Agent()
Scores = []

agent.Model = load_model("car.h5")
agent.Target = agent.Model


for times in range(500):
    time_ = 0
    s = env.reset()
    Score = 0

    while True:

        time_ += 1
        agent.steps += 1
        a = agent.sample(s)
        next_s, reward, done = env.step(a)
        agent.add(s, a, reward, next_s, done)
        agent.learn()
        Score += reward
        s = next_s

        if done or time_ == 30:
            Scores.append(Score)
            print('episode:', times, 'score:', Score, 'max:', np.max(Scores))
            break

    # 提前终止训练
    #if np.mean(Scores[-3:]) >= -25:
    #    agent.Model.save("car.h5")
    #    break

agent.Model.save("car.h5")

    5.4 训练过程
Webots搭建强化学习二轮避障小车(看看吧 蛮详细的)_第39张图片

6.Webots搭建八自由度四足机器狗子尝试(多有不足,刚接触webots,只是控制尝试)

    稍微熟悉软件之后,就可以尝试做点别的。我是简单凑了个狗子,足端等还未改进。步态也没去设计,所以多有缺陷。下面是简单的效果样例,然后这篇文章到此也正式结束了。感谢各位能看到结束,莫大的感谢。其中定有不足与错误,还请各位指教。

你可能感兴趣的:(练习,机器人,人工智能,强化学习,python,算法)