我们在 Ultralytics 如何让 YOLO 模型在你喜爱的芯片上运行得更快

在 Ultralytics，我们制作计算机视觉模型；简单来说，就是教计算机看东西！你可以把这些模型想象成巨大的数学配方。它们由各种运算（我们称之为层）以及一大堆数字组成，这些数字我们称为权重。

我们的 Ultralytics YOLO 模型将图像按照它们真正的形式进行处理：数字数组！每个像素其实就是颜色值，也就是组成图像的每个点对应的 Red、Green 和 Blue 值（因此称为 RGB）。我们把这些数字数组称为“张量”，因为这听起来比“多维矩阵”酷多了，而“多维矩阵”又比“堆在数字上的数字，再堆上更多数字”酷多了。

当你把图像输入模型后，它会踏上一段史诗般的网络之旅。想象一下，你的张量在一层又一层之间冲浪，不断经历变换、卷积，以及尽可能美妙的数学处理。你可以把它想象成一场舞会，数字们在其中混合、交流，提取出猫之所以是猫、汽车之所以是汽车的本质。我们把这个过程称为特征提取。

另一端输出的是什么？更多数字！有意义的数字。在检测任务中，它们会准确告诉你图像中有什么东西、位于哪里，以及它可能是什么。“嘿，那是狗的概率有 95%，坐标是 (x, y)！”我们把这个神奇的过程称为推理。

不过，在模型施展魔法之前，它们得先去上学，也就是接受训练。训练阶段才是真正紧张的部分。

在训练过程中，每次我们向网络展示一张图像时，得到的不只是一个答案。我们还要做两件非常繁重的事情。第一，计算网络错得有多严重（我们称之为损失，基本上就是它偏离靶心的距离）。第二，也是最重要的部分，根据这个损失更新网络中的每一个数字（也就是权重）。你可以把它想象成同时调节成千上万个微小旋钮，而且每次调整都经过计算，以便让网络变得越来越准确。

本质上，我们是通过纠错来训练网络：每个错误都会教它哪些事情不要做，我们则调整所有权重，这样它下次看到类似图像时，就能更接近正确答案。换句话说，网络通过一次次犯错、一次次被轻轻推向正确方向来学习，直到它开始准确命中预测结果。

我们说的到底是多少个数字？我们的可爱小家伙 YOLO11n 有几百万个参数。但 YOLO11x 呢？这个大家伙拥有超过 5000 万个参数！参数越多，你能编码的细节就越丰富，就像用蜡笔画画和拥有一整套艺术家调色板之间的区别。

在推理过程中，参数数量就变得至关重要。运行一个拥有 300 万个参数的网络，就像绕着街区慢跑。运行一个拥有 5000 万个参数的网络？那更像是一边跑马拉松，一边抛接燃烧的火炬。

那么，计算到底是什么？所有这些数字运算实际上是如何发生的？我们怎样让它更快？“优化计算”究竟又意味着什么？

芯片究竟如何进行数学运算#

计算是在芯片中进行的。这些小小的硅方块，基本上就是宇宙中最有条理的沙堡。计算机执行的每一个操作——每次加法、每次比较、每个“如果这样就那样”——都被物理地刻在硅片中。芯片的特定区域里有专门用于加法的实际物理电路，也有用于逻辑运算的其他电路。这就像一座微型城市，不同街区分别专门负责不同类型的数学运算。

即使你是计算机科学家，这听起来也可能很不可思议。这是因为过去 40 年里，我们构建了一层又一层的抽象，就像一盘越堆越高的科技千层面，高到我们甚至看不到最底下的盘子。我们把事情简化到了极致，以至于如今大多数程序员都不知道计算实际上是如何在硅片中发生的。这不是他们的错，而是设计使然！

让我们剥开这些层次。先看这段简单得不能再简单的 Python 代码：

x = 1
if x == 1:
    y = x + 1

我们创建了一个变量 x，将它设为 1；如果 x 等于 1（剧透：确实等于），就创建一个值为 x 加 1 的 y。三行代码。很简单。

