极速Jetson视觉！10倍效率搞定8路30FPS机器人感知

兄弟们，大家好！作为在跨境实战摸爬滚打多年的老兵，今天咱们来聊聊一个特别提气的话题：如何用NVIDIA Jetson Thor平台，把咱们机器人视觉处理的效率推向新高。这可不是什么虚头巴脑的理论，而是实打实能帮我们降本增效、提升竞争力的硬核技术。

咱们做机器人的，都知道视觉感知是核心。但往往高性能就意味着高成本、高功耗、高热量。NVIDIA Jetson平台，特别是Jetson Thor这样的新一代硬件，它牛就牛在不仅有强大的GPU，更集成了像可编程视觉加速器（PVA）、光流加速器（OFA）和视频图像合成器（VIC）这些专用硬件。它们就像机器人大脑里的“特种兵”，专门处理计算机视觉任务，这样就能大大减轻GPU的负担，降低功耗，还能更好地控制散热，让咱们的机器人跑得更稳、更久。

而Vision Programming Interface（VPI）库呢，就是这些“特种兵”的总指挥。它提供了一个统一的编程接口，让咱们能透明、异步、并行地调动所有Jetson的加速器。说白了，就是能把不同的视觉任务，交给最擅长的“特种兵”去完成，让整个感知流水线在复杂的实时应用中，实现最高效率的负载均衡。

新媒网跨境了解到，最新的基准测试数据显示，Thor T5000在RELATIVE模式下，能同时处理8路立体深度估计，分辨率达到960x600，最大视差128，帧率稳定在30FPS。这相比Jetson AGX Orin 64 GB，性能提升了足足10倍！更关键的是，这些视觉任务完全由专用加速器处理，GPU可以全心全意去跑更复杂的深度学习模型，互不干扰。

像美国波士顿动力公司（Boston Dynamics）这样的国际顶尖企业，他们也在Jetson硬件上大量使用VPI来部署和优化感知算法。这不仅加速了他们的原型开发，方便了硬件迭代，更重要的是，为他们的智能自主机器人提供了强大、可扩展的3D视觉能力。所以，这套技术咱们必须学透、用好。

智能机器人的研发，离不开稳定、低延迟的视觉感知能力，比如深度识别、障碍物检测、定位导航等等，这些都需要巨大的计算资源。NVIDIA Jetson平台虽然为深度学习提供了强劲的GPU，但随着AI模型的日益复杂，以及对实时性能的更高要求，单靠GPU往往会力不从心，甚至造成GPU过载。如果所有感知任务都压在GPU上，不仅容易出现性能瓶颈，还会增加功耗，带来散热挑战，这在咱们移动机器人这种对功耗和散热都极为敏感的场景下，是个大问题。

NVIDIA Jetson平台正是为了解决这些痛点而生的。它巧妙地将强大的GPU与前面提到的专用硬件加速器结合起来。比如Jetson AGX Orin和Jetson Thor这些设备，里面的专用加速器就是为了高效执行图像处理和计算机视觉任务而设计的，这样就能把GPU解放出来，让它专注于更核心、更耗资源的深度学习工作。

NVIDIA VPI正是打开这些“特种兵”潜力的金钥匙。今天，咱们就一起深入探讨这些加速器的优势，手把手教你如何利用VPI，把Jetson平台的全部潜能都激发出来。

接下来，咱们会以一个低延迟、低功耗的立体深度感知应用为例，带你走一遍开发流程。从一个简单的单路立体相机管线开始，逐步扩展到一个能同时处理8路立体相机、帧率达到30FPS的多流管线，性能比Orin AGX 64 GB快上10倍，这绝对是咱们实战派的福音！

在正式动手之前，咱们先快速捋一遍Jetson平台上都有哪些加速器，它们各自的优势、能解锁哪些应用场景，以及VPI在其中扮演的角色。

Jetson除了GPU，还有哪些“特种兵”加速器？

Jetson设备的GPU确实强大，是深度学习的核心。但随着AI复杂度的不断提升，咱们需要更精细地管理GPU的计算周期。Jetson提供了专门的引擎来处理计算机视觉（CV）任务。GPU虽然灵活强大，但如果能将这些专用引擎与GPU协同使用，就能获得显著的计算优势。VPI的作用就是简化这些引擎的访问，让咱们轻松地进行实验和负载均衡。

图1. 专为Jetson开发者打造的视觉编程接口（VPI）

