ROS+Gazebo强化学习从虚拟训练到实车部署全流程分析

Gazebo仿真环境下的强化学习实现 实际上利用Gazebo进行强化学习无非是环境获取上的不同,Gazebo的环境控制需要使用ROS服务进行控制,状态可以通过Gazebo进行获取,同时某些必要数据需要从话题中获取,最重要的是组织获取 的数据(通过话题等)与控制Gazebo的仿真步骤之间的组合。强化学习的手段与传统算法无异,强化学习方法最重要的是要确定动作空间、状态空间、奖励空间,这三个空间是work的前提。在笔者自己的环境中,将获取里程计的话题以及获取激光点的数据替换成为了自己的本机的仿真环境匹配的话题。 阅读详情
AI摘要

本文详细介绍了一个基于ROS的强化学习项目的全过程,从环境搭建到算法训练再到实车部署,特别强调了TD3算法的应用及实践中遇到的问题与解决方案。

也学ros这个东西学了好长时间了,但是在ROS中进行强化学习并最终部署到实车这个过程一直都出现各种问题,实验室也没什么相关的积累,自己一个人搞就很痛苦。这次看论文时候看到别人公布的源码,于是去学习了一下别人怎么做的这个流程,真的是受益匪浅。
最终也能够实现从虚拟训练到实车部署这整个过程了!
现在把整个流程总结下来,后面关键部分的描述都在注释里面,希望实验室之后的学弟学妹们能轻松做实验带带学长发文章,也希望能够帮到各位刚接触ROS的同学们~!
(另外不知道为啥直接上传的md文件还会出现一些奇怪的格式问题,但也懒得处处改了,各位担待着看吧)
预训练模型:网盘 提取码 cwnw

但是说实话复现了很多算法了,目前来看 没有一个算法实车部署效果和虚拟仿真环境训练效果一样好的 (即便是论文里声称可以直接来用)。这个案例实车部署时,也总会出现原地转圈、踟蹰不前这种情况。如果有人真的用过什么可以在实车上也跑的很好的算法,也麻烦在评论区或者私信里面说一下!

0227更新 我个人试过两种效果比较好的方法,一是将连续动作改为离散动作;二是采用多阶段的学习,从无障碍物到有障碍物到动态障碍物分阶段训练,收敛会很快。

一 、运行一个示例

1、前提准备

(1)下载代码

使用了 Goal-Driven Autonomous Exploration Through Deep Reinforcement Learning 这篇论文作为例子,上面的流程可以给我们一个很好的示范,其github网址为:

https://github.com/reiniscimurs/DRL-robot-navigation

将其解压,我们可以得到如下的文件结构:

请添加图片描述

其中 **catkin_ws **为ROS工作空间,包含了gazebo仿真环境、p3dx小车模型、velody激光雷达模型等。但其主要任务就是打开一个仿真环境

TD3 中包含了文章中介绍的算法,其内部结构如下:
请添加图片描述

velodyne_env 是发送订阅数据、处理数据、获取状态、计算奖励等功能的代码,相当于gym中的环境部分

train_velodyne_td3 是训练代码,其中包括了网络结构以及训练部分。

(2)python环境

我们需要在Ubuntu环境中安装Anaconda,创建虚拟环境,安装好如pytorch之类的库,这部分想必各位既然已经开始做ROS了都有经验,不再赘述。

(3)ROS环境

用ROS当然需要安装ROS环境!我这里用的是Ubuntu 20.04 +ROS1 noetic版本

2、 进行仿真训练

(1)对工作空间进行编译

进入到catkin_ws工作空间内,打开一个终端

cd ~/DRL-robot-navigation-main/catkin_ws
catkin_make

在编译过程中,可能会出现各种各样的库缺失,具体缺失的内容可以读取报错信息,然后安装

sudo apt install ros-noetic-$ 你缺失的库 $                    

(2)运行训练文件

进入到TD3文件夹下,打开终端,cd到路径,python运行,这里会发现可能还是会缺少很多的库,这里我们使用pip install 安装

python train_velodyne_td3.py

按照其github上面所说,这样就可以进行训练了。但实际操作过程中发现这样无法打开gazebo,也会出现各种奇怪的报错,于是对其进行了如下更改

(3)更改部分

①手动创建launch文件

cd ./DRL-robot-navigation-main/catkin_ws/src/multi_robot_scenario/launch

我们可以看到这里面的文件,TD3.world,这里面就是其gazebo 的仿真环境文件,我们可以创建一个新的launch文件,用于打开这个.world文件

创建一个新的launch文件,命名为 TD3_world.launch

在其中输入如下内容

