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

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

我们的 Ultralytics YOLO 模型会如实处理图像：把图像看作数字数组！每个像素其实就是颜色值，也就是构成图像的每个点的红、绿、蓝数值（因此称为 RGB）。我们把这些数字数组称为“张量”，因为听起来比“多维矩阵”酷多了，而“多维矩阵”听起来又比“层层叠叠的数字”酷多了。

当你将图像输入模型后，它就会开启一段精彩的网络之旅。想象一下，你的张量像冲浪一样穿过一层又一层，不断变换、卷积，并以一种美妙的方式经历各种数学运算。你可以把这想象成一场舞会，数字们在其中交融互动，提取出让猫成为猫、让汽车成为汽车的本质。我们把这个过程称为特征提取。

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

在模型施展本领之前，它们得先上学，也就是接受训练。训练过程会变得相当激烈。

训练期间，每次我们向网络输入图像，得到的都不只是一个答案。我们还要完成两项非常繁重的工作。首先，计算网络的错误程度（我们称之为损失，基本上就是预测结果与靶心之间的距离）。其次，也是关键所在，根据损失更新网络中的每一个数字（也就是权重）。你可以把它想象成同时调节成千上万个微小旋钮，每次调节都会经过计算，让网络变得更加准确。

从本质上说，我们通过纠错来训练网络：每次犯错都会教会它哪些事不该做，而我们会调整所有权重，这样它再次看到相似图像时，就能更接近正确答案。归根结底，网络通过一次次错误被轻轻推向正确方向，最终开始准确地做出预测。

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

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

那么，计算究竟是什么？所有这些数字运算实际是如何进行的？我们怎样才能让它更快？“优化计算”到底又是什么意思？

芯片实际如何进行数学运算#

计算由芯片完成。这些小小的硅片，简直就是宇宙中组织最严密的沙堡。计算机执行的每一项操作——每一次加法、比较，以及每一个“如果这样，那么那样”——都由硅片上的物理结构实现。芯片的特定区域中有专门用于数字加法的实体电路，另一些区域则负责逻辑运算。这就像一座微型城市，不同街区各自专精于不同类型的数学运算。

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

让我们一层层剥开这些抽象。来看这段简单至极的 Python 代码：

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

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

不过，有意思的地方来了。从这三行看似简单的代码，到电子实际穿过硅芯片，中间至少发生了四层庞大的转换（实际上不止四层，但四层已经足以说明问题）。让我带你走一遍这段令人惊叹的旅程：

第 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（吉赫兹）指的就是时钟速度，即每秒 35 亿个节拍。每个节拍称为一个时钟周期，它是计算中最基本的时间单位。

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

• 数据在组件之间传输
• 执行计算
• 做出逻辑判断
• 读取或写入内存

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

你可以通过提高处理器的时钟频率来超频；所有操作都会变快，但处理器也会产生更多热量，稳定性随之降低。超频过度，电脑就会崩溃，因为电子的运行速度真的跟不上节奏了。

过去，这些运算由占据整间屋子的机器实现。但负责所有这些计算的组件其实非常简单：它们只是开关。只有开或关的开关。

只要按照正确的方式把足够多的开关连接起来，就能实现计算。整个数字革命归根结底就是一套精密的开关组合。

正因为原理如此简单，只要有开关——任何类型的开关——就能造出计算机。人们曾用水管和阀门、多米诺骨牌、乐高积木、弹珠，甚至 Minecraft 中的红石，搭建出能正常运行的计算机。

自 20 世纪 40 年代以来，基本原理并没有改变。我们只是越来越擅长把开关做得极其微小。你的手机的计算能力超过了所有把人类送上月球的计算机的总和，而且还能放进口袋里，这都是因为我们找到了在原子尺度上制造开关的方法。

运行拥有数百万个参数的神经网络时，我们每秒都会翻转数十亿次这些微小开关，并让所有开关与晶体的心跳完美同步。每次权重更新、每次矩阵乘法、每个激活函数，都跟着时钟的节拍运转。

难怪训练模型时，你的计算机听起来像是要起飞了！

让神经网络跑得飞快#

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

要让神经网络快速运行，就像要在这样的厨房里做一顿五道菜的大餐：冰箱在三个街区外，你只有一个平底锅，而且每种食材重达 500 磅。数学运算本身并不是最大的问题，其他一切才是。

架构不匹配#