但有趣的地方来了。在这三行无害的代码与实际流经硅片的电子之间，至少发生了四个巨大的翻译层（实际上更多，但我们的数字内容经理说我的字数已经让她焦虑了）。让我带你走过这段令人脑洞大开的旅程：

第 1 层：Python → 字节码 首先，Python 读取你的代码，并将其编译成一种叫作字节码的东西。这是一种更容易被计算机理解的中间语言，但如果你试图阅读它，可能会看得两眼流血。

第 2 层：字节码 → 机器码 Python 解释器（例如 CPython）接收字节码，并将其翻译成机器码，也就是处理器能够理解的实际指令。在这一层，你优雅的“if x == 1”会变成类似“加载寄存器、比较寄存器、如果零标志位已设置则跳转”的内容。

第 3 层：机器码 → 微码 剧情反转！现代处理器甚至不会直接执行机器码。它们会进一步将机器码拆解成微码，也就是芯片内部组件能够处理的更细小操作。你的一条“ADD”指令可能会变成多个微操作。

第 4 层：微码 → 物理电子电路 最后，我们抵达硅片。那些微操作会触发实际的电信号，使其流经晶体管。数十亿个微小开关不停开关，电子在精心设计的路径中舞动，不知怎的，奇迹般地让 1 + 1 变成了 2。

每一层的存在，都是为了隐藏下一层那疯狂的复杂性。这就像俄罗斯套娃，只不过每个娃娃都说着完全不同的语言，而最小的娃娃实际上是由困在沙子里的闪电构成的。

讽刺的是？那三行 Python 代码可能会触发数百万个晶体管开关。但多亏了这些抽象，你不需要考虑这一切。你只需写下“y = x + 1”，然后相信在某个深藏于硅片中的地方，魔法正在发生。

架构#

每个操作都以物理方式实现在硅片中，而它在芯片上的具体位置则完全取决于芯片的拓扑结构。这就像城市规划，只不过规划对象是电子。加法器位于这里，乘法器位于那里，而它们都需要高效地相互通信。

市场上有数百种不同的芯片，每种都为不同用途而设计。它们之间有什么区别？区别就在于拓扑结构，也就是运算在物理领域中的位置和实现方式。这就是我们所说的架构，而架构种类可真不少：

• x86（Intel 和 AMD）- 桌面计算的老祖宗，复杂但强大
• ARM - 驱动你的手机，并越来越多地用于笔记本电脑，专为高能效而设计
• RISC-V - 开源的反叛者，正在各处获得发展势头
• PowerPC - IBM 的猛兽，至今仍运行于游戏主机和服务器中
• MIPS - 学术界的宠儿，简单而优雅
• SPARC - Sun Microsystems（现为 Oracle）对高性能计算的贡献
• GPU 架构（NVIDIA 的 CUDA 核心、AMD 的 RDNA）- 并行处理怪兽

每种架构不仅以不同方式排列晶体管，还使用不同的语言。我们用来向这些机器发送指令的抽象层完全不同。这就像要为某人编写旅行路线，但根据对方开的车不同，你可能需要用法语、普通话，或者解释性舞蹈来书写。

硅片的心跳#

芯片的燃料是电子，也就是流入芯片、为计算提供能量的电流。但仅有能量还不够。芯片要真正工作、让数据在复杂的拓扑结构中移动，一切都取决于一个关键组件：时钟。它让电子在特定时间沿特定路径流动。没有它，你得到的只是一块通了电却什么也不做的硅片。

想象一下，要协调一场规模庞大的演出，其中数十亿个组件必须完美同步地移动。没有节拍，一切都会陷入混乱。这正是时钟对处理器所做的事情。它是一块以极其稳定的频率振动的晶体，每秒发出数十亿次电脉冲。

当你听到“3.5 GHz 处理器”时，其中的 GHz（gigahertz）就是时钟频率，即每秒 35 亿次节拍。每次节拍都称为一个时钟周期，它是计算机领域最基本的时间单位。

时钟周期之间什么都不会发生。整台计算机会冻结，等待下一个节拍。这就像宇宙中最极端的一场“红灯停、绿灯行”游戏。在每次“绿灯”（时钟脉冲）期间：

