ljg2np的个人空间动态-电子工程世界

ljg2np

个性签名：

波光潋滟.~

动态发布点评好友关于

2025-03-11
回复了主题帖：具身智能机器人系统三-基础模块（规划与控制）

最优化方法在机器人的路径规划与轨迹规划中，起了很重要的作用。:loveliness:
回复了主题帖：具身智能机器人系统四-具身智能机器人大模型

okhxyyo 发表于 2025-3-11 08:56 有具体的身体。所以叫具身机器人，不单单是人形，像机器狗也是具身机器人，甚至，扫地机器人也算是具身机 ... “具身”里的这个“具”字，我还以为是“具有”的意思，原来可以理解为“具体”，这样更加形象、具体，学习了。:congratulate:
回复了主题帖：具身智能机器人系统四-具身智能机器人大模型

RT-1的框架图是英文版的，从哪里下载的？
2025-03-10
回复了主题帖：《具身智能机器人系统》阅读分享-书籍概览

freebsder 发表于 2025-3-10 14:13 是不是政府报告里面出现了“具身智能”这个词了？ 2月27日，北京人民政府发布《北京具身智能科技创新与产业培育行动计划（2025-2027年）》，发力“具身智能+”； 3月3日，深圳市科技创新局发布了《深圳市具身智能机器人技术创新与产业发展行动计划（2025-2027年）》，定好了接下来3年的行动路线，抢跑具身智能。
回复了主题帖：人工智能机器人主要用哪种电池？

在机器人市场中，使用最多的电池，也是市场上最主流的电池非锂离子电池莫属。目前很多电动车使用的就是锂电池，很轻便。
2025-03-07
回复了主题帖：《具身智能机器人系统》阅读分享-定位系统

oxlm_1 发表于 2025-3-5 19:17 问题就在这，为啥机器人要求那么高的精度，而人就不需要那么高的精度？机器人算法中反复强调多少平方的范 ... 实际上人从出生到长大是经过了反复的学习和训练的，是在与环境交互适应中逐渐趋于成熟稳定的，人体内的神经元细胞数量也是庞大的。
回复了主题帖：《具身智能机器人系统》阅读分享-具身智能大模型

生酱哥发表于 2025-3-7 09:50 具身智能大模型为机器人赋予更强环境交互力，在多领域有应用潜力，但面临算法优化与数据安全等挑战。具身智能能否应对算法优化与数据安全，乃至伦理规范，都是未来发展的热点话题。
回复了主题帖：《具身智能机器人系统》阅读分享-具身智能大模型

秦天qintian0303 发表于 2025-3-7 07:02 这个工程量就有点大了感觉这是以后发展方向中的重中之重，至少会有一段时间是这样。
2025-03-06
发表了主题帖：《具身智能机器人系统》阅读分享-具身智能大模型

