物理 AI 实战：使用 Synaptics Astra® SL2610 实现机械臂自主操作

2026年9月10日 · 阅读需 23 分钟

Nicholas Christoffersen

Embedded AI @ Synaptics

本指南介绍完整的端到端流程：教会一台低成本机械臂完成抓取与放置任务，然后在 Synaptics Astra SL2610 系列开发套件上运行视觉与电机控制策略——推理时无需云端、无需 GPU、无需主机 PC。 这是物理 AI（Physical AI）的一个实践示例：模型在真实世界中感知并行动，且完全在设备端运行。

视频 1：基于 Astra SL2619 的自主抓取与放置——无需云端、无需 PC、无需 GPU

硬件

开源 SO-101 机械臂
Synaptics Astra Machina™ SL2610 或 Synaptics Coralboard™ SL 2GB

模型 / 策略

我们使用 Action Chunking with Transformers（ACT），这是一种轻量级模仿学习策略，也是在 SO-101 等机械臂上测试简单操作任务的标准首选方案。

每次推理的输入为：

每个摄像头的一帧图像
机器人 6 个电机的位置

然后预测接下来的 100 个电机位置——即一个"动作块"（action chunk），在 30 Hz 下约为 3.3 秒的运动。一次输出一整块动作而不是单个动作，使策略具有前瞻的时间范围：它会把一个动作执行到底，而不是每一步都重新决策、在原地犹豫不前。这也意味着策略每秒只需重新规划几次，而不必在每个 33 ms 的控制周期都进行规划，因此在下一次推理（在开发板上约 320 ms）仍在进行时，机械臂也能保持平稳运动——并且为异步重新规划提供了可能，我们将在第 6 步中使用这一点。

ACT 策略由两部分组成：

每个摄像头对应一个 ResNet-18 主干网络：320×240 帧 → 特征向量
一个小型 Transformer（4 个编码器层、1 个解码器层）：图像特征 + 编码后的电机位置 → 动作块

软件

训练 / 控制
- LeRobot
模型编译
- Torq™ 编译器
运行环境
- 基于 Yocto Project 的 Astra SDK Linux

测试环境

主机：x86-64 Ubuntu 24.04、Python 3.12、lerobot==0.6.1
主机和开发板均使用 uv 0.12.13
Torq v2.2.0 编译器和运行时 wheel 包，torq-tools @ d605a4d
开发板：Astra Machina SL2619，Astra SDK 镜像 sl2619_scarthgap_6.12_v2.5.0，由 uv 管理的 Python 3.12
示例脚本：sl2610-act-example

性能

在 NPU 上运行的模型（数据类型：bf16）：

推理时间：约 320 ms，比 CPU 快约 6 倍[1]
关节精度：低于 1 度（与 fp32 参考相比，每个关节的平均误差为 0.08°）

整体流程

准备硬件
录制示教数据——约 1 小时，50 个回合
训练模型（ACT）——在 GPU 上需要几个小时
熟悉 Torq AI 平台——约 30 分钟
为 Torq NPU 编译模型——只需几条命令
在开发板上运行——以 30 Hz 实时运行
进一步提速——将在本博客的第二部分介绍！

第 1–3 步是标准的 LeRobot 流程。如果你之前训练过 SO-101 策略，可以直接跳到第 4 步。

第 4–6 步是新内容。它们介绍如何将 PyTorch 策略快速运行在 Synaptics Astra 上。第 4 步介绍工具链；第 5–6 步让策略在开发板上运行起来。

1. 准备硬件

