TOON 格式终于赢了！AI 大模型基准测试揭示惊人真相

最近在深入研究 TOON.NET 的时候，发现了一组非常有意思的基准测试数据。说实话，我对结果有点震惊——一个相对较新的格式，居然在多个主流 AI 大模型上的表现都远超 JSON 和 YAML。今天就想和大家好好聊聊这个发现，以及它背后的意义。
什么是 TOON？为什么它如此特殊

在深入测试结果之前，咱们得先理解 TOON 到底是个啥。
TOON（Text-Oriented Object Notation） 是一种轻量级的数据序列化格式，它的设计理念就是为了在保持人类可读性的同时，最大化地减少 token 消耗。相比 JSON 和 YAML 的冗长语法，TOON 采用了更加紧凑的表示方式：

• 元数据前置：通过 [size]{fields} 的方式声明数组大小和对象字段，一次性告诉模型即将到来的数据结构
  
• 紧凑的值表示：避免了 JSON 中大量的引号、冒号、括号等符号
  
• 结构化的分隔：用冒号和缩进来表达层级关系，而不是嵌套的括号
  

这种设计对 AI 模型来说有个天然的好处——结构信息更清晰，需要的上下文窗口更小。但这只是我的推测，真正的验证需要拿数据说话。
实战测试：从本地部署到数据分析

我决定按照项目提供的方式，亲自跑一遍完整的基准测试。过程其实不复杂，但需要一点点耐心。
环境准备

首先确保你的电脑装了 .NET 10 SDK 和 VSCode。这是跑测试的基础。然后克隆项目到本地：

1. git clone https://github.com/AIDotNet/Toon.NET

复制代码

启动基准测试

进入基准测试目录：

1. cd benchmarks\AIDotNet.Toon.ModelBenchmarks

复制代码

运行启动脚本（这是我最喜欢的地方——直接一个 bat 脚本，省去了手动配置的麻烦）：

1. .\run-benchmark.bat

复制代码

脚本会交互式地询问你的配置。我这次的参数设置是：

1. ======================================================
2.   AIDotNet.Toon 模型基准测试 启动脚本 (Windows .bat)
3.   该脚本将引导你输入 API Key 和模型后启动程序
4. ======================================================
6. 请输入 OPENAI_API_KEY：[你的 API Key]
8. 请输入模型名称（逗号分隔）：gpt-5-mini,gpt-4o-mini,gemini-2.5-flash,grok-code-fast-1,claude-haiku-4.5
10. 可选：每个任务运行次数 BENCHMARK_RUNS：5
12. 可选：模型级并发 BENCHMARK_MODEL_PARALLELISM：5

复制代码

然后就是等待。测试会并行执行多个模型和格式组合，进度条会实时显示：

数据揭露：TOON 的压倒性优势

等待大约 3 分多钟后，测试完成了。输出的汇总结果直接让我眼前一亮：