大多数芯片的设计初衷是运行 Microsoft Word，而不是神经网络。设计 CPU 时，工程师认为它一辈子都会忙着运行 if 语句、循环，偶尔还会计算一下你的税款（这项计算连超级计算机做起来都觉得心累）。CPU 针对顺序操作进行了优化：先做这个，再做那个，然后再做另一件事。

但神经网络完全不同。它们想要同时完成所有事情！训练时，你要根据预测结果的错误程度更新数百万个权重。推理时（也就是实际使用训练好的模型时），你要同时将数据送入数百万次计算。想象一下，你需要将一百万个数字分别乘以另一百万个数字。你的 CPU 虽然尽心尽力，但还是想一次处理一个，就像一个速度很快、却非常讲究条理的会计。

这就是 GPU 成为 AI 计算支柱的原因。GPU 的设计初衷是运行电子游戏，在游戏中，你需要同时计算数百万个像素的颜色。结果发现，计算像素颜色和进行神经网络运算出奇地相似：两者都需要对大量数据并行执行相同的操作。

但即使 GPU 也不是运行神经网络的完美选择。因此，现在各家公司都在打造专用 AI 芯片（TPU、NPU，以及其他所有以 PU 结尾的缩写）。这些芯片从设计之初就只有一个任务：让神经网络飞快运行。它们就像一位只会做一道菜的厨师，但做起这道菜来快得超乎常人。CPU 顺序执行矩阵运算时会吃力不已，GPU 并行处理矩阵运算的表现还不错，而这些专用芯片则能把矩阵当作一日三餐，大快朵颐。

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

在现代神经网络计算中，移动数据所花费的时间和能量，比实际进行计算还要多。

把你的计算机芯片想象成一位聪明绝顶的数学家，运算速度快如闪电，但所有参考书都放在镇上不同的建筑里。他们能瞬间解出任何方程，但首先得拿到数字，而这趟路程却要花很长时间。

你的芯片可以在一个时钟周期内将两个数字相乘（记得吗，一个周期就是每秒数十亿个节拍中的一个）。快如闪电！但要把这些数字从内存送到芯片上呢？可能需要数百个周期。这就像一位数学家能在一秒钟内解出一道题，却需要五分钟才能往返图书馆。

原因在于距离（以及空间）。电流移动得很快，但并非无限快。数据在芯片上要移动得越远，耗时就越长。计算机设计人员通过建立分层内存体系来解决这个问题，就像在不同距离设置多个存储位置：

• 寄存器（直接集成在计算单元中）：数学家的办公桌。可以立即访问！但空间很小，只能存放大约 32 个数字。这就像你眼前的便利贴。
• L1 缓存（相距几微米）：办公室里的书架。取用需要 3-4 个周期。这里可以存放几千个数字。
• L2 缓存（相距几毫米）：走廊另一头的文件柜。取用需要 10-15 个周期，可以存放几百万个数字。
• L3 缓存（位于芯片另一侧）：楼下的储藏室。取用需要 30-50 个周期，可以存放数千万个数字。
• RAM（位于另一块芯片上）：镇另一头的仓库。取用需要 100-300 个周期。数十亿个数字都存放在这里。
• SSD/硬盘（通过电缆连接）：完全是另一座城市。取用需要数百万个周期。存储容量巨大，速度却慢得像冰川。

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

现在，神经网络面临的棘手问题来了。假设你的 Ultralytics YOLO 模型有 5000 万个参数（顺便说一下，ChatGPT 有数十亿个参数）。这意味着有 5000 万个数字需要在内存和计算单元之间来回传输。即使每个数字只有 4 字节，也有 2 亿字节的数据需要在系统中移动。

芯片可能只需一个周期就能处理每个数字，但如果从 RAM 获取这个数字要花 100 个周期，那么你有 99% 的时间都在等待数据送达。这就像一辆一级方程式赛车堵在车流里。计算能力再强，也只能停在那里等待数据到来。

这里有个关键认识：这就是现代计算中的瓶颈所在。它被称为冯·诺依曼瓶颈。提高芯片的数学运算速度相对容易，但提高内存速度已经触及物理极限。这就是为什么 AI 中几乎所有性能优化都发生在内存层面。工程师加速神经网络时，很少是让数学运算本身更快；他们通常会设法减少数据移动、改善缓存，或更智能地访问数据。

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

每次移动一点数据，都会消耗能量。虽然不多，我们说的是皮焦耳级别，但每秒移动数 TB 数据时，消耗就会迅速累积。事实上，在芯片上移动 1 mm 的数据，比实际执行计算消耗的能量还多！

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

现代 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 位数值完全没问题。负责判断“这是猫还是狗？”的最终检测层则需要更高一点的精度。因此，我们逐层调整精度，只使用维持准确率所需的位数，同时尽可能提高速度。