物品	说明
SO-101 机械臂（从动臂 + 主动臂）	3D 打印件 + 模型舵机。可以自行打印，也可以购买套件。从动臂（follower）负责执行任务；主动臂（leader）是你用来示教的"木偶"。
2 个 USB 摄像头	一个腕部摄像头（安装在夹爪上）+ 一个顶部/全局摄像头。请选择原生输出 QVGA（320×240）MJPG 的摄像头——参见下方说明。
Synaptics Astra Machina SL2610（或 Synaptics Coralboard™ SL 2GB）	运行推理的开发板，搭载我们所使用的 NPU。
开发系统（仅用于训练）	现代 CPU + GPU 组合可在一小时内完成训练（在 AMD Ryzen 9 5900X + Nvidia 5060 Ti 上 <30 分钟）。

选择原生 QVGA 摄像头

我们发现 QVGA 分辨率足以完成简单的抓取与放置任务，并能显著提升模型速度。优先选择输出压缩 MJPG 流的摄像头：两个摄像头共享一条 USB 2.0 总线，两路未压缩（YUYV）视频流可能会超出 USB 带宽，尤其是在 VGA 分辨率下。仅支持 VGA（640×480）的摄像头也可以使用，只需在预处理步骤中将图像缩小到 QVGA。但是，如果进行了任何图像预处理，训练和推理时必须保持一致。

关于 GPU

较旧或较小的显卡（例如 GTX 1060）也能训练，只是速度较慢。如果你的训练 GPU 性能一般，可以减少 --steps（根据我们的经验，一个示教良好的单一任务在 5-30K 步内即可收敛），或按小时租用云 GPU。 LeRobot 也可以在 Apple Silicon（mps）上运行。

按照 SO-101 ARM Github 和 LeRobot SO-101 指南组装机械臂，并在你的笔记本电脑上安装 LeRobot。 SO-101 使用 Feetech 舵机，因此除了机器人工作流和训练相关的扩展包外，还需要安装该扩展包——仅执行 pip install lerobot 会缺少电机和命令行工具的依赖：

# uv is much faster at the dependency resolver than native pip; install the pinned version
# (other install methods: https://docs.astral.sh/uv/#installation)
curl -LsSf https://astral.sh/uv/0.12.13/install.sh | sh
source $HOME/.local/bin/env   # put uv on PATH in this shell
uv venv -p 3.12 venv_lerobot   # lerobot 0.6.1 requires Python >= 3.12
source venv_lerobot/bin/activate
uv pip install 'lerobot[feetech,core_scripts,training]==0.6.1'
# feetech      → SO-101 servo driver + serial deps
# core_scripts → lerobot-record / -replay / -calibrate / -teleoperate
# training     → lerobot-train (+ wandb, accelerate)

找到电机端口并尝试遥操作机器人——如果你尚未校准，它会自动引导你完成校准：

lerobot-find-port                         # tells you which /dev/ttyACM* is which
lerobot-teleoperate \
  --robot.type=so101_follower --robot.port=<FOLLOWER_PORT> --robot.id=my_follower \
  --teleop.type=so101_leader --teleop.port=<LEADER_PORT> --teleop.id=my_leader

如果遥操作命令因端口权限错误而失败，请将自己加入拥有串口设备的用户组：

sudo usermod -aG dialout $USER   # Ubuntu/Debian; on Arch the group is uucp

注销并重新登录使更改生效，然后重试。

备注

请保留从动臂的校准文件；之后开发板需要使用完全相同的校准文件，以确保策略输出的关节角度能正确映射到实际电机。

2. 录制示教数据

视频 2：通过模仿教会策略

你通过亲自完成任务来教策略：用手移动主动臂，从动臂会同步跟随，两个摄像头的画面和所有关节角度都会被记录下来。这就是模仿学习：没有奖励函数，没有仿真，只需向它展示什么是"好"的操作。详细说明请参见 LeRobot 模仿学习指南。

首先确认哪些摄像头是你的：

lerobot-find-cameras

然后开始录制回合：

# to push your dataset to the Hugging Face Hub (the hf CLI comes with lerobot)
hf auth login

