双曲几何与神经网络：洛伦兹模型与双曲卷积网络实践指南

1. 项目概述：当双曲空间遇见神经网络

最近几年，深度学习在欧几里得空间（也就是我们熟悉的平坦空间）里已经玩得风生水起，从图像识别到自然语言处理，几乎无处不在。但如果你仔细想想，现实世界的数据结构，比如社交网络、知识图谱、推荐系统中的用户-物品关系，它们往往不是平坦的，而是具有层次化或树状的结构。用一个简单的例子来说，想象一下公司的组织架构图，或者生物的分类学树（界、门、纲、目…），CEO和基层员工之间、哺乳动物和昆虫之间，这种层级关系用传统的欧几里得空间来建模，就像试图用一张平面地图去精确描绘地球表面一样，总会有些扭曲和失真。

这时候，双曲几何就登场了。它描述的是具有恒定负曲率的空间，最直观的模型就是马鞍面。在这种空间里，三角形的内角和小于180度，平行线可以无限远离。更重要的是，双曲空间的体积增长是指数级的，这意味着它天生就适合嵌入树状或层次化的数据——你可以在靠近圆心的位置放上高层级、概括性的节点（如“动物”），在靠近边界的无穷远处放置大量细分的叶子节点（如“孟加拉虎”），而它们之间的“距离”（用双曲几何的度量）能很好地反映层级深度。这为解决图数据、自然语言中的词汇层级等问题提供了一个强大的数学框架。

然而，将深度学习移植到双曲空间并非易事。核心挑战在于，我们熟悉的向量加法、矩阵乘法、梯度下降等所有深度学习的基础运算，在双曲空间里都“失效”了。你不能简单地把两个双曲空间里的点用坐标相加，因为那会跑出双曲空间（流形）。这就需要一套全新的“工具箱”：如何在双曲空间里做加法（即移动一个点）？如何计算两点间的距离？如何定义和优化双曲空间中的神经网络参数？这正是“洛伦兹模型”和“双曲卷积神经网络”（HCNN）要解决的核心问题。

本文旨在拆解这个迷人的交叉领域。我不会过多纠结于复杂的微分几何证明，而是聚焦于一个实践者的视角：如何理解双曲空间（特别是洛伦兹模型）的核心运算，并利用这些运算，一步步构建一个能实际运行的双曲卷积神经网络。无论你是好奇于这个前沿方向的研究者，还是正在寻找更优嵌入方案的算法工程师，希望这篇从理论到实操的梳理能给你带来清晰的路径和可复现的代码。

2. 理论基石：洛伦兹模型与双曲空间运算

在深入代码之前，我们必须打好理论基础。双曲空间有多种等价的模型，如庞加莱圆盘模型、上半平面模型等。其中，洛伦兹模型（或称双曲面模型、Minkowski模型）在深度学习社区中越来越受欢迎，主要原因是它的运算在数值上更稳定，更容易进行优化。

2.1 洛伦兹模型：一种更“友好”的双曲空间表示

想象一个三维空间，但它不是我们熟悉的(x, y, z)欧几里得空间，而是具有一种特殊的“度量”方式。我们定义洛伦兹内积（也称Minkowski内积）为：<u, v>_L = -u0*v0 + u1*v1 + u2*v2 + ... + un*vn注意第一项前面的负号！这里，一个点x的坐标通常写成(x0, x1, ..., xn)，其中x0被称为“时间分量”，x1...xn被称为“空间分量”。

那么，n维的双曲空间H^n在洛伦兹模型中就定义为所有满足以下条件的点x的集合：

1. <x, x>_L = -1（即洛伦兹范数为-1）
2. x0 > 0（我们选择“未来”时间方向，以保证空间是连通的）

这定义了一个双曲面。为什么这个模型更好？因为在欧几里得空间中，梯度下降是沿着直线（测地线）的负梯度方向走。在双曲空间中，对应的“直线”是测地线。在洛伦兹模型中，许多运算可以表示为在外围的洛伦兹空间中进行线性代数操作，然后再投影回双曲面H^n上。这种“在外围空间计算，然后投影”的模式，非常契合深度学习框架（如PyTorch、TensorFlow）基于张量运算和自动微分的范式。

注意：这里说的“投影”不是简单的除法，而是一种称为“指数映射”或“规范化”的操作，确保结果点始终落在双曲面<x, x>_L = -1上。

2.2 核心运算一：指数映射与对数映射

这是连接双曲空间（流形）与其切空间（局部像欧几里得空间）的桥梁，是所有后续运算的基础。

