论文解读（SUBLIME）《Towards Unsupervised Deep Graph Structure Learning》

🚀 优质资源分享 🚀

论文信息

论文标题：Towards Unsupervised Deep Graph Structure Learning论文作者：Yixin Liu, Yu Zheng, Daokun Zhang, Hongxu Chen, Hao Peng, Shirui Pan论文来源：2022, WWW Best Paper Award candidate 论文地址：download 论文代码：download

1 Introduction

Deep Graph Structure Learning (GSL) is designed to enhance graph structure optimization through supervised node classification tasks in conjunction with Graph Neural Networks (GNN). Its primary drawbacks include a high reliance on labels, discrepancies in edge distribution, and limitations in application-specific tasks.

本文和监督 GSL 对比：

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220603110042541-900671382.png)

2 Problem Definition

符号定义 ：

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220603111747369-862204264.png)

Definition 3.1 (Structure inference). Given a feature matrix X ∈ ℝ^{n × d}, the objective of structure inference is to automatically derive a graph topology 𝒮 ∈ [0, 1]^{n × n}, which captures the inherent relationships among data points. Particularly, each entry 𝒮_{i,j} ∈ [0, 1] signifies whether nodes 𝒙_i and 𝒙_j are connected by an edge.

Definition 3.2 (Structure refinement). Consider a graph G defined as G=(A,X) where A represents a perturbed adjacency matrix with noise. The aim of structural refinement is to optimize the adjacency matrix A into an optimized version S∈[0,1]^{n×n}, which more accurately reflects the inherent relationships among nodes.

3 Method

整体框架：

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220603113320958-1604943610.png)

包括两个模块：

• • network arrangement learning component
  • self-supervised structural bootstrap and contrastive learning framework

3.1 Graph Learner

该模型能够输出一个带有参数的adjacency matrix \tilde{\mathrm{S}} \in \mathbb{R}^{n \times n}。本文中的 Graph Learner 包括以下四种：

• • FGP learner * Attentive Learner * MLP Learner * GNN Learner

3.1.1 FGP learner

通过一个参数矩阵直接建模邻接矩阵中的每一个元素，并无需额外输入信息。FGP Learner：

S=pFGPω=σ(Ω)(1)S=pωFGP=σ(Ω)(1)\tilde{\mathrm{S}}=p_{\omega}^{F G P}=\sigma(\Omega)\quad\quad\quad(1)

其中参数矩阵\omega由\Omega ∈ ℝ^{{n×n}确定，并且该矩阵属于ℝ}{n×n}空间。非线性函数σ(⋅)的存在有助于提升训练稳定性。FGP学习器基于以下假设：图中的每一条边都是独立存在的。

ruby

    class FGP\_learner(nn.Module):
    def \_\_init\_\_(self, features, k, knn\_metric, i, sparse):
        super(FGP\_learner, self).\_\_init\_\_()
    
        self.k = k
        self.knn\_metric = knn\_metric
        self.i = i
        self.sparse = sparse
    
        self.Adj = nn.Parameter(
            torch.from\_numpy(nearest\_neighbors\_pre\_elu(features, self.k, self.knn\_metric, self.i)))
    
    def forward(self, h):
        if not self.sparse:
            Adj = F.elu(self.Adj) + 1
        else:
            Adj = self.Adj.coalesce()
            Adj.values = F.elu(Adj.values()) + 1
        return Adj
    
    def nearest\_neighbors\_pre\_elu(X, k, metric, i):
    adj = kneighbors\_graph(X, k, metric=metric)
    adj = np.array(adj.todense(), dtype=np.float32)
    adj += np.eye(adj.shape[0])
    adj = adj * i - i
    return adj

不同于传统的FGP Learner，基于度量学习的Learner [7,58] 首先从输入数据中提取节点嵌入 E∈Rn×dE∈Rn×d\mathbf{E} \in \mathbb{R}^{n \times d}，随后利用节点间相似关系对 SS\tilde{\mathrm{S}} 进行建模：

该模型的性能指标\tilde{\mathrm{S}}可表示为p^{ML}_{ω}(X, A)等于式为\phi(h_{ω}(X, A))并进一步简化为\phi(\mathbf{E})（见公式2）。同样地，在另一种计算方式中p^{ML}_{ω}(X, A)也等于\phi(h_{ω}(X, A))并最终得出结果\phi(\mathbf{E})（见公式2）。