<launch> 
    <include file="$(find gazebo_ros)/launch/empty_world.launch">
        <arg name="world_name" value="$(find multi_robot_scenario)/launch/TD3.world"/>
        <arg name="paused" value="false"/>
        <arg name="use_sim_time" value="true"/>
        <arg name="gui" value="true"/>
        <arg name="headless" value="false"/>
        <arg name="debug" value="false"/>
      </include>
</launch>

②打开环境

打开一个新的终端

cd DRL-robot-navigation-main/catkin_ws/
catkin_make
source devel/setup.sh
roslaunch multi_robot_scenario TD3_world.launch 

请添加图片描述

那么我们就能够打开这个仿真环境了,但是我们发现这里并没有我们需要的机器人模型,所以我们还需要打开launch文件夹下的pioneer3dx.gazebo.launch文件,则新建一个终端

cd DRL-robot-navigation-main/catkin_ws/
source devel/setup.sh
roslaunch multi_robot_scenario pioneer3dx.gazebo.launch 

那么我们就可以在仿真环境内看到移动机器人了
请添加图片描述

③修改velody_env.py文件

接下来我们 python运行 train_velody_td3.py时候会发现,依旧会报一堆乱七八糟的错误。

我们需要对如下内容进行更改:

a: 将文件中所有的**"r1"改为“p3dx”**

​ 包括82行、116行、130行

在这里插入图片描述

在这里插入图片描述

这是由于如果不修改的话,他会将机器人命名为r1,但是我们直接打开,机器人是p3dx,当然也可以在打开过程中修改他的名字r1,但是对于初学者来说直接修改可能更容易理解。

b:注释掉它文件中打开launch文件的部分

​ 主要是98行-113行,但是注意104行初始化节点不要注释
在这里插入图片描述

(4)开始训练

接下来就可以愉快的训练了!我个人更喜欢直接在vscode中训练
在这里插入图片描述
这里需要选择相应的环境

然后直接run就行了,我们发现它可以运行了!

在这里插入图片描述

二、具体部分分析

1、Gazebo仿真环境部分

按照第一大部分运行Gazebo后,通过rostopic list 可以看到目前有如下的话题在ROS中存在

在这里插入图片描述

gazebo仿真环境如图所示:

在这里插入图片描述

2、velody_env.py文件

(1)init 关键部分

    rospy.init_node("gym", anonymous=True) #初始化ros节点
    
    #--------------------------发布内容----------------------------
    self.vel_pub = rospy.Publisher("/p3dx/cmd_vel", Twist, queue_size=1)  			#用于发布移动机器人的控制信息
    self.set_state = rospy.Publisher(
        "gazebo/set_model_state", ModelState, queue_size=10) 					   #用于设置移动机器人的位置、角度信息
    self.publisher = rospy.Publisher("goal_point", MarkerArray, queue_size=3)		#用于发布目标点
    self.publisher2 = rospy.Publisher("linear_velocity", MarkerArray, queue_size=1)  #线速度 MarkerArraty算法中无实际作用
    self.publisher3 = rospy.Publisher("angular_velocity", MarkerArray, queue_size=1) #角速度 MarkerArray算法中无实际作用
    #--------------------------服务内容----------------------------
    self.unpause = rospy.ServiceProxy("/gazebo/unpause_physics", Empty)				#恢复仿真
    self.pause = rospy.ServiceProxy("/gazebo/pause_physics", Empty)				    #暂停仿真
    self.reset_proxy = rospy.ServiceProxy("/gazebo/reset_world", Empty)				#重置仿真环境
    #--------------------------订阅内容----------------------------
    self.velodyne = rospy.Subscriber(
        "/velodyne_points", PointCloud2, self.velodyne_callback, queue_size=1)       #订阅激光雷达发布的点云
    self.odom = rospy.Subscriber(
        "/p3dx/odom", Odometry, self.odom_callback, queue_size=1)				    #订阅里程计信息

(2)step部分