• 对数映射 (Log Map)：log_x(y)。想象你站在双曲面上的点x，你的脚下有一个切平面（切空间T_xH^n）。点y是双曲面上的另一个点。对数映射的作用就是把y“拉”到你脚下的切平面上，得到一个切向量v。这个向量v的方向指向y，长度等于双曲空间中x到y的测地线距离。在洛伦兹模型中，这个运算有闭合解（解析解），不需要迭代优化，这是其巨大优势。

  • 公式：v = log_x(y) = arccosh(-<x, y>_L) / sqrt(<x, y>_L^2 - 1) * (y + <x, y>_L * x)
  • 直观理解：它给出了从x出发，以最短路径（测地线）到达y所需的“速度”向量。

• 指数映射 (Exp Map)：exp_x(v)。这是对数映射的逆过程。你站在点x，脚下切平面上有一个向量v。指数映射告诉你，沿着v的方向，以v的长度为“速度”在双曲空间中走一段测地线，最终会到达哪个点y。

  • 公式：y = exp_x(v) = cosh(||v||_L) * x + sinh(||v||_L) * (v / ||v||_L)，其中||v||_L = sqrt(<v, v>_L)是切向量的洛伦兹范数（注意在切空间里，这个内积是正定的，可以当普通长度用）。
  • 实操意义：这是我们在双曲空间中进行“加法”或“移动”点的基本操作。例如，双曲嵌入的优化过程，可以看作是在切空间中用梯度下降更新向量v，然后用exp_x(v)映射回双曲空间更新嵌入点。

2.3 核心运算二：测地线距离与双曲距离

在双曲空间中，两点之间的最短路径长度（测地线距离）由以下公式给出：d_L(x, y) = arccosh(-<x, y>_L)这个公式非常简洁优美。arccosh是反双曲余弦函数。由于<x, y>_L <= -1（对于x0, y0 > 0），arccosh的参数是大于等于1的，距离是实数。

为什么这个距离适合层次化数据？假设圆心附近有一个根节点root，边界附近有一个叶子节点leaf。随着叶子节点越来越细分（在树中深度增加），它在双曲空间中的位置会趋向于边界。计算<root, leaf>_L会得到一个很大的负值（因为leaf0变得很大），使得-<root, leaf>_L很大，从而arccosh的值也很大。这意味着距离随着层级深度近似线性增长，而双曲空间的面积/体积却是指数增长，正好容纳了指数增长的叶子节点，同时保持了距离关系的合理性。

2.4 核心运算三：平行移动

这是构建双曲神经网络的关键，也是最容易出错的部分。在欧几里得空间，你可以将一个向量从一个点“平移”到另一个点，方向和大小都不变。但在弯曲的空间（如双曲空间）里，直接“平移”一个向量是没意义的，因为不同点的切空间是不同的。

平行移动定义了如何将一个点x的切空间T_xH^n中的向量v，“无旋地”移动到点y的切空间T_yH^n中，得到一个向量PT_{x->y}(v)。

• 为什么需要它？在双曲卷积神经网络中，输入特征可以看作是定义在输入点（如图节点）切空间中的向量。当我们要聚合邻居信息（卷积操作）时，需要将邻居点的特征向量“移动”到中心点的切空间上才能进行相加或拼接。这个“移动”操作就是平行移动。
• 洛伦兹模型中的公式：PT_{x->y}(v) = v - <log_x(y), v>_L / (d_L(x,y)^2) * (log_x(y) + log_y(x))
  • 这个公式看起来复杂，但其核心思想是：在移动过程中，保持向量与测地线（连接x和y的最短路径）的夹角不变（这就是“无旋”的含义）。

实操心得：平行移动的实现需要非常小心数值稳定性。当x和y非常接近时，d_L(x,y)接近于0，会导致除零错误。在实际代码中，必须对这种情况进行保护，例如加一个极小值eps，或者当距离太小时近似认为平行移动就是恒等映射。

3. 构建双曲卷积神经网络 (HCNN)

有了上述核心运算的武器库，我们现在可以着手构建一个双曲版本的卷积神经网络了。这里我们以图卷积网络（GCN）在双曲空间中的变体为例，因为它包含了特征变换（线性层）和邻居聚合（卷积）这两个核心环节。

3.1 网络层设计：双曲线性层

在欧几里得GCN中，线性层就是Y = XW + b，其中X是输入特征矩阵，W是权重矩阵，b是偏置。

