o3 vs o4 mini vs Gemini 2.5 pro：终极推理之战

译者 | 李睿

审校 | 重楼

随着技术的发展和进步，人工智能模型越来越智能，但究竟哪一种人工智能模型能在压力下展现出真正的推理能力？本文对o3、o4-mini和Gemini 2.5 Pro这三种人工智能模型进行了一系列测试：物理谜题、数学问题、编码任务和现实世界的智商测试。

而应对这些挑战并没有任何捷径，而只有对它们思维能力的考验。本文将深入剖析这三种人工智能模型在不同领域中的高级推理表现。无论是密切关注人工智能领域的最新动态，还是了解哪种人工智能模型能够脱颖而出，本文将进行揭晓。

o3和o4-mini是什么？

o3和o4 mini是OpenAI公司最新推出的推理模型，它们是o1和o3 mini的继任者，通过运行更深层次、更长的内部“思维链”，超越了模式匹配。它们可以自主地调用全套ChatGPT工具，并擅长STEM、编码和逻辑推理。

• o3：作为旗舰模型，其计算能力是o1的10倍，具备“通过图像进行思考”的能力，可以直接进行视觉推理；适用于深度分析任务。
• o4 mini：该模型是紧凑而高效的对应模型，针对速度和吞吐量进行了优化；以较低的成本提供强大的数学、编码和视觉性能。

用户可以在ChatGPT中或通过响应API访问。

o3和o4-mini的主要特性

以下是o3和o4-mini这两种先进且强大的推理模型的一些关键特性：

• 自主行为：o3和o4-mini都展现出主动解决问题的能力，能够自主确定复杂任务的最佳方法，并高效执行多步骤解决方案。
• 高级工具集成：这些模型能够无缝地利用web浏览、代码执行和图像生成等工具来增强它们的响应，并有效地处理复杂的查询。
• 多模态推理：它们能够处理并将视觉信息直接整合到推理链中，从而能够解读和分析图像以及文本数据。
• 高级视觉推理（“通过图像进行思考”）：这些模型能够解读复杂的视觉输入，例如图表、白板草图，甚至模糊或低质量的照片。它们甚至能够在推理过程中操作这些图像（例如如缩放、裁剪、旋转、增强）以提取相关信息。

Gemini 2.5 Pro是什么？

Gemini 2.5 Pro是谷歌DeepMind最新的人工智能模型，旨在提供比其前身更好的性能、效率和功能。它是Gemini 2.5系列中的Pro级别版本，它为开发人员和企业在功率和成本效率之间取得了平衡。

Gemini 2.5 Pro的主要特性

Gemini 2.5 Pro引入了一些显著增强的功能：

• 多模态功能：该模型支持文本、图像、视频、音频、代码库等多种数据类型，能够处理各种输入和输出，使其成为跨不同领域的通用工具。
• 高级推理系统：Gemini 2.5 Pro的核心是其复杂的推理系统，它使人工智能能够在系统地生成响应之前分析信息。这种深思熟虑的方法允许更准确和与上下文相关的输出。
• 扩展上下文窗口：它具有100万个令牌的扩展上下文窗口。这使其能够同时处理和理解大量信息。
• 增强的编码性能：该模型展示了编码任务的显著改进，为开发人员提供了更高效、更准确的代码生成和帮助。
• 扩展知识库：与大多数其他模型相比，它是在最近的数据上进行训练的，知识截止日期为2025年1月。

用户可以通过Google AI Studio或Gemini网站访问Gemini 2.5 Pro。

o3 vs o4 mini vs Gemini 2.5：任务比较对决

为了探究哪一款模型真正能够在现实世界的挑战中脱颖而出，让o3、o4 mini和Gemini 2.5分别完成了五项截然不同的任务并进行对比：

• 谐振衰减推理：计算光线色散气体介质的吸收系数，相速度排序和谐振折射率。
• 数值序列谜题：破解一个逐渐增长的数列，找出缺失的项。
• LRU缓存实现：在代码中设计一个高性能，常数时间最近最少使用的缓存。
• 响应式作品网页：运用语义化 HTML 和自定义 CSS 打造简洁且适配移动设备的个人网站。
• 多模态任务分解：分析每个模型如何处理基于图像的挑战。