该函数 h_ω(.) 作为基于神经网络的参数化嵌入机制存在，并且能够有效提取数据中的潜在特征信息。其采用非参数化的方式衡量样本间的相似程度（主要包含余弦相似度与闵可夫斯基距离等方法），用于评估样本间的配对相似性。

针对不同类型的 h_{\omega}(\cdot), 本文涉及包括: 注意力学习器 (Attentive Learner)、多层感知机学习器 (MLP Learner) 以及图神经网络学习器 (GNN Learner)。

3.1.2 Attentive Learner

采用一个注意网络作为其嵌入网络：

输入向量经过线性变换后与激活函数σ作用于这些变换后的向量得到当前时刻的误差项E_l。(3)

其中：

• • \mathbf{E}^{(l)}表示第l层的嵌入矩阵；\mathbf{e}_{i}^{(l-1)}\in\mathbb{R}^d即为该矩阵中对应于输入序列位置i的row vector；
• \omega^{(l)}\in\mathbb{R}^d则代表该层网络中的参数向量。

reasonml

    class ATT\_learner(nn.Module):
    def \_\_init\_\_(self, nlayers, isize, k, knn\_metric, i, sparse, mlp\_act):
        super(ATT\_learner, self).\_\_init\_\_()
    
        self.i = i
        self.layers = nn.ModuleList()
        for \_ in range(nlayers):
            self.layers.append(Attentive(isize))
        self.k = k
        self.knn\_metric = knn\_metric
        self.non\_linearity = 'relu'
        self.sparse = sparse
        self.mlp\_act = mlp\_act
    
    def internal\_forward(self, h):
        for i, layer in enumerate(self.layers):
            h = layer(h)
            if i != (len(self.layers) - 1):
                if self.mlp\_act == "relu":
                    h = F.relu(h)
                elif self.mlp\_act == "tanh":
                    h = F.tanh(h)
        return h
    
    def forward(self, features):
        if self.sparse:
            embeddings = self.internal\_forward(features)
            rows, cols, values = knn\_fast(embeddings, self.k, 1000)
            rows\_ = torch.cat((rows, cols))
            cols\_ = torch.cat((cols, rows))
            values\_ = torch.cat((values, values))
            values\_ = apply\_non\_linearity(values\_, self.non\_linearity, self.i)
            adj = dgl.graph((rows\_, cols\_), num\_nodes=features.shape[0], device='cuda')
            adj.edata['w'] = values\_
            return adj
        else:
            embeddings = self.internal\_forward(features)
            embeddings = F.normalize(embeddings, dim=1, p=2)
            similarities = cal\_similarity\_graph(embeddings)
            similarities = top\_k(similarities, self.k + 1)
            similarities = apply\_non\_linearity(similarities, self.non\_linearity, self.i)
            return similarities
    
    
    class Attentive(nn.Module):
    def \_\_init\_\_(self, isize):
        super(Attentive, self).\_\_init\_\_()
        self.w = nn.Parameter(torch.ones(isize))
    
    def forward(self, x):
        return x @ torch.diag(self.w)

ATT_learner Code

3.1.3 MLP Learner

使用多层感知(MLP)作为其嵌入网络：

通过动态规划算法逐步优化目标函数的最大化问题（4），该过程涉及通过递归关系逐步更新状态变量并结合权重矩阵进行非线性变换。（4）

其中，Ω(l)∈Rd×dΩ(l)∈Rd×d\Omega^{(l)} \in \mathbb{R}^{d \times d} 是第 lll 层的参数矩阵。

相较于Attentive Learner而言，MLP Learner进一步探讨了特征间的关联性及其组合，并在下游相似性度量学习中提供了更为丰富的嵌入空间。