本帖最后由 ljg2np 于 2025-3-6 23:58 编辑本文分享书中第三部分具身智能机器人大模型的阅读理解。一．具身智能大模型的发展历程 1.ChatGPT for Robotics ChatGPT for Robotics是谷歌早期利用大模型进行机器人控制的工作，它在ChatGPT正式发布几个月后被提出，完成了大部分的工作和实验。主要工作： ①确定了将机器人的底层控制、运动封装为函数库，并由大模型在此基础上编写程序来控制机器人的方式。 ②确定了大模型与机器人应该是多模态的发展方向，因为机器人所处的工作环境本身是多模态的。 ChatGPT for Robotics的工作流程如下图所示： ChatGPT通过代码方式使机器人具有视觉，成为多模态大模型的一种早期应用方式，如下图所示： 2.Robotic Transformers Robotic Transformers（RT）是谷歌的机器人学习小组在2023年提出的一项工作，该工作的目的是建立一个通用的机器人学习系统，这一学习系统的结构可以吸收大规模的数据并能有效地将其泛化。主要包括以下几个部分： ①模型设计：采用图像和自然语言指令两个模态进行输入，来实现对机器人的控制。 ②数据集：收集大型、多样化的机器人轨迹数据，包括多个任务、对象和环境，具有泛化性和较大规模。 ③成功率：在四个维度上进行量化展示，包括：训练集中可见任务的成功率、训练集中不可见任务的成功率、任务的稳健性、长复杂任务的成功率。 Robotic Transformers-1（RT-1）的网络架构如下图所示： RT-1采取双编码器设计：自然语言指令通过Universal Sentence Encoder进行编码，得到一个512维的向量，前后6帧的视觉信息通过输入基于ImageNet预训练的EfficientNet-B3网络进行编码，二者融合后经过多层卷积网络，得到融合了自然语言和视觉信息的词元序列，然后由TokenLearner网络对词元序列进行降采样，得到8个词元后，输入Transformer网络对动作进行预测。 RT-1模型仍面临一些问题，谷歌机器人小组在RT-1之后，陆续完成了RT-2、RT-X等工作。 RT-2创造性地将机器人动作进行编码，使编码作为一种“文字”由图文模型输出。 3.经典小模型由于具身智能机器人的实时性要求，典型的小模型收效显著，对系统设计具有重要意义。 ①RoboFlamingo的工作模式和网络结构，见下图。 RoboFlamingo是字节跳动公司提出的一个小模型，它利用预训练的VLM理解每个决策步骤的视觉观察和语言指令，使用显式策略头建模历史特征，并仅使用语言条件下的操作数据集进行微调，这种分解模式只需要少量的数据就可以使模型适应下游操作任务。 RoboFlamingo在固定场景的抓取任务数据集Calvin上取得了非常好的效果，证明了在某些专用任务上，通过特殊的模型设计、训练方式和数据集选择等方法，使用相对较小的模型来提升任务性能是可能的。 ②UniPi的工作模式，见下图。 UniPi提出了利用text-to-video的图生文能力，即使用扩散模型，根据用户的自然语言指令和当前的机器人静态图像，生成一段未来状态的视频，然后根据这段预测视频中机器人的位姿，反解码出控制机器人所需的速度、加速度、位姿等信息，传给机器人进行控制。这种思路在实验中得到了很好的验证。 UniPi将图像作为一个新的中间介质，利用对图像的的预测实现对机器人动作的预测，使得大量图像生成与视频生成的技术和工具应用于具身智能机器人方向。二．具身智能大模型的现状分析 1.基础大模型的分类 ①视觉基础模型，如ResNet、VGG、Inception等。 ②视觉内容生成模型，如生成对抗网络GAN和变分自编码器VAE。 ③大语言模型，如GPT-4、BERT、Transformer等。 ④视觉语言模型，如CLIP、DALL-E。 ⑤大型多模态模型，如Perceiver IO和Multimodel Transformers。每一类基础大模型都根据其独特的功能和应用场景，对机器人在复杂场景中展现出更高的智能和适应性，提供了各自有力的技术支持。 2.具身智能大模型指标具身智能机器人完成任务时需要满足指标要求，指标是评估具身智能机器人的重要依据。 ①成功率机器人任务的成功率是衡量智能机器人在执行特定任务时达到预期目标的比例。 ②实时性机器人任务的实时性指机器人在执行特定任务时，对外部环境变化的响应速度和处理效率。 ③安全性机器人的安全性指机器人在执行任务时确保自身和周围人、物的安全的能力。 3.构建具身智能大模型具身智能涉及将人工智能嵌入有形实体，使它们具备感知、学习和与环境互动的能力。书中给出了3个关于具身智能构建的指导原则： ①具身智能机器人系统不依赖预定义的复杂逻辑来管理特定场景，而是灵活地应对多变的环境。 ②具身智能机器人系统必须包含进化学习机制，使其能够不断适应运行环境，从而允许具身智能机器人系统从经验中学习。 ③环境在塑造物理行为和认知结构方面起着关键作用。作者指出从环境中学习是具身智能系统的关键特征，认为元学习+GPICL方法虽然在计算和内存方面面临重大挑战，但在构建具身智能基础模型方面具有潜力，能够提供更好的长期适应性和泛化能力。
回复了主题帖：《具身智能机器人系统》阅读分享-规划与控制系统

Jacktang 发表于 2025-3-6 07:29 学习过程与环境的互动是强化学习的关键特征，是这样理解是这样的，更具体的说法是把状态空间和动作空间作为监督学习的对应来进行讨论的。
2025-03-05
发表了主题帖：《具身智能机器人系统》阅读分享-规划与控制系统