• 数据在组件之间移动
• 执行计算
• 做出逻辑决策
• 读取或写入内存

有些操作只需一个周期（例如简单的加法），而另一些操作则需要多个周期（例如除法或从 RAM 获取数据）。这一切都经过精确编排：数十亿个组件执行各自的操作，并全部与这个永不停歇的节拍保持同步。

你可以让晶体振动得更快，从而对处理器进行超频；所有事情都会加速，但也会产生更多热量，稳定性则会下降。超频过度，计算机就会崩溃，因为电子确实跟不上节拍了。

过去，这些操作是由房间大小的机器实现的。但完成所有这些计算的组件其实非常简单：它们只是开关。打开或关闭的开关。

按照正确的模式将足够多的这些开关连接起来，你就得到了计算。整个数字革命归根结底就是一种精密的开关排列。

这种简单性意味着，只要你有开关——任何类型的开关——就能构建计算机。人们曾用水管和阀门、多米诺骨牌、LEGO 积木、弹珠，甚至 Minecraft 中的红石，构建出能够运行的计算机。

自 20 世纪 40 年代以来，原理从未改变。我们只是变得极其擅长把开关做得非常小。你的手机拥有比所有将人类送上月球的计算机加起来还强的计算能力，而且能装进口袋，是因为我们掌握了在原子尺度制造开关的方法。

当我们运行拥有数百万参数的神经网络时，就是在每秒翻转数十亿个微小开关，并且全部与晶体的心跳完美同步。每次权重更新、每次矩阵乘法、每个激活函数，全都随着时钟的节拍前进。

难怪训练模型时，你的计算机听起来像是在努力升空！

让神经网络 BRRRRR 地飞起来#

好了，现在我们有了这些拥有数十亿个开关、随着晶体节拍起舞的芯片，还想在它们上面运行拥有数百万参数的神经网络。应该很简单，对吧？把数字扔给芯片，让它尽情运行就行了！

让神经网络快速运行，就像要在这样的厨房里烹制五道菜：冰箱在三个街区之外，你只有一口锅，而且每种食材重达 500 磅。数学本身不是最大的问题；其他所有事情才是。

架构不匹配#

大多数芯片是为运行 Microsoft Word 设计的，而不是为神经网络设计的。你的 CPU 在诞生时就被设想为一生都要运行 if 语句、循环，偶尔还要计算你的税款（这是连超级计算机都觉得情绪疲惫的唯一一种计算）。它针对顺序操作进行了优化：先做这个，再做那个，然后做另一件事。

但神经网络完全不同。它们想要同时做所有事情！训练期间，你会根据预测结果有多错误来更新数百万个权重。在推理阶段（也就是实际使用训练好的模型时），你会同时将数据送入数百万次计算中。想象一下，你需要将一百万个数字分别乘以另外一百万个数字。你的 CPU，虽然很勤奋，却想一次做一个，就像一个速度很快但非常严谨的会计。

这就是 GPU 成为 AI 计算支柱的原因。GPU 最初是为电子游戏设计的，因为游戏需要同时计算数百万个像素的颜色。结果发现，计算像素颜色和进行神经网络数学运算竟然非常相似：两者都需要对海量数据并行执行相同的操作。

但即使 GPU 也并非最适合神经网络。这就是为什么各家公司现在开始构建专用 AI 芯片（TPU、NPU，以及其他所有以 PU 结尾的缩写）。这些芯片从底层开始设计，只有一个任务：让神经网络快速运行。它们就像雇了一位只会做一道菜的厨师，但这位厨师能以超人的速度把它做好。CPU 在顺序执行矩阵运算时举步维艰，GPU 能很好地并行处理，而这些专用芯片则把矩阵当作早、中、晚餐来吃。

内存墙（或者：为什么移动比特比数学运算更难）#

在现代神经网络计算中，我们花在移动数据上的时间和能量，比真正用数据进行计算的时间和能量更多。