1. 正在启动基准测试（首次运行将进行构建）...
2. 模型格式准确性基准（.NET）
3.                  claude-haiku-4.5 总结
4. ┌──────────────┬──────────┬─────────────┬─────────────┐
5. │ 格式         │ 准确率 % │ 提示 Tokens │ 生成 Tokens │
6. ├──────────────┼──────────┼─────────────┼─────────────┤
7. │ JSON         │ 41.7     │ 150.2       │ 18.6        │
8. │ JSON compact │ 50.0     │ 115.2       │ 13.1        │
9. │ TOON         │ 91.7     │ 110.5       │ 6.8         │
10. │ YAML         │ 52.8     │ 120.3       │ 10.8        │
11. └──────────────┴──────────┴─────────────┴─────────────┘
12.                  gemini-2.5-flash 总结
13. ┌──────────────┬──────────┬─────────────┬─────────────┐
14. │ 格式         │ 准确率 % │ 提示 Tokens │ 生成 Tokens │
15. ├──────────────┼──────────┼─────────────┼─────────────┤
16. │ JSON         │ 72.2     │ 152.1       │ 150.8       │
17. │ JSON compact │ 75.0     │ 111.2       │ 199.3       │
18. │ TOON         │ 100.0    │ 106.2       │ 181.0       │
19. │ YAML         │ 88.9     │ 123.9       │ 173.4       │
20. └──────────────┴──────────┴─────────────┴─────────────┘
21.                    gpt-4o-mini 总结
22. ┌──────────────┬──────────┬─────────────┬─────────────┐
23. │ 格式         │ 准确率 % │ 提示 Tokens │ 生成 Tokens │
24. ├──────────────┼──────────┼─────────────┼─────────────┤
25. │ JSON         │ 41.7     │ 137.9       │ 9.4         │
26. │ JSON compact │ 36.1     │ 110.4       │ 8.3         │
27. │ TOON         │ 83.3     │ 107.0       │ 4.1         │
28. │ YAML         │ 50.0     │ 117.3       │ 9.5         │
29. └──────────────┴──────────┴─────────────┴─────────────┘
30.                     gpt-5-mini 总结
31. ┌──────────────┬──────────┬─────────────┬─────────────┐
32. │ 格式         │ 准确率 % │ 提示 Tokens │ 生成 Tokens │
33. ├──────────────┼──────────┼─────────────┼─────────────┤
34. │ JSON         │ 58.3     │ 134.8       │ 277.4       │
35. │ JSON compact │ 58.3     │ 108.4       │ 323.7       │
36. │ TOON         │ 83.3     │ 105.2       │ 152.8       │
37. │ YAML         │ 75.0     │ 114.9       │ 300.4       │
38. └──────────────┴──────────┴─────────────┴─────────────┘
39.                  grok-code-fast-1 总结
40. ┌──────────────┬──────────┬─────────────┬─────────────┐
41. │ 格式         │ 准确率 % │ 提示 Tokens │ 生成 Tokens │
42. ├──────────────┼──────────┼─────────────┼─────────────┤
43. │ JSON         │ 58.3     │ 330.0       │ 6.9         │
44. │ JSON compact │ 58.3     │ 301.9       │ 5.4         │
45. │ TOON         │ 97.2     │ 290.7       │ 3.4         │
46. │ YAML         │ 66.7     │ 301.3       │ 5.3         │
47. └──────────────┴──────────┴─────────────┴─────────────┘

复制代码

关键数据洞察

1. 准确率：TOON 全面领先

看看准确率那一列，我觉得这是最能说明问题的地方：

• gemini-2.5-flash：TOON 达到了完美的 100% 准确率，其他格式最高也只有 88.9%（YAML）
  
• grok-code-fast-1：TOON 以 97.2% 击败其他所有格式，JSON 和 JSON compact 只有 58.3%
  
• claude-haiku-4.5：TOON 的 91.7% 远超 JSON 的 41.7% 和 YAML 的 52.8%
  
• gpt-4o-mini：TOON 的 83.3% 高出第二名 YAML（50%）整整 33 个百分点
  
• gpt-5-mini：TOON 的 83.3% 同样稳健领先
  

这不是偶然现象，而是一个在所有五个主流大模型上都能重现的规律。
2. Token 消耗：成本与效率的双重胜利

这里更有意思。不仅准确率高，TOON 的 token 占用也是最低的：

看看提示 Token 和生成 Token 的平均消耗：
模型格式平均提示 Tokens平均生成 Tokens平均总 Tokensclaude-haiku-4.5JSON150.218.6168.9claude-haiku-4.5JSON compact115.213.1128.3claude-haiku-4.5TOON110.56.8117.3claude-haiku-4.5YAML120.310.8131.1gemini-2.5-flashJSON152.1150.8302.9gemini-2.5-flashJSON compact111.2199.3310.4gemini-2.5-flashTOON106.2181.0287.2gemini-2.5-flashYAML123.9173.4297.3gpt-4o-miniJSON137.99.4147.3gpt-4o-miniJSON compact110.48.3118.7gpt-4o-miniTOON107.04.1111.1gpt-4o-miniYAML117.39.5126.8gpt-5-miniJSON134.8277.4412.2gpt-5-miniJSON compact108.4323.7432.0gpt-5-miniTOON105.2152.8258.0gpt-5-miniYAML114.9300.4415.3grok-code-fast-1JSON330.06.9336.9grok-code-fast-1JSON compact301.95.4307.3grok-code-fast-1TOON290.73.4294.1grok-code-fast-1YAML301.35.2306.5看到这组数据，我当时的反应就是——这简直是在替开发者省钱。对于大规模数据传输的场景，token 消耗的降低直接转化为 API 调用成本的下降。
为什么 TOON 会这么"聪明"？