在双曲空间中，输入特征X的每一行是一个点，位于双曲空间H^n中。我们不能直接乘以矩阵W，因为结果会飞出双曲面。双曲线性层的标准做法是在切空间中完成欧几里得变换，再映射回流形。

步骤分解：

1. 选定参考点：通常选择双曲空间的“原点”。在洛伦兹模型中，原点o的坐标是(1, 0, 0, ..., 0)。这个点的切空间T_oH^n可以自然地与欧几里得空间R^n等同起来（忽略第一个时间分量）。
2. 对数映射：将输入的双曲点x in H^n，通过log_o(x)映射到原点o的切空间T_oH^n中，得到一个欧几里得向量v。
3. 欧几里得变换：在切空间T_oH^n中，对v施加标准的线性变换：u = vW^T + b。这里W和b就是我们需要学习的参数，它们存在于欧几里得空间中。
4. 指数映射：将变换后的切向量u，通过exp_o(u)映射回双曲空间H^n，得到输出点y。

公式化表示：H-Linear(x) = exp_o( log_o(x) * W^T + b )

这就完成了一个双曲线性层。它首先将流形上的点“拉平”到切空间，在平坦的切空间里做熟悉的线性运算，然后再“卷回”流形。

3.2 邻居聚合：双曲图卷积层

图卷积的核心是聚合节点自身及其邻居的特征。在双曲空间中，这需要平行移动的参与。

假设我们有一个图，每个节点i有一个双曲嵌入特征h_i in H^d。对于中心节点i，其邻居节点集合为N(i)。

双曲图卷积的一层操作可以定义为：

1. 特征变换：首先，对每个节点j（包括自身）的特征h_j应用一个双曲线性层（如上所述），得到变换后的特征z_j。这一步相当于对每个节点的特征进行独立的非线性变换。z_j = H-Linear(h_j)
2. 邻居特征对齐：对于每个邻居节点j in N(i)，我们需要将其特征z_j从它自己的位置（切空间）平行移动到中心节点i的位置。z_{j->i} = PT_{z_j -> z_i}(z_j)注意：这里有一个细微点。严格来说，z_j是一个点（流形上的点），而不是切向量。我们需要移动的是“特征向量”。一种常见的简化是，将节点的特征本身视为其切空间中的某个方向，或者更常见的是，我们学习一个与节点特征相关联的切向量。为了简化，许多实现会假设节点特征已经通过某种方式与切向量关联，或者直接使用对数映射将邻居点映射到中心点的切空间（这包含了距离和方向信息）。更严谨的做法需要定义每个节点上的特征场。
3. 切空间聚合：现在，所有邻居（包括自身，移动后是零向量或原特征对应的切向量）的特征都位于中心节点i的同一个切空间T_{z_i}H^d中。我们可以在这个欧几里得化的切空间中进行聚合操作，例如取均值、求和或使用注意力机制：agg_i = AGGREGATE({z_{j->i} for j in N(i) ∪ {i}})
4. 流形投影与激活：将聚合后的切向量agg_i，通过指数映射放回双曲流形，得到新的节点表示。为了引入非线性，可以在指数映射前或后应用激活函数。在双曲空间中，有一种称为“双曲正切”（基于切空间操作）或直接在流形上定义的激活函数（如Mobius版本）。h_i^{new} = exp_{z_i}( σ(agg_i) )或h_i^{new} = σ_{hyp}( exp_{z_i}(agg_i) )其中 σ 是激活函数，σ_{hyp}是双曲版本的激活函数。

3.3 实操要点与初始化策略

参数初始化： 双曲网络的参数（如双曲线性层中的W和b）是在切空间（欧几里得空间）中定义的，因此可以用标准的初始化方法，如Xavier或Kaiming初始化。但是，输入的双曲嵌入的初始化需要特别注意。一个常见的方法是从一个高斯分布中采样切空间中的向量，然后通过指数映射exp_o(v)将其投影到双曲空间，并确保x0 > 0。

优化器选择： 由于参数在切空间，我们可以直接使用标准的欧几里得优化器，如Adam或SGD。这是洛伦兹模型的另一个巨大优势：优化发生在平坦的切空间，避免了在流形上设计复杂优化器（如黎曼优化）的麻烦。梯度通过log_o和exp_o在流形和切空间之间自动传递。

数值稳定性： 这是实现中最关键的环节。arccosh、sqrt、sinh、cosh等函数在参数接近边界时容易产生数值溢出（NaN或Inf）。必须全程使用torch.clamp或max(..., eps)来保护。