把你的计算机芯片想象成一位思维敏捷、工作速度如闪电的数学家，但他的所有参考书都存放在城里不同的建筑中。他可以瞬间解出任何方程，但首先得拿到数字，而这段路程要花很长时间。

你的芯片可以在一个时钟周期内将两个数字相乘（记住，这只是每秒数十亿次节拍中的一次）。快如闪电！但把这些数字从内存取到芯片上呢？可能需要数百个周期。这就像你的数学家能在一秒内解决问题，却需要五分钟步行去图书馆再回来。

原因在于距离（以及空间）。电移动得很快，但并非无限快。数据在芯片上需要移动的距离越远，耗时就越长。计算机设计人员通过创建内存层次结构解决了这个问题，就像把多个存储位置安排在不同距离处：

• 寄存器（直接构建在计算单元中）：数学家的书桌。即时访问！但空间很小，这里只能存放大约 32 个数字。就像把便签直接贴在眼前。
• L1 Cache（相距几微米）：办公室里的书架。取出内容需要 3-4 个周期。这里可以容纳几千个数字。
• L2 Cache（相距几毫米）：走廊尽头的文件柜。需要 10-15 个周期，可以容纳几百万个数字。
• L3 Cache（位于芯片另一侧）：楼下的储藏室。需要 30-50 个周期，可容纳数千万个数字。
• RAM（位于完全不同的芯片上）：城另一头的仓库。需要 100-300 个周期。你的数十亿个数字就存放在那里。
• SSD/硬盘（通过线缆连接）：完全是另一座城市。需要数百万个周期。存储空间巨大，但速度慢如蜗牛。

具体结构各不相同：你的手机芯片可能没有 L3 Cache，而服务器 CPU 可能拥有海量 L3 Cache。不过，原理始终相同：距离越近的内存速度越快，但容量越小。

现在，神经网络的痛点来了。假设你的 Ultralytics YOLO 模型有 5000 万个参数（顺便一提，ChatGPT 有数十亿个参数）。这意味着 5000 万个数字需要从内存移动到计算单元，再返回内存。即使每个数字只有 4 字节，也有 200 MB 数据需要在系统中移动。

芯片可能在一个周期内处理每个数字，但如果从 RAM 获取这个数字需要 100 个周期，那么你有 99% 的时间都在等待数据送达。这就像让一辆一级方程式赛车陷入交通堵塞。所有计算能力都闲置在那里，等待数据到来。

这里有一个关键认识：这就是现代计算中的瓶颈。它被称为冯·诺依曼瓶颈。让芯片进行更快的数学运算相对容易，而让内存变快则正在触及物理极限。这就是为什么 AI 中几乎所有性能优化都发生在内存层面。当工程师加速神经网络时，他们很少是在让数学运算更快，而是在寻找巧妙的方法来减少数据移动、更好地缓存数据，或更智能地访问数据。

现代 AI 芯片不仅关注计算速度，还极度重视内存带宽和数据移动策略。它们会预取数据，重复利用缓存中已有的值，并组织计算以尽量减少内存访问。AI 硬件竞赛中的赢家，不是拥有最快计算器的芯片，而是那些找到方法让计算器持续获得数据的芯片。整个竞争的核心都是优化内存访问模式。

每次移动一点数据，都会消耗能量。虽然不多，我们说的是皮焦耳，但当你每秒移动数 TB 数据时，消耗很快就会累积起来。事实上，在芯片上将数据移动 1mm 所消耗的能量，比完成实际计算还多！

这就是为什么训练神经网络时，你的笔记本电脑听起来像喷气式发动机。产生热量的不是数学运算，而是数据移动。每次参数更新、每次梯度计算、每次前向传播，都在实实在在地让你的房间升温。

现代 AI 加速器基本上就是热力学实践。芯片熔化之前，我们能塞进多少计算？我们能多快地把热量带走？这就像超频，只不过时钟永远开到了 11 档，而我们只是努力避免起火。

解决方案？架构感知设计#

最快的神经网络未必是最聪明的，而是那些在设计时考虑了芯片特性的网络。它们会：