def step(self, action):
        target = False
        # 发布机器人的动作,这里的step输入是action,action[0]是线速度,action[1]是角速度
        vel_cmd = Twist()
        vel_cmd.linear.x = action[0]
        vel_cmd.angular.z = action[1]
        self.vel_pub.publish(vel_cmd)
        self.publish_markers(action)
        #这里要注意了!!!!!
        # 首先unpause,发布消息后,开始仿真
        rospy.wait_for_service("/gazebo/unpause_physics")
        try:
            self.unpause()
        except (rospy.ServiceException) as e:
            print("/gazebo/unpause_physics service call failed")
        # 接下来需要停一小段时间,让小车以目前的速度行驶一段时间,TIME_DELTA = 0.1
        time.sleep(TIME_DELTA)
        # 然后我们停止仿真,开始观测目前的状态
        rospy.wait_for_service("/gazebo/pause_physics")
        try:
            pass
            self.pause()
        except (rospy.ServiceException) as e:
            print("/gazebo/pause_physics service call failed")
        # 检测碰撞
        done, collision, min_laser = self.observe_collision(self.velodyne_data)
        # 雷达状态
        v_state = []
        v_state[:] = self.velodyne_data[:]
        laser_state = [v_state]
        # 从里程计信息中获取小车朝向
        self.odom_x = self.last_odom.pose.pose.position.x
        self.odom_y = self.last_odom.pose.pose.position.y
        quaternion = Quaternion(
            self.last_odom.pose.pose.orientation.w,
            self.last_odom.pose.pose.orientation.x,
            self.last_odom.pose.pose.orientation.y,
            self.last_odom.pose.pose.orientation.z,
        )
        euler = quaternion.to_euler(degrees=False)
        angle = round(euler[2], 4)

        # 计算到目标点的距离
        distance = np.linalg.norm(
            [self.odom_x - self.goal_x, self.odom_y - self.goal_y]
        )

        # 计算偏离角度
        skew_x = self.goal_x - self.odom_x
        skew_y = self.goal_y - self.odom_y
        dot = skew_x * 1 + skew_y * 0
        mag1 = math.sqrt(math.pow(skew_x, 2) + math.pow(skew_y, 2))
        mag2 = math.sqrt(math.pow(1, 2) + math.pow(0, 2))
        beta = math.acos(dot / (mag1 * mag2))
        if skew_y < 0:
            if skew_x < 0:
                beta = -beta
            else:
                beta = 0 - beta
        theta = beta - angle
        if theta > np.pi:
            theta = np.pi - theta
            theta = -np.pi - theta
        if theta < -np.pi:
            theta = -np.pi - theta
            theta = np.pi - theta
        # 判断是否到达了目标点
        if distance < GOAL_REACHED_DIST:
            target = True
            done = True
        # 输出机器人状态
        robot_state = [distance, theta, action[0], action[1]]
        state = np.append(laser_state, robot_state)
        # 计算奖励
        reward = self.get_reward(target, collision, action, min_laser)
        # 返回状态、奖励、是否结束、是否到达目标点
        return state, reward, done, target

那么我们可以总结出来step的流程

①发布cmd_vel控制话题

②开始仿真,运行0.1s(也可以更改),停止仿真

③获取目前的状态信息

④计算奖励

⑤返回状态、奖励、是否结束等信息

(3)reset部分

def reset(self):
        # 重置环境
        rospy.wait_for_service("/gazebo/reset_world")
        try:
            self.reset_proxy()
        except rospy.ServiceException as e:
            print("/gazebo/reset_simulation service call failed")
        angle = np.random.uniform(-np.pi, np.pi)
        quaternion = Quaternion.from_euler(0.0, 0.0, angle)
        object_state = self.set_self_state
        x = 0
        y = 0
        position_ok = False
        while not position_ok:
            x = np.random.uniform(-4.5, 4.5)
            y = np.random.uniform(-4.5, 4.5)
            position_ok = check_pos(x, y)
        # 下面通过 /gazebo/set_model_state 话题更改移动机器人的初始位置
        object_state.pose.position.x = x
        object_state.pose.position.y = y
        # object_state.pose.position.z = 0.
        object_state.pose.orientation.x = quaternion.x
        object_state.pose.orientation.y = quaternion.y
        object_state.pose.orientation.z = quaternion.z
        object_state.pose.orientation.w = quaternion.w
        self.set_state.publish(object_state)

        self.odom_x = object_state.pose.position.x
        self.odom_y = object_state.pose.position.y

        # 更改一个目标点
        self.change_goal()
        # 更改环境中的小方块障碍物
        self.random_box()
        self.publish_markers([0.0, 0.0])
        #开始仿真
        rospy.wait_for_service("/gazebo/unpause_physics")
        try:
            self.unpause()
        except (rospy.ServiceException) as e:
            print("/gazebo/unpause_physics service call failed")
        #执行一段时间
        time.sleep(TIME_DELTA)
        #停止仿真,获得目前的状态
        rospy.wait_for_service("/gazebo/pause_physics")
        try:
            self.pause()
        except (rospy.ServiceException) as e:
            print("/gazebo/pause_physics service call failed")
        v_state = []
        v_state[:] = self.velodyne_data[:]
        laser_state = [v_state]

        distance = np.linalg.norm(
            [self.odom_x - self.goal_x, self.odom_y - self.goal_y]
        )

        skew_x = self.goal_x - self.odom_x
        skew_y = self.goal_y - self.odom_y

        dot = skew_x * 1 + skew_y * 0
        mag1 = math.sqrt(math.pow(skew_x, 2) + math.pow(skew_y, 2))
        mag2 = math.sqrt(math.pow(1, 2) + math.pow(0, 2))
        beta = math.acos(dot / (mag1 * mag2))

        if skew_y < 0:
            if skew_x < 0:
                beta = -beta
            else:
                beta = 0 - beta
        theta = beta - angle

        if theta > np.pi:
            theta = np.pi - theta
            theta = -np.pi - theta
        if theta < -np.pi:
            theta = -np.pi - theta
            theta = np.pi - theta

        robot_state = [distance, theta, 0.0, 0.0]
        state = np.append(laser_state, robot_state)
        #返回状态值
        return state