reasonml

    class MLP\_learner(nn.Module):
    def \_\_init\_\_(self, nlayers, isize, k, knn\_metric, i, sparse, act):
        super(MLP\_learner, self).\_\_init\_\_()
    
        self.layers = nn.ModuleList()
        if nlayers == 1:
            self.layers.append(nn.Linear(isize, isize))
        else:
            self.layers.append(nn.Linear(isize, isize))
            for \_ in range(nlayers - 2):
                self.layers.append(nn.Linear(isize, isize))
            self.layers.append(nn.Linear(isize, isize))
    
        self.input\_dim = isize
        self.output\_dim = isize
        self.k = k
        self.knn\_metric = knn\_metric
        self.non\_linearity = 'relu'
        self.param\_init()
        self.i = i
        self.sparse = sparse
        self.act = act
    
    def internal\_forward(self, h):
        for i, layer in enumerate(self.layers):
            h = layer(h)
            if i != (len(self.layers) - 1):
                if self.act == "relu":
                    h = F.relu(h)
                elif self.act == "tanh":
                    h = F.tanh(h)
        return h
    
    def param\_init(self):
        for layer in self.layers:
            layer.weight = nn.Parameter(torch.eye(self.input\_dim))
    
    def forward(self, features):
        if self.sparse:
            embeddings = self.internal\_forward(features)
            rows, cols, values = knn\_fast(embeddings, self.k, 1000)
            rows\_ = torch.cat((rows, cols))
            cols\_ = torch.cat((cols, rows))
            values\_ = torch.cat((values, values))
            values\_ = apply\_non\_linearity(values\_, self.non\_linearity, self.i)
            adj = dgl.graph((rows\_, cols\_), num\_nodes=features.shape[0], device='cuda')
            adj.edata['w'] = values\_
            return adj
        else:
            embeddings = self.internal\_forward(features)
            embeddings = F.normalize(embeddings, dim=1, p=2)
            similarities = cal\_similarity\_graph(embeddings)
            similarities = top\_k(similarities, self.k + 1)
            similarities = apply\_non\_linearity(similarities, self.non\_linearity, self.i)
            return similarities

MLP Learner Code

3.1.4 GNN Learner

基于原始拓扑架构设计的GNN学习器主要应用于结构细化过程

本文采用 GCN 形成嵌入式网络：

该模型通过信息传递机制实现节点表示的更新过程（5）

其中，在图论中，带有自环的邻接矩阵 \widetilde{\mathbf{A}} 表示为 \mathbf{A} + \mathbf{I}；而 \widetilde{\mathbf{D}} 表示为 \tilde{\mathbf{A}} 的度矩阵。

GNN学习器基于两个节点之间的连接不仅受到特征的影响，并且也受到原始结构的影响。

reasonml

    class GNN\_learner(nn.Module):
    def \_\_init\_\_(self, nlayers, isize, k, knn\_metric, i, sparse, mlp\_act, adj):
        super(GNN\_learner, self).\_\_init\_\_()
    
        self.adj = adj
        self.layers = nn.ModuleList()
        if nlayers == 1:
            self.layers.append(GCNConv\_dgl(isize, isize))
        else:
            self.layers.append(GCNConv\_dgl(isize, isize))
            for \_ in range(nlayers - 2):
                self.layers.append(GCNConv\_dgl(isize, isize))
            self.layers.append(GCNConv\_dgl(isize, isize))
    
        self.input\_dim = isize
        self.output\_dim = isize
        self.k = k
        self.knn\_metric = knn\_metric
        self.non\_linearity = 'relu'
        self.param\_init()
        self.i = i
        self.sparse = sparse
        self.mlp\_act = mlp\_act
    
    def internal\_forward(self, h):
        for i, layer in enumerate(self.layers):
            h = layer(h, self.adj)
            if i != (len(self.layers) - 1):
                if self.mlp\_act == "relu":
                    h = F.relu(h)
                elif self.mlp\_act == "tanh":
                    h = F.tanh(h)
        return h
    
    def param\_init(self):
        for layer in self.layers:
            layer.weight = nn.Parameter(torch.eye(self.input\_dim))
    
    def forward(self, features):
        if self.sparse:
            embeddings = self.internal\_forward(features)
            rows, cols, values = knn\_fast(embeddings, self.k, 1000)
            rows\_ = torch.cat((rows, cols))
            cols\_ = torch.cat((cols, rows))
            values\_ = torch.cat((values, values))
            values\_ = apply\_non\_linearity(values\_, self.non\_linearity, self.i)
            adj = dgl.graph((rows\_, cols\_), num\_nodes=features.shape[0], device='cuda')
            adj.edata['w'] = values\_
            return adj
        else:
            embeddings = self.internal\_forward(features)
            embeddings = F.normalize(embeddings, dim=1, p=2)
            similarities = cal\_similarity\_graph(embeddings)
            similarities = top\_k(similarities, self.k + 1)
            similarities = apply\_non\_linearity(similarities, self.non\_linearity, self.i)
            return similarities