来，咱们一个个仔细看看这些加速器，了解它们的用处和优点。

1. 可编程视觉加速器（PVA）：这可不是一般的DSP（数字信号处理器），它拥有1024位单指令多数据（SIMD）单元和灵活的直接内存访问（DMA）局部存储器，特别针对视觉和图像处理做了优化，功耗表现极佳。它能与CPU、GPU及其他加速器异步并行工作，除了Jetson Nano，所有Jetson SKU都配备了它。通过VPI，咱们能直接调用现成的算法，比如AprilTag检测、目标跟踪和立体深度估计。如果想自定义算法，现在Jetson开发者还能使用PVA SDK，通过C/C++ API和工具，直接在PVA上开发视觉算法。
2. 光流加速器（OFA）：OFA是一个固定功能的硬件加速器，专门用于计算光流和立体相机对的立体视差。它有两种工作模式：
   (1) 立体视差模式：OFA处理经过校正的左右相机图像，估算出视差图。
   (2) 光流模式：OFA估算两帧图像之间的2D运动矢量。
3. 视频图像合成器（VIC）：VIC是Jetson设备中一个固定功能、低功耗的硬件加速器，专长于底层图像处理任务，比如图像缩放、重映射、扭曲、色彩空间转换和降噪等等。

哪些应用场景能从这些加速器中受益？

下面这些场景，咱们做开发的兄弟们，就得好好考虑利用这些GPU之外的“特种兵”了：

1. GPU过载的应用：作为最佳实践，咱们应该把深度学习（DL）这种重活儿优先交给GPU，而把计算机视觉任务则通过VPI卸载到PVA、OFA或VIC。举个例子，DeepStream的多目标跟踪器，单靠Orin AGX的GPU只能处理12路视频流，但如果配合PVA进行负载均衡，就能支持16路，效率高了一大截！
2. 功耗敏感的应用：在一些对功耗要求极高的场景，比如哨兵模式或者活动监测，把大部分计算量卸载到PVA、OFA、VIC这些低功耗加速器上，能实现最高的能效比。
3. 有散热限制的工业应用：在高温环境下，将工作负载分散到所有加速器上，能有效减少热节流现象，帮助咱们在热预算范围内维持稳定的延迟和吞吐量。

如何用VPI解锁所有加速器？

VPI提供了一个统一且灵活的框架，让开发者可以在Jetson模块、工作站乃至带独立GPU的PC上无缝访问这些加速器。现在，咱们就来看一个把所有这些功能整合起来的实际例子。

案例解析：立体视觉管线

现代机器人技术中，被动立体视觉系统是实现周围世界3D感知的重要手段。因此，计算立体视差图，是构建复杂感知堆栈的关键一步。在这里，咱们就来看看一个能生成立体视差图和置信度图的示例管线。下面，我将演示如何利用VPI，结合所有可用的加速器，构建一个低延迟、高能效的管线。

图2. 在Jetson上部署跨多个加速器的立体视觉管线示意图。PVA = 可编程视觉加速器。VIC = 视频图像合成器。OFA = 光流加速器。

1. CPU预处理：这个预处理步骤只需要执行一次，所以放在CPU上跑就足够了。它主要计算校正映射图，用来校正立体相机帧的镜头畸变。
2. VIC重映射：这一步是利用预先计算好的校正映射图，对相机帧进行去畸变和对齐，确保两个光轴水平且平行。VPI支持多项式和鱼眼畸变模型，也能让咱们自定义扭曲映射图。具体细节可以参考重映射文档。
3. OFA立体视差计算：经过校正的图像对，会作为半全局匹配（SGM）算法的输入。在实际应用中，SGM算法单独使用时可能会产生噪声和错误的视差值。为了提升结果，我们可以创建一个置信度图，丢弃那些置信度低的视差估计。关于SGM和支持的参数，可以参考立体视差文档。
4. PVA置信度图计算：VPI支持三种置信度图模式：ABSOLUTE（绝对）、RELATIVE（相对）和INFERENCE（推理）。其中，ABSOLUTE和RELATIVE模式需要两次OFA通道（左右视差）加上PVA的交叉检查，而INFERENCE模式则采用单次OFA通道后，再在PVA上运行一个CNN（包含两个卷积层和两个非线性激活层）。跳过置信度计算最快，但会生成噪声较多的视差图；而RELATIVE和INFERENCE模式则能显著提升视差质量和置信度。