那么我们可以总结出来step的流程

①使用 /gazebo/reset_world 重置仿真环境

②设置环境中的小车、障碍物等的位置

③开始仿真,运行0.1s(也可以更改),停止仿真

④获取目前的状态信息

⑤返回状态信息

(4)reward部分

@staticmethod
def get_reward(target, collision, action, min_laser):
    if target:
        return 100.0
    elif collision:
        return -100.0
    else:
        r3 = lambda x: 1 - x if x < 1 else 0.0
        return action[0] / 2 - abs(action[1]) / 2 - r3(min_laser) / 2

这里即计算reward的部分,我们可以自己设定奖励函数,返回reward

(5)总结

那么我们在env部分最关键的代码就介绍完了!

这一部分其实本质上和在gym中没有什么不同,唯一的区别就是这里通过话题的订阅发布获取了环境状态信息。

同时有一个最重要的部分是,我们需要在每一次执行action的时候,让这个action运行那么0.1或者0.05秒,这样我们的小车才能够正常的运行一段距离。如果不设置这个运行时间的话,小车的action就会以最快的速度发布,那么根本就没有办法正常运行,step也会瞬间爆炸。

3、train_velodyne_td3.py文件

这一部分就是训练网络参数的python文件了。

其中的1-287行是TD3网络结构以及各种参数设定,这部分就不介绍了。

从288行的while是训练的主要部分,这部分本质上和在gym中也没有什么不同。拿出其中最重要的流程说一下。

#291
if done:
    ''''''
    #314
    state = env.reset()
    done = False
# 这部分是当结束本回合后的重置部分,使用env.reset()重置环境,给小车和障碍物重新分配位置,并对其他变量初始化
''''''
#325
action = network.get_action(np.array(state))
#这部分是将我们观测获得的状态输入到神经网络之中,从中获取动作
''''''
#348
a_in = [(action[0]+1)/2,action[1]]
next_state, reward, done, target = env.step(a_in)
#这里我们将动作输入到环境之中,进行step操作,step函数返回next_state,reward,done,target

那么我们可以看到这其实和任何强化学习中的训练步骤都基本一样,最后保存网络参数即可。

三、如何部署到实车上

(1)仿真训练得到好的网络

在这里插入图片描述

经过仿真训练后,能够得到ac网络各自的网络参数

(2)网络参数载入

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Actor, self).__init__()

        self.layer_1 = nn.Linear(state_dim, 800)
        self.layer_2 = nn.Linear(800, 600)
        self.layer_3 = nn.Linear(600, action_dim)
        self.tanh = nn.Tanh()

    def forward(self, s):
        s = F.relu(self.layer_1(s))
        s = F.relu(self.layer_2(s))
        a = self.tanh(self.layer_3(s))
        return a
# TD3 network
class TD3(object):
    def __init__(self, state_dim, action_dim):
        # Initialize the Actor network
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # cuda or cpu
        self.actor = Actor(state_dim, action_dim)
        self.actor.load_state_dict(torch.load("/home/polya/DRL-robot-navigation-main/pytorch_models180/TD3_final_actor.pth"))
        self.actor = self.actor.to(self.device)
        self.max_action = 1
    def get_action(self, state):
        # Function to get the action from the actor
        state = torch.Tensor(state.reshape(1, -1)).to(self.device)
        action = self.actor(state).cpu().data.numpy().flatten()
        action = action.clip(-self.max_action,self.max_action)
        linear_v = (action[0]+1)/2
        angle_v = action[1]
        return linear_v,angle_v
    def load(self, filename, directory):
        self.actor.load_state_dict(
            torch.load("%s/%s_actor.pth" % (directory, filename))
        )

这里我们其实只需要一个actor网络就可以了,函数则只需要一个get_action
当然也可以直接按照之前的网络来写,这样你还可以顺便收集实际数据,进行进一步训练。

(3)实车信息获取与处理

        #-------------------Pub and Sub--------------
        self.GoalPub = rospy.Publisher("/GoalPoint",Marker,queue_size=10)
        self.LaserSub = rospy.Subscriber("/scan",LaserScan,self.LaserScanCallBack)
        self.OdomSub = rospy.Subscriber("/odom",Odometry,self.OdomCallBack)
        self.goalxSub = rospy.Subscriber("/goal_x",Float32,self.goalxCallBack)
        self.goalySub = rospy.Subscriber("/goal_y",Float32,self.goalyCallBack)