GNN Learner Code

3.2 Post-processor

函数 q(\cdot) 的目的是将原始邻接矩阵 \tilde{S} 细化为一个同时具有稀疏性、非负性以及对称性，并满足归一化条件的新邻接矩阵。

因此，依次采如下步骤：

执行稀疏处理以去除数据中的冗余信息 qsp(\cdot)；
采用激活函数以引入非线性特性 qact(\cdot)；
实施对称变换以保持数据结构的一致性 qsym(\cdot)；
应用归一化过程以标准化输出结果 q_{\text{norm}}(\cdot)

3.2.1 Sparsification

根据相似性生成的邻接矩阵 \tilde{\mathrm{S}} 通常呈现出稠密的特点，并用于描述一个全局连通的状态。然而这种全连接状态并无实际价值，在此情况下我们倾向于使用基于 K近邻的方法来实现稀疏化处理以减少计算复杂度

具体来说，在每个节点处，我们保留具有 top-k\text{top-k} 个连接值的边，并将其余连接置零。稀疏化的 qsp(⋅)\mathcal{q}_{s p}(\cdot) 表示为：

\tilde{\mathbf{S}}_{i j}^{(s p)}由映射函数QSP作用于\tilde{\mathbf{S}}_{j}生成，并定义如下：当\tilde{s}_{j}包含于前k个最大值时，则\tilde{s}_{j}^{(s p)} = \tilde{s}_{j}；否则\tilde{s}_{j}^{(s p)} = 0。

其中，
\topminus{}k(\tilde{\mathrm{S}}_i)
表示行向量
\tilde{\mathrm{S}}_i
的最大
k
个值构成的集合。注意，
本文并不对
FGP learner
进行稀疏化处理。

对于大型图而言，在进行k近邻稀疏化时应采用局部敏感近似法[11]。具体而言，在这种情况下 nearest neighbors 的选择范围是基于一批节点而非全部节点。这种方法显著降低了内存占用需求。

cpp

    def cal\_similarity\_graph(node\_embeddings):
     similarity\_graph = torch.mm(node\_embeddings, node\_embeddings.t())
    return similarity\_graph

cal_similarity_graph Code

irpf90

    def top\_k(raw\_graph, K):
    values, indices = raw\_graph.topk(k=int(K), dim=-1)
    assert torch.max(indices) < raw\_graph.shape[1]
    mask = torch.zeros(raw\_graph.shape).cuda()
    mask[torch.arange(raw\_graph.shape[0]).view(-1, 1), indices] = 1.
    
    mask.requires\_grad = False
    sparse\_graph = raw\_graph * mask
    return sparse\_graph

top_k Code
3.2.2 Symmetrization and Activation

对称化和激活的执行方式为：

对称版本的\tilde{\mathbf{S}}^{(s y m)}可表示为 q_{s y m}作用于q_{a c t}(\tilde{\mathbf{S}}^{(s p)})的结果。\ 该值等于 \sigma_q(\tilde{\mathbf{S}}^{(s p)})与其转置后的均值。\ 参考式（7）

其中, σ_q作为一个非线性激活函数被引入.在度量学习框架下定义的模型中,则采用 ReLU 作为激活函数.而 FGP 学习器则选择 ELU 激活函数以避免梯度消失问题.

ruby

    def symmetrize(adj):  # only for non-sparse
    return (adj + adj.T) / 2

Symmetrization and Activation Code

3.2.3 Normalization

为了使边权值维持在 [0, 1]^3 范围内并确保数值稳定性和一致性的一致性需求下，在最终步骤中进行了 \tilde{\mathrm{S}} 的归一化处理。特别地，在这一过程中采用了对称性设计以平衡各维度的影响。

S=qnorm (S(sym))=(D(sym))−12S(sym)(D(sym))−12(8)S=qnorm (S(sym))=(D(sym))−12S(sym)(D(sym))−12(8)\mathrm{S}=q_{\text {norm }}\left(\tilde{\mathrm{S}}^{(s y m)}\right)=\left(\tilde{\mathbf{D}}^{(s y m)}\right)^{-\frac{1}{2}} \tilde{\mathbf{S}}^{(s y m)}\left(\tilde{\mathbf{D}}^{(s y m)}\right)^{-\frac{1}{2}}\quad\quad\quad(8)