• 尽可能将数据保留在本地
• 极其充分地重复利用计算结果
• 与硬件能力完美匹配
• 不惜一切代价减少内存移动

这就像一道菜谱所说的“使用本地杂货店的食材”，与另一道要求你从西藏进口香料、从法国进口奶酪、从南极洲进口水的菜谱之间的区别。两道菜可能都很好吃，但其中一道显然更实用。

这就是为什么让神经网络快速运行是一门艺术。仅有优秀的数学运算还不够；你需要理解硬件、尊重内存层次结构，并与架构完美共舞。

欢迎来到这样一个世界：计算机科学、物理学、工程学与纯粹的魔法在这里交汇。移动一个数字的代价高于用它进行计算。并行很快，但同步却是致命的。你最大的敌人不是复杂性，而是距离。

我们如何让 YOLO 更快#

当你训练 YOLO 模型时，你会得到一个在训练环境中运行得非常出色的神经网络。但问题在于：你的游戏 GPU、你的 iPhone，以及安防摄像头中的那块小芯片，说的完全是不同的语言。它们各有不同的优势和劣势，对于如何处理数据也有完全不同的想法。

可以这样理解：GPU 拥有数千个能够同时工作的核心——它就是为并行处理而构建的。与此同时，移动芯片可能配备专为 AI 运算设计的特殊电路，但只能处理某些类型的数学运算。而门铃摄像头中的边缘设备呢？它试图在比 LED 灯泡还小的功耗预算下运行 AI。

在 Ultralytics，我们支持十多种不同的导出格式，因为每种格式都针对不同硬件进行了优化。这不是选项太多的问题，而是要为你的具体需求提供正确的选项。

融合运算：用更少资源完成更多工作#

在原始 YOLO 模型中，许多运算是按顺序进行的。例如，我们可能先进行卷积，再对结果进行归一化，最后应用激活函数。这是三个独立步骤，每一步都需要单独读取和写入内存。

但巧妙之处在于：我们可以将这些运算合并为一个步骤。在导出 YOLO 以进行部署时，我们会将这些运算融合在一起。我们不再执行：

1. 计算卷积 → 保存到内存
2. 从内存加载 → 归一化 → 保存到内存
3. 从内存加载 → 应用激活函数 → 保存到内存

而是执行：

1. 计算卷积 + 归一化 + 激活函数 → 保存到内存

对于处理 640×640 图像的典型 YOLO 模型来说，这个简单技巧可以消除数 GB 的不必要内存传输。在手机上，这可能就是流畅的实时检测与令人沮丧的延迟之间的区别。

使用更小的数字：量化的魔力#

YOLO 实际上并不需要特别精确的数值就能准确检测对象。在训练期间，我们使用 32 位来表示每个权重——这就像用科学计算器测量制作三明治所需的食材。实际部署时？8 位就完全够用了。

这叫作量化，是我们最强大的优化技术之一。通过使用更小的数值：

• 模型缩小 75%（对于 Ultralytics YOLO11x，从 200MB 缩小到 50MB）
• 在大多数设备上运行速度提升 2-4 倍
• 功耗大幅降低（你的手机电池会感谢你）

YOLO 中并非所有层对这种精度降低都同样敏感。检测基本边缘和形状的早期层呢？它们很稳健——我们可以使用 8 位数值而不会遇到任何问题。决定“这是猫还是狗？”的最终检测层则需要更高一些的精度。因此，我们会逐层调整精度，只使用足以保持准确率的位数，同时最大限度地提升速度。

我们发现，通过谨慎量化，Ultralytics YOLO 在手机上运行速度提升 3 倍的同时，还能保持原始准确率的 99.5%。这就是研究模型与真正能在现实世界中使用的模型之间的差别。

选择最佳算法#

执行同一个数学运算有几十种不同方式。简单的卷积（YOLO 的核心运算）可以使用完全不同的算法来计算，而最佳选择取决于你的具体硬件和输入尺寸。