本帖最后由 ljg2np 于 2025-3-5 22:32 编辑本文分享对具身智能机器人基础模块中规划与控制系统这部分的阅读理解。一．机器人的运动规划机器人的运动规划可以采用路径或轨迹的形式。在路径规划框架中，不规定如何跟随这条路径；在轨迹规划框架中，则明确考虑控制执行时间。与路径不同，轨迹规定了机器人配置随时间的演变。 1.路径规划路径规划关注在机器人的配置空间中找到一条从起点到目标区域的路径，同时满足各种全局和局部约束。求解规划路径可分为“可行”解和“最优”解，可行路径规划指确定一条满足某些约束的路径，而不关注解的质量；而最优路径规划指在给定约束条件下找到优化某些质量的路径问题。在大多数机器人规划问题中，在全约束和微分约束下找到最优路径规划问题的解，其计算复杂性约等同于NP完全问题，因此，通常采用数值计算方法。 2.轨迹规划轨迹规划多应用于动态环境，它通过时间参数化的方式，考虑机器人的控制执行时间和动态约束，使规划出的轨迹能够适应复杂的动态变化。在动态环境中，轨迹规划问题的复杂性是路径规划在静态环境中的推广，其求解比静态环境中的路径规划更难，通常需要考虑问题的可解性。轨迹规划问题可以转换为路径规划问题，解决此类路径规划问题的方法是使用可以处理微分约束的路径规划算法，并将其转换为轨迹形式。 3.数值方法路径规划的数值方法大致分为三类： ①变分方法，将路径表示为由有限维向量参数化的函数，并通过使用非线性连续优化技术来优化向量参数来寻找最优路径。 ②图搜索方法，将机器人的配置空间离散化为一张图，并在图中搜索最小成本路径来求解问题，其中顶点代表有限集合的机器人配置，边代表顶点之间的转换。 ③增量搜索方法，对配置空间进行采样，并逐步构建一张可达性图（通常是树结构），该图维护一组离散的可达配置及它们之间的可行转换。与图搜索方法相比，基于采样的方法逐步增加图的大小，直到在图中找到一个满意的解决方案。二．基于强化学习的规划与控制强化学习（Reinforcement Learning，RL）通过与环境的持续互动，使得智能体能够在动态和复杂的情境中逐步优化其决策和行为。强化学习的关键特征是学习过程与环境的互动。强化学习是智能体通过采取行动、感知状态和获取奖励，与环境进行迭代交互的过程。应用案例强化学习在行为决策、运动规划和反馈控制等多个层次上都得到应用。书中以自动驾驶车辆为例进行了论述。端到端解决方案：基于深度神经网络的监督学习方法用于自动驾驶，输入是原始传感器数据，如图像像素；输出是直接控制信号，如转向、油门和制动。基于强化学习的规划与控制方法，重点关注以下几个方面：问题范围、状态空间设计、动作空间设计、网络结构设计及应用约束。 1.行为决策中的强化学习行为决策中应用强化学习的主要目的是应对高度多样化的交通场景。工业界的主流方法：将人类驾驶经验作为教授强化学习系统做出更人性化决策的优秀示例，以此补充基于规则的行为决策方法。强化学习应用于行为决策，其动作空间定义为：其中，是自动驾驶车辆的目标速度，是一组离散的横向车道位置，分别代表对其它障碍车辆的让行、超车和保持距离（推挤/注意）。状态空间则包含从传感器信息解释生成的车辆周围的“环境模型”，以及任何其它有用的信息，如前一帧的运动物体的运动学信息。 2.规划与控制中的强化学习基于强化学习的规划与控制的关键挑战是如何设计状态空间。运动规划与反馈控制的计算，需要自动驾驶车辆与环境的信息。由于包含了环境信息的状态空间是一个庞大的多维连续空间，书中提到了单元映射技术，将其与强化学习结合来解决自动驾驶车辆的控制问题。状态空间（在单元映射之前）与动作空间示例，见下图：单元映射技术用相邻属性作为状态转移的约束条件对状态空间进行离散化。主要特点包括： ①由于使用相邻属性显著缩小了实际状态空间，这种方法不使用神经网络结构进行强化学习。 ②使用两个状态-行动对表：Q表和模型表，Q表与传统强化学习的意义相同，模型表维护满足D-k相邻属性的局部转换的平均值，来近似表示最优控制策略。书中给出了控制相邻单元映射算法CACM-RL，如下：上面两个例子的动作空间未定制到特定场景，作者提到了基于循环神经网络（RNN）的方法专门处理两种特殊情况的控制问题：自适应巡航控制（ACC）和合并进入交通环岛。并在此基础上，为了普遍适用，提出：预测可预测的近期未来并学习不可预测的环境。这种提法，主要过程如下：将问题分为两个阶段，第一个阶段：学习一个可微分函数，将当前状态和动作映射到下一个状态，学习到的函数是近期未来的预测器；定义一个从状态空间到动作空间的策略函数，其中是一个RNN。下一个状态定义为，其中表示不可预测的环境。第二个阶段：通过反向传播学习的参数。由于表示环境的不可预测性，这种RNN方法具有鲁棒性。三．相关分析与实现（依托AI） 1.基于变分方法实现路径规划的程序，如下： import torch import numpy as np # Environment dimensions N = 20 # number of cells in each dimension dx = 0.1 # cell size (meters) # Define the grid grid = torch.zeros((N, N)) # Set obstacles (walls) in the grid for i in range(N): for j in range(N): if i < N // 2: # left half of the grid is obstacle-free grid[i, j] = -1 # obstacle (wall) elif i >= N // 2 and i < N - 5: # middle section has a narrow path grid[i, j] = 0 # free space # Define start and goal points start = torch.tensor([N // 4, N // 4], dtype=torch.float) goal = torch.tensor([3 * N // 4, 3 * N // 4], dtype=torch.float) print("Environment setup complete!") ''' **Variational method implementation** The variational method is a probabilistic approach that uses a latent variable `z` to model the uncertainty in the path planning problem. We'll use a simple Gaussian distribution for `z`. ''' import torch.nn as nn import torch.distributions as dist class PathPlanner(nn.Module): def __init__(self, N): super(PathPlanner, self).__init__() self.N = N self.z_dim = 2 # dimensionality of the latent variable z self.eta = 0.1 # learning rate self.z_mean = nn.Parameter(torch.zeros(self.z_dim)) self.z_logstd = nn.Parameter(torch.ones(self.z_dim)) def forward(self, start): z = dist.Normal(self.z_mean, torch.exp(self.z_logstd)).sample() path = [] # store the path points for t in range(N): # iterate through time steps (cells) x_t = start + t * dx z_t = z + dist.Normal(torch.zeros(2), self.eta).sample() if grid[int(z_t[0]), int(z_t[1])] > 0: # is the cell free? path.append(x_t) # add the point to the path return torch.stack(path) ''' **Training and evaluation** We'll use a simple loss function (mean squared error between the planned path and the goal point) and train the model using stochastic gradient descent. ''' # Train the model planner = PathPlanner(N) optimizer = torch.optim.SGD(planner.parameters(), lr=0.01) for epoch in range(100): optimizer.zero_grad() path = planner(start) loss = torch.mean((path - goal) ** 2) loss.backward() optimizer.step() print("Training complete!") # Evaluate the planned path path = planner(start) print(f"Planned path: {path}") 2.基于图搜索方法实现路径规划的程序，如下： import torch import numpy as np # Environment dimensions N = 20 # number of cells in each dimension dx = 0.1 # cell size (meters) # Define the grid grid = torch.zeros((N, N)) # Set obstacles (walls) in the grid for i in range(N): for j in range(N): if i < N // 2: # left half of the grid is obstacle-free grid[i, j] = -1 # obstacle (wall) elif i >= N // 2 and i < N - 5: # middle section has a narrow path grid[i, j] = 0 # free space # Define start and goal points start = torch.tensor([N // 4, N // 4], dtype=torch.float) goal = torch.tensor([3 * N // 4, 3 * N // 4], dtype=torch.float) print("Environment setup complete!") ''' **Graph search implementation** We'll use PyTorch's `torch.nn` module to define a simple graph neural network (GNN) that performs the graph search. We'll use Dijkstra's algorithm as our graph search method. ''' import torch.nn as nn class GraphSearch(nn.Module): def __init__(self, N): super(GraphSearch, self).__init__() self.N = N self.V = 2 # number of nodes in the graph (start and goal) self.edges = [] # store the edges in the graph for i in range(N): for j in range(N): if grid[i, j] > 0: # is this cell free? self.edges.append((i * N + j, i * N + (j - 1) % N)) # left edge self.edges.append((i * N + j, i * N + (j + 1) % N)) # right edge def forward(self): # Initialize the graph distances and predecessors dist = torch.zeros(self.V) pred = torch.zeros(self.V) # Run Dijkstra's algorithm for _ in range(self.N): # Find the node with the smallest distance that has not been visited yet node_idx = torch.argmin(dist[dist != 0]) if dist[node_idx] == 0: break # Update the distances and predecessors of neighboring nodes for edge in self.edges: neighbor_idx = edge[1] if dist[neighbor_idx] > dist[node_idx] + 1: dist[neighbor_idx] = dist[node_idx] + 1 pred[neighbor_idx] = node_idx # Reconstruct the shortest path from start to goal path = [] current_node = int(goal[0] * N + goal[1]) while current_node != int(start[0] * N + start[1]): path.append(current_node) current_node = pred[current_node] path.append(int(start[0] * N + start[1])) return torch.tensor(path[::-1]) ''' **Training and evaluation** We'll use a simple loss function (mean squared error between the planned path and the goal point) and train the model using stochastic gradient descent. ''' # Train the model graph_search = GraphSearch(N) optimizer = torch.optim.SGD(graph_search.parameters(), lr=0.01) for epoch in range(100): optimizer.zero_grad() path = graph_search.forward() loss = torch.mean((path - goal) ** 2) loss.backward() optimizer.step() print("Training complete!") # Evaluate the planned path path = graph_search.forward() print(f"Planned path: {path}") 3.基于增量搜索方法实现路径规划的程序，如下： import torch import numpy as np # Environment dimensions N = 20 # number of cells in each dimension dx = 0.1 # cell size (meters) # Define the grid grid = torch.zeros((N, N)) # Set obstacles (walls) in the grid for i in range(N): for j in range(N): if i < N // 2: # left half of the grid is obstacle-free grid[i, j] = -1 # obstacle (wall) elif i >= N // 2 and i < N - 5: # middle section has a narrow path grid[i, j] = 0 # free space # Define start and goal points start = torch.tensor([N // 4, N // 4], dtype=torch.float) goal = torch.tensor([3 * N // 4, 3 * N // 4], dtype=torch.float) print("Environment setup complete!") ''' **Incremental search implementation** We'll use PyTorch's `torch.nn` module to define a simple neural network that performs the incremental search. We'll use the A\* algorithm as our search method. ''' import torch.nn as nn class IncrementalSearch(nn.Module): def __init__(self, N): super(IncrementalSearch, self).__init__() self.N = N self.V = 2 # number of nodes in the graph (start and goal) self.edges = [] # store the edges in the graph for i in range(N): for j in range(N): if grid[i, j] > 0: # is this cell free? self.edges.append((i * N + j, i * N + (j - 1) % N)) # left edge self.edges.append((i * N + j, i * N + (j + 1) % N)) # right edge def forward(self): # Initialize the graph distances and predecessors dist = torch.zeros(self.V) pred = torch.zeros(self.V) # Run A\* algorithm for _ in range(self.N): # Find the node with the smallest distance that has not been visited yet node_idx = torch.argmin(dist[dist != 0]) if dist[node_idx] == 0: break # Update the distances and predecessors of neighboring nodes for edge in self.edges: neighbor_idx = edge[1] if dist[neighbor_idx] > dist[node_idx] + 1: dist[neighbor_idx] = dist[node_idx] + 1 pred[neighbor_idx] = node_idx # Reconstruct the shortest path from start to goal path = [] current_node = int(goal[0] * N + goal[1]) while current_node != int(start[0] * N + start[1]): path.append(current_node) current_node = pred[current_node] path.append(int(start[0] * N + start[1])) return torch.tensor(path[::-1]) ''' **Training and evaluation** We'll use a simple loss function (mean squared error between the planned path and the goal point) and train the model using stochastic gradient descent. ''' # Train the model incremental_search = IncrementalSearch(N) optimizer = torch.optim.SGD(incremental_search.parameters(), lr=0.01) for epoch in range(100): optimizer.zero_grad() path = incremental_search.forward() loss = torch.mean((path - goal) ** 2) loss.backward() optimizer.step() print("Training complete!") # Evaluate the planned path path = incremental_search.forward() print(f"Planned path: {path}") 综合之上的过程，可以看出路径规划的数值方法可以依托AI大模型给出AI实现代码，这对于具身智能机器人在路径规划与控制系统中应用软件栈提供了技术支持。
回复了主题帖：《具身智能机器人系统》阅读分享-定位系统