其中，D(sym)D(sym)\tilde{\mathbf{D}}^{(s y m)} 为 S(sym)S(sym)\tilde{\mathbf{S}}^{(s y m)} 的度矩阵。

maxima

    def normalize(adj, mode, sparse=False):
    if not sparse:
        if mode == "sym":
            inv\_sqrt\_degree = 1. / (torch.sqrt(adj.sum(dim=1, keepdim=False)) + EOS)
            return inv\_sqrt\_degree[:, None] * adj * inv\_sqrt\_degree[None, :]
        elif mode == "row":
            inv\_degree = 1. / (adj.sum(dim=1, keepdim=False) + EOS)
            return inv\_degree[:, None] * adj
        else:
            exit("wrong norm mode")
    else:
        adj = adj.coalesce()
        if mode == "sym":
            inv\_sqrt\_degree = 1. / (torch.sqrt(torch.sparse.sum(adj, dim=1).values()))
            D\_value = inv\_sqrt\_degree[adj.indices()[0]] * inv\_sqrt\_degree[adj.indices()[1]]
    
        elif mode == "row":
            aa = torch.sparse.sum(adj, dim=1)
            bb = aa.values()
            inv\_degree = 1. / (torch.sparse.sum(adj, dim=1).values() + EOS)
            D\_value = inv\_degree[adj.indices()[0]]
        else:
            exit("wrong norm mode")
        new\_values = adj.values() * D\_value
    
        return torch.sparse.FloatTensor(adj.indices(), new\_values, adj.size())

Normalization Code

3.3 Multi-view Graph Contrastive Learning

本文使用多视图对比学习来提供有效的监督信号来指导图结构学习。

3.3.1 Graph View Establishment

SUBLIME 根据学习数据构建并根据学习到的图像（learner view）定义一个子视图，并基于输入数据构建另一个子视图（anchor view）。

Learner view

从 learner 的视角出发，在学习过程中使用 SSS 作为邻接矩阵，并以 XXX 表示特征矩阵。其中 \mathcal{G}_{l} = (\mathbb{R}, XXX) 定义为图的邻接矩阵与特征矩阵组成的图结构。在每次训练迭代中，在学习过程中使用 S 和用于建模的参数通过梯度下降算法进行优化。

在 SUBLIME 环境中详细说明其构建过程，请问您指的是哪一种情况？

• 给定FGP学习器，在其kNN边相关参数中设置值为1^{(l)}= [{ \begin{array}{c} 1 \\ \end{array} }]_{d\times d} ，其余参数均设为空矩阵\mathbf{O}^{(l)}；
• 对于带有注意力机制的学习器（attentive learner），令其中每个权重\omega_{i,j}^{(l)}\in\omega取值均为[{ \begin{array}{c} 3 \\ \end{array} }]_{d\times d} 。随后采用度量函数计算特征间的相似性指标，并通过后处理方法获得稀疏化后的kNN关系矩阵；
• 在MLP学习器及GNN学习器中分别设定相同的嵌入维度d ，并令各自的初始权重矩阵\Omega^{(l)}\in\mathbb{R}^{d\times d} 均初始化为空矩阵\mathbf{O}；

ini

    learned\_adj = graph\_learner(features)

Learner view Code
Anchor view
Anchor view 扮演着 "teacher” 的角色，为GSL提供了正确和稳定的指导。
对于 structure refinement task ，采用 原始图邻接矩阵 AAA，即 Ga=(Aa,X)=(A,X)Ga=(Aa,X)=(A,X)\mathcal{G}{a}=\left(\mathbf{A}{a}, \mathbf{X}\right)=(\mathbf{A}, \mathrm{X})。

对于 graph structure inference task, 我们以单位矩阵III作为图结构定义为\mathcal{G}_a = (\mathrm{I}, \mathrm{X}).

stylus

    if args.gsl\_mode == 'structure\_inference':
    if args.sparse:
        anchor\_adj\_raw = torch\_sparse\_eye(features.shape[0])
    else:
        anchor\_adj\_raw = torch.eye(features.shape[0])
    elif args.gsl\_mode == 'structure\_refinement':
    if args.sparse:
        anchor\_adj\_raw = adj\_original
    else:
        anchor\_adj\_raw = torch.from\_numpy(adj\_original)