lerobot-record \
  --robot.type=so101_follower --robot.port=<FOLLOWER_PORT> --robot.id=my_follower \
  --teleop.type=so101_leader  --teleop.port=<LEADER_PORT>  --teleop.id=my_leader \
  --robot.cameras="{ wrist: {type: opencv, index_or_path: 0, width: 320, height: 240, fps: 30, fourcc: MJPG},
                     top:   {type: opencv, index_or_path: 2, width: 320, height: 240, fps: 30, fourcc: MJPG} }" \
  --dataset.repo_id=<HF_USERNAME>/pick_place_demo \
  --dataset.push_to_hub=true \
  --dataset.single_task="Pick up the block and place it in the bin" \
  --dataset.num_episodes=50

fourcc: MJPG

请求摄像头输出压缩的 MJPG 流，请查阅你所用摄像头支持的分辨率/格式组合。

真正重要的技巧：

每个回合都改变物体的起始位置。 完成任务的方式保持一致、物体起始位置保持多样，这才能让策略更加稳健。
对于简单任务，约 50 个回合就足够了——例如放置位置固定、抓取位置变化。对于更复杂的任务（例如抓取和放置位置都变化），如果无法很快获得良好的结果，请考虑收集更多数据。
QVGA（320×240）是刻意为之。 小尺寸图像能让模型保持小巧、让开发板运行更快。抓一个方块并不需要 1080p。
数据集会自动上传到 Hugging Face Hub（通常带有时间戳）；可以使用 Hugging Face 上的"visualize dataset"工具查看各回合（强烈推荐）。

3. 训练模型

我们训练一个 ACT（Action Chunking with Transformers）策略：一个 ResNet-18 图像主干网络（两个摄像头共享）为一个小型 Transformer（4 个编码器层 + 1 个解码器层）提供特征，后者一次性预测一个包含未来关节动作的 100 步动作块。它通常是在新机器人上使用的第一个"概念验证"模型，并且在 LeRobot 中得到一流的支持。

如果你在另一台机器上训练，请在该机器上重复第 1 步中的虚拟环境设置。 training 扩展包已包含 wandb；登录一次即可查看训练统计数据（或去掉 --wandb.enable=true）。

wandb login
lerobot-train \
  --policy.type=act \
  --dataset.repo_id=<HF_USERNAME>/pick_place_demo \
  --policy.repo_id=<HF_USERNAME>/act_pick_place \
  --policy.push_to_hub=true \
  --dataset.eval_split=0.10 \
  --eval_steps=1000 \
  --batch_size=8 \
  --wandb.enable=true --wandb.disable_artifact=true \
  --steps=20000

我们沿用了 LeRobot（v0.6.1）提供的默认参数：dim_model=512、n_heads=8、dim_feedforward=3200、chunk_size=100、使用 ImageNet 权重的 ResNet-18 主干网络、use_vae=true。上述命令会将最后 10% 的录制回合留作评估回合。我们发现训练 5-20K 步效果最佳。在单张 NVIDIA 5060 Ti 16 GB 上，训练大约需要 25 分钟。

在使用开发板之前，先确认策略在你的笔记本电脑/台式机上能驱动真实机械臂正常工作，LeRobot 同样让这一步变得简单。

lerobot-rollout \
  --strategy.type=base \
  --policy.path=<HF_USERNAME>/act_pick_place \
  --robot.type=so101_follower --robot.port=<FOLLOWER_PORT> --robot.id=my_follower \
  --robot.cameras="{ wrist: {...}, top: {...} }" \
  --duration=30

如果策略无法完成任务（一个不错的初始目标是 70-90% 的成功率），请使用 HuggingFace 的 visualize dataset 功能检查你的训练数据。可以问自己几个问题：

物体是否在顶部摄像头的视野内？
你是否总是以相同的方式、从相同的角度接近物体？
训练数据是否足够？

如果由笔记本电脑/台式机进行推理时运行良好，说明你已经得到了一个好的策略。现在让它在边缘端运行。

4. 熟悉 Torq AI 平台