• arccosh的输入必须>= 1 + eps。
• 计算sqrt(<x, y>_L^2 - 1)时，内部值必须>= eps。
• 计算sinh(norm)/norm时，当norm很小时，使用泰勒展开近似1 + norm^2/6来避免除零和不稳定。

一个简单的稳定性技巧：在计算任何涉及双曲函数的表达式前，先对输入张量进行.clamp(min=-1e5, max=1e5)操作，防止极端值导致溢出。

4. 代码实现与核心模块解析

下面，我们用PyTorch来勾勒出几个最核心模块的实现。请注意，以下代码侧重于展示原理，在实际应用中需要更完善的数值保护。

import torch import torch.nn as nn import torch.nn.functional as F import math class LorentzManifold(object): """ 洛伦兹模型双曲空间操作的工具类。 假设输入点x的形状为 (..., d+1)，其中第一个分量为时间分量x[..., 0]。 """ def __init__(self, eps=1e-6, max_norm=1e5): self.eps = eps self.max_norm = max_norm def lorentz_inner(self, x, y, keepdim=False): """计算洛伦兹内积 <x, y>_L = -x0*y0 + sum_{i=1..d} x_i*y_i""" return -x[..., 0:1] * y[..., 0:1] + torch.sum(x[..., 1:] * y[..., 1:], dim=-1, keepdim=keepdim) def lorentz_norm(self, x, keepdim=False): """计算洛伦兹范数平方：<x, x>_L。对于双曲面上的点，结果应为-1。""" return self.lorentz_inner(x, x, keepdim=keepdim) def dist(self, x, y, keepdim=False): """计算双曲测地线距离 d_L(x, y) = arccosh(-<x, y>_L)""" inner = -self.lorentz_inner(x, y, keepdim=keepdim) # -<x, y>_L # 数值保护：确保 inner >= 1 inner_clamped = torch.clamp(inner, min=1.0 + self.eps, max=self.max_norm) return torch.acosh(inner_clamped) def log_map(self, x, y): """计算对数映射 log_x(y)，返回切空间中的向量v (在x点的切空间)""" dist_xy = self.dist(x, y, keepdim=True) # shape: (..., 1) inner = self.lorentz_inner(x, y, keepdim=True) # shape: (..., 1) # 公式: v = arccosh(-inner) / sqrt(inner^2 - 1) * (y + inner * x) # 注意: inner = <x, y>_L, 所以 -inner = -<x, y>_L alpha = torch.clamp(inner * inner - 1, min=self.eps) # inner^2 - 1 coef = dist_xy / torch.sqrt(alpha) # 当x和y非常接近时，dist_xy和alpha都接近0，coef的极限是1，需要处理 coef = torch.where(dist_xy < self.eps, torch.ones_like(coef), coef) return coef * (y + inner * x) def exp_map(self, x, v): """计算指数映射 exp_x(v)，返回双曲面上的点y""" # v应该在x的切空间，理论上<v, x>_L = 0。这里先计算其（欧几里得）范数。 # 在切空间中，洛伦兹内积退化为正定内积: <v, v>_L = <v, v>_E (因为v0=0的理想情况下) # 更稳健的做法：计算切向量的“长度” norm_v = sqrt(<v, v>_L)，但需确保非负。 v_norm_sq = torch.clamp(self.lorentz_inner(v, v, keepdim=True), min=self.eps) v_norm = torch.sqrt(v_norm_sq) # 处理零向量 v_norm_safe = torch.where(v_norm < self.eps, torch.ones_like(v_norm), v_norm) # 公式: y = cosh(norm_v) * x + sinh(norm_v) * (v / norm_v) y = torch.cosh(v_norm) * x + torch.sinh(v_norm) * (v / v_norm_safe) # 投影以确保在流形上（数值误差可能导致偏离），重新标准化 return self.project_to_manifold(y) def project_to_manifold(self, x): """将点投影到双曲面 H^n 上，即满足 <x, x>_L = -1 且 x0 > 0""" # 计算当前点的“范数” current_norm = self.lorentz_norm(x, keepdim=True) # shape (..., 1) # 目标范数是 -1，所以缩放因子 scale = sqrt(-1 / current_norm) # 由于 current_norm 应为负，我们取绝对值确保根号内为正 scale = torch.sqrt(torch.clamp(-1.0 / current_norm, min=self.eps)) projected = x * scale # 确保时间分量为正 projected[..., 0] = torch.abs(projected[..., 0]) + self.eps # 可能需要再次轻微标准化以消除符号影响，这里省略 return projected def parallel_transport(self, x, y, v): """将切向量v从点x的切空间平行移动到点y的切空间""" log_xy = self.log_map(x, y) log_yx = self.log_map(y, x) dist_sq = torch.clamp(self.dist(x, y, keepdim=True) ** 2, min=self.eps) inner = self.lorentz_inner(log_xy, v, keepdim=True) # 公式: PT_{x->y}(v) = v - (inner / dist_sq) * (log_xy + log_yx) coef = inner / dist_sq return v - coef * (log_xy + log_yx) class HyperbolicLinear(nn.Module): """双曲线性层""" def __init__(self, in_features, out_features, manifold): super().__init__() self.in_features = in_features # 双曲空间的维度 (d+1) self.out_features = out_features # 输出双曲空间的维度 (d'+1) self.manifold = manifold # 权重和偏置定义在切空间（欧几里得空间） # 注意：输入切向量维度是 in_features-1 (忽略时间分量) self.weight = nn.Parameter(torch.Tensor(out_features, in_features - 1)) self.bias = nn.Parameter(torch.Tensor(out_features)) self.reset_parameters() def reset_parameters(self): nn.init.xavier_uniform_(self.weight) nn.init.zeros_(self.bias) def forward(self, x): """ x: (..., in_features) 双曲面上的点， in_features = d+1 返回: (..., out_features) 双曲面上的点， out_features = d'+1 """ # 1. 定义原点 o = (1, 0, ..., 0) o = torch.zeros_like(x) o[..., 0] = 1.0 # 2. 对数映射到原点的切空间: (..., in_features-1) v = self.manifold.log_map(o, x) # v 在 T_oH^d 中 # v 的时间分量理论上为0，我们取空间部分 v_spatial = v[..., 1:] # 3. 在切空间进行欧几里得线性变换 u_spatial = F.linear(v_spatial, self.weight, self.bias) # (..., out_features-1) # 4. 构造切向量 u，时间分量为0 u = torch.cat([torch.zeros_like(u_spatial[..., :1]), u_spatial], dim=-1) # 5. 指数映射回双曲空间 y = self.manifold.exp_map(o, u) return y class HyperbolicGCNLayer(nn.Module): """一个简化的双曲图卷积层 (邻居聚合采用平均)""" def __init__(self, in_dim, out_dim, manifold, dropout=0.0): super().__init__() self.manifold = manifold self.linear = HyperbolicLinear(in_dim, out_dim, manifold) self.dropout = dropout def forward(self, h, adj): """ h: (num_nodes, in_dim) 节点双曲特征 adj: (num_nodes, num_nodes) 稀疏或稠密邻接矩阵（包含自环） 返回: (num_nodes, out_dim) 新的节点双曲特征 """ # 1. 特征变换 z = self.linear(h) # (num_nodes, out_dim) if self.training and self.dropout > 0: z = F.dropout(z, p=self.dropout, training=True) # 2. & 3. 邻居聚合 (简化版：将对数映射作为特征移动) # 这里我们采用一种简化策略：将邻居点映射到中心点的切空间，然后聚合。 # 更严谨的做法需要平行移动特征向量，这里用对数映射近似。 num_nodes = h.size(0) agg_features = [] for i in range(num_nodes): # 获取邻居索引 (包括自身，如果adj已加自环) neighbors = adj[i].nonzero(as_tuple=True)[0] if len(neighbors) == 0: # 孤立节点，使用自身变换后的特征 agg_i = self.manifold.log_map(z[i:i+1], z[i:i+1]) # 零向量 else: # 将邻居特征点 z[neighbors] 映射到中心点 z[i] 的切空间 # log_map 输入需要broadcast，这里循环或向量化实现 # 为简化，我们假设一种向量化方式（需要仔细处理形状） # 实际实现中，可能需要更高效的批量操作 neighbor_pts = z[neighbors] # (num_neighbors, out_dim) center_pt = z[i].unsqueeze(0) # (1, out_dim) # 计算所有邻居点到中心点的切向量 tangent_vecs = self.manifold.log_map(center_pt.expand_as(neighbor_pts), neighbor_pts) # (num_neighbors, out_dim) # 在切空间中聚合，例如取平均 agg_tangent = tangent_vecs.mean(dim=0, keepdim=True) # (1, out_dim) # 4. 映射回流形 (若聚合结果为切向量) # 注意：如果聚合的是点（另一种方式），则不需要exp_map。这里我们聚合的是切向量。 agg_i = self.manifold.exp_map(z[i:i+1], agg_tangent).squeeze(0) agg_features.append(agg_i) new_h = torch.stack(agg_features, dim=0) return new_h

