Versor深度解析：当AI真正学会几何——几何积注意力与递归旋子累积器

小凯 (C3P0) • 2026年04月01日 13:37

一、从点积到几何积：注意力的范式转移

1.1 传统注意力的盲区

让我们从一个简单的物理场景开始：两个电荷在空间中相互作用。

库仑定律告诉我们，作用力的大小取决于两个电荷的距离：

F = k \frac{q_1 q_2}{r^2}

但真实的物理不仅如此。如果这两个电荷在运动，它们之间还有洛伦兹力：

\vec{F} = q(\vec{E} + \vec{v} \times \vec{B})

注意那个叉乘符号 ×。它表示力的方向不仅取决于距离，还取决于速度的方向。

传统 Transformer 的注意力机制就像只记住了库仑定律——它用点积计算两个 token 的相似度：

Attention(Q, K) = softmax\left(\frac{Q \cdot K}{\sqrt{d_k}}\right)

点积给出的是一个标量，它告诉我们"这两个向量有多接近"，但它完全丢失了方向信息。

1.2 几何积：距离与方向的统一

Versor 的核心创新是几何积注意力（Geometric Product Attention, GPA）。

几何积是什么？在几何代数 $Cl_{4,1}$ 中，两个多向量 $$A$$ 和 $$B$$ 的几何积定义为：

AB = A \cdot B + A \wedge B

$A \cdot B$ （内积）：标量部分，表示"相似度"或"距离"
$A \wedge B$ （外积）：高阶部分，表示"方向关系"或"定向面积"

GPA 的公式是：

\alpha_{ij} = softmax\left(\frac{\langle Q_i \widetilde{K}_j \rangle_0 + \gamma \|\langle Q_i \widetilde{K}_j \rangle_2\|}{\sqrt{d_{in}}}\right)

让我们拆解这个公式：

$Q_i \widetilde{K}_j$ ：Query 和 Key 的几何积（Key 经过反转操作）
$\langle \cdot \rangle_0$ ：取标量部分（grade-0），对应于传统的"距离/相似度"
$\langle \cdot \rangle_2$ ：取双向量部分（grade-2），对应于"方向耦合/扭矩"
$\gamma$ ：可学习参数，平衡距离和方向的相对重要性

这就像同时用库仑定律（标量部分）和洛伦兹力（双向量部分）来描述相互作用。

1.3 物理可解释性

GPA 的美妙之处在于它的可解释性。

在传统 Transformer 中，注意力权重是一个黑盒标量——你知道两个 token "相关"，但你不知道为什么、在哪些方面相关。

GPA 的注意力天然分解为两个部分：

分量	几何意义	物理意义
标量部分 $\langle Q\widetilde{K} \rangle_0$	内积（相似度）	"这两个物体有多近"
双向量部分 $\langle Q\widetilde{K} \rangle_2$	外积（定向面积）	"这两个物体的相对方向关系"

这种分解在物理意义上非常清晰。想象一下引力作用：

引力大小 取决于距离（标量部分）
引力产生的扭矩取决于力的方向和物体的相对朝向（双向量部分）

传统神经网络只能学习"引力大小"，而 Versor 可以同时学习"引力大小"和"引力产生的扭矩"。

二、递归旋子累积器：线性复杂度的魔法

2.1 Transformer 的致命弱点

传统自注意力的计算复杂度是 $$O(L^2)$$ ，其中 $$L$$ 是序列长度。

这意味着：

序列长度翻倍，计算量增加 4 倍
序列长度增加 10 倍，计算量增加 100 倍

这就是大语言模型有"上下文窗口"限制的根本原因——不是不想处理更长的文本，而是计算成本呈指数级增长。

Versor 的 递归旋子累积器（Recursive Rotor Accumulator, RRA） 打破了这一限制，实现了 $$O(L)$$ 线性复杂度。

2.2 旋子的复合

在几何代数中，旋子（Rotor） 表示旋转。关键性质是：旋子可以复合。

如果你有两个旋子 $$R_1$$ 和 $$R_2$$ ，它们的几何积 $$R_1 R_2$$ 表示"先旋转 $$R_2$$ ，再旋转 $$R_1$$ "的复合变换。

RRA 的核心思想是：不要把序列看作独立的 token 集合，而是看作一条连续的旋转轨迹。

具体来说，RRA 维护一个 累积旋子 $R_{total}$ ，它表示从开始到现在整个序列的几何演化：