oxlm_1 发表于 2025-3-5 19:17 问题就在这，为啥机器人要求那么高的精度，而人就不需要那么高的精度？机器人算法中反复强调多少平方的范 ... 这个问题提的好，人是具有创造性的，而且善于创造和使用工具，比如显微镜、放大镜、望远镜等，当然还有很多，这些工具扩展了人与环境交互的能力，同样，具身智能机器人也可以说是人类创造的一类具有扩展能力的“工具”，尤其是具身特点、智能特点等都极大程度的扩充了人的本体能力。
回复了主题帖：《具身智能机器人系统》阅读分享-书籍概览

本帖最后由 ljg2np 于 2025-3-5 10:28 编辑推荐阅读：从机器人系统开发，看具身智能（链接一）从机器人系统开发，看具身智能（链接二）
回复了主题帖：《具身智能机器人系统》阅读分享-定位系统

oxlm_1 发表于 2025-3-5 08:53 有个问题，为啥机器人要关心全局坐标系？貌似人几乎不会考虑自己在空间的哪个位置（也就头脑中有个大致 ... 这涉及到与环境的交互，可以进一步提高对机器人的定位精度，这也就是传感器空间融合要做的事情。
回复了主题帖：《具身智能机器人系统》阅读分享-定位系统

Jacktang 发表于 2025-3-5 07:30 影响机器人的定位精度主要因素是哪些呢首先是传感器的精度，书中着重说了多传感器的融合可以进一步提高定位精度；当然，定位中观测方程和运动方程的求解算法也会对机器人的定位精度产生影响。
2025-03-04
回复了主题帖：《具身智能机器人系统》阅读笔记 vol. 1 - 具身智能背景知识