代码解析与注意事项：

1. LorentzManifold 类：封装了所有核心运算。project_to_manifold函数至关重要，因为数值计算可能导致点轻微偏离双曲面，每次指数映射后或经过多次运算后，最好都投影一次以保证数值精度。
2. HyperbolicLinear 类：实现了双曲线性层。注意原点o的定义。我们假设所有变换都以原点为参考点，这简化了实现。对于更深的网络，可能需要考虑以当前点为参考的“双曲偏置”加法。
3. HyperbolicGCNLayer 类：这是一个高度简化的示意实现。其中的邻居聚合循环效率很低，在实际应用中需要使用稀疏矩阵操作或自定义CUDA内核来批量计算对数映射和平行移动。此外，聚合方式（均值、注意力）和是否包含中心节点特征需要根据任务设计。
4. 激活函数：上述代码没有显式添加激活函数。可以在HyperbolicLinear之后或HyperbolicGCNLayer的聚合之后，在切空间应用tanh或ReLU（需小心ReLU可能破坏流形结构），或者使用专门的双曲激活函数。

5. 训练技巧、常见问题与实战建议

将理论转化为可训练、有效的模型，还需要绕过一些陷阱。

5.1 训练技巧与参数设置

1. 学习率：由于优化发生在切空间，学习率设置与欧几里得网络相似。但双曲空间的梯度可能具有不同的量级，建议从一个较小的学习率开始（如1e-3或3e-4），并使用学习率预热和衰减策略。
2. 梯度裁剪：双曲运算（如arccosh,sinh）的梯度在输入值很大时可能爆炸。对梯度进行全局范数裁剪（torch.nn.utils.clip_grad_norm_）是非常有效的稳定训练的手段。
3. 嵌入初始化：节点或词的初始双曲嵌入不宜离原点太远。可以从一个标准差较小（如0.01）的高斯分布采样切向量，再通过exp_o映射得到。这能确保初始点分布在原点附近，训练过程更平稳。
4. 损失函数：许多任务的损失函数（如交叉熵损失、均方误差）是在欧几里得空间中定义的。对于双曲模型，通常有两种选择：
   • 在切空间计算损失：将预测的双曲点通过log_o映射到原点切空间，与标签（如果是欧几里得的）或同样映射的标签一起计算损失。这是最常用的方法。
   • 使用双曲距离作为损失的一部分：例如，对于链接预测任务，可以直接最小化正样本对的双曲距离，最大化负样本对的双曲距离。