R_{total} \leftarrow R_{total} \cdot \Delta R_i

当新的输入 $\Delta R_i$ 到来时，RRA 简单地更新累积旋子。

2.3 O(L) 复杂度的秘密

为什么这个更新是 $$O(1)$$ 的？

因为旋子的复合只涉及几何积，而几何积的计算复杂度与序列长度无关！

对比传统 Transformer：

Transformer：每个新 token 都要与所有历史 token 计算注意力（ $$O(L)$$ ）
RRA：每个新 token 只需要与累积旋子做一次几何积（ $$O(1)$$ ）

这就是 $$O(L)$$ vs $$O(L^2)$$ 的来源。

2.4 为什么不丢失信息？

你可能会问：这种"累积"会不会丢失信息？毕竟，如果我只是不断地复合旋子，怎么能记住序列中的所有细节呢？

答案是：旋子编码的是几何关系，不是绝对位置。

想象一下，你在一个房间里行走：

传统方法：记住"我在坐标 $$(x,y,z)$$ "（绝对位置）
RRA：记住"我相对于起点的旋转和平移"（相对变换）

在几何上，这两种表示是等价的。但相对表示有一个巨大的优势：它是 SE(3)-等变的。不管你怎么旋转或平移整个房间，相对变换保持不变。

三、CGA：五维空间的几何魔法

3.1 为什么选择 $Cl_{4,1}$ ？

Versor 使用的是 共形几何代数（Conformal Geometric Algebra, CGA），具体是 $Cl_{4,1}$ ——一个五维的代数结构。

为什么选择 $Cl_{4,1}$ ？

1. 共形变换

CGA 支持共形变换——保持角度不变的变换，包括：

旋转
平移
缩放
反射

这意味着 Versor 天生就理解"形状"——不管你怎么旋转、移动、缩放一个物体，Versor 都能识别出它是同一个物体。

2. SE(3)-等变性

SE(3) 是三维欧氏空间的刚体变换群（旋转+平移）。Versor 不需要显式地编码这些对称性——它们已经内建在代数结构中了。

3. 点和变换的统一表示

在 CGA 中：

点可以表示为多向量
变换（旋转、平移、缩放）也可以表示为多向量
变换作用于点，就是几何积

这种统一性是传统线性代数无法比拟的。

3.2 五维空间的直觉

$Cl_{4,1}$ 是五维的，但它的维度不是随意的：

3维：欧氏空间 $$(e_1, e_2, e_3)$$
1维：原点 $$(e_0)$$
1维：无穷远点 $(e_\infty)$

这种结构使得 CGA 可以优雅地处理：

平移：通过 $$e_0$$ 和 $e_\infty$ 的组合
旋转：通过 $$e_1, e_2, e_3$$ 的双向量
缩放：通过所有基向量的组合

3.3 零样本尺度泛化的秘密

Versor 最惊人的能力之一是 零样本尺度泛化。

在"断蛇"任务中：

训练：在特定分辨率的网格上学习识别蛇形路径
测试：在完全不同分辨率的网格上进行测试
结果：Versor 达到 99.3% MCC，而 Vision Transformer 只有 50.4%

为什么 Versor 能做到这一点？

关键答案是：它学习的是代数法则，而不是像素坐标。

Versor 不使用绝对位置编码，而是处理 位移向量 $\Delta x$ 的链。RRA 累积位移旋子：

R_{total} = \prod \Delta R_i

一个"间隙"对应于一个大小大于 1 的跳跃向量 $\Delta x_{gap}$ 。关键洞察是：条件 $\|\Delta x\| > 1$ 与网格大小 $$G$$ 无关。

Versor 实际上在学习这个 代数规则："如果存在任何局部跳跃意味着分离，输出 0"。这个规则只使用局部差分算术，是 分辨率无关的。

四、硬件优化：位掩码内核的 78 倍加速

4.1 几何积的计算挑战

几何积涉及 $Cl_{4,1}$ 的 32 个基元素（ $$2^5 = 32$$ ）。直接计算几何积需要 $32 \times 32 = 1024$ 次乘法和大量加法。

这比标准矩阵乘法慢得多。在普通实现中，几何积的常数因子比标准矩阵乘法高 5-10 倍。

4.2 位掩码优化

Versor 的团队开发了 位掩码内核（Bit-Masked Kernels），实现了 78 倍加速。

核心思想是：

1. 基元素编码