VPI统一的内存架构，能有效避免不同引擎之间不必要的数据拷贝，大大提高效率。它的异步流/事件模型，则允许开发者提前规划任务调度和同步点。硬件管理的调度机制，确保了不同引擎之间的并行执行，从而解放了CPU，并通过高效的流式管线隐藏了延迟。

使用VPI构建高性能立体视差管线

从Python API上手实战

这部分，咱们用VPI的Python API来搭建一个不含重映射（Remap）的基础立体视差管线，手把手教你如何操作。

准备工作：

• 一台NVIDIA Jetson设备（比如Jetson AGX Thor）
• 通过NVIDIA SDK Manager或apt安装VPI
• 安装Python库：vpi, numpy, Pillow, opencv-python

在这个教程里，咱们将：

• 加载左右立体图像
• 转换图像格式以进行处理
• 同步数据流，确保数据准备就绪
• 执行立体视差算法
• 对输出结果进行后处理并保存

配置与初始化

第一步，就是导入咱们需要的库，并创建VPIStream对象。VPIStream就像一个命令队列，你可以把任务提交给它进行异步执行。为了演示并行处理，咱们这里会用到两个流。

import vpi
import numpy as np
from PIL import Image
from argparse import ArgumentParser

# 创建两个流，用于并行处理
streamLeft = vpi.Stream()
streamRight = vpi.Stream()

streamLeft负责处理左图，streamRight负责处理右图。

加载并转换图像

VPI的Python API可以直接与NumPy数组协同工作。咱们先用Pillow库加载图像，然后用VPI的asimage函数对其进行封装。接下来，把图像转换成适合立体视差算法处理的格式。在这个例子中，咱们会从RGBA8转换成Y8_ER_BL（8位灰度，块线性格式）。

# 加载图像并用VPI图像对象封装
left_img = np.asarray(Image.open(args.left))
right_img = np.asarray(Image.open(args.right))
left = vpi.asimage(left_img)
right = vpi.asimage(right_img)

# 将图像并行转换为Y8_ER_BL格式，使用不同的后端
left = left.convert(vpi.Format.Y8_ER_BL, scale=1, stream=streamLeft, backend=vpi.Backend.VIC)
right = right.convert(vpi.Format.Y8_ER_BL, scale=1, stream=streamRight, backend=vpi.Backend.CUDA)

可以看到，左图的转换任务提交给了streamLeft，并由VIC后端处理；而右图的转换任务则提交给了streamRight，并由NVIDIA CUDA后端处理。这种方式让两个操作能在不同的硬件单元上并行运行，这正是VPI的核心优势之一。

同步并执行立体视差计算

在执行立体视差计算之前，咱们必须确保两幅图像都已经准备好了。这里，咱们使用streamLeft.sync()来阻塞主线程，直到左图转换完成。然后，就可以在streamRight上提交vpi.stereodisp操作了。

# 同步streamLeft，确保左图已准备就绪
streamLeft.sync()

# 在streamRight上提交立体视差操作
disparityS16 = vpi.stereodisp(left, right, backend=vpi.Backend.OFA|vpi.Backend.PVA|vpi.Backend.VIC, stream=streamRight)

立体视差算法将在VPI的多个后端（OFA、PVA、VIC）协同执行，充分利用专用硬件的优势。结果会生成一个S16格式的视差图，它代表了两个图像中对应像素之间的水平偏移量。

后处理与可视化

原始的视差图需要进行后处理才能方便可视化。视差值是Q10.5固定点格式，咱们需要将其缩放到0-255的范围，然后保存。

# 后处理视差图
# 将Q10.5转换为U8，并按比例缩放以便可视化
disparityU8 = disparityS16.convert(vpi.Format.U8, scale=255.0/(32*128), stream=streamRight, backend=vpi.Backend.CUDA)

# 使其在CPU中可访问
disparityU8 = disparityU8.cpu()

# 用pillow保存
d_pil = Image.fromarray(disparityU8)
d_pil.save('./disparity.png')

这最后一步，将原始数据转换成一幅人类可读的图像，其中灰度值代表深度信息。

利用C++ API构建多流视差管线

对于一些对吞吐量要求极高的先进机器人应用，VPI通过并行多流技术，能实现惊人的高性能。它结合了精简的API和对硬件加速器的高效利用，让咱们开发者能够构建快速、可靠的视觉管线——就像美国波士顿动力公司（Boston Dynamics）那些下一代机器人所采用的技术一样。