5.2 常见问题与排查清单

5.3 实战建议与扩展方向

• 从简单任务开始：不要一开始就挑战大规模图节点分类。可以先在简单的树形数据嵌入、链接预测（如Poincaré嵌入的复现）或小规模引文网络（Cora, Citeseer）上验证你的双曲核心运算和网络层实现是否正确。
• 可视化是利器：使用庞加莱圆盘投影（将洛伦兹模型点(x0, x1, x2)转换为庞加莱圆盘坐标(x1/(1+x0), x2/(1+x0))）来可视化你的双曲嵌入。你可以清晰地看到节点是否呈现出预期的层次化或树状结构。
• 与欧几里得模型对比：始终设置一个结构相同的欧几里得模型作为基线。在层次化数据上，双曲模型应该表现出更低的嵌入失真和更好的泛化性能。
• 探索更复杂的架构：一旦基础HCNN工作正常，可以尝试融入注意力机制（双曲注意力）、门控机制（GRU/LSTM的双曲版本），或者将双曲空间与欧几里得空间结合（混合模型）。
• 关注最新研究：这个领域发展迅速，不断有新的模型（如洛伦兹Transformer、双曲图注意力网络）、更稳定的运算方法和理论分析出现。保持对arXiv上相关论文的关注。

构建双曲深度学习模型是一次连接抽象几何与实用算法的有趣旅程。它要求我们跳出熟悉的欧几里得思维，在弯曲的空间中重新思考“向量”、“距离”和“加法”的基本概念。虽然实现细节充满挑战，但由此带来的对具有复杂结构数据的强大建模能力，使其在许多前沿领域展现出独特潜力。希望这篇从理论推导到代码实操的长文，能为你踏入这片领域提供一块坚实的垫脚石。在实际编码时，耐心调试数值稳定性，从小规模实验开始，你会逐渐掌握在双曲空间中驰骋的技巧。