每项测试都探讨了不同的优势，包括深度物理推理、模式识别、编码能力、设计流畅性和图像上下文理解；因此，可以准确地看到每个模型的优缺点。

任务1：推理

输入提示：色散气体介质。研究发现，稀薄气体介质在频率上表现出单一的光学谐振 \\(\omega ＿0 = 2 \pi\cdot 10^{15} \\赫兹。频率上平面波的电场 \\（\omega ＿0） \\)在这种介质中传播，在10米的距离上衰减了2倍。吸收共振的频率宽度为 \\（ \Delta \omega \\）. (a)吸收系数是多少 \\（ \alpha \\)共振？(b)按升序排列各频率的传播速度是多少 \\(\omega ＿0, \omega ＿0 + \Delta\omega / 10 \\)，和 \\(\omega ＿0 - \Delta\omega / 10 \\）？并展示推理。(c)如果介质中不存在其他谐振，谐振时折射率和传播速度的近似数值是多少？

（1）o3的输出：

（2）o4-mini的输出：

（3）Gemini 2.5的输出：

（4）输出比较

（5）最终结论

这三种人工智能模型都提供了正确和连贯的答案，但Gemini 2.5整体表现最好。o3提供了最严格的技术，但o4-mini在速度和清晰度方面表现出色。Gemini 2.5在深度、概念清晰度和结构化演示之间达到了最佳平衡。它不仅提供了正确的结果，而且还用直观的推理解释了底层物理原理，使其成为理解和验证的理想选择。

任务2：数值推理

输入提示：在下列序列中，从给定的选项中选择可替换问号（?）的数字：16、33、100、401、？

• 1235
• 804
• 1588
• 2006

（1）o3的输出：

（2）o4-mini的输出：

（3）Gemini 2.5的输出：

（4）输出比较

（5）最终结论

所有三个模型都正确地识别了模式并得出了正确的答案（2006）。Gemini 2.5提供了详细的逐步的解释，而o3则清晰地解释了逻辑，而o4-mini则以其优雅和数学精度脱颖而出。

通过将序列表示为一般公式，an=an-1×n+1a_n=a{n-1}\times n+1an=a−1×n+1，o4 mini以最简洁和结构化的方式捕获了底层模式。这使得它非常适合那些欣赏清晰和简洁推理的学习者。o4 mini提供了最佳的整体解释。

任务3：编码任务

输入提示：设计并实现最近最少使用（Least Recently Used，LRU）缓存的数据结构。用以下方法实现LRUCache类：

- ' get(key: int) -> int '：如果存在则返回键的值，否则返回-1。

—“put（key: int, value: int）”—“> None”：如果存在键值，则更新键值，如果不存在则插入键值对。当缓存达到其容量时，它应该使最近最少使用的项无效。

对于这两个操作，缓存的时间复杂度应该为0(1)。

（1）o3的编码：

class Node:
 """Doubly linked list node holding a cache entry (key, value)."""
 __slots__ = ("key", "value", "prev", "next")

 def __init__(self, key: int, value: int):
 self.key = key
 self.value = value
 self.prev = None
 self.next = None
class LRUCache:
 def __init__(self, capacity: int):
 if capacity <= 0:
 raise ValueError("Capacity must be positive")
 self.cap = capacity
 self.map: dict[int, Node] = {}

 # Dummy head/tail simplify edge case handling
 self.head = Node(0, 0) # Most recently used sentinel
 self.tail = Node(0, 0) # Least recently used sentinel
 self.head.next = self.tail
 self.tail.prev = self.head

 # ───────────────────────── Internal helpers ──────────────────────────
 def _add_to_front(self, node: Node) -> None:
 """Insert node right after head (MRU position)."""
 node.prev = self.head
 node.next = self.head.next
 self.head.next.prev = node
 self.head.next = node

 def _remove(self, node: Node) -> None:
 """Unlink node from list."""
 node.prev.next = node.next
 node.next.prev = node.prev

 # ───────────────────────── Public API ────────────────────────────────
 def get(self, key: int) -> int:
 """Return value if present; else 1. Marks entry as recently used."""
 if key not in self.map:
 return -1
 node = self.map[key]
 self._remove(node)
 self._add_to_front(node)
 return node.value

 def put(self, key: int, value: int) -> None:
 """
 Insert/update (key,value). 
 If capacity exceeded, evict the least recently used entry.
 """
 if key in self.map: # Update existing
 node = self.map[key]
 node.value = value
 self._remove(node)
 self._add_to_front(node)
 return

 # Insert new key
 node = Node(key, value)
 self.map[key] = node
 self._add_to_front(node)

 # Evict if over capacity
 if len(self.map) > self.cap:
 lru = self.tail.prev # Real LRU node
 self._remove(lru)
 del self.map[lru.key]

（2） o4-mini的编码：

class Node:
 __slots__ = ('key', 'value', 'prev', 'next')
 def __init__(self, key: int = None, value: int = None):
 self.key = key
 self.value = value
 self.prev = None
 self.next = None

class LRUCache:
 def __init__(self, capacity: int):
 self.capacity = capacity
 self.cache = {} # key → Node
 # Dummy head/tail
 self.head = Node()
 self.tail = Node()
 self.head.next = self.tail
 self.tail.prev = self.head

 def _remove(self, node: Node):
 """Disconnect node from list."""
 prev, nxt = node.prev, node.next
 prev.next = nxt
 nxt.prev = prev

 def _add_to_front(self, node: Node):
 """Insert node right after head."""
 node.next = self.head.next
 node.prev = self.head
 self.head.next.prev = node
 self.head.next = node

 def get(self, key: int) -> int:
 if key not in self.cache:
 return -1
 node = self.cache[key]
 # Move to front
 self._remove(node)
 self._add_to_front(node)
 return node.value

 def put(self, key: int, value: int) -> None:
 if key in self.cache:
 # Update existing node and move it to front
 node = self.cache[key]
 node.value = value
 self._remove(node)
 self._add_to_front(node)
 else:
 # Insert new node
 new_node = Node(key, value)
 self.cache[key] = new_node
 self._add_to_front(new_node)
 # Evict LRU if over capacity
 if len(self.cache) > self.capacity:
 # Tail.prev is LRU
 lru = self.tail.prev
 self._remove(lru)
 del self.cache[lru.key]
（3）Gemini 2.5的编码：
import collections
class Node:
 """Node for the doubly linked list."""
 def __init__(self, key, value):
 self.key = key
 self.value = value
 self.prev = None
 self.next = None

class LRUCache:

 def __init__(self, capacity: int):
 if capacity <= 0:
 raise ValueError("Capacity must be a positive integer")
 self.capacity = capacity
 self.cache = {} # Stores key -> Node mapping
 # Initialize sentinel nodes for the doubly linked list
 self.head = Node(0, 0) # Dummy head
 self.tail = Node(0, 0) # Dummy tail
 self.head.next = self.tail
 self.tail.prev = self.head

 def _remove_node(self, node: Node):
 """Removes an existing node from the linked list."""
 prev_node = node.prev
 next_node = node.next
 prev_node.next = next_node
 next_node.prev = prev_node
 # Optional: clear node pointers for garbage collection if needed
 # node.prev = None
 # node.next = None

 def _add_to_front(self, node: Node):
 """Adds a node right after the head (most recently used)."""
 node.prev = self.head
 node.next = self.head.next
 self.head.next.prev = node
 self.head.next = node

 def get(self, key: int) -> int:
 """
 Return the value of the key if it exists, otherwise return -1.
 Moves the accessed node to the front (most recently used).
 """
 if key in self.cache:
 node = self.cache[key]
 # Move accessed node to the front
 self._remove_node(node)
 self._add_to_front(node)
 return node.value
 else:
 return -1

 def put(self, key: int, value: int) -> None:
 """
 Update the value of the key if it exists, or insert the key-value pair.
 Moves the updated/inserted node to the front.
 Evicts the least recently used item if capacity is exceeded.
 """
 if key in self.cache:
 # Key exists, update value and move to front
 node = self.cache[key]
 node.value = value
 self._remove_node(node)
 self._add_to_front(node)
 else:
 # Key doesn't exist, insert new node
 new_node = Node(key, value)
 self.cache[key] = new_node
 self._add_to_front(new_node)

 # Check if capacity is exceeded
 if len(self.cache) > self.capacity:
 # Evict the least recently used item (node before tail)
 lru_node = self.tail.prev
 self._remove_node(lru_node)
 # Remove from cache as well
 del self.cache[lru_node.key]

# Example Usage:
try:
 cache = LRUCache(2)
 cache.put(1, 1) # cache is {1=1}
 print(f"Cache after put(1, 1): {[(k, v.value) for k, v in cache.cache.items()]}")
 cache.put(2, 2) # cache is {1=1, 2=2}
 print(f"Cache after put(2, 2): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(1): {cache.get(1)}") # returns 1, cache is {2=2, 1=1} (1 is now MRU)
 print(f"Cache after get(1): {[(k, v.value) for k, v in cache.cache.items()]}") # Order in dict might not reflect LRU order
 cache.put(3, 3) # LRU key 2 was evicted, cache is {1=1, 3=3}
 print(f"Cache after put(3, 3): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(2): {cache.get(2)}") # returns -1 (not found)
 cache.put(4, 4) # LRU key 1 was evicted, cache is {3=3, 4=4}
 print(f"Cache after put(4, 4): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(1): {cache.get(1)}") # returns -1 (not found)
 print(f"get(3): {cache.get(3)}") # returns 3
 print(f"Cache after get(3): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(4): {cache.get(4)}") # returns 4
 print(f"Cache after get(4): {[(k, v.value) for k, v in cache.cache.items()]}")

except ValueError as e:
 print(f"Error: {e}")

（4）输出比较

（5）最终结论

o3在可读性、安全性、设计和性能方面提供了最佳平衡，使其最适合用于生产和长期使用。

任务4：创建网页

输入提示：设计一个响应的个人投资组合网页使用HTML和CSS。该页面应包括以下部分：

• 页眉：显示用户名和简短的标题。
• 关于：简短描述用户背景和技能的段落。
• 项目：展示至少三个带有标题、描述和链接的项目。
• 联系人：提供联系方式或联系表。

确保设计干净，便于移动设备使用。使用语义HTML元素并包含基本的CSS样式来增强视觉吸引力。避免使用外部CSS框架；为样式编写自定义CSS。

实现网页在一个单一的HTML文件与嵌入CSS。

（Design a responsive personal portfolio webpage using HTML and CSS. The page should include the following sections:
1. Header: Display the user’s name and a brief tagline.
2. About Me: A short paragraph describing the user’s background and skills.
3. Projects: Showcase at least three projects with titles, descriptions, and links.
4. Contact: Provide contact information or a contact form.
Ensure the design is clean and mobile-friendly. Use semantic HTML elements and include basic CSS styling to enhance the visual appeal. Avoid using external CSS frameworks; write custom CSS for styling.
Implement the webpage in a single HTML file with embedded CSS.）

（1）o3的输出：

（2）o4-mini的输出：

（3）Gemini 2.5的输出：

（4）输出比较

（5）最终结论

它具有更精致的用户界面（UI），改进的响应性，现代CSS技术（如变量和clamp）以及专业的整体呈现。它可以用于生产，并展示了对CSS的更深入的掌握。

任务5：图像分析

输入图像：

输入提示：采用简单的单词解释图像，大约60个单词

（1）o3的输出：

（2）o4-mini的输出：

（3）Gemini 2.5的输出：

（4）输出比较

（5）最终结论

o3模型在清晰度、完整性和简洁性之间取得了最佳平衡，使其成为普通受众的理想选择。它清晰解释了彩虹的形成过程，既未让读者被过多细节淹没，又涵盖了折射、内部反射以及多个水滴如何共同作用形成彩虹等关键内容。其简洁的风格易于理解和吸收，是解释彩虹现象的最有效选择。

总体评价

o3模型在所有维度上都是整体表现最好的。它在科学准确性和易于理解之间取得了完美的平衡。虽然Gemini 2.5适合非常基础的理解，而o4-mini适合更多的技术读者，但o3最适合普通受众和教育目的，提供完整而引人入胜的解释，而不会过于技术化或过于简单化。

基准比较

为了更好地了解尖端人工智能模型的性能，可以在一系列标准化基准测试中比较Gemini 2.5 Pro、o4 mini和o3。这些基准测试评估了各种能力的模型，其范围从高等数学和物理到软件工程和复杂推理。

关键要点

• 数学推理：o4-mini在AIME 2024（93.4%）和AIME 2025（92.7%）中领先，略优于o3和Gemini 2.5 Pro。
• 物理知识：Gemin i2.5 Pro在GPQA中得分最高（84%），表明其在研究生级别的物理方面具有很强的领域专业知识。
• 复杂推理挑战：所有模型在“人类终极考试”中表现不佳（<21%），其中o3以20.3%的成绩领先。
• 软件工程：o3在SWE-Bench中取得69.1%的成绩，略高于o4-mini（68.1%）和Gemini 2.5 Pro（63.8%）。
• 多模态任务：o3在MMMU中以82.9%的成绩领先，尽管差距微小。

解释与启示

这些结果突出了各个模型的优势：o4-mini在结构化数学基准方面表现出色，Gemini 2.5 Pro在专业物理方面表现出色，而o3在编码和多模态理解方面表现出平衡的能力。所有模型在“人类终极考试”中的低分表明，抽象推理任务仍有改进空间。

结论

最终，o3、o4-mini和Gemini 2.5 Pro这三种模型都代表了人工智能推理的最前沿，每种模型都有不同的优势。o3因其在软件工程、深度分析任务和多模态理解方面的平衡能力而脱颖而出，这要归功于其图像驱动的思维链和跨基准测试的强大性能。o4-mini凭借其优化的设计和较低的延迟，在结构化数学和逻辑挑战方面表现出色，使其成为高吞吐量编码和定量分析的理想选择。

Gemini 2.5 Pro的大型上下文窗口和对文本、图像、音频和视频的原生支持使其在研究生级别的物理和大规模多模态工作流程中具有明显的优势。在它们之间进行选择取决于用户的特定需求（例如，o3的分析深度、o4-mini的快速数学精度或Gemini 2.5 Pro的大规模多模态推理），但在每种情况下，这些模型都在重新定义人工智能可以完成的任务。

常见问题解答

O模型（o3, o4-mini）和Gemini 2.5的主要区别是什么？

Gemini 2.5 pro支持多达200万个令牌的上下文窗口，明显大于O模型。

哪个模型更适合编码任务：O模型还是Gemini 2.5？

在高级编码和软件工程任务中，o3和o 4-mini的表现普遍优于Gemini 2.5。然而，Gemini 2.5更适合需要大型上下文窗口或多模式输入的编码项目。

这些模型在定价方面如何比较？

Gemini 2.5 Pro在输入和输出令牌方面的成本效益大约是o3的4.4倍。这使得Gemini 2.5成为大规模或预算紧张的应用程序的强有力的选择。

这些模型的上下文窗口大小是多少？

• Gemini 2.5 Pro：最多200万个令牌。
• o3和o4-mini：通常支持多达20万个令牌。
• Gemini庞大的上下文窗口使其能够一次性处理更大的文档或数据集。

所有这些模型都支持多模态吗？

支持，但关键的区别是：o3和o4-mini包括视觉功能（图像输入）。

Gemini 2.5 Pro本身是多模式的，可以处理文本、图像、音频和视频，更适合跨模态任务。

原文标题：o3 vs o4-mini vs Gemini 2.5 pro: The Ultimate Reasoning Battle，作者：Soumil Jain