这里我是用了一个Publisher 发布/GoalPoint 话题,这个就是把目标点做成Marker发出去,仅仅是为了在Rviz中进行显示

订阅:1、/scan 激光雷达信息,这里我用的是一个2D激光雷达,获取的扫描信息转成了PointCloud2点云信息并用于后面的计算,当然我在训练过程中也用的是一个2D激光雷达进行的训练

​ 2、/odom 里程计信息,用于实时获取实车目前的位置和速度,当然这里你也可以换成什么gps imu之类的信息,只需要最后都转变成为训练时对应的状态输入

​ 3、/goal_x和/goal_y 。 这里是接收我们目标位置的坐标,因为偷懒直接写了两个float32 Subscriber来接收,后面可以改成自定义信息或者什么里程计信息

接下来是整合信息,返回state状态数组

    def GetStates(self): #其实这里和之前的velody_env.py中获取信息的方式大同小异
        target =False
        v_state = []
        v_state[:] = self.velodyne_data[:]
        #雷达状态输入
        laser_state = [v_state]
        self.odom_x = self.last_odom.pose.pose.position.x
        self.odom_y = self.last_odom.pose.pose.position.y
        quaternion = Quaternion(
            self.last_odom.pose.pose.orientation.w,
            self.last_odom.pose.pose.orientation.x,
            self.last_odom.pose.pose.orientation.y,
            self.last_odom.pose.pose.orientation.z,
        )
        euler = quaternion.to_euler(degrees=False)
        angle = round(euler[2], 4)
        distance = np.linalg.norm(
            [self.odom_x - self.goal_x, self.odom_y - self.goal_y]
        )
        skew_x = self.goal_x - self.odom_x
        skew_y = self.goal_y - self.odom_y
        dot = skew_x * 1 + skew_y * 0
        mag1 = math.sqrt(math.pow(skew_x, 2) + math.pow(skew_y, 2))
        mag2 = math.sqrt(math.pow(1, 2) + math.pow(0, 2))
        beta = math.acos(dot / (mag1 * mag2))
        if skew_y < 0:
            if skew_x < 0:
                beta = -beta
            else:
                beta = 0 - beta
        theta = beta - angle
        if theta > np.pi:
            theta = np.pi - theta
            theta = -np.pi - theta
        if theta < -np.pi:
            theta = -np.pi - theta
            theta = np.pi - theta
        self.dis = distance
        if distance < GOAL_REACHED_DIST:
            target = True
      	#机器人状态输入
        robot_state = [distance, theta, self.last_odom.twist.twist.linear.x,self.last_odom.twist.twist.angular.z]
        print(self.dis)
        print(distance)
        print(robot_state)
        state = np.append(laser_state,robot_state)
        # 最后我们返回小车的状态输入,包括雷达输入和机器人状态输入以及是否到达了目标位置
        return state,target
    

(4)简单的执行部分

rospy.init_node("my_car") #初始化节点
car = mycar()	#实例化实车信息获取类
# --------偷懒的目标点发布---------------
xpub = rospy.Publisher("/goal_x",Float32,queue_size=10)
ypub = rospy.Publisher("/goal_y",Float32,queue_size=10)
xpub.publish(2.5)
ypub.publish(0.5)
network = TD3(24,2) #实例化TD3网络
pub = rospy.Publisher("/cmd_vel",Twist,queue_size=10) #/cmd_vel发布,用于控制小车的运动
rate = rospy.Rate(10) #等待频率,相当于仿真环境中的DELTA_TIME

while not rospy.is_shutdown():
    state,target = car.GetStates() #获取状态信息
    if not target:
        linear_x,angular_z = network.get_action(np.array(state)) #将状态输入到网络之中,输出线速度和角速度
        cmd_vel = Twist() #将速度放到Twist中发布
        cmd_vel.linear.x = linear_x/5 #这里发现最快1m/s的话还是太快了,所以又手动降为最大0.2
        cmd_vel.angular.z = angular_z/5
        pub.publish(cmd_vel) #发布消息
        
    if state[20]<COLLISION_DIST: #简易判断碰撞
        pub.publish(Twist())
        break
    if target: #简易判断是否到达目标点
        pub.publish(Twist())
        break
    rate.sleep() #停止一段时间,让这里设置为0.1s,那么控制频率就是10hz

然后运行,我们可以打开rviz,看到小车的移动了!

不过这里我用的小车其实仿真环境中的不是一个小车,em但是他们的控制方式也比较相似吧,最后也能实现相应的效果,最正确的方式是将你们自己小车的urdf导入到gazebo中进行仿真!