说实话，这个问题我琢磨了一会儿。为什么 AI 模型对 TOON 格式的理解能力会这么强？
我的初步理解是：

• 信息密度更高：TOON 的结构化表示让模型能更快速地建立起"这是一个包含 N 个元素、每个元素有 M 个字段"的心智模型，而不需要逐个解析括号和引号。
  
• 更少的干扰信息：JSON 的语法糖虽然对人类友好，但对模型来说是额外的认知负担。TOON 则直奔主题。
  
• 预测路径更清晰：TOON 的规则性强，模型的 next-token 预测变得更有把握。这在 token 生成阶段表现为更少的"纠结"，生成结果也更准确。
  

实际应用场景：什么时候该用 TOON？

基于这些数据，我的建议是：

• 大数据量场景：API 调用传输 MB 级别的数据时，TOON 的 token 节省会非常显著
  
• 成本敏感项目：每一个 token 都算钱的时候，TOON 的优势不可忽视
  
• 高准确率要求：需要模型准确理解和处理结构化数据时，TOON 是更好的选择
  
• .NET 生态：如果你本身就是 .NET 栈，有现成的 SDK 支持，何乐而不为
  

C# 快速上手：用 TOON SDK 序列化数据

如果你是 .NET 开发者，我得好好介绍一下官方提供的 SDK，因为用起来真的很舒服。
安装

通过 NuGet 一行命令搞定：

1. dotnet add package AIDotNet.Toon

复制代码

序列化为 TOON

1. using Toon;
3. var options = new ToonSerializerOptions
4. {
5.     Indent = 2,                          // 用 2 个空格缩进
6.     Delimiter = ToonDelimiter.Comma,     // 用逗号分隔值
7.     Strict = true,                       // 严格模式
8.     LengthMarker = null                  // 不添加额外的长度标记
9. };
11. var data = new
12. {
13.     users = new[]
14.     {
15.         new { name = "alice", age = 30 },
16.         new { name = "bob", age = 25 }
17.     },
18.     tags = new[] { "a", "b", "c" },
19.     numbers = new[] { 1, 2, 3 }
20. };
22. string toonText = ToonSerializer.Serialize(data, options);
23. // 输出结果是这样的：
24. // users[2]{name,age}:
25. //   alice,30
26. //   bob,25
27. // tags[3]: a,b,c
28. // numbers[3]: 1,2,3

复制代码

看看这个输出格式，是不是特别清爽？没有多余的符号，每一个数据都清清楚楚地摆在那里。
反序列化（当前支持原子值）

1. using Toon;
3. var s = ToonSerializer.Deserialize<string>("hello", options);   // "hello"
4. var n = ToonSerializer.Deserialize<double>("3.1415", options);  // 3.1415

复制代码

总结：一个小格式的大潜力

这次测试让我认识到，有时候看似"新奇"的技术方案，真的是在踏踏实实地解决实际问题。TOON 不是为了标新立异而标新立异，它的每一个设计决策都指向一个目标——让 AI 模型理解得更快、更准，让开发者的成本更低。
在 AI 时代，结构化数据的表示方式直接关系到应用的成本和体验。如果你还在用 JSON 传输大量数据给 AI 模型，不妨试试 TOON，相信你会有惊喜的发现。
项目地址：https://github.com/AIDotNet/Toon.NET
官方地址：https://github.com/toon-format/toon
toon标准：https://github.com/toon-format/spec
如果这篇文章对你有帮助，请记得给项目一个 Star！每一个 Star 都是对开源作者的认可，也会激励他们继续打磨这个工具。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！