VPI使用VPIStream对象，它们是先进先出（FIFO）的命令队列，用于向后端异步提交任务。这使得不同硬件单元上的操作可以并行执行（异步流）。为了在关键任务应用中获得最大性能，VPI的C++ API是理想的选择。

下面的代码片段来自一个C++基准测试，它演示了如何构建和运行一个多流立体视差管线。这个SimpleMultiStreamBenchmark C++应用通过预先生成合成的NV12_BL图像来避免运行时开销，然后并行运行多个流并测量每秒帧数（FPS）吞吐量。它还支持保存输入、视差图和置信度图以进行调试。这个示例预先生成数据，是为了模拟高速、实时的工作负载。

资源设置、对象声明与初始化

首先，咱们需要声明并初始化VPI管线所需的每个流的所有对象。这包括创建流、输入/输出图像以及立体有效载荷。由于咱们将向立体算法输入NV12_BL类型的图像，所以我们分配了该类型，并为中间格式转换分配了Y8_ER图像类型。

int totalIterations = itersPerStream * numStreams;

std::vector<VPIImage> leftInputs(numStreams), rightInputs(numStreams), confidences(numStreams), leftTmps(numStreams), rightTmps(numStreams);
std::vector<VPIImage> leftOuts(numStreams), rightOuts(numStreams), disparities(numStreams);
std::vector<VPIPayload> stereoPayloads(numStreams);
std::vector<VPIStream> streamsLeft(numStreams), streamsRight(numStreams);
std::vector<VPIEvent> events(numStreams);

int width = cvImageLeft.cols;
int height = cvImageLeft.rows;

int vic_pva_ofa = VPI_BACKEND_VIC | VPI_BACKEND_OFA | VPI_BACKEND_PVA;

VPIStereoDisparityEstimatorCreationParams stereoPayloadParams;
VPIStereoDisparityEstimatorParams stereoParams;

CHECK_STATUS(vpiInitStereoDisparityEstimatorCreationParams(&stereoPayloadParams));
CHECK_STATUS(vpiInitStereoDisparityEstimatorParams(&stereoParams));

stereoPayloadParams.maxDisparity = 128;
stereoParams.maxDisparity= 128;
stereoParams.confidenceType = VPI_STEREO_CONFIDENCE_RELATIVE;

for (int i = 0; i < numStreams; i++)
{
    CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(cvImageLeft, 0, &leftInputs[i]));
    CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(cvImageRight, 0, &rightInputs[i]));

    CHECK_STATUS(vpiStreamCreate(0, &streamsLeft[i]));
    CHECK_STATUS(vpiStreamCreate(0, &streamsRight[i]));

    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_Y8_ER, 0, &leftTmps[i]));
    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_NV12_BL, 0, &leftOuts[i]));

    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_Y8_ER, 0, &rightTmps[i]));
    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_NV12_BL, 0, &rightOuts[i]));

    CHECK_STATUS(vpiCreateStereoDisparityEstimator(vic_pva_ofa, width, height, VPI_IMAGE_FORMAT_NV12_BL, &stereoPayloadParams, &stereoPayloads[i]));
    CHECK_STATUS(vpiEventCreate(0, &events[i]));
}

int outCount = saveOutput ? (numStreams * itersPerStream) : numStreams;
disparities.resize(outCount);
confidences.resize(outCount);
for (int i = 0; i < outCount; i++)
{
    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_S16, 0, &disparities[i]));
    CHECK_STATUS(vpiImageCreate(width, height, VPI_IMAGE_FORMAT_U16, 0, &confidences[i]));
}

转换图像格式

咱们使用VPI的C API来提交每个流的图像转换操作，将其转换为NV12_BL输入格式，模拟相机帧的输入。

for (int i = 0; i < numStreams; i++)
{
    CHECK_STATUS(vpiSubmitConvertImageFormat(streamsLeft[i], VPI_BACKEND_CPU, leftInputs[i], leftTmps[i], NULL));
    CHECK_STATUS(vpiSubmitConvertImageFormat(streamsLeft[i], VPI_BACKEND_VIC, leftTmps[i], leftOuts[i], NULL));
    CHECK_STATUS(vpiEventRecord(events[i], streamsLeft[i]));

    CHECK_STATUS(vpiSubmitConvertImageFormat(streamsRight[i], VPI_BACKEND_CPU, rightInputs[i], rightTmps[i], NULL));
    CHECK_STATUS(vpiSubmitConvertImageFormat(streamsRight[i], VPI_BACKEND_VIC, rightTmps[i], rightOuts[i], NULL));

    CHECK_STATUS(vpiStreamWaitEvent(streamsRight[i], events[i]));
}