在这里插入图片描述

对了,这里用的是jupyter来写的,我发现在jupyter里面搞ROS的算法部分真的是很方便啊!值得一试!

ROS-gazebo 简介 gazebo 一、什么是Gazebo? Gazebo的典型用途 Gazebo的一些主要特点 二、系统要求 三、安装 1.添加源 2.安装Gazebo 四、用户界面 1、场景 2、左右面板 3、工具栏 4、菜单栏 5、鼠标 一、什么是Gazebo? Gazebo是一款3D动态模拟器,能够在复杂的室内和室外环境中准确有效地模拟机器人群。与游戏引擎提供高保真度的视觉模拟类似,Gazebo提供高保真度的物理模拟,其提供一整套传感器模型,以及对用户. 阅读详情

相关推荐

SARL*深度强化学习+ROS室内导航:从仿真训练到实车部署全流程

深度强化学习通过智能体与环境的交互学习最优策略,在机器人控制领域展现出强大的泛化能力。ROS作为机器人开发的标准框架,提供了模块化的通信机制和丰富的传感器接口,二者结合能够有效解决传统路径规划对高精度地图的依赖问题。在室内导航场景中,基于空间注意力机制的网络架构可显著提升策略对关键区域的感知能力,配合奖励塑形和域随机化技术,能够加速训练收敛并增强仿真到实车的迁移鲁棒性。SARL*方案正是这一技术路线的典型实践,通过ROS节点化部署实现感知、推理与控制的完整闭环。

weixin_29057065的博客 240

ROS:Gazebo详解

ROS:Gazebo详解

立于皓月之边,不弱星光之势 2840

从零开始:在VMware虚拟机中搭建turtlebot3仿真环境(ROS+Gazebo+强化学习)

本文详细介绍了在VMware虚拟机中搭建TurtleBot3仿真环境的完整流程,涵盖ROS Melodic安装、Gazebo配置及强化学习框架集成。通过优化虚拟机性能和ROS通信设置,即使在资源有限的设备上也能实现流畅的机器人仿真体验,为学习ROS和开展强化学习研究提供实用解决方案。

weixin_29305313的博客 245

iOS原生布局简介