Anchor view Code

3.3.2 Data Augmentation

数据增强：Feature mask 和 Edge drop。

Feature masking
为了干扰节点特征, 随机选取一定数量的特征维度, 并将其设置为全零向量.

对于给定的特征矩阵 XX\mathbf{X} ，我们首先生成一个遮蔽向量 m(x)∈{0,1}^d m(x)∈{0,1}^d\mathbf{m}{(x)} \in {0,1}^d ，其中每个元素独立地服从伯努利分布 p(x)p(x)p^{(x)} 。接着通过该遮蔽向量 m(x)m(x)\mathbf{m}^{(x)} 对每个节点的特征向量进行遮蔽处理：

\bm{\overline{X}} = \bm{T}_{f m}(\bm{X}) = \left[\bm{x}_{1} \odot \bm{m}^{(x)}, ⋯, ⌈\texttt{n⌉}} ⊙ ⌊\texttt{n⌋}} ⊗ ⌋\texttt{(x)}\right]^{\top}

其中

Edge dropping

随机删除部分边来破坏图的结构。具体地说，对于给定的邻接矩阵 AAA，首先采样掩蔽矩阵 M(a)∈{0,1}n×nM(a)∈{0,1}n×n\mathbf{M}^{(a)} \in{0,1}^{n \times n}，其中每个元素 M(a)ijMij(a)\mathbf{M}{i j}^{(a)} 是从概率为 p(a)p(a)p^{(a)} 的伯努利分布中抽取的。邻接矩阵被 M(a)M(a)\mathbf{M}^{(a)} 屏蔽后：
A¯¯¯¯=Ted(A)=A⊙M(a)(10)A¯=Ted(A)=A⊙M(a)(10)\overline{\mathbf{A}}=\mathcal{T}{e d}(\mathbf{A})=\mathbf{A} \odot \mathbf{M}^{(a)}\quad\quad\quad(10)

其中 \overline{\mathbf{A}} 表示增广邻接矩阵，而 \mathcal{T}_{e d}(\cdot) 则代表边丢弃变换。

通过 SUBLIME 平台借助两种增强方案，在 learner's view 和 anchor view 中生成增强图形。

该图的表示方法包括两部分：一个是Transformed Set S及其对应的Feature Mapping X；另一个是Transformed Set Aa及其对应的相同Feature Mapping X。（11）

其中，在这里我们用 \overline{\mathcal{G}}_{l} 和 \overline{\mathcal{G}}_{a} 分别代表强化的学习者视角和强化的锚定视角。

基于两个不同的视图，在Feature masking过程中遵循了各自独立的概率分布p_l^{(x)} \neq p_a^{(x)}。对于Edge dropping这一操作，在两子图中已经存在显著差异的基础上，则采用了相同的丢弃概率p_l{(a)} = p_a{(a)} = p{(a)}。

3.3.3 Node-level Contrastive Learning

在获得两个增广图视图后, 进行基于节点级别的对比学习, 以提高它们之间的 MI. 在 SUBLIME 中, 借鉴了 SimCLR[6] 中的简单对比学习方案, 其由以下几个组成部分构成:

一种基于图神经网络（GNN）的方法 fθ(⋅) 被用来生成增广图 \overline{\mathcal{G}}{l} 和 \overline{\mathcal{G}}{a} 的节点层表示：

该方法通过映射函数得到Hl和Ha，并达本研究的目标(12)

其中 θ 是用于 encoder f_θ(⋅) 参数化的变量。这些节点嵌入矩阵 H_l 和 H_a 分别代表 learner 和 anchor 视图的空间结构特征，在我们的实验环境中，默认设置下我们采用了 Graph Convolutional Network (GCN) 作为编码器模型，并将其深度配置为 L₁=2。

MLP-based projector

经过编码器处理后，模型中包含一个带有 L₂ 层的 MLP 映射层 g_φ(⋅)，它将被设计用于将数据映射到另一个潜在空间，并在此空间内进行对比损失计算：

根据上述公式\mathbf{Z}_{l}等于说g_{\varphi}作用于\mathbf{H}_{l}的结果，
而\mathbf{Z}_{a}则等于g_{\varphi}作用于\mathbf{H}_{a}。
这些关系式被标记为(13)。