从这里开始的所有步骤都通过 Torq 完成，这是 Synaptics 为 Torq NPU 提供的工具链。正是它让"在开发板上运行模型"成为现实。它基于 MLIR / IREE，并在 GitHub 的 synaptics-torq 组织下开源。你无需对厂商的二进制文件进行逆向工程；通过查看各个中间表示（Intermediate Representation）的输出，就能清楚了解模型是如何被逐步降级（lower）的。

有两个关键仓库：

仓库	说明
`torq-compiler`	编译器本身：接收 ONNX/TFLite 模型 → MLIR → Torq NPU 可运行的 `.vmfb` 模块。基于 IREE/MLIR 构建。它还可以模拟硬件，因此无需开发板也能测试编译结果。
`torq-tools`	配套工具箱：模型导出器、数据类型转换（`convert_dtype`，例如 fp32→bf16），以及驱动编译器的胶水代码。"准备模型"的脚本都在这里。

完整文档——安装、快速入门、torq-compile 命令行参考——请参见 Torq 文档。

整个流程的思维模型：

 any trained model (onnx, tflite, etc.)  ──►  MLIR  ──►  Torq (compile)  ──►  .vmfb  ──►  runs on the Torq NPU

我们的 ACT 策略只是可以通过该流程处理的模型之一。本指南的其余部分就是将这一流程应用到我们的机器人上。

5. 为 Torq NPU 编译模型

PyTorch 策略无法直接在 Torq NPU 上运行——它必须被降级为加速器能够理解的 .vmfb 模块，而这正是 Torq 编译器所做的工作。

在 x86-64 Linux 主机上的一个独立虚拟环境中设置 Torq 编译器和 torq-tools（详情请参见 Torq 文档）。 onnx 扩展包提供 ONNX 导入器；torq-tools 提供 torq-cleanup-model。

uv venv -p 3.12 venv_torq
source venv_torq/bin/activate
# torq-tools pulls in torch; the CPU index keeps the CUDA packages out
uv pip install "torq-compiler[onnx] @ https://github.com/synaptics-torq/torq-compiler/releases/download/v2.2.0/torq_compiler-2.2.0-cp312-cp312-manylinux_2_28_x86_64.whl" \
  "torq-tools @ git+https://github.com/synaptics-torq/torq-tools@d605a4d" \
  --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match

从 GitHub 获取两个模型专用的辅助脚本（ONNX 导出和归一化常量），以及第 6 步中用到的开发板脚本：

git clone https://github.com/synaptics-astra-demos/sl2610-act-example.git

# your trained checkpoint: the training run's checkpoints/last/pretrained_model directory,
# or `hf download <HF_USERNAME>/act_pick_place --local-dir act_pick_place`
MODEL_DIR=<path_to_your_trained_checkpoint>

运行流程。每一步都只是一条命令，并且导出之后的所有步骤都与模型无关；任何导出的 ONNX 模型都是这样部署到该硬件上的。在 LeRobot 环境中运行两个辅助脚本；在第 1 步创建的 Torq 虚拟环境中运行其余命令。

为什么导出是唯一与模型相关的步骤

转换本身使用的是 PyTorch 标准、通用的 torch.onnx.export，但它需要一个输入和输出均为普通张量的函数，并且需要知道它们的具体形状。 LeRobot 策略并没有直接提供这样的接口： select_action() 隐藏了 Python 端的控制流（动作块队列），归一化位于单独的前处理/后处理器中，而 VAE 编码器只在训练时存在。因此，导出脚本是一个小型封装，用于选出可部署的子图—— 用两帧 320×240 图像和 6 维状态调用 policy.model，只返回动作块—— 然后交给标准导出器处理。如果换成其他策略——另一种架构，或不同的摄像头配置——只需修改这个封装；下面的其余流程对任何 ONNX 模型都是相同的。