自动布局核心公式view1.attr1 = view2.attr2*multiplier+constant 自动布局构造函数 NSLayoutConstraint( item: 视图, attribute: 约束属性, relatedBy: 约束关系,

Felix_Smile的博客 1046

机器人强化学习导航仿真实践:从ROS 2、Gazebo到PPO算法全流程解析

强化学习作为机器学习的重要分支,通过智能体与环境的交互试错来学习最优策略,其核心原理基于马尔可夫决策过程。在机器人领域,这项技术的价值在于能够处理动态、非结构化环境中的复杂决策问题,尤其适用于传统规则方法难以应对的导航场景。通过将仿真环境(如Gazebo)与强化学习框架(如Stable-Baselines3)结合,开发者可以在低成本、零风险的虚拟世界中训练机器人自主导航策略,有效解决了真实机器人训练成本高、风险大的痛点。本文以“众擎PM01”项目为例,详细拆解了如何利用ROS 2、Gazebo仿真器搭建训练

weixin_33766805的博客 381

基于ROS 2与Gazebo的机器人强化学习导航仿真实践

强化学习作为人工智能的核心技术,通过智能体与环境的交互试错来学习最优策略。其核心原理在于利用奖励信号引导智能体行为,在机器人领域,这一技术能赋予机器自主决策与适应能力。结合ROS 2(机器人操作系统)与Gazebo高保真物理仿真器,为算法验证提供了安全、高效的虚拟沙盒。通过构建包含状态(如激光雷达数据)、动作(运动指令)和奖励函数的标准训练环境,可将PPO、DQN等先进算法应用于解决机器人自主导航与动态避障等工程难题。本文以“众擎PM01”模型为例,详解从仿真环境搭建、机器人模型配置到强化学习算法集成的全流

weixin_34396103的博客 376

ROS自学笔记八:Gazebo

Gazebo是一款开源的多机器人仿真器,用于模拟和测试机器人系统。它提供了一个类似真实环境的三维仿真环境,可以用于模拟各种机器人、传感器、环境和任务。以下是Gazebo的一些主要特点和功能:1. 逼真的3D仿真:Gazebo提供了高度逼真的物理引擎和图形渲染,能够准确地模拟物体之间的物理交互、碰撞和运动。2. 多机器人支持:Gazebo支持同时模拟多个机器人,可以进行多机器人系统的协同控制和仿真。

m0_71721954的博客 8094

【ROS】ROS+Gazebo强化学习:训练

ROS+TD3强化学习:环境搭建、训练

郭老二 4547

【2021.11.11更新】ROS机器人强化学习环境搭建(Ubuntu20.04 + ROS Noetic + OpenAI_ROS),以Turtlebot3为例,包含自定义训练任务环境

本文介绍了基于强化学习的turtlebot3自主导航学习环境,包括openai_ros的安装以及以其为基础创建自己的强化学习任务环境。

qq_33361420的博客 9569

深度强化学习实车部署0.1版:从仿真到真实硬件的闭环落地

深度强化学习(DRL)在机器人控制中日益普及,但其从仿真环境迁移到真实硬件面临显著挑战。核心在于理解物理系统固有的延迟、传感器噪声、执行器非线性与状态异步等约束,而非单纯优化算法reward。本文聚焦DRL实车部署的‘最小可行闭环’——即确保策略网络能在真实ROS2底盘上稳定推理、安全执行并支持可观测调试。围绕状态空间压缩、动作死区与饱和处理、低延迟通信架构及模型确定性加载等关键技术点,结合PyTorch与ROS2 Humble实战,为工程师提供可复现、可归因、可复位的第一版实车部署方案,是通往在线微调与安

weixin_31815843的博客 238

Silvaco二极管、三极管、CMOS的制备

Silvaco二极管和三极管的制备

yytu231的博客 5753

基于强化学习ur机械臂项目论文复现

因为该项目中的moveit与gazebo联动是本人所需要的,故复现一下该项目,运用moveit的圆弧轨迹规划控制gazebo中机械臂模型画圆。1.先把大佬的ur5文件包下载下来,大佬的ros版本是16.04的,我是18.04的。后期可能需要更改许多环境的bug,慢慢来吧。2.安装包导入ros后,配置环境时报的第一个bug,环境配置中opencv-python下载报错除了opencv-python,剩下三个已经安装好了。

weixin_69762283的博客 1468

保姆级图解:FD-SOI工艺流程中的关键三步(外延生长、应变硅、HKMG)

本文详细解析了FD-SOI工艺流程中的三大关键技术:外延生长、应变硅工程和HKMG集成。通过选择性外延生长技术优化接触电阻,利用应变硅提升载流子迁移率,并结合先栅高k金属栅工艺实现精准栅极控制,FD-SOI技术在智能手机处理器和自动驾驶芯片制造中展现出卓越的低功耗与高性能平衡。

weixin_29267307的博客 492

【亲测免费】 ROS+Gazebo强化学习预训练模型:从虚拟训练到实车部署全流程分析

ROS+Gazebo强化学习预训练模型:从虚拟训练到实车部署全流程分析 【下载地址】ROSGazebo强化学习预训练模型从虚拟训练到实车部署全流程分析 本仓库提供了一个预训练的强化学习模型,该模型专门针对ROS(机器人操作系统)和Gazebo仿真环境进行了优化。模型经过精心训练,能够在虚拟环境中实现高效的路径规划和导航任...

gitblog_09769的博客 929

PID详解

1、什么是PID及其作用 设定一个输出目标,反馈系统传回输出值,如与目标不一致,则存在一个误差,PID 根据此误差调整输入值,直至输出达到设定值. 为什么需要PID呢,比如控制温度,我们需要设置一个要达到的目标温度值,当将温度稳定在目标温度值 例如,我们希望水的目标温度值为70°,其希望无非就是可以快速而且无抖动的达到70°,并稳定在70° 如果我们使用普通的方式加热,当温度到达70°后就以及停止加热,岂不是简单快速,当然用在要求不高的场合也可以,但是如果要求更高的场合呢,会出现温度到达70°后......

weixin_48435215的博客 5万+

Ubuntu快速安装miniconda

以下是卸载anaconda的步骤,记录下来给我自己看,因为学校平台anaconda版本较老,且平台不好用,每次需要卸载anaconda,我记性又不好,所以简单记录下步骤~删除类似这样的行(因为已经卸载成功了,没有截图了,拿miniconda来充当一下,样子是很像的)本次安装Ubuntu版本:18.04 但是miniconda版本是最新的。退出编辑,输入命令,清除索引缓存,保证用的是镜像站提供的索引。直接复制粘贴清华源的索引(如果是第一次安装,这个文件是空的)重启终端出现(base)2.初始化conda。

xiang_muran的博客 5370

【亲测免费】 ROS+Gazebo强化学习:从虚拟训练到实车部署的全流程指南

ROS+Gazebo强化学习:从虚拟训练到实车部署的全流程指南 【下载地址】ROSGazebo强化学习从虚拟训练到实车部署全流程分析分享 本资源文件详细介绍了如何使用ROS(Robot Operating System)和Gazebo仿真环境进行强化学习,并最终将训练好的模型部署到实际车辆上的全流程。通过本资源,您将学习...

gitblog_06537的博客 840

告别密码明文传输:手把手带你用Python实现SRP-6协议(附完整代码)

本文详细介绍了如何使用Python实现SRP-6协议,确保密码安全传输和存储。通过零知识证明与密钥交换技术,SRP协议在不传输明文密码的情况下完成认证,适用于金融App等高安全需求场景。文章包含完整代码示例和实战技巧,帮助开发者规避常见安全陷阱。

weixin_30689307的博客 414

强化学习与ROS结合的机器人导航实践

强化学习(Reinforcement Learning)作为人工智能的重要分支,通过智能体与环境的持续交互来优化决策策略。在机器人导航领域,结合ROS(Robot Operating System)框架,可以实现从仿真训练到真实部署的完整流程。核心技术原理包括价值函数优化和策略梯度方法,其中PPO、DQN等算法在路径规划、避障等任务中表现优异。通过Gazebo搭建高保真仿真环境进行离线训练,再迁移到实体机器人,不仅能大幅降低硬件损耗风险,还能提升算法泛化能力。这种模式在仓储AGV、服务机器人等场景已得到验证

weixin_30729609的博客 304

LLC电路细讲笔记(二)LLC谐振转换器:频率、增益与Q值的详细探讨

这本电子书通过详细分析LLC谐振转换器的工作原理、等效电路和增益公式,帮助读者深入理解如何设计和优化谐振转换器系统。通过这些公式和设计方法,工程师可以根据不同的应用需求调整参数,实现高效的电能转换。

weixin_43199439的博客 6911

测试用例设计工具大盘点:总有一款适合你

本文旨在帮助测试工程师、开发人员及团队管理者快速了解主流测试用例设计工具的特点、适用场景和选择逻辑。覆盖工具类型包括传统文档工具、开源管理工具、商业集成平台及新兴AI工具,范围涵盖中小团队到大型企业的不同需求。本文从“测试用例设计的痛点”切入,用生活案例解释核心概念;接着按“工具类型”分类盘点主流工具(附优缺点对比表);再通过“小团队/中大型团队/敏捷团队”等真实场景教你选工具;最后展望AI等未来趋势,帮你“一次学透,终身受用”。

项目管理的博客 1593

探索未来自动化:ROS2与Gazebo下的六自由度机械臂模拟项目

探索未来自动化:ROS2与Gazebo下的六自由度机械臂模拟项目 在机器人技术和人工智能日益蓬勃的今天,一个能够从零开始搭建并在ROS2与Gazebo环境中自由翱翔的六自由度(6DoF)机械臂模拟器,无疑是探索机器学习与自动控制领域的一把金钥匙。让我们深入挖掘【Robotic Arm Simulation in ROS2 and Gazebo】项目,它不仅为工程师和研究者们提供了一个强大的实验平台...

gitblog_01122的博客 1422

5 分钟上手 Kimi Work:安装、配置、跑通第一个任务

这篇文章提供了Kimi Work的快速入门指南,帮助用户在5分钟内完成从安装到运行第一个任务的全过程。主要内容包括: 安装步骤: macOS用户下载.dmg文件并拖入Applications Windows用户下载.exe安装包,需注意中文路径问题 初始设置: 使用现有Kimi账号登录 检查任务配额和文件访问权限 首个任务推荐: 建议从简单的本地文件整理开始(如按类型分类桌面文件) 详细说明了任务执行流程和审批机制 常见问题: 计划生成卡顿的解决方法 文件无变化的排查步骤 进阶建议: 提供难度递增的后续任务

sg_knight的专栏 2810

从仿真到落地:PPO强化学习与ROS2交互实战指南

在动手实操前,我们先理清两个核心工具的定位,以及它们结合的优势——理解这一点,能帮你避开很多实操中的无效尝试。现象:Gazebo加载机器人模型后,关节无法运动,或碰撞检测异常。解决方案:① 检查URDF文件中的transmission标签,确保hardwareInterface配置正确;② 调整关节的damping(阻尼)和friction(摩擦)参数,避免动力学响应迟钝;③ 核对link的惯性参数,确保与真实机器人一致。

ShenHeTechnology的博客 530

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

深度强化学习在ros+gazebo来实现导航的流程

注意是首先创立了一个虚拟环境drl,然后用安装了torch,torchaudio,torchvision,以及安装opencv库、cv2库、tensorboardx库,安装的命令在上面的博客中。安装后可以在终端输入python3后运行下面的指令检测一下是否安装完整。

m0_53079604的博客 289
上一篇: 在使用 nav2_bringup tb3_simulation_launch.py 时无法启动Gazebo的问题
PolypolyA
博客等级 码龄8年 153粉丝 7原创
评论 273
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值