其中, \phi 代表投影头 g_\phi(\cdot) 的参数, \mathbf{Z}_l, \mathbf{Z}_a \in \mathbb{R}^{n \times d_2}（其中 d_2 为投影维度）分别代表学习者与锚点视角下的降维表示。

Node-level contrastive loss function

通过对比损失 LL\mathcal{L} 强制达到了最大化的程度，在两个视图中的同一节点 viviv_{i} 的投影 zl,i 和 za,i 在一致性上得到了强化。我们采用了对称归一化的温度尺度交叉熵损失 NT-Xent [29,35] 来构建这一框架。

令 L 等于 ½ 乘以求总合号下从 n 乘以 i 等于 1 到 N 的项

3.4 Structure Bootstrapping Mechanism

基于由 \mathbf{A} 或 III 定义的恒定 Anchor 邻接矩阵 \mathbf{A}_a 的方法中,SUBLIME 值得注意的是它旨在通过最大化两个视图之间的互信息来推导出图结构 \Theta。

然而，使用固定的AaAa\mathbf{A}_{a} 可能会导致几个问题：

• Error information inheritance. Since A_a\mathbf{A}_a is directly derived from the input data, it inherently preserves inherent noise characteristics of the original graph (e.g., missing or redundant edges). If noise persists during learning, the learned structure will inevitably inherit this contamination;
• Persistent guidance absence. A fixed anchor graph contains limited information to guide GSL. Once the graphical learner captures this limited information, subsequent training steps will struggle to obtain effective supervision;
• Overfitting tendencies. Under the learning objective that maximizes consistency between two views, learned structures tend to overfit to fixed anchor structures, resulting in test performance similar to that of the original data.

启发于基于 bootstrap 的算法 [5,14,37] 的启发下

Aa←τAa+(1−τ)S(15)Aa←τAa+(1−τ)S(15)\mathbf{A}{a} \leftarrow \tau \mathbf{A}{a}+(1-\tau) \mathrm{S} \quad\quad\quad(15)

在更新过程中（段落保持不变），AaAa\mathbf{A}{a} 中一些噪声边的权值逐渐降低（将"降低"替换为"减少"），从而减弱了它们对结构学习的负面作用（将"减轻了它们对..."改为"减弱了它们的影响"）。与此同时（使用更精确的时间表达），由于学习目标 AaAa\mathbf{A}{a} 在训练阶段发生了变化（将"由于"改为"因为"），它始终能够包含更多有效的信息来指导拓扑的学习（将"包含了"改为"包含更多"），从而导致过拟合问题自然得到了缓解（将"解决为'自然得到解决'"）。此外，在语言保持不变的前提下（保持原文的语言类型），Structure Bootstrapping Mechanism 通过利用已掌握的知识来提升学习目标（将'利用'改为'通过'），从而促使模型持续发现更加优化的图结构（将'发现了越来越最优'改为'发现了更加优化'）。最后，在保持稳定性的前提下（使用更专业的表达），通过 slow-moving average（τ≥0.99）更新确保了整个训练过程的高度稳定性。

4 Experiments

数据集

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220604112147954-1262269307.png)

Node classification in structure inference scenario

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220604112311746-106600379.png)

Node classification in structure refinement scenario

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220604112413254-2033874168.png)

Node clustering in structure refinement scenario

[

](https://img2022.cnblogs.com/blog/1664108/202206/1664108-20220604112507200-1124369512.png)

5 Conclusion

本文对无监督图结构学习问题进行了开创性研究

论文信息

1 Introduction

2 Problem Definition

3 Method

3.1 Graph Learner

3.1.1 FGP learner

3.1.2 Attentive Learner

3.1.3 MLP Learner

3.1.4 GNN Learner

3.2 Post-processor

3.2.1 Sparsification

3.2.3 Normalization

3.3 Multi-view Graph Contrastive Learning

3.3.1 Graph View Establishment

3.3.2 Data Augmentation

3.3.3 Node-level Contrastive Learning

3.4 Structure Bootstrapping Mechanism

4 Experiments

5 Conclusion

EOF

Blair朋友的博客文章：外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

[推荐](javascript:void(0)😉

[推荐](javascript:void(0)😉

[推荐](javascript:void(0)😉

[推荐](javascript:void(0)😉