# --- LeRobot env ---
source venv_lerobot/bin/activate
# the ONNX exporter needs these; lerobot doesn't install them
uv pip install 'onnx==1.23.0' 'onnxscript==0.7.2'
# export the trained policy to a single self-contained fp32 ONNX
python sl2610-act-example/build/onnx_01_export.py "$MODEL_DIR" -o act_fp32.onnx
# bake the normalization constants (image/state/action mean-std) the board applies around the model
python sl2610-act-example/build/export_norm_params.py "$MODEL_DIR" norm_params.npz

# --- Torq venv (torq-compile + torq-tools) ---
source venv_torq/bin/activate
# undo the PyTorch->ONNX exporter artifacts (works on any ONNX model):
# merges unrolled per-token Concats back into one op, evaluates constant
# subgraphs offline, and fuses each BatchNorm into the preceding conv.
# --verify re-runs both models and checks the outputs still match.
torq-cleanup-model onnx act_fp32.onnx -o act_clean.onnx --verify

# convert fp32 -> bf16 (fp32 I/O preserved via Cast)
torq-convert-dtype onnx -i act_clean.onnx -o act_bf16.onnx -d bf16

# ONNX -> MLIR -> Torq NPU module
python -m iree.compiler.tools.import_onnx act_bf16.onnx -o act.mlir --data-prop
torq-compile act.mlir -o act_full.vmfb --torq-hw=SL2610 --torq-disable-css --torq-disable-host

这会生成一个 act_full.vmfb（约 70 MB）：包含图像主干网络 + 完整的 Transformer，全部在一个模块中。输入为两路摄像头画面 + 机器人状态；输出为 100 步动作块（main_graph(image_wrist, image_top, state) → [1,100,6]）。

默认流程到此结束——这是一个无需任何变通处理的流程，不需要手动编辑计算图。最终得到一个约 70 MB 的模块，在开发板上以约 320 ms/次推理的速度运行。下一步将介绍如何在开发板上集成该 vmfb 以实现电机控制。

可视化

使用 netron 等可视化工具查看 ONNX 版本的模型也很有帮助。对比原始的 act_fp32.onnx 与 act_clean.onnx，看看清理脚本做了哪些改动！

精度

在 30 帧真实图像上与 fp32 参考对比，bf16 模块在动作块上的相对 L2 误差为 0.46%——每个关节的平均误差低于 0.1°（单个时间步的最大误差为 0.91°）。这完全是 bf16 舍入带来的误差下限；未进行任何精度调优。

6. 在开发板上运行模型

将编译好的模块（vmfb）、归一化常量（npz）和从动臂校准文件（json）推送到开发板，然后运行控制循环。CPU 负责摄像头和电机；Torq NPU 负责推理。

准备开发板（仅需一次）

开发板需要一个包含 LeRobot（电机和摄像头）和 Torq 运行时（在 NPU 上运行 vmfb）的虚拟环境。在开发板上（通过 adb shell 或 ssh；开发板需要联网）：

# from the board
curl -LsSf https://astral.sh/uv/0.12.13/install.sh | sh
source $HOME/.local/bin/env   # put uv on PATH in this shell
# --managed-python: the image's own Python lacks stdlib modules we need
# (fcntl for the motor serial port, statistics for the control loop)
uv venv -p 3.12 --managed-python /home/root/act-venv
source /home/root/act-venv/bin/activate
# the CPU-only torch index keeps uv from pulling in CUDA packages the board can't use
uv pip install --extra-index-url https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match \
  'lerobot[feetech]==0.6.1' 'pyusb==1.3.1' \
  'https://github.com/synaptics-torq/torq-compiler/releases/download/v2.2.0/torq_runtime-2.2.0-cp312-cp312-manylinux_2_28_aarch64.whl'

board_config.sh 中的 BOARD_PY 已经指向该虚拟环境。