导出 YOLO 时，我们的优化框架会实际测试不同的算法，并为你的具体场景选择速度最快的算法。这就像有多条路线可以到达同一个目的地，然后根据当前交通状况选择路线。在 GPU 上，我们可能会使用能同时处理大量像素的算法。在 CPU 上，我们可能会使用针对顺序处理进行优化的算法。数学原理相同，但执行策略完全不同。

内存：隐藏的瓶颈#

还记得我们之前提到过，内存是现代计算中真正的瓶颈吗？这对 YOLO 尤其如此。模型可能拥有 5000 万个参数，而在推理期间，它还会创建数 GB 的中间结果。搬运所有这些数据往往比实际计算更慢。

我们使用多种技巧来尽量减少内存移动：

智能调度：我们安排运算顺序，让数据在仍处于高速缓存中的时候立即得到使用。对于 YOLO 的特征金字塔网络，这可以减少 40% 的内存流量。

分块：我们不一次处理整张图像，而是将其拆分成适合放入缓存的较小图块。这样，处理器就能使用快速的本地内存，而不必不断从速度较慢的主内存中读取数据。

缓冲区复用：我们不持续为中间结果创建新的内存，而是复用相同的内存缓冲区。这种方式效率极高——YOLO 的整个骨干网络只需使用一组可复用的缓冲区就能运行。

剪枝：少即是多#

这里有一个令人意外的事实：YOLO 模型往往设计得过于复杂。在许多层中，我们可以移除 30% 的通道，而几乎不会影响准确率。这不仅仅是让模型变小——还会让它运行得更快，因为需要执行的计算确实变少了。

这个过程很简洁：我们分析网络中对最终检测结果贡献最小的部分，将其移除，然后对模型进行微调以弥补影响。剪枝后的 YOLO11m 模型速度可以提升 30%，同时保持原始准确率的 99%。在电池供电设备上，这种效率提升可能意味着额外数小时的运行时间。

硬件加速：发挥每种芯片的优势#

不同处理器擅长不同的任务，性能差异非常惊人。同一个 YOLO11n 模型需要：

• 在现代 Intel CPU 上每帧 45 毫秒
• 在 NVIDIA RTX GPU 上 4 毫秒
• 在高端手机处理器上 22 毫秒
• 在 Google Coral 边缘 TPU 上 15 毫秒

这些并不只是时钟频率带来的速度差异——它们反映了根本性的架构差异。GPU 拥有数千个可并行工作的核心，非常适合 YOLO 的卷积运算。移动 NPU 配备了专为神经网络设计的专用电路。CPU 是全能型处理器，灵活但不专用。

优化的关键在于，让 YOLO 的运算匹配每种芯片最擅长的能力。GPU 喜欢同时对大量数据执行相同的运算。移动 NPU 可能只支持某些运算，但执行这些运算时效率极高。边缘 TPU 只能处理 8 位整数，但在这一限制下仍能达到惊人的速度。

编译的魔力#

导出 YOLO 模型时，幕后会发生一些非同寻常的事情。我们不只是转换文件格式——实际上还会针对你的目标硬件专门编译模型。这就像 Google 翻译与母语人士之间的区别。编译过程会：

1. 分析你的模型，了解其结构和需求
2. 考虑你的硬件能力——它擅长什么、又不擅长什么
3. 生成优化代码，使用你的硬件的原生语言

编译器可能会重新组织运算，以更好地利用处理器的缓存；选择芯片支持的专用指令；甚至使用机器学习来找到最佳优化策略。没错，我们正在使用 AI 来优化 AI——未来已经到来！

这一步编译可以带来 10 倍的性能差异。同一个 YOLO 模型使用通用代码时可能运行缓慢，但配合经过适当优化的指令后则会飞快运行。

真实世界中的边缘部署#

让我们谈谈 YOLO 遇到现实世界时会发生什么——具体来说，是充满挑战的边缘设备环境。想象一台需要全天候运行 YOLO 进行对象检测的安防摄像头。它面临着严苛的限制：

• 内存：总共可能只有 512MB 到 2GB 的 RAM
• 功耗：通常只有 2-5 瓦（低于手机充电器）
• 散热：没有风扇，只能被动散热
• 可靠性：必须持续运行而不能崩溃