感觉书中作者对机器人的常规系统组成进行了介绍，更多的还是侧重对具身智能机器人系统在AI大模型影响下的发展方向与涉及技术的论述。
2025-03-03
发表了主题帖：《具身智能机器人系统》阅读分享-定位系统

本帖最后由 ljg2np 于 2025-3-4 16:07 编辑本文分享对书中具身智能机器人基础模块这部分中定位系统内容的阅读理解。定位系统计算机器人在其运行环境中的位置和朝向，是实现自主导航的必要、核心功能。下面介绍机器人定位中的基本问题、主要解决方法和系统设计中需要考虑的因素。一．定位系统基本原理 1.定位概述机器人定位的本质是基于内感受型和外感受型传感器的数据，通过建立机器人自身状态与环境物体间关系和机器人的运动方程，精准的估计机器人自身的状态。具身智能机器人要实现自主探索和导航，需要确定自身在运行环境中的位置和朝向，确定运动目标和环境中障碍物的位置，才能确定当前位置到目标位置的导航路径。为了确定机器人自身位置和环境中物体与机器人的相对关系，需要建立两个坐标系统：机器人坐标系和全局坐标系，如图所示。自主机器人的定位系统，需要精准地计算机器人的本体坐标系在全局坐标系中的位置和朝向。现代自主机器人采用多传感器融合定位的方法获取精准的位置和朝向信息。 ①利用GNSS或IMU，获得位置测量或推算机器人的相对位移。 ②利用摄像头或激光雷达，获取机器人与周围环境物体之间的距离信息，然后反推出机器人的相对运动和位置。自主机器人采用卡尔曼滤波和最大后验估计等方法融合多传感器的测量和计算结果，降低噪声影响，综合优化机器人的位置和运动状态信息，最终得出精准的定位信息。 2.定位任务定位任务的本质是对机器人自身状态的估计问题，包括位置、朝向、速度等状态。机器人自主导航的原理和状态估计在自主导航中的作用，如下图所示：机器人的状态估计和运动控制是机器人自主导航的两大支柱技术。机器人的定位地图，是一系列传感器检测到的三维空间静态物体的特征点或路标点。在计算机视觉和机器人领域，路标点是指环境中具有独特且易于识别特征的点，这些点为机器人定位系统提供参考点，使其能够确定自身相对于环境的位置和方向。在地图未知的定位问题中，机器人需要维护一份定位或者推断机器人连续运动的特征地图。在各类机器人产品中，SLAM系统和定位系统发挥着不同的作用。SLAM系统用于机器人的离线建图，定位系统借助离线构建的地图和传感器的数据，实时给出机器人的位置和朝向。建图没有实时性要求，可以离线进行；定位有很强的实时性要求，只能在当前时刻前的环境数据和控制指令上进行计算。 3.定位原理按使用的环境感知传感器分类，机器人定位一般分为视觉定位和激光雷达定位。（书中没有考虑超声波定位方式，例如蝙蝠的声波定位）多传感器融合定位算法：对摄像头或激光雷达等传感器数据进行特征提取与跟踪，获取路标点的观测与位置关系，建立传感器的观测方程；根据IMU的数据推算机器人的相对运动，建立机器人的运动方程；根据观测方程和运动方程估计机器人的状态。多传感器融合算法可以有效地提升机器人定位的准确性和稳定性。 ①根据传感器建立观测和运动方程内感受型传感器，测量机器人本体的运动数据，如IMU和轮式编码器。IMU是一种集成了加速度计和陀螺仪的传感器。外感受型传感器，测量机器人运行环境的信息和状态，如摄像头、激光雷达等传感器。 ②机器人定位中的状态估计基于贝叶斯滤波的机器人定位，是通过用机器人的初始状态和传感器的观测历史来计算机器人当前状态的概率密度分布函数，从而得到机器人在各个状态下的概率值。基于最大后验估计的机器人定位，基本思想是从最优化的角度来求解定位问题。 4.定位计算高精度和稳定的定位系统，需要融合多类传感器的观测，以降低单类传感器噪声或者暂时缺失的影响。多传感器数据对齐传感器的空间对齐，也称传感器的外参标定，指的是获得传感器与机器人间的位置关系，把布置在机器人上不同位置的传感器采集的数据映射到机器人的坐标系中。多传感器的空间对齐通过多传感器标定算法实现。传感器标定算法的本质是状态估计问题，将传感器间的相对关系设计成待估计的状态变量，建立观测和运动方程进行估计。传感器的时间对齐，也称传感器数据同步，指的是多传感器的数据有统一的时间系统，多传感器能够在同一时刻采集数据，并且时间系统能够精准地记录传感器采集数据的时间。传感器数据时间对齐的质量对机器人的定位精度影响非常大。机器人计算系统实现多传感器时间的严格同步十分困难，主要原因有： ①触发条件不一致。 ②采集频率不同。 ③数据采集机制复杂。机器人计算系统需要根据其配置传感器的特性和工作机制，设计软硬件系统，实现多传感器时间对齐。满足机器人定位需求的时间同步系统应具有以下特点： ①使用硬件产生触发物理信号，同时触发外部传感器。 ②计算系统使用统一的定时器和时间系统，产生触发信号和时间戳。 ③在传感器内部给采集的数据打时间戳，不支持内部打时间戳的情况，则在传感器接口处打时间戳。定位硬件平台定位计算系统需要在功耗、性能和计算资源的约束下实现满足应用要求的定位算法。根据使用场景、系统尺寸、成本和供电方式等因素，自主机器人会配备与应用场景、尺寸和供电约束相匹配的传感器和计算平台。嵌入式SoC、FPGA和专用芯片是工业界和学术界常用的定位算法实现平台。嵌入式SoC芯片集成了CPU、DSP、和GPU，在其上实现和优化定位算法，要分析和评估定位算法中各模块的特点和性能，使用在能耗和吞吐率等指标上计算效率高的硬件，达到算法加速和高效计算的目的。目前，工业界普遍使用嵌入式SoC芯片的方案实现机器人定位算法，用SoC的DSP进行多传感器数据的处理，如滤波和特征提取，用SoC的CPU实现状态估计算法，如卡尔曼滤波或最大后验估计算法。 SoC嵌入式系统用软件实现机器人定位算法在功耗和计算延时方面没有硬件的实现效率高，相比于嵌入式SoC的实现，FPGA的定位系统在计算延时、吞吐率和功耗方面有显著的提升。二．相关实现与分析（依托AI） 1.采用AI得到多传感器空间对齐的程序，如下： import torch from torch.utils.data import Dataset ''' Step 1: Data Preparation First, let's prepare the data for training. We'll create a dataset class that loads the GPS and IMU measurements. ''' class SensorData(Dataset): def __init__(self, gps_data, imu_data): self.gps_data = gps_data self.imu_data = imu_data def __len__(self): return len(self.gps_data) def __getitem__(self, idx): gps_meas = self.gps_data[idx] imu_meas = self.imu_data[idx] # Convert IMU data to a useful format (e.g., Euler angles) imu_meas['orientation'] = torch.tensor([imu_meas['roll'], imu_meas['pitch'], imu_meas['yaw']]) imu_meas['acceleration'] = torch.tensor([imu_meas['ax'], imu_meas['ay'], imu_meas['az']]) return {'gps': gps_meas, 'imu': imu_meas} ''' Step 2: Network Architecture Next, let's define a neural network that takes the GPS and IMU measurements as input and predicts the aligned position and orientation in space. ''' import torch.nn as nn class SensorFusionNetwork(nn.Module): def __init__(self): super(SensorFusionNetwork, self).__init__() # Define the network architecture: # 1. GPS branch: feedforward network with two hidden layers self.gps_branch = nn.Sequential( nn.Linear(3, 64), # input (x, y, z) -> hidden layer 1 (64 units) nn.ReLU(), nn.Linear(64, 32), # hidden layer 1 -> hidden layer 2 (32 units) nn.ReLU() ) # 2. IMU branch: feedforward network with two hidden layers self.imu_branch = nn.Sequential( nn.Linear(6, 128), # input (roll, pitch, yaw, ax, ay, az) -> hidden layer 1 (128 units) nn.ReLU(), nn.Linear(128, 64), # hidden layer 1 -> hidden layer 2 (64 units) nn.ReLU() ) # 3. Fusion layer: concatenate GPS and IMU outputs self.fusion_layer = nn.Sequential( nn.Linear(32 + 64, 128), # input (GPS) + (IMU) -> hidden layer 1 (128 units) nn.ReLU(), nn.Linear(128, 3) # final output: aligned position (x, y, z) ) def forward(self, gps_meas, imu_meas): # GPS branch gps_output = self.gps_branch(gps_meas['gps']) # IMU branch imu_output = self.imu_branch(imu_meas['imu']) # Fusion layer fusion_output = self.fusion_layer(torch.cat((gps_output, imu_output), dim=1)) return fusion_output ''' Step 3: Training Now that we have the network architecture defined, let's train it on our dataset. ''' # Create a dataset instance dataset = SensorData(gps_data, imu_data) # Define the training hyperparameters batch_size = 32 epochs = 100 # Initialize the model and optimizer model = SensorFusionNetwork() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) for epoch in range(epochs): for batch_idx, (gps_batch, imu_batch) in enumerate(dataset): # Forward pass output = model(gps_batch['gps'], imu_batch['imu']) # Loss calculation loss = torch.mean((output - gps_batch['gps']) ** 2) # Backward pass and optimization optimizer.zero_grad() loss.backward() optimizer.step() print(f'Epoch {epoch+1}, Loss: {loss.item()}') ''' Step 4: Evaluation Once the model is trained, we can evaluate its performance on a test dataset. ''' # Evaluate the model on a test set test_loss = 0 for batch_idx, (gps_batch, imu_batch) in enumerate(test_dataset): output = model(gps_batch['gps'], imu_batch['imu']) loss = torch.mean((output - gps_batch['gps']) ** 2) test_loss += loss.item() print(f'Test Loss: {test_loss / len(test_dataset)}') 2.采用AI得到多传感器时间对齐的程序，如下： ''' Step 1: Data Preparation First, let's prepare the data for training. We'll create a dataset class that loads the measurements from each sensor. ''' import torch from torch.utils.data import Dataset class SensorData(Dataset): def __init__(self, gps_data, imu_data, camera_data): self.gps_data = gps_data self.imu_data = imu_data self.camera_data = camera_data def __len__(self): return len(self.gps_data) def __getitem__(self, idx): gps_meas = self.gps_data[idx] imu_meas = self.imu_data[idx] camera_meas = self.camera_data[idx] # Convert IMU data to a useful format (e.g., Euler angles) imu_meas['orientation'] = torch.tensor([imu_meas['roll'], imu_meas['pitch'], imu_meas['yaw']]) imu_meas['acceleration'] = torch.tensor([imu_meas['ax'], imu_meas['ay'], imu_meas['az']]) return {'gps': gps_meas, 'imu': imu_meas, 'camera': camera_meas} ''' Step 2: Network Architecture Next, let's define a neural network that takes the measurements from each sensor as input and predicts the aligned timestamps. ''' import torch.nn as nn class SensorFusionNetwork(nn.Module): def __init__(self): super(SensorFusionNetwork, self).__init__() # Define the network architecture: # 1. GPS branch: feedforward network with two hidden layers self.gps_branch = nn.Sequential( nn.Linear(4, 64), # input (x, y, z, t) -> hidden layer 1 (64 units) nn.ReLU(), nn.Linear(64, 32), # hidden layer 1 -> hidden layer 2 (32 units) nn.ReLU() ) # 2. IMU branch: feedforward network with two hidden layers self.imu_branch = nn.Sequential( nn.Linear(7, 128), # input (roll, pitch, yaw, ax, ay, az, t) -> hidden layer 1 (128 units) nn.ReLU(), nn.Linear(128, 64), # hidden layer 1 -> hidden layer 2 (64 units) nn.ReLU() ) # 3. Camera branch: feedforward network with two hidden layers self.camera_branch = nn.Sequential( nn.Linear(5, 128), # input (SIFT/ORB features, t) -> hidden layer 1 (128 units) nn.ReLU(), nn.Linear(128, 64), # hidden layer 1 -> hidden layer 2 (64 units) nn.ReLU() ) # 4. Fusion layer: concatenate GPS, IMU, and Camera outputs self.fusion_layer = nn.Sequential( nn.Linear(32 + 64 + 64, 128), # input (GPS) + (IMU) + (Camera) -> hidden layer 1 (128 units) nn.ReLU(), nn.Linear(128, 3) # final output: aligned timestamps ) def forward(self, gps_meas, imu_meas, camera_meas): # GPS branch gps_output = self.gps_branch(gps_meas['gps']) # IMU branch imu_output = self.imu_branch(imu_meas['imu']) # Camera branch camera_output = self.camera_branch(camera_meas['camera']) # Fusion layer output = torch.cat((gps_output, imu_output, camera_output), dim=1) output = self.fusion_layer(output) return output ''' Step 3: Training and Evaluation We'll train the network using a loss function that measures the difference between the predicted timestamps and the ground truth timestamps. We'll use mean squared error (MSE) as our loss function. ''' criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) for epoch in range(100): for batch in dataset: gps_meas, imu_meas, camera_meas = batch output = model(gps_meas, imu_meas, camera_meas) loss = criterion(output, gt_timestamps) optimizer.zero_grad() loss.backward() optimizer.step() print('Test Loss:', criterion(model(*dataset[0]).unsqueeze(0), gt_timestamps).item()) 综合之上的过程，可以看出用于传感器对齐操作的AI学习代码依然是两段式：训练+应用模式，据此依托AI在定位系统中建立实现多传感器对齐操作（定位系统）的软件栈，这对于具身智能机器人定位系统架构的发展提供了有力的支持。
回复了主题帖：关于上升沿死区和下降沿死区和高有效

实际中的波形一般不是理想的矩形波形，所谓的死区应该是指实际波形投射到理想波形使能点引发的区间，不了解具体内容，供参考。
回复了主题帖：《具身智能机器人系统》阅读分享-感知系统

Jacktang 发表于 2025-3-3 07:32 按图4.21流程看不同时间戳中创建相同物体的关联看，还挺复杂它是引入了注意力机制，然后对历史帧和当前帧通过在BEV空间查询并匹配，由此实现物体的关联，其中也采用了归一化与残差和等措施实现对信号的对齐和补偿。
2025-03-02
回复了主题帖：具身智能机器人系统阅读分享一

Jacktang 发表于 2025-3-2 09:32 大模型的缺点中生成命令不合理难以控制，怎么理解大模型的缺点中生成命令不合理难以控制的问题，我觉得可以通过设计环境上下文，并引入回馈机制来降低此类问题，就好比“困惑”这个词在人类沟通中产生的现象一样。