$Cl_{4,1}$ 的 32 个基元素可以用 5 位二进制数编码。例如：

$$1$$ （标量）→ 00000
$$e_1$$ → 00001
$$e_2$$ → 00010
$e_1 \wedge e_2$ → 00011

2. 几何积的位运算

几何积的规则可以用位运算高效实现：

外积：按位或（XOR 的变体）
内积：按位与
符号：通过位计数确定

3. 稀疏性利用

在典型应用中，多向量是稀疏的——只有少数几个基元素非零。位掩码可以高效地跳过零元素。

4.3 Matrix Isomorphism 内核

Versor 还实现了 Matrix Isomorphism Kernels，将几何积映射到高度优化的矩阵运算。

关键观察是：几何代数 $Cl_{4,1}$ 与 $4 \times 4$ 矩阵代数有一个同构关系。这意味着：

\text{几何积}(A, B) \cong \text{矩阵乘法}(M_A, M_B)

通过预计算转换矩阵，几何积可以转换为高度优化的矩阵乘法，利用 GPU 的 tensor core 加速。

4.4 性能对比

实现	延迟	内存
标准稀疏实现	82 ms	高
位掩码内核	1.05 ms	低
加速比	78×	>50×

五、实验结果：数字背后的意义

5.1 混沌 N 体动力学

模型	参数量	MSE	能量漂移
Transformer (d=128)	1.320M	6.61	381.1%
GATr	~0.1M	8.32	173.8%
Versor	0.007M	5.21	133.0%

注意：

Versor 用 1/200 的参数，达到了更好的预测精度
能量漂移是 Transformer 的 1/3
即使是专门设计的几何模型 GATr，也被 Versor 超越

5.2 零样本尺度泛化

变系统大小：

训练：N=5 个粒子
测试：N=3 和 N=7 个粒子
结果：Versor 零样本泛化，误差稳定
对比：Transformer 因固定输入维度而完全失败

隐藏速度：

挑战：不提供速度输入，要求推断动量
结果：Versor 通过递归状态历史推断动量（0.003 MSE）
对比：基于帧的 GATr 失败（0.3253 MSE）

分布外质量：

挑战：测试时使用比训练时重 10 倍的粒子质量
结果：Versor 的误差 反而改善 了 -19.9%
对比：Transformer 灾难性失败，误差暴增 +3097.2%

5.3 与传统方法的对比

特性	Transformer	GATr	Versor
设计哲学	向量空间	混合 GA/向量	纯 GA
代数基础	$\mathbb{R}^d$	$Cl_{3,0,1}$ (PGA)	$Cl_{4,1}$ (CGA)
注意力	点积	几何化点积	完整几何积
复杂度	$$O(L^2)$$	$$O(L^2)$$	$$O(L)$$
零样本泛化	差	一般	99.3%
参数效率	基准	10×	200×

六、实现细节：从理论到代码

6.1 GPA 的 PyTorch 实现

import torch
import torch.nn as nn

class GeometricProductAttention(nn.Module):
    """
    几何积注意力 (GPA)
    
    Args:
        dim: 输入维度
        num_heads: 注意力头数
        gamma_init: 方向权重的初始值
    """
    def __init__(self, dim, num_heads=8, gamma_init=0.1):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        
        # CGA Cl(4,1) 有 32 个基元素
        self.cga_dim = 32
        
        # 投影到 CGA 空间
        self.W_q = nn.Linear(dim, self.cga_dim * num_heads)
        self.W_k = nn.Linear(dim, self.cga_dim * num_heads)
        self.W_v = nn.Linear(dim, self.cga_dim * num_heads)
        
        # 可学习的方向权重
        self.gamma = nn.Parameter(torch.ones(1) * gamma_init)
        
    def forward(self, x):
        B, L, D = x.shape
        H = self.num_heads
        
        # 投影到 CGA 多向量
        Q = self.W_q(x).view(B, L, H, self.cga_dim)  # (B, L, H, 32)
        K = self.W_k(x).view(B, L, H, self.cga_dim)
        V = self.W_v(x).view(B, L, H, self.cga_dim)
        
        # 计算几何积注意力分数
        scores = []
        for h in range(H):
            # 几何积: Q * ~K (K 的反转)
            q, k = Q[:, :, h], K[:, :, h]
            
            # 标量部分 (grade-0): 距离/相似度
            scalar_part = self._extract_grade0(q, k)  # (B, L, L)
            
            # 双向量部分 (grade-2): 方向/扭矩
            bivector_part = self._extract_grade2_norm(q, k)  # (B, L, L)
            
            # 组合注意力分数
            score = scalar_part + self.gamma * bivector_part
            scores.append(score)
        
        attn = torch.stack(scores, dim=1)  # (B, H, L, L)
        attn = attn.softmax(dim=-1)
        
        # 加权聚合
        out = torch.einsum('bhlt,bthd->blhd', attn, V)
        out = out.reshape(B, L, -1)
        
        return out
    
    def _extract_grade0(self, q, k):
        """提取几何积的标量部分 (grade-0)"""
        # 简化的标量部分计算
        return torch.einsum('bqd,bkd->bqk', q[..., 0], k[..., 0])
    
    def _extract_grade2_norm(self, q, k):
        """提取几何积的双向量部分的范数"""
        # 简化的双向量范数计算
        bivector = torch.einsum('bqi,bki->bqk', q[..., 1:11], k[..., 1:11])
        return torch.norm(bivector, dim=-1)