下面是在实践中进行优化所能达到的效果。一台运行 YOLO11s 的安防摄像头：

• 原始模型：15 瓦，在 85°C 下高温运行，达到 20 FPS
• 经过量化和剪枝优化：3 瓦，温度舒适地保持在 45°C，达到 25 FPS

我们将功耗降低了 80%，同时还提升了性能！这就是设备过热、耗尽电池与设备能够可靠运行数年之间的差别。

关键在于选择正确的权衡方案。在边缘设备上，我们通常会：

• 使用 INT8 量化（精度更低，功耗也大幅降低）
• 在活动较少时处理更少的帧
• 将工作分配到不同的处理器上，以管理热量
• 让模型足够小，从而完全放入高速内存中

优化过程#

在 Ultralytics，我们采用系统化的方法进行优化。首先，我们对模型进行性能分析，以了解时间实际消耗在哪里。瓶颈往往并不在你预期的位置。可能 80% 的时间都消耗在少数几个层上，也可能内存传输占据了大部分计算时间。

接下来，我们会迭代应用优化：

1. 从最大的瓶颈入手
2. 一次应用一种优化
3. 同时衡量速度提升和对准确率的影响
4. 保留能够提供良好权衡的优化
5. 重复这一过程，直到达到目标

例如，在手机上部署 YOLO11m：

• 基线：每帧 200ms，模型大小 200MB
• 量化后：每帧 80ms，模型大小 50MB
• 剪枝后：每帧 60ms，模型大小 35MB
• 运算融合后：每帧 45ms，模型大小 35MB

每一步都会提升性能，同时保持超过原始准确率 99% 的水平。结果呢？在一台可以放进口袋的设备上实现实时对象检测。

未来：异构计算#

现代设备在协同使用多个处理器方面变得越来越智能。你的手机并不只有一个处理器——它拥有多个处理器，分别针对不同任务进行了专门优化：

• 摄像头传感器配备 ISP（图像信号处理器），用于预处理
• NPU（神经处理单元）运行 YOLO 推理
• CPU 处理复杂逻辑和协调工作
• GPU 在屏幕上渲染结果

YOLO 优化的未来在于智能地将模型拆分到这些处理器上。也许 NPU 负责主要的卷积运算，CPU 执行最终的检测逻辑，GPU 则将结果可视化。每个处理器都执行自己最擅长的任务，从而构建出比任何单个处理器都更高效的流水线。

我们正在开发智能分区算法，自动确定将 YOLO 拆分到可用处理器上的最佳方式，同时不仅考虑它们的能力，还考虑在处理器之间移动数据的成本。

归根结底#

优化 YOLO 模型不仅仅是转换文件格式；更是将尖端 AI 转化为真正能在现实世界中运行的方案。通过量化（使用更小的数值）、剪枝（移除不必要的部分）、运算融合（合并步骤）和智能内存管理等技术，我们在保持准确率的同时实现了 10-100 倍的性能提升。

最值得注意的是什么？不存在一种适用于所有场景的“最佳”优化方案。拥有无限电力的云服务器与电池供电的无人机需要不同的优化方式。配备专用 AI 芯片的手机与 Raspberry Pi 也需要不同的处理方式。这就是 Ultralytics 提供如此多导出选项的原因——每个选项都针对不同场景进行了优化。

我们讨论的每一项优化都服务于同一个目标：让计算机视觉无处不在。无论你是在构建智能门铃、无人机应用，还是大规模云服务，我们都提供工具，让 YOLO 在你的约束条件下运行。

使用 Ultralytics 导出 YOLO 模型时，你保存的不只是一份文件。你还在利用我们多年积累的神经网络实用化研究成果。你正在将最先进的 AI 模型转化为能够在真实硬件上运行、应对真实限制并解决真实问题的方案。

这就是我们在 Ultralytics 所做的事情。我们弥合 AI 研究与实际部署之间的差距。我们让计算机视觉能够在任何地方运行，因为 AI 的未来不仅在于拥有最好的模型，更在于让这些模型在现实世界中发挥作用。