for (int i = 0; i < numStreams; i++)
{
    CHECK_STATUS(vpiStreamSync(streamsLeft[i]));
    CHECK_STATUS(vpiStreamSync(streamsRight[i]));
}

和之前一样，咱们把操作提交到两个独立流上的不同硬件。类型会根据输入/输出图像的类型自动推断。这次，咱们还在左侧流的转换操作后记录了一个VPIEvent。VPIEvent是一个VPI对象，它允许一个流等待另一个流完成记录时的所有操作。这使得咱们可以强制右侧流等待左侧流的转换操作，而不会阻塞调用（主）线程，从而使多个左侧流和右侧流能够并行操作。

同步并执行立体视差计算

咱们继续使用VPI的C API来提交立体视差操作。同时，咱们还会用std::chrono来对立体视差计算进行基准测试。

auto benchmarkStart = std::chrono::high_resolution_clock::now();

for (int iter = 0; iter < itersPerStream; iter++)
{
    for (int i = 0; i < numStreams; i++)
    {
        int dispIdx = saveOutput ? (i * itersPerStream + iter) : i;
        CHECK_STATUS(vpiSubmitStereoDisparityEstimator(streamsRight[i], vic_pva_ofa, stereoPayloads[i], leftOuts[i], rightOuts[i], disparities[dispIdx], confidences[dispIdx], &stereoParams));
    }
}

// ====================
// 结束基准测试

for (int i = 0; i < numStreams; i++)
{
    CHECK_STATUS(vpiStreamSync(streamsRight[i]));
}

auto benchmarkEnd = std::chrono::high_resolution_clock::now();

和前面类似，咱们提交了包含置信度图的操作，并获得了最终的视差图。咱们也在这里结束了基准测试计时器，记录了转换和视差计算所花费的时间。在提交完所有流之后，咱们会显式地同步所有流，以确保在提交时调用线程永远不会被阻塞。

后处理与清理

咱们使用VPI的C API和OpenCV的互操作性，在同一个迭代循环中对视差图进行后处理并保存。咱们可以选择性地保存输出数据以供检查，然后在循环结束后清理所有对象。

// ====================
// 保存输出
if (saveOutput)
{
    for (int i = 0; i < numStreams * itersPerStream; i++)
    {
        VPIImageData dispData, confData;
        cv::Mat cvDisparity, cvDisparityColor, cvConfidence, cvMask;

        CHECK_STATUS( vpiImageLockData(disparities[i], VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &dispData));
        vpiImageDataExportOpenCVMat(dispData, &cvDisparity);
        cvDisparity.convertTo(cvDisparity, CV_8UC1, 255.0 / (32 * stereoParams.maxDisparity), 0);
        applyColorMap(cvDisparity, cvDisparityColor, cv::COLORMAP_JET);
        CHECK_STATUS(vpiImageUnlock(disparities[i]));

        std::ostringstream fpStream;
        fpStream << "stream_" << i / itersPerStream << "_iter_" << i % itersPerStream << "_disparity.png";
        imwrite(fpStream.str(), cvDisparityColor);

        // 置信度输出 (U16 -> 缩放到8位并保存)
        CHECK_STATUS( vpiImageLockData(confidences[i], VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &confData));
        vpiImageDataExportOpenCVMat(confData, &cvConfidence);
        cvConfidence.convertTo(cvConfidence, CV_8UC1, 255.0 / 65535.0, 0);
        CHECK_STATUS(vpiImageUnlock(confidences[i]));

        std::ostringstream fpStreamConf;
        fpStreamConf << "stream_" << i / itersPerStream << "_iter_" << i % itersPerStream << "_confidence.png";
        imwrite(fpStreamConf.str(), cvConfidence);
    }
}