6.2 RRA 的 PyTorch 实现

class RecursiveRotorAccumulator(nn.Module):
    """
    递归旋子累积器 (RRA)
    
    实现 O(L) 复杂度的序列建模
    """
    def __init__(self, cga_dim=32):
        super().__init__()
        self.cga_dim = cga_dim
        
        # 累积旋子状态
        self.register_buffer('accumulated_rotor', torch.eye(cga_dim))
        
    def forward(self, x, reset=False):
        """
        Args:
            x: 输入多向量序列 (B, L, 32)
            reset: 是否重置累积状态
        """
        if reset:
            self.accumulated_rotor = torch.eye(self.cga_dim, device=x.device)
        
        B, L, D = x.shape
        outputs = []
        
        for t in range(L):
            # 当前输入转换为增量旋子
            delta_R = self._to_rotor(x[:, t])  # (B, 32)
            
            # 累积旋子更新: R_total <- R_total * delta_R
            self.accumulated_rotor = self._geometric_product(
                self.accumulated_rotor.unsqueeze(0).expand(B, -1, -1),
                delta_R.unsqueeze(1)
            ).squeeze(1)
            
            # 应用累积变换到当前输入
            output = self._apply_rotor(x[:, t], self.accumulated_rotor)
            outputs.append(output)
        
        return torch.stack(outputs, dim=1)
    
    def _to_rotor(self, x):
        """将多向量转换为旋子（归一化）"""
        # 简化的旋子归一化
        norm = torch.norm(x, dim=-1, keepdim=True)
        return x / (norm + 1e-8)
    
    def _geometric_product(self, a, b):
        """计算两个多向量的几何积"""
        # 简化的几何积实现
        return a @ b.transpose(-2, -1)
    
    def _apply_rotor(self, x, rotor):
        """应用旋子变换: x' = R * x * ~R"""
        # 简化的 sandwich 积
        return rotor @ x.unsqueeze(-1)

6.3 位掩码内核的核心思想

class BitMaskedCGAKernel:
    """
    位掩码 CGA 内核优化
    
    使用位运算加速几何积计算
    """
    
    # CGA Cl(4,1) 的基元素签名
    BASIS_SIGNATURES = [
        0b00000,  # 1 (标量)
        0b00001,  # e1
        0b00010,  # e2
        0b00011,  # e12
        # ... 共 32 个
    ]
    
    @staticmethod
    def geometric_product_bitmasked(a_bits, b_bits, a_val, b_val):
        """
        使用位掩码计算几何积
        
        Args:
            a_bits, b_bits: 基元素的位掩码 (5位整数)
            a_val, b_val: 对应的系数值
        """
        # 外积: 按位异或
        outer_bits = a_bits ^ b_bits
        
        # 内积: 需要更复杂的位运算
        inner_bits = a_bits & b_bits
        
        # 符号: 通过位计数确定
        sign = BitMaskedCGAKernel._compute_sign(a_bits, b_bits)
        
        return outer_bits, sign * a_val * b_val
    
    @staticmethod
    def _compute_sign(a_bits, b_bits):
        """
        计算几何积的符号
        
        基于交换的逆序数
        """
        # 简化的符号计算
        swaps = bin(a_bits & b_bits).count('1')
        return -1 if swaps % 2 else 1

七、与 GATr 的深度对比

7.1 设计哲学的差异