电机串口。 开发板镜像中没有 USB 串口内核驱动，因此插入从动臂的电机适配器不会创建 /dev/ttyACM*（lerobot-find-port 也找不到任何设备）。取而代之的是，ch343_pty_bridge.py（随开发板脚本提供）通过 pyusb 在用户空间与适配器通信，并将其暴露为 /dev/ttyFOLLOWER，LeRobot 可以像打开普通串口一样打开它。适配器必须是 CH343（USB id 1a86:55d3）；可在开发板上使用 cat /sys/bus/usb/devices/*/idProduct 进行检查。

备注

然后填写 sl2610-act-example/board/board_config.sh，包括开发板地址（adb 或 user@host）、两个摄像头的设备路径、录制时使用的摄像头旋转（如有）、电机端口，以及从动臂校准文件。

# from the host — deploys over USB (adb) or ssh, per board_config.sh
bash sl2610-act-example/board/deploy_to_board.sh act_full.vmfb norm_params.npz

部署脚本会打印出需要在开发板上执行的具体命令。按以下三个逐步递进的步骤运行——在让机械臂真正运动之前，务必先进行空运行（先执行 source ./board_config.sh 以设置摄像头/电机/校准文件；在开发板的 sh 中 ./ 是必需的）：

cd /home/root/act_run_2cam   # BOARD_DEST from board_config.sh
source ./board_config.sh

# motor serial bridge (once per boot) -> /dev/ttyFOLLOWER
"$BOARD_PY" ch343_pty_bridge.py --link "$MOTOR_PORT" > /tmp/ch343_bridge.log 2>&1 &
sleep 2; cat /tmp/ch343_bridge.log   # expect "BRIDGE UP ... /dev/ttyFOLLOWER"

# 0) seam check — cameras → Torq NPU → action, no motion. Confirms the pipeline is wired right.
"$BOARD_PY" board_probe_2cam.py

# 1) dry run — reads motors, computes targets, moves NOTHING.
"$BOARD_PY" board_act_loop_2cam.py --duration 15 --fps 30

# 2) LIVE — the arm moves. Clear the workspace. Start slow (add --vmax 2.5 for a gentler first run).
"$BOARD_PY" board_act_loop_2cam.py --live --duration 60 --fps 30

控制循环并行运行一个电机线程和一个 Torq NPU 推理线程，持续重新规划动作块（约 2–3 Hz）并融合相互重叠的动作块——这与 LeRobot 使用的异步分块方案相同，只是推理在加速器上而不是 GPU 上进行。

查看模型看到的画面。 添加 --stream-port 8080，然后在主机的浏览器中打开 <Board_IP_Address>:8080（通过 USB 连接时：执行 adb forward tcp:8080 tcp:8080，然后打开 localhost:8080），即可实时查看推理过程中机器人看到的视频画面、电机测量值和动作，以及推理速度。

默认启用安全保护

除非传入 --live，否则控制循环只进行空运行；关节目标被限制在训练数据的范围内；启动时有渐进过程，并且每步有跳变上限（--vmax，默认 5°/步）；按 Ctrl-C 会释放扭矩。首次实际运行时请调低 --vmax。

至此，你已经拥有一台完全在开发板上运行的机器人！

7. 进一步提速

量化为 int8（将在第二部分介绍！）

bf16 版本效果已经很好，但量化可以用少量精度换取更快的速度。后续博客将介绍如何量化 ACT 模型以获得最佳的精度/速度平衡，并通过 Torq 在 Astra 上运行该模型。

"在边缘端可行"在这里的真正含义

在 SL2610 Torq NPU 上运行时，与同一芯片上 CPU 的延迟对比（全部在同一块 SL2610 开发板、同一会话中测量）：

配置	每次推理延迟	精度（关节误差）	对比 CPU
torq vmfb (bf16)（第 5–6 步）	约 320 ms	0.46% relL2，<0.1°/关节（平均）	快约 6 倍
CPU 上的 fp32 ONNX（ONNX Runtime）	约 1.75 s	—	1×

该策略以 30 Hz 控制循环驱动实体 SO-101 机械臂完成了完整的抓取与放置任务，关节跟踪误差远低于 1 度——完全在开发板上运行。无需 GPU，无需云端，无需主机参与控制循环。

这正是整个实践的意义所在：真正的模仿学习机器人，完全运行在单个低功耗边缘加速器上。

故障排除

在 --live 模式下机械臂抖动或滞后。 调高 --vmax（默认 5°/步；设为 2.5 时我们观察到约 18% 的步数被限幅），让机械臂能够跟上模型的指令。
关节角度错误 / 机械臂猛冲。 开发板必须使用你在第 1 步中创建的同一个从动臂校准文件。部署脚本会复制主机上的校准文件——不要在开发板上单独重新校准。
控制循环提示"Press ENTER to use provided calibration file…"。 电机中存储的校准数据与你推送的文件不匹配（换了一台机械臂，或之后重新校准过）。按 ENTER 将推送的文件写入电机；只有在确实想在开发板上重新校准时才输入 c。
could not open port /dev/ttyFOLLOWER。 电机串口桥没有运行（重启后不会自动恢复）——请按上文所示启动它。如果它输出 device 1a86:55d3 not found，说明电机适配器未插入或不是 CH343；Resource busy 表示已有另一个串口桥占用了适配器（请先 kill 它）。
摄像头顺序颠倒。 模型的输入顺序为 (wrist, top)。如果机械臂的表现像是在"看错方向"，说明控制循环配置中两个摄像头被交换了。
torq-compile 输出 tile-and-fuse: failed to compute producer's operand slices 警告和 LRAM 分配信息，但仍以 0 退出。 这是分块搜索回退到更小分块的正常过程，并非致命错误——vmfb 会正常生成。
推理失败并报 failed to writeXram()。 在默认设置下，torq-runtime 2.2.0 的 Python 运行器在该模型的首次推理时会失败。示例脚本已经传入了 --torq_device_allocator=cpu；如果你自行加载 vmfb，也请这样做： VMFBInferenceRunner(vmfb, function="main_graph", runtime_flags=["--torq_device_allocator=cpu"])。

总结

在本博客中，我们介绍了完整的端到端流程：通过示教让 SO-101 机械臂学会抓取与放置任务，然后在 Synaptics Astra Machina SL2610（或 Synaptics Coralboard™ SL）上完全在设备端运行训练好的策略——推理时无需云端、无需 GPU、无需主机 PC。借助 Torq NPU，我们实现了比 CPU 快约 6 倍的性能，以及低于 1° 的关节精度。这仅仅展示了 Synaptics Astra SL2610 能力的冰山一角。本博客中介绍的技术同样适用于其他模型和应用场景。我们迫不及待地想看到你们打造的各种机器人项目！

附注

同一个 fp32 ONNX 模型在 Astra CPU 上使用 ONNX Runtime 运行时约为 1.75 s/次推理，而在 Torq NPU 上约为 320 ms。我们没有 CPU 上的 bf16 数据可供对比：原生 bf16 运算仅存在于较新的服务器级 CPU 上（Intel Cooper Lake 及更新的 Xeon、AMD Zen 4 及更新型号、Armv8.6+ 内核）——Astra 的 Arm 内核、主流笔记本/台式机芯片以及 Raspberry Pi 都不支持。半精度（fp16）也不是捷径：CPU 运行时通常先将 fp16 转换为 fp32 计算后再转换回来，我们实测其速度反而慢于直接运行 fp32。因此 fp32 是 CPU 的自然基准。

Coralboard 是 Google LLC 的商标。

硬件​

模型 / 策略​

软件​

性能​

整体流程​

1. 准备硬件​

2. 录制示教数据​

3. 训练模型​

4. 熟悉 Torq AI 平台​

5. 为 Torq NPU 编译模型​

6. 在开发板上运行模型​

7. 进一步提速​

"在边缘端可行"在这里的真正含义​

故障排除​

总结​

附注​

硬件