// ====================
// 清理 VPI 对象
for (int i = 0; i < numStreams; i++)
{
    CHECK_STATUS(vpiStreamSync(streamsLeft[i]));
    CHECK_STATUS(vpiStreamSync(streamsRight[i]));

    vpiStreamDestroy(streamsLeft[i]);
    vpiStreamDestroy(streamsRight[i]);

    vpiImageDestroy(rightInputs[i]);
    vpiImageDestroy(leftInputs[i]);
    vpiImageDestroy(leftTmps[i]);
    vpiImageDestroy(leftOuts[i]);
    vpiImageDestroy(rightTmps[i]);
    vpiImageDestroy(rightOuts[i]);

    vpiPayloadDestroy(stereoPayloads[i]);
    vpiEventDestroy(events[i]);
}

// 销毁所有视差和置信度图像
for (int i = 0; i < (int)disparities.size(); i++)
{
    vpiImageDestroy(disparities[i]);
}
for (int i = 0; i < (int)confidences.size(); i++)
{
    vpiImageDestroy(confidences[i]);
}

收集基准测试结果

现在，咱们可以收集并展示基准测试结果了。

double totalTimeSeconds = totalTime / 1000000.0;
double avgTimePerFrame = totalTimeSeconds / totalIterations;
double throughputFPS= totalIterations / totalTimeSeconds;

std::cout << "\n" << std::string(70, '=') << std::endl;
std::cout << "简单的多流测试结果" << std::endl;
std::cout << std::string(70, '=') << std::endl;
std::cout << "输入: RGB8 -> Y8_BL_ER" << std::endl;
std::cout << "总耗时: " << totalTimeSeconds << " 秒" << std::endl;
std::cout << "每帧平均耗时: " << (avgTimePerFrame * 1000) << " 毫秒" << std::endl;
std::cout << "吞吐量: " << throughputFPS << " FPS" << std::endl;
std::cout << std::string(70, '=') << std::endl;
std::cout << "吞吐量: " << throughputFPS << " FPS" << std::endl;
std::cout << std::string(70, '=') << std::endl;

成果回顾

咱们来看看实打实的测试结果。在960x600的图像分辨率和128的最大视差设置下，这个解决方案在Thor T5000上，能同时运行8路立体视差估计流，并且包含了置信度图，帧率稳定在30FPS，而且GPU几乎没有负载！这可是比Orin AGX 64 GB快了大约10倍。两种情况都设置在MAX_N的最高功耗模式下。性能对比具体看下表：

立体视差全管线性能（RELATIVE模式，分辨率：960×600，最大视差：128）

表1. Orin AGX 与 Thor T5000 在 RELATIVE 模式下立体视差管线性能对比

美国波士顿动力公司如何运用VPI

作为Jetson平台的重度用户，美国波士顿动力公司（Boston Dynamics）对视觉编程接口（VPI）的依赖性极高，它帮助这家公司大大加速了其感知管线。

VPI能够无缝地访问Jetson的专用硬件加速器，提供了一套经过优化的视觉算法，比如AprilTags和SGM视差，以及ORB、Harris角点、Pyramidal LK和OFA驱动的光流等特征检测器。这些都是美国波士顿动力公司感知堆栈的核心组成部分，既支持原型测试，又通过负载均衡优化了系统。通过采用VPI，工程师们能够快速适应硬件更新，大大缩短了产品上市时间，确保了其在机器人领域的领先地位。

总结与感悟

兄弟们，从今天的分享中，咱们不难看出，Jetson Thor平台在硬件能力上的飞跃，以及VPI这样强大的软件库，正在实实在在地赋能咱们开发者，去设计和实现边缘侧机器人高效、低延迟的解决方案。

通过充分利用Jetson平台上每一个可用加速器的独特优势，像美国波士顿动力公司这样的机器人企业，才能实现复杂而精密的视觉处理，而且这种处理既高效又可扩展。这正是让智能自主机器人在各种实际应用场景中成为现实的关键一步。

所以，咱们中国的跨境从业者，更要紧跟技术前沿，把这些“硬核”技术学到手，用到咱们自己的产品和解决方案中去，为咱们的智能制造、智慧生活贡献一份力量。

想要在Jetson上构建自己的CV应用吗？这里有几条路子：

• 通过JetPack SDK获取VPI
• 查阅VPI文档和示例应用
• 深入了解PVA SDK，学习如何为PVA引擎构建自定义算法

新媒网（公号: 新媒网跨境发布），是一个专业的跨境电商、游戏、支付、贸易和广告社区平台，为百万跨境人传递最新的海外淘金精准资讯情报。

本文来源：新媒网 https://nmedialink.com/posts/jetson-vision-boost-10x-efficiency-8s-30fps.html