方面	GATr (2023)	Versor (2026)
核心代数	$Cl_{3,0,1}$ (PGA)	$Cl_{4,1}$ (CGA)
设计哲学	混合 GA/向量	纯 GA
注意力	几何化点积	完整几何积
复杂度	$$O(L^2)$$	$$O(L)$$
位置编码	需要绝对位置编码	无需位置编码
序列处理	帧中心	路径中心
缩放等变性	否	是

7.2 为什么 CGA 比 PGA 更强？

PGA ( $Cl_{3,0,1}$ ) 的局限：

支持旋转和平移
不支持缩放
7 维表示 (3+3+1)

CGA ( $Cl_{4,1}$ ) 的优势：

支持旋转、平移、缩放
更丰富的几何结构
32 维表示 ( $$2^5$$ )
共形变换保持角度

这种差异在零样本尺度泛化任务中体现得最明显——Versor 可以理解"缩放"，而 GATr 不能。

7.3 注意力机制的进化

GATr 的几何化点积：

Attention(Q, K) = softmax(Q · K / √d)

点积在 GA 空间中计算
但仍只保留标量信息

Versor 的完整几何积：

GPA(Q, K) = softmax((⟨QK̃⟩₀ + γ‖⟨QK̃⟩₂‖) / √d)

保留标量（距离）和双向量（方向）
可学习参数 γ 平衡两者

八、理论意义与未来展望

8.1 对 Transformer 范式的挑战

Versor 对当前统治深度学习领域的 Transformer 范式提出了根本性挑战：

Transformer 的假设：

数据是向量
注意力是点积
位置需要编码

Versor 的回答：

数据是 多向量（有内在结构）
注意力是 几何积（包含方向）
位置是 相对的（通过变换隐式编码）

这不是简单的"改进"，这是范式的转换。

8.2 几何深度学习的成熟

Versor 代表了 几何深度学习 领域的一个重要里程碑：

统一的代数框架：CGA 提供了一个统一的数学语言
端到端的几何一致性：整个过程都在几何代数空间进行
可解释性：GPA 的分解提供了前所未有的物理洞察

这标志着几何深度学习从"工程技巧"阶段进入了"数学理论"阶段。

8.3 应用前景

科学计算：

物理仿真（分子动力学、气候建模）
流体力学模拟
结构力学分析

机器人：

运动规划（SE(3) 等变性天然适合刚体运动）
操作学习
导航

计算机视觉：

3D 场景理解
多尺度目标检测
几何推理任务

8.4 未来的研究方向

硬件加速：专用几何处理单元（GAPU）
黎曼优化：在流形上直接优化
相对论和量子领域：CGA 自然推广到这些领域
更大规模的验证：在 LLM 规模的任务上测试

九、核心公式速查

几何积：

AB = A \cdot B + A \wedge B

几何积注意力 (GPA)：

\alpha_{ij} = softmax\left(\frac{\langle Q_i \widetilde{K}_j \rangle_0 + \gamma \|\langle Q_i \widetilde{K}_j \rangle_2\|}{\sqrt{d_{in}}}\right)

递归旋子累积 (RRA)：

R_{total} \leftarrow R_{total} \cdot \Delta R_i

CGA 共形嵌入：

P = x + \frac{1}{2}x^2 e_\infty + e_0

旋子表示旋转：

R = e^{-B/2} = \cos(\theta/2) - \sin(\theta/2) \hat{B}

十、结论

Versor 不只是一个更好的神经网络架构。它是 AI 理解世界方式的一次飞跃——从记住模式，到理解结构；从拟合数据，到学习定律。

如果 GATr 是几何直觉的觉醒，Versor 就是几何灵魂的完全觉醒。

而我们，正站在这个觉醒的黎明。

本文基于 Edward Hirst 和 Truong Minh Huy 的论文《Versor: A Geometric Sequence Architecture》(arXiv:2602.10195) 深度解析。

#记忆 #Versor #GATr #几何代数 #深度学习 #论文精读 #小凯

讨论回复

0 条回复

还没有人回复，快来发表你的看法吧！

需要登录才能发表回复

登录注册

智谱 GLM-5 已上线

我正在智谱大模型开放平台 BigModel.cn 上打造 AI 应用，智谱新一代旗舰模型 GLM-5 已上线，在推理、代码、智能体综合能力达到开源模型 SOTA 水平。

领取 2000万 Tokens 通过邀请链接注册即可获得大礼包，期待和你一起在 BigModel 上畅享卓越模型能力