选择最佳算法#

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

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

内存：隐藏的瓶颈#

还记得我们说过，内存是现代计算真正的瓶颈吗？对 YOLO 来说尤其如此。模型可能有 5000 万个参数，而在推理过程中还会产生数 GB 的中间结果。移动这些数据往往比实际计算还慢。

我们使用多种技巧来尽量减少内存数据传输：

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

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

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

剪枝：少即是多#

有个令人意外的事实：YOLO 模型往往经过了过度设计。我们通常可以移除许多层中的通道，而几乎不会影响准确率。这不只是缩小模型，而是让模型更快，因为实际需要执行的计算确实变少了。

这个过程很巧妙：我们分析网络中哪些部分对最终检测结果贡献最小，将它们移除，然后微调模型进行补偿。对于使用电池供电的设备，这种效率提升可能意味着数小时的额外运行时间。

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

不同处理器各有所长，性能差距不仅仅是时钟频率带来的速度差异，还反映了底层架构的根本差异。GPU 拥有数千个可以并行工作的核心，非常适合处理 YOLO 的卷积运算。移动 NPU 配备了专为神经网络设计的专用电路。CPU 则是多面手，灵活但不专精。

优化的关键，是让 YOLO 的操作与每种芯片最擅长的任务相匹配。GPU 擅长同时对大量数据执行相同操作。移动 NPU 可能只支持某些操作，但执行效率极高。Edge TPU 只能处理 8 位整数，但在这一限制下仍能实现惊人的速度。

编译的妙处#

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

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

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

这一步编译能让性能相差 10 倍。同一个 YOLO 模型用通用代码运行时可能慢得像爬，而换成经过适当优化的指令后就能飞快运行。

真实世界中的边缘部署#

来聊聊 YOLO 遇上现实世界时会发生什么——特别是面对充满挑战的边缘设备时。想象一台需要全天候运行 YOLO 来检测物体的安防摄像头。它面临着严苛的限制：

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

关键在于选好取舍。在边缘设备上，我们通常会：

• 使用 INT8 量化（精度较低，功耗也低得多）
• 在活动较少时减少处理帧数
• 将工作分配给不同的处理器，以控制温度
• 让模型足够小，能够完整放入高速内存

优化流程#

在 Ultralytics，我们采用系统化的方法进行优化。首先，我们分析模型性能，了解时间实际花在了哪里。瓶颈往往出乎意料。也许 80% 的时间都花在少数几个层上，或者内存传输占用了大部分计算时间。

接下来，我们逐步应用优化：

1. 从最大的瓶颈入手
2. 每次只应用一种优化
3. 同时衡量速度提升和准确率变化
4. 保留能带来良好取舍的优化
5. 重复以上步骤，直到达到目标

未来：异构计算#

现代设备越来越善于同时利用多个处理器。你的手机不只有一个处理器，而是有好几个，各自专门负责不同任务：

• 摄像头传感器配有 ISP（图像信号处理器），用于预处理
• NPU（神经处理单元）负责运行 YOLO 推理
• CPU 处理复杂逻辑并协调各方
• GPU 将结果渲染到屏幕上

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

我们正在开发智能分区算法，自动确定如何将 YOLO 最佳地拆分到可用处理器上，同时考虑各处理器的能力以及它们之间的数据传输成本。

归根结底#

优化 YOLO 模型不只是转换文件格式，而是让最先进的 AI 真正能在现实世界中运行。通过量化（使用更小的数值）、剪枝（移除不必要的部分）、算子融合（合并计算步骤）和智能内存管理等技术，我们可以在保持准确率的同时大幅提升性能。

最了不起的是什么？根本不存在通用的“最佳”优化方案。电力不受限制的云服务器需要的优化，与电池供电的无人机不同。配有专用 AI 芯片的手机，所需的优化也不同于 Raspberry Pi。这就是为什么 Ultralytics 提供这么多导出选项——每种选项都针对不同场景进行了优化。

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

使用 Ultralytics 导出 YOLO 模型时，你做的不只是保存文件，更是在借助多年研究成果，让神经网络变得实用。你正在把最先进的 AI 模型转化为能够在真实硬件上运行、满足实际限制并解决现实问题的模型。

这就是 Ultralytics 所做的事：弥合 AI 研究与实际部署之间的鸿沟。我们让计算机视觉无处不在，因为 AI 的未来不只是拥有最好的模型，更是让这些模型在现实世界中发挥作用。