CVPR-2022《Efficient Deep Embedded Subspace Clustering》

推荐深蓝学院的《深度神经网络加速：cuDNN 与 TensorRT》，课程面向就业，细致讲解CUDA运算的理论支撑与实践，学完可以系统化掌握CUDA基础编程知识以及TensorRT实战，并且能够利用GPU开发高性能、高并发的软件系统，感兴趣可以直接看看链接：深蓝学院《深度神经网络加速：cuDNN 与 TensorRT》

---

核心思想分析

该论文提出了一种高效的深度嵌入子空间聚类方法（Efficient Deep Embedded Subspace Clustering, EDESC），旨在解决传统深度子空间聚类方法在处理大规模数据集时因自表达模型导致的二次时间和空间复杂度问题。其核心思想是将深度特征学习与子空间聚类结合，通过迭代优化子空间基和嵌入表示，构建一个非自表达框架的聚类模型，从而实现线性时间和空间复杂度，适用于大规模和在线聚类场景。论文假设数据点分布在多个低维子空间中，利用深度神经网络（DNN）从高维数据中学习嵌入表示，并通过子空间基的迭代更新实现准确的聚类。

具体而言：

1. 深度特征学习：利用自编码器（Auto-Encoder, AE）从高维数据中提取低维嵌入表示 $\mathbf{Z}$，捕捉数据的内在结构。
2. 子空间基学习：通过子空间基矩阵 $\mathbf{D}$ 表示不同子空间，迭代优化 $\mathbf{D}$ 和嵌入表示 $\mathbf{Z}$，以增强聚类性能。
3. 非自表达框架：摒弃传统子空间聚类中需要计算 $n\times n$ 自表达矩阵的做法，降低计算复杂度。
4. 在线聚类适应性：设计支持小批量（mini-batch）训练的模型，适用于流式数据和在线聚类。

该方法不仅提升了聚类精度，还通过线性复杂度突破了传统方法的规模限制。

---

目标函数分析

论文的目标函数旨在联合优化嵌入表示、子空间基和聚类分配，包含三个主要损失项，定义为：
$$L=L_{\text{Recon}}+D_{\text{Cons}}+\beta L_{\text{Sub}}$$

1. 重建损失 $L_{\text{Recon}}$：
   用于确保自编码器能够从嵌入表示 $\mathbf{Z}$ 重建原始数据 $\mathbf{X}$，保持数据的内在结构：
   $$L_{\text{Recon}}=\frac{1}{2n}\sum _{i=1}^n\Vert {\mathbf{x}}_i-{\hat{\mathbf{x}}}_i{\Vert }_F^2$$
   其中，${\mathbf{x}}_i$ 是输入数据，${\hat{\mathbf{x}}}_i=h_{\mathcal{W}}({\mathbf{z}}_i)$ 是通过解码器 $h_{\mathcal{W}}$ 从嵌入表示 ${\mathbf{z}}_i$ 重建的数据，$n$ 是样本数，$\Vert \cdot {\Vert }_F$ 表示 Frobenius 范数。

2. 子空间基正则化项 $D_{\text{Cons}}$：
   确保子空间基 $\mathbf{D}$ 的列向量满足单位范数约束，并使不同子空间基 ${\mathbf{D}}^{(j)}$ 和 ${\mathbf{D}}^{(l)}$（$j\ne l$）之间的相关性尽可能小：
   $$D_{\text{Cons}}=\xi \left(D_{\text{Cons1}}+D_{\text{Cons2}}\right)$$

   • $D_{\text{Cons1}}$ 约束 $\mathbf{D}$ 的列范数为 1：
     $$D_{\text{Cons1}}=\frac{1}{2}\Vert {\mathbf{D}}^{\top }\mathbf{D}\odot \mathbf{I}-\mathbf{I}{\Vert }_F^2$$
     其中，$\odot$ 表示 Hadamard 乘积，$\mathbf{I}$ 是 $kd\times kd$ 的单位矩阵，$k$ 是聚类数，$d$ 是子空间维数。
   • $D_{\text{Cons2}}$ 最小化不同子空间基之间的 Frobenius 范数：
     $$D_{\text{Cons2}}=\frac{1}{2}\Vert {\mathbf{D}}^{\top }\mathbf{D}\odot \mathbf{O}{\Vert }_F^2$$
     其中，$\mathbf{O}$ 是一个矩阵，对角块元素为 0，其余为 1。$\xi$ 是一个固定为 $10^{-3}$ 的调谐参数。

3. 子空间聚类损失 $L_{\text{Sub}}$：
   通过 Kullback-Leibler（KL）散度最小化子空间亲和度 $S$ 和精炼子空间亲和度 $\tilde{S}$ 之间的差异，驱动嵌入表示 $\mathbf{Z}$ 与子空间基 $\mathbf{D}$ 的正确分配：
   $$L_{\text{Sub}}=KL(\tilde{S}\Vert S)=\sum _i\sum _j{\tilde{s}}_{ij}\log \frac{{\tilde{s}}_{ij}}{s_{ij}}$$

   • 子空间亲和度 $S$ 定义为：
     $$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d}{{\sum }_j\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d\right)}$$
     其中，$\eta$ 是平滑参数，$s_{ij}$ 表示嵌入表示 ${\mathbf{z}}_i$ 属于第 $j$ 个子空间的概率。
   • 精炼子空间亲和度 $\tilde{S}$ 增强高置信度分配：
     $${\tilde{s}}_{ij}=\frac{s_{ij}^2/{\sum }_i{s}_{ij}}{{\sum }_j\left(s_{ij}^2/{\sum }_i{s}_{ij}\right)}$$
     $\beta$ 是一个控制 $L_{\text{Sub}}$ 权重的超参数。

目标函数通过联合优化这三项，实现嵌入表示学习、子空间基更新和聚类分配的协同优化。

---

目标函数的优化过程

优化过程通过迭代更新神经网络参数 $\mathcal{W},{\mathcal{W}}^{\prime }$（编码器和解码器的参数）和子空间基 $\mathbf{D}$ 来最小化目标函数 $L$，具体流程如 算法 1 所述：

1. 初始化：

   • 使用预训练自编码器的权重初始化神经网络。
   • 通过对预训练模型的嵌入表示 $\mathbf{Z}$ 应用 $k$-means 聚类，初始化子空间基 $\mathbf{D}$。

2. 迭代优化：

   • 步骤 1：通过编码器 $h_{{\mathcal{W}}^{\prime }}$ 从输入数据 $\mathbf{X}$ 计算嵌入表示 $\mathbf{Z}$：
     $${\mathbf{z}}_i=h_{{\mathcal{W}}^{\prime }}({\mathbf{x}}_i),i=1,\dots ,n$$
   • 步骤 2：根据公式 (13) 计算子空间亲和度 $S$，衡量 ${\mathbf{z}}_i$ 与子空间基 ${\mathbf{D}}^{(j)}$ 的相关性。
   • 步骤 3：根据公式 (14) 计算精炼子空间亲和度 $\tilde{S}$，增强高置信度分配。
   • 步骤 4：计算损失项：
     • 重建损失 $L_{\text{Recon}}$（公式 9）。
     • 子空间聚类损失 $L_{\text{Sub}}$（公式 15）。
     • 子空间基正则化项 $D_{\text{Cons}}$（公式 12）。
   • 步骤 5：通过最小化目标函数 $L$（公式 16），使用 Adam 优化器更新网络参数 $\mathcal{W},{\mathcal{W}}^{\prime }$ 和子空间基 $\mathbf{D}$。

3. 终止条件：

   • 训练进行 $T$ 个 epoch（实验中设为 200）。
   • 收敛分析表明，损失在约 25 个 epoch 后趋于平坦，100 个 epoch 后基本收敛。

4. 聚类结果：

   • 训练完成后，通过公式 (17) 获取最终聚类标签：
     $${\mathcal{C}}_i=\arg \underset{j}{\max }{s}_{ij}$$

优化过程通过小批量训练实现，支持大规模和在线聚类场景。每次迭代联合优化嵌入表示和子空间基，子空间亲和度 $S$ 和 $\tilde{S}$ 提供自监督信息，驱动模型学习更具区分性的表示。

---

主要贡献点

1. 新型深度子空间聚类框架：

   • 提出了一种非自表达框架的深度子空间聚类方法，摆脱了传统方法对 $n\times n$ 自表达矩阵的依赖。

2. 线性时间和空间复杂度：

   • 通过迭代优化子空间基 $\mathbf{D}$ 和嵌入表示 $\mathbf{Z}$，实现时间复杂度 $O(kdpn+\tilde{m}\tilde{p}n)$ 和空间复杂度 $O(\tilde{m}n+kn+kpd+\theta )$，显著优于传统方法的二次复杂度。

3. 支持大规模和在线聚类：

   • 设计支持小批量训练的模型，适用于任意规模数据集和流式数据场景。

4. 高聚类精度：

   • 在多个基准数据集（如 Fashion-MNIST、STL-10、REUTERS-10K）上，聚类精度（ACC 和 NMI）显著优于现有方法，验证了方法的有效性。

5. 理论分析：

   • 分析了深度神经网络在距离基聚类和子空间聚类之间转换的可行性，证明子空间聚类更适合复杂数据结构。

---

实验结果分析

实验在六个广泛使用的基准数据集上进行，包括 MNIST、Fashion-MNIST、CIFAR-10、CIFAR-100、STL-10 和 REUTERS-10K。评估指标为聚类准确率（ACC）和归一化互信息（NMI）。

1. 与经典和深度聚类方法的比较（表 3）：

   • 在 STL-10 上，EDESC 的 ACC 和 NMI 分别为 0.745 和 0.687，分别比 PICA 高 3.2% 和 7.6%。
   • 在 REUTERS-10K 上，ACC 和 NMI 分别为 0.825 和 0.611，优于大多数竞争方法。
   • 在 Fashion-MNIST、CIFAR-10 和 CIFAR-100 上，EDESC 始终位列前三，显示出对不同数据类型的鲁棒性。
   • 结果表明，基于欧几里得距离的深度聚类方法（如 DEC、IDEC）在复杂数据结构上表现较差，而 EDESC 的子空间方法更有效。

2. 与子空间聚类方法的比较（表 4）：

   • 在 MNIST 上，EDESC 的 ACC 和 NMI 分别为 0.913 和 0.862，显著优于 SSC-SAE、LRR-SAE 和 DSC-Net。
   • 在 Fashion-MNIST 上，ACC 和 NMI 为 0.631 和 0.670，优于大多数子空间聚类方法。
   • 表明 EDESC 在图像数据集上具有更强的特征学习和聚类能力。

3. 运行时间比较（表 5）：

   • EDESC（无 mini-batch）在 MNIST、Fashion-MNIST 和 REUTERS-10K 上的运行时间分别为 68.37s、59.43s 和 10.53s，远低于 SSC 和 DSC-Net。
   • 即使使用 mini-batch，EDESC 的运行时间仍具竞争力，验证了其高效性。

4. 消融研究（表 6）：

   • 移除 $L_{\text{Recon}}$、$L_{\text{Sub}}$ 或 $D_{\text{Cons}}$ 后，聚类性能下降，证明各损失项的重要性。
   • 例如，在 STL-10 上，完整 EDESC 的 ACC 为 0.745，去除 $L_{\text{Recon}}$ 后降至 0.512。

5. 参数敏感性（图 6）：

   • 超参数 $\beta$ 在 $[0.1,1]$ 范围内性能最佳，过大或过小会影响嵌入空间的学习。
   • 子空间维数 $d$ 对 NMI 更敏感，但整体性能在合理范围内稳定。

6. 在线聚类（图 8）：

   • 在 STL-10 和 HAR 数据集上，EDESC 的在线聚类性能优于 DEC 和 IDEC，验证了其在流式数据场景中的适用性。

---

算法实现过程详细解释

以下是 EDESC 算法的详细实现过程，结合 算法 1 和论文描述，逐步解析：

1. 输入与初始化

• 输入：
  • 数据矩阵 $\mathbf{X}\in {\mathbb{R}}^{m\times n}$，$m$ 为特征维数，$n$ 为样本数。
  • 嵌入维数 $p$，子空间维数 $d$，聚类数 $k$。
  • 超参数：平滑参数 $\eta$，聚类损失权重 $\beta$，总训练轮数 $T$。
• 初始化：
  • 网络初始化：使用预训练自编码器（50 个 epoch）初始化编码器和解码器权重。编码器结构为 $m-500-500-1000-p$ 的全连接网络，解码器对称。
  • 子空间基初始化：对预训练自编码器的嵌入表示 $\mathbf{Z}$ 应用 $k$-means 聚类，提取各簇的列空间作为初始 $\mathbf{D}$。

2. 训练流程（迭代 $t=1$ 到 $T$）

训练过程通过小批量方式进行，每次迭代处理一个 batch 的数据，具体步骤如下：

• 步骤 1：计算嵌入表示 $\mathbf{Z}$：

  • 对于输入 batch 的数据 ${\mathbf{X}}_{\text{batch}}$，通过编码器 $h_{{\mathcal{W}}^{\prime }}$ 计算嵌入表示：
    $${\mathbf{z}}_i=h_{{\mathcal{W}}^{\prime }}({\mathbf{x}}_i),{\mathbf{x}}_i\in {\mathbf{X}}_{\text{batch}}$$
  • $\mathbf{Z}$ 是低维表示，维度为 $p$，捕捉数据的子空间结构。

• 步骤 2：计算子空间亲和度 $S$：

  • 根据公式 (13)，计算每个样本 ${\mathbf{z}}_i$ 与子空间基 ${\mathbf{D}}^{(j)}$ 的亲和度：
    $$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d}{{\sum }_j\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d\right)}$$
  • $s_{ij}$ 表示 ${\mathbf{z}}_i$ 属于第 $j$ 个子空间的概率，$\eta d$ 防止分母为零并控制平滑。

• 步骤 3：计算精炼子空间亲和度 $\tilde{S}$：

  • 根据公式 (14)，对 $S$ 进行精炼，增强高置信度分配：
    $${\tilde{s}}_{ij}=\frac{s_{ij}^2/{\sum }_i{s}_{ij}}{{\sum }_j\left(s_{ij}^2/{\sum }_i{s}_{ij}\right)}$$
  • $\tilde{S}$ 强调更确定的聚类分配，充当自监督信号。

• 步骤 4：计算损失项：

  • 重建损失 $L_{\text{Recon}}$：
    • 通过解码器 $h_{\mathcal{W}}$ 从 $\mathbf{Z}$ 重建数据：
      $${\hat{\mathbf{x}}}_i=h_{\mathcal{W}}({\mathbf{z}}_i)$$
    • 计算重建误差：
      $$L_{\text{Recon}}=\frac{1}{2n_b}\sum _{i\in \text{batch}}\Vert {\mathbf{x}}_i-{\hat{\mathbf{x}}}_i{\Vert }_F^2$$
      其中，$n_b$ 是 batch 大小。
  • 子空间聚类损失 $L_{\text{Sub}}$：
    • 计算 $\tilde{S}$ 和 $S$ 之间的 KL 散度：
      $$L_{\text{Sub}}=\sum _i\sum _j{\tilde{s}}_{ij}\log \frac{{\tilde{s}}_{ij}}{s_{ij}}$$
  • 子空间基正则化项 $D_{\text{Cons}}$：
    • 计算 $D_{\text{Cons1}}$ 和 $D_{\text{Cons2}}$：
      $$D_{\text{Cons1}}=\frac{1}{2}\Vert {\mathbf{D}}^{\top }\mathbf{D}\odot \mathbf{I}-\mathbf{I}{\Vert }_F^2$$
      $$D_{\text{Cons2}}=\frac{1}{2}\Vert {\mathbf{D}}^{\top }\mathbf{D}\odot \mathbf{O}{\Vert }_F^2$$
    • 组合正则化项：
      KaTeX parse error: Expected '}', got '\right' at position 66: …_{\text{Cons2} \̲r̲i̲g̲h̲t̲), \quad \xi = …

• 步骤 5：更新参数：

  • 计算总损失：
    $$L=L_{\text{Recon}}+D_{\text{Cons}}+\beta L_{\text{Sub}}$$
  • 使用 Adam 优化器（学习率 0.001，batch 大小 512）更新网络参数 $\mathcal{W},{\mathcal{W}}^{\prime }$ 和子空间基 $\mathbf{D}$。

3. 输出聚类结果

• 训练完成后，对所有样本计算最终子空间亲和度 $S$。
• 根据公式 (17) 分配聚类标签：
  $${\mathcal{C}}_i=\arg \underset{j}{\max }{s}_{ij}$$
• 返回聚类标签 $\mathcal{C}$。

4. 在线聚类扩展

• 对于在线聚类，算法以流式方式处理数据：
  • 每次接收一个数据 batch，更新 $\mathbf{Z}$、$S$、$\tilde{S}$ 和损失项。
  • 增量式更新 $\mathbf{D}$ 和网络参数，适应动态数据流。
• 实验验证了其在 STL-10 和 HAR 数据集上的有效性。

5. 实现细节

• 网络结构：编码器和解码器为对称全连接网络，结构为 $m-500-500-1000-p$。
• 预处理：对于图像数据集（如 CIFAR-10、CIFAR-100、STL-10），使用 ResNet50 提取 2048 维特征。
• 超参数：
  • $\eta =d$，$d$ 通常不超过 10。
  • $\beta \in [0.1,1]$。
  • 训练 200 个 epoch，Adam 优化器，学习率 0.001，batch 大小 512。
• 代码实现：基于 PyTorch，代码公开在 GitHub（https://github.com/JinyuCai95/EDESC-pytorch）。

---

总结

EDESC 提出了一种高效、准确的深度子空间聚类方法，通过非自表达框架和线性复杂度解决了传统方法的局限性。其目标函数联合优化重建损失、子空间基正则化和聚类损失，优化过程通过迭代更新嵌入表示和子空间基实现。实验结果表明，EDESC 在多个基准数据集上显著优于现有方法，适用于大规模和在线聚类场景。算法实现结合自编码器和子空间基迭代优化，支持小批量训练，具有高度的实用性和扩展性。

---

两个函数：seperate 和 Initialization_D源码分析，它们是论文《Efficient Deep Embedded Subspace Clustering》（EDESC, CVPR 2022）中用于初始化子空间基矩阵 $\mathbf{D}$ 的实现部分。我将结合论文内容，详细分析这两个函数的功能、实现逻辑、潜在问题，并提出改进建议，同时解释它们在 EDESC 算法中的作用。

---

1. 函数 seperate 分析

功能

seperate 函数根据初始聚类标签 y_pred 将嵌入表示矩阵 $\mathbf{Z}$ 分成 $k$ 个子集，每个子集对应一个簇的嵌入向量。这些子集用于后续子空间基 $\mathbf{D}$ 的初始化。

代码逐行解析

from collections import defaultdict
import numpy as np
import torchdef seperate(Z, y_pred, n_clusters):n, d = Z.shape[0], Z.shape[1]Z_seperate = defaultdict(list)Z_new = np.zeros([n, d])for i in range(n_clusters):for j in range(len(y_pred)):if y_pred[j] == i:Z_seperate[i].append(Z[j].cpu().detach().numpy())Z_new[j][:] = Z[j].cpu().detach().numpy()return Z_seperate

1. 输入参数：

   • Z：嵌入表示矩阵，形状为 $(n,p)$，$n$ 是样本数，$p$ 是嵌入维数。$\mathbf{Z}$ 通常由预训练自编码器的编码器生成，为 PyTorch 张量。
   • y_pred：初始聚类标签，长度为 $n$，通常通过对 $\mathbf{Z}$ 应用 $k$-means 聚类获得，表示每个样本所属的簇（值从 0 到 $n_{c}lusters-1$）。
   • n_clusters：聚类数 $k$，即子空间数量。

2. 初始化：

   • n, d = Z.shape[0], Z.shape[1]：获取 $\mathbf{Z}$ 的形状，$n$ 是样本数，$d$ 是嵌入维数（即 $p$）。
   • Z_seperate = defaultdict(list)：创建一个默认字典，键为簇索引（0 到 $n_{c}lusters-1$），值为对应簇的嵌入向量列表。
   • Z_new = np.zeros([n, d])：初始化一个 $(n,p)$ 的零矩阵，用于存储 $\mathbf{Z}$ 的 NumPy 副本。

3. 分离嵌入表示：

   for i in range(n_clusters):for j in range(len(y_pred)):if y_pred[j] == i:Z_seperate[i].append(Z[j].cpu().detach().numpy())Z_new[j][:] = Z[j].cpu().detach().numpy()
   

   • 双重循环遍历每个簇 $i$ 和样本 $j$：
     • 如果样本 $j$ 的标签 y_pred[j] 等于簇 $i$，将 $\mathbf{Z}[j]$（第 $j$ 个嵌入向量）转换为 NumPy 数组（通过 .cpu().detach().numpy()）并添加到 Z_seperate[i]。
     • 同时，将 $\mathbf{Z}[j]$ 复制到 Z_new[j]。
   • Z_seperate[i] 是一个列表，包含第 $i$ 个簇的所有嵌入向量，每个向量的形状为 $(p,)$。

4. 输出：

   • 返回 Z_seperate，一个 defaultdict，其中 Z_seperate[i] 是第 $i$ 个簇的嵌入向量列表。
   • Z_new 未被使用，可能用于调试或后续扩展，但当前未返回。

潜在问题

1. 效率低：

   • 双重循环（$O(n\cdot k)$）效率较低，尤其是当样本数 $n$ 和聚类数 $k$ 较大时。
   • 改进建议：使用 NumPy 的布尔索引或 PyTorch 的张量操作重写：

     Z_seperate = defaultdict(list)
     for i in range(n_clusters):mask = (y_pred == i)Z_seperate[i] = Z[mask].cpu().detach().numpy()
     

     这将复杂度降至 $O(n)$，仅需遍历一次样本。

2. Z_new 的冗余：

   • Z_new 仅复制 $\mathbf{Z}$ 到 NumPy 数组，未在后续使用，增加了内存和计算开销。
   • 改进建议：移除 Z_new 相关代码，除非其在其他部分有明确用途。

3. 数据类型假设：

   • 假设 Z 是 PyTorch 张量，y_pred 是 NumPy 数组或列表。如果 y_pred 是张量，需确保一致性。
   • 改进建议：添加类型检查或统一数据类型：

     if isinstance(y_pred, torch.Tensor):y_pred = y_pred.cpu().numpy()
     

4. 空簇处理：

   • 如果某个簇 $i$ 没有样本（Z_seperate[i] 为空），后续 SVD 会失败。
   • 改进建议：检查空簇并提供默认处理（如跳过或填充零向量）。

---

2. 函数 Initialization_D 分析

功能

Initialization_D 函数利用 seperate 函数的输出，通过对每个簇的嵌入表示进行奇异值分解（SVD），初始化子空间基矩阵 $\mathbf{D}$。$\mathbf{D}$ 是 EDESC 算法的核心组件，用于表示 $k$ 个子空间的基。

代码逐行解析

def Initialization_D(Z, y_pred, n_clusters, d):Z_seperate = seperate(Z, y_pred, n_clusters)Z_full = NoneU = np.zeros([n_clusters * d, n_clusters * d])print("Initialize D")for i in range(n_clusters):Z_seperate[i] = np.array(Z_seperate[i])u, ss, v = np.linalg.svd(Z_seperate[i].transpose())U[:,i*d:(i+1)*d] = u[:,0:d]D = Uprint("Shape of D: ", D.transpose().shape)print("Initialization of D Finished")return D

1. 输入参数：

   • Z、 y_pred、 n_clusters：与 seperate 函数相同。
   • d：每个子空间的维数，即 ${\mathbf{D}}^{(j)}\in {\mathbb{R}}^{p\times d}$ 的列数。

2. 调用 seperate：

   • Z_seperate = seperate(Z, y_pred, n_clusters)：获取每个簇的嵌入向量列表。

3. 初始化变量：

   • Z_full = None：未使用，可能为占位符。
   • U = np.zeros([n_clusters * d, n_clusters * d])：初始化 $(kd,kd)$ 的零矩阵，用于存储 SVD 结果。

4. SVD 计算：

   for i in range(n_clusters):Z_seperate[i] = np.array(Z_seperate[i])u, ss, v = np.linalg.svd(Z_seperate[i].transpose())U[:,i*d:(i+1)*d] = u[:,0:d]
   

   • 将 Z_seperate[i]（列表）转换为 NumPy 数组，形状为 $(n_i,p)$，$n_i$ 是第 $i$ 个簇的样本数。
   • 对 Z_seperate[i].transpose()（形状 $(p,n_i)$）进行 SVD：
     $${\mathbf{Z}}_{\text{sep}[i]}^{\top }={\mathbf{U}}_i{\mathbf{\Sigma }}_i{\mathbf{V}}_i^{\top }$$
     其中，${\mathbf{U}}_i\in {\mathbb{R}}^{p\times p}$，${\mathbf{\Sigma }}_i$ 是奇异值矩阵，${\mathbf{V}}_i\in {\mathbb{R}}^{n_i\times n_i}$。
   • 取 ${\mathbf{U}}_i$ 的前 $d$ 列（对应最大奇异值），赋值到 U 的第 $i\cdot d$ 到 $(i+1)\cdot d$ 列。

5. 设置 $\mathbf{D}$：

   • D = U：将 U 赋值为 $\mathbf{D}$，形状为 $(kd,kd)$。
   • 打印 ${\mathbf{D}}^{\top }$ 的形状（$(kd,kd)$）和完成信息。

6. 输出：

   • 返回 $\mathbf{D}$。

潜在问题

1. $\mathbf{D}$ 形状错误：

   • 论文中，$\mathbf{D}\in {\mathbb{R}}^{p\times kd}$，每块 ${\mathbf{D}}^{(j)}\in {\mathbb{R}}^{p\times d}$。但代码中，D 的形状为 $(kd,kd)$，与论文不符。
   • 原因：SVD 的 ${\mathbf{U}}_i$（$(p,p)$）被错误使用，应使用 ${\mathbf{V}}_i$ 的前 $d$ 列（形状 $(n_i,d)$，但需调整以匹配 $p$）。
   • 改进建议：
     • 修改为使用 ${\mathbf{V}}_i$：

       u, ss, v = np.linalg.svd(Z_seperate[i])  # SVD on (n_i, p)
       U[i*d:(i+1)*d, :] = v[:, 0:d].transpose()  # v: (p, n_i)
       

     • 调整 U 的形状为 $(kd,p)$，使 ${\mathbf{D}}^{\top }\in {\mathbb{R}}^{kd\times p}$。

2. 空簇问题：

   • 如果 Z_seperate[i] 为空，SVD 会失败。
   • 改进建议：添加空簇检查：

     if len(Z_seperate[i]) == 0:U[:, i*d:(i+1)*d] = np.random.randn(p, d)  # 随机初始化U[:, i*d:(i+1)*d] /= np.linalg.norm(U[:, i*d:(i+1)*d], axis=0)  # 归一化
     

3. 正交性约束：

   • 论文要求 ${\mathbf{D}}^{(j)}$ 的列单位范数，且 ${\mathbf{D}}^{(j{)}^{\top }}{\mathbf{D}}^{(l)}$ 接近零。SVD 保证 ${\mathbf{U}}_i$ 列正交，但未处理跨簇正交性。
   • 改进建议：初始化后正交化 $\mathbf{D}$：

     D = np.linalg.qr(D)[0]  # 正交化
     

4. 效率问题：

   • SVD 的复杂度为 $O(\min (n_i{p}^2,n_i^{2}p))$，对大规模簇可能较慢。
   • 改进建议：使用随机 SVD（如 sklearn.utils.extmath.randomized_svd）。

---

3. 与 EDESC 算法的关系

根据论文（第 4 页，算法 1 和 3.2 节），seperate 和 Initialization_D 是子空间基 $\mathbf{D}$ 初始化的核心步骤：

1. 论文描述：

   • $\mathbf{D}$ 的初始化基于预训练自编码器的嵌入表示 $\mathbf{Z}$，通过 $k$-means 聚类生成簇，然后提取每个簇的列空间。
   • $\mathbf{D}=[{\mathbf{D}}^{(1)},\dots ,{\mathbf{D}}^{(k)}]$，${\mathbf{D}}^{(j)}\in {\mathbb{R}}^{p\times d}$，列满足单位范数。

2. 函数作用：

   • seperate：将 $\mathbf{Z}$ 分成 $k$ 个簇的子集，准备 SVD 输入。
   • Initialization_D：通过 SVD 提取每个簇的子空间基，构造初始 $\mathbf{D}$。

3. 算法 1 中的上下文：

   • 初始化 $\mathbf{D}$ 后，用于计算子空间亲和度 $S$：
     $$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d}{{\sum }_j\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d\right)}$$
   • $\mathbf{D}$ 在训练中通过优化目标函数 $L=L_{\text{Recon}}+D_{\text{Cons}}+\beta L_{\text{Sub}}$ 更新。

---

4. 改进后的代码

以下是修复形状问题和效率问题的改进版本：

from collections import defaultdict
import numpy as np
import torch
from sklearn.utils.extmath import randomized_svddef seperate(Z, y_pred, n_clusters):if isinstance(y_pred, torch.Tensor):y_pred = y_pred.cpu().numpy()Z_seperate = defaultdict(list)Z_numpy = Z.cpu().detach().numpy()for i in range(n_clusters):mask = (y_pred == i)Z_seperate[i] = Z_numpy[mask]return Z_seperatedef Initialization_D(Z, y_pred, n_clusters, d):p = Z.shape[1]  # 嵌入维数Z_seperate = seperate(Z, y_pred, n_clusters)D = np.zeros([p, n_clusters * d])  # D: (p, k*d)print("Initialize D")for i in range(n_clusters):if len(Z_seperate[i]) == 0:# 空簇处理D[:, i*d:(i+1)*d] = np.random.randn(p, d)D[:, i*d:(i+1)*d] /= np.linalg.norm(D[:, i*d:(i+1)*d], axis=0)else:# 使用随机 SVD 提高效率u, ss, v = randomized_svd(Z_seperate[i], n_components=d, random_state=0)D[:, i*d:(i+1)*d] = v.T  # v: (p, d)# 正交化 DD = np.linalg.qr(D)[0]print("Shape of D: ", D.shape)  # (p, k*d)print("Initialization of D Finished")return D

改进点：

• 使用布尔索引优化 seperate，降低复杂度。
• 修正 Initialization_D 中 $\mathbf{D}$ 的形状为 $(p,kd)$。
• 添加空簇处理和正交化步骤。
• 使用随机 SVD 提高效率。

---

5. 在 EDESC 算法中的意义

• 初始化的作用：seperate 和 Initialization_D 提供高质量的初始 $\mathbf{D}$，影响子空间亲和度 $S$ 和后续优化。
• 支持在线聚类：小批量训练中，$\mathbf{D}$ 可增量更新，适应流式数据。
• 与目标函数的连接：初始 $\mathbf{D}$ 通过 $D_{\text{Cons}}$ 正则化（确保单位范数和跨簇正交性）和 $L_{\text{Sub}}$（驱动聚类分配）优化。

---

相似度矩阵计算的分析

论文《Efficient Deep Embedded Subspace Clustering》中定义的子空间亲和度 $s_{ij}$，具体为：
$$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d}{{\sum }_{j^{\prime }}\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\prime })}{\Vert }_F^2+\eta d\right)}$$
其中：

• ${\mathbf{z}}_i\in {\mathbb{R}}^p$ 是第 $i$ 个样本的嵌入表示。
• ${\mathbf{D}}^{(j)}\in {\mathbb{R}}^{p\times d}$ 是第 $j$ 个子空间的基矩阵。
• $\Vert \cdot {\Vert }_F$ 表示 Frobenius 范数。
• $\eta$ 是一个平滑参数，$d$ 是子空间维数。
• 分母中的 ${\sum }_{j^{\prime }}$ 表示对所有 $k$ 个子空间的求和。

下面我将分析为什么可以用这种方式计算相似度矩阵（即子空间亲和度 $S$），并解释其背后的理论依据和合理性。

---

1. 核心思想与理论依据

子空间聚类的假设

EDESC 基于子空间聚类的假设：数据点分布在多个低维线性子空间中，每个子空间由基矩阵 ${\mathbf{D}}^{(j)}$ 表征。嵌入表示 ${\mathbf{z}}_i$ 应该与它所属的子空间基 ${\mathbf{D}}^{(j)}$ 有较高的相关性，而与其他子空间基的相关性较低。因此，相似度 $s_{ij}$ 应量化 ${\mathbf{z}}_i$ 与 ${\mathbf{D}}^{(j)}$ 之间的匹配程度。

相似度的定义

• ${\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}$ 是 ${\mathbf{z}}_i$ 在 ${\mathbf{D}}^{(j)}$ 列空间中的投影。
• $\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2$ 表示 ${\mathbf{z}}_i$ 在第 $j$ 个子空间中的投影长度平方，度量 ${\mathbf{z}}_i$ 与 ${\mathbf{D}}^{(j)}$ 的相关性。
• 由于 ${\mathbf{D}}^{(j)}$ 的列被正则化为单位范数（$\Vert {\mathbf{D}}_u^{(j)}\Vert =1$，见论文约束条件），$\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2$ 反映了 ${\mathbf{z}}_i$ 在该子空间中的“能量”或匹配度。

归一化形式

• 分母 ${\sum }_{j^{\prime }}\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\prime })}{\Vert }_F^2+\eta d\right)$ 对所有子空间的投影能量求和，起到归一化作用，使 $s_{ij}$ 成为一个概率分布（${\sum }_j{s}_{ij}\approx 1$）。
• $\eta d$ 是一个平滑项，避免分母为零（当所有 $\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\prime })}{\Vert }_F^2$ 很小时），并防止数值不稳定。

因此，$s_{ij}$ 可以理解为 ${\mathbf{z}}_i$ 属于第 $j$ 个子空间的“归一化相似度”或“分配概率”。

---

2. 为什么这样计算的合理性

(1) 基于投影的相似性度量

• 在子空间聚类中，数据点与子空间的相似性通常通过投影或相关性衡量。$\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2$ 是 ${\mathbf{z}}_i$ 在 ${\mathbf{D}}^{(j)}$ 列空间中的平方投影长度，反映了 ${\mathbf{z}}_i$ 与该子空间的几何匹配程度。
• 与欧几里得距离（如 $k$-means 中的 $\Vert {\mathbf{z}}_i-{\mathbf{\mu }}_j{\Vert }^2$）不同，这种基于投影的度量更适合捕捉子空间结构，尤其是在数据具有非线性或高维特性时。

(2) 概率归一化

• 分母的求和归一化使 $s_{ij}$ 成为一个软分配概率，类似于 softmax 函数的形式：
  $$s_{ij}\propto \Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d$$
  这与 softmax 的指数形式 $\exp (x_{ij})/{\sum }_{j^{\prime }}\exp (x_{i{j}^{\prime }})$ 类似，但使用平方范数，强调正向相关性。
• 这种归一化确保 $s_{ij}$ 表示 ${\mathbf{z}}_i$ 在所有子空间中的相对亲和度，便于后续聚类分配（${\mathcal{C}}_i=\arg {\max }_j{s}_{ij}$）。

(3) 平滑项 $\eta d$

• $\eta d$ 是一个小的正值（$\eta$ 通常与 $d$ 相关，论文中设 $\eta =d$），在分母中加入平滑项，防止数值溢出或零分母问题。
• 它还为每个子空间提供一个最小置信度，避免对某些子空间的过度偏见，尤其是在初始阶段 ${\mathbf{D}}^{(j)}$ 尚未优化时。

(4) 与自监督的兼容性

• $s_{ij}$ 被进一步精炼为 ${\tilde{s}}_{ij}$（论文公式 (14)），用于自监督信号：
  $${\tilde{s}}_{ij}=\frac{s_{ij}^2/{\sum }_i{s}_{ij}}{{\sum }_{j^{\prime }}\left(s_{i^{\prime }j}^2/{\sum }_{i^{\prime }}{s}_{i^{\prime }j}\right)}$$
  原始 $s_{ij}$ 的计算方式提供了初始的软分配，${\tilde{s}}_{ij}$ 增强高置信度分配，两者结合驱动聚类损失 $L_{\text{Sub}}=KL(\tilde{S}\Vert S)$ 的优化。

---

3. 数学推导与直观解释

推导过程

假设 ${\mathbf{z}}_i$ 属于第 $j^{\ast }$ 个子空间，则 ${\mathbf{z}}_i$ 与 ${\mathbf{D}}^{(j^{\ast })}$ 的投影应最大化：

• ${\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\ast })}$ 是 ${\mathbf{z}}_i$ 在 ${\mathbf{D}}^{(j^{\ast })}$ 上的线性组合。
• $\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\ast })}{\Vert }_F^2$ 是该投影的能量。
• 对于其他 $j\ne j^{\ast }$，$\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2$ 应较小（由于子空间基正交性约束 $\Vert {\mathbf{D}}^{(j{)}^{\top }}{\mathbf{D}}^{(l)}{\Vert }_F\le \tau$）。

定义相似度为投影能量的归一化形式：
$$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2}{{\sum }_{j^{\prime }}\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\prime })}{\Vert }_F^2}$$
但为了数值稳定性，加入 $\eta d$：
$$s_{ij}=\frac{\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d}{{\sum }_{j^{\prime }}\left(\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j^{\prime })}{\Vert }_F^2+\eta d\right)}$$
这确保了 $s_{ij}$ 在 $[0,1]$ 范围内，且总和接近 1。

直观解释

• 想象 ${\mathbf{z}}_i$ 是一个向量，${\mathbf{D}}^{(j)}$ 是子空间的“方向”。$\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2$ 衡量 ${\mathbf{z}}_i$ 在该方向上的投影大小。
• 分母归一化后，$s_{ij}$ 类似于投票机制：${\mathbf{z}}_i$ 将其“亲和度”分配给最匹配的子空间。
• $\eta d$ 像是一个“背景噪声”阈值，确保每个子空间至少有一定影响力。

---

4. 与传统方法的对比

传统子空间聚类（如 SSC）

• Sparse Subspace Clustering (SSC) 使用自表达模型 $\mathbf{Z}=\mathbf{ZC}$，计算稀疏系数矩阵 $\mathbf{C}$，复杂度为 $O(n^2)$。
• 相似度来自 $\mathbf{C}$ 的非零项，依赖谱聚类。

EDESC 的优势

• EDESC 直接通过 ${\mathbf{D}}^{(j)}$ 计算投影相似度，复杂度为 $O(kdp)$（线性），适合大规模数据。
• $s_{ij}$ 嵌入到端到端优化中，与深度特征学习结合，优于两阶段方法。

---

5. 局限性与改进空间

• 假设依赖性：$s_{ij}$ 假设 ${\mathbf{z}}_i$ 与 ${\mathbf{D}}^{(j)}$ 的投影能反映真实子空间归属，若 ${\mathbf{D}}^{(j)}$ 初始化不佳，$s_{ij}$ 可能失真。
• 平滑项影响：$\eta d$ 过大可能削弱真实相似度的区分能力。
• 改进建议：
  • 动态调整 $\eta$，根据训练阶段自适应。
  • 加入正交正则化，进一步增强子空间分离。

---

6. 总结

相似度矩阵 $S$ 之所以通过 $\Vert {\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}{\Vert }_F^2+\eta d$ 计算，是因为它基于子空间投影的几何特性，通过归一化形成概率分布，适合子空间聚类的需求。平滑项 $\eta d$ 确保数值稳定，自监督精炼 $\tilde{S}$ 进一步提升了聚类性能。这种计算方式将深度表示学习与子空间结构有效结合，是 EDESC 高效性和准确性的关键所在。

---

奇异值分解（Singular Value Decomposition, SVD）是一种强大的线性代数工具，在《Efficient Deep Embedded Subspace Clustering》（EDESC, CVPR 2022）论文中被用于初始化子空间基矩阵 $\mathbf{D}$。为了理解 SVD 的物理含义，我将结合 EDESC 算法的上下文，解释 SVD 的数学意义、几何意义以及在子空间聚类中的具体物理含义，并通过一个简单例子进行说明。

---

1. SVD 的数学定义与分解

给定一个矩阵 $\mathbf{A}\in {\mathbb{R}}^{m\times n}$（可以是实数矩阵，不必是方阵），SVD 将其分解为：
$$\mathbf{A}=\mathbf{U\Sigma }{\mathbf{V}}^{\top }$$
其中：

• $\mathbf{U}\in {\mathbb{R}}^{m\times m}$ 是一个正交矩阵，列向量是 $\mathbf{A}{\mathbf{A}}^{\top }$ 的特征向量（称为左奇异向量）。
• $\mathbf{\Sigma }\in {\mathbb{R}}^{m\times n}$ 是一个对角矩阵，对角元素 ${\sigma }_1\ge {\sigma }_2\ge \cdots \ge {\sigma }_r\ge 0$（$r=\min (m,n)$）是奇异值。
• $\mathbf{V}\in {\mathbb{R}}^{n\times n}$ 是一个正交矩阵，列向量是 ${\mathbf{A}}^{\top }\mathbf{A}$ 的特征向量（称为右奇异向量）。

---

2. SVD 的物理含义

SVD 的物理含义可以通过几何变换和数据结构的分解来理解。以下从几个角度分析：

(1) 几何意义：矩阵变换的分解

SVD 将矩阵 $\mathbf{A}$ 的线性变换分解为三个基本步骤：

1. 旋转/反射（${\mathbf{V}}^{\top }$）：${\mathbf{V}}^{\top }$ 是一个正交矩阵，将输入空间的坐标系旋转或反射到新的坐标系（右奇异向量定义的方向）。
2. 缩放（$\mathbf{\Sigma }$）：$\mathbf{\Sigma }$ 沿着新坐标系的轴进行缩放，缩放因子是奇异值 ${\sigma }_i$。奇异值的大小反映了变换在每个方向上的“重要性”或“能量”。
3. 旋转/反射（$\mathbf{U}$）：$\mathbf{U}$ 再次旋转或反射，将缩放后的结果映射到输出空间（左奇异向量定义的方向）。

物理含义：

• 奇异值 ${\sigma }_i$ 表示矩阵 $\mathbf{A}$ 在第 $i$ 个方向上的“拉伸强度”或“影响力”。
• $\mathbf{U}$ 和 $\mathbf{V}$ 定义了输入和输出空间的主方向，反映数据的内在结构。

(2) 数据降维与主成分

SVD 常用于数据降维（如 PCA）。假设 $\mathbf{A}$ 是一个数据矩阵（行是特征，列是样本）：

• 奇异值 ${\sigma }_i$ 表示第 $i$ 个主方向上的数据方差。
• 左奇异向量 $\mathbf{U}$ 的列是数据的“主模式”（principal modes），右奇异向量 $\mathbf{V}$ 的列是样本的“主方向”。

物理含义：

• 奇异值大的方向对应数据的“主要变化模式”，捕捉数据中最显著的结构。
• 奇异值小的方向对应噪声或次要变化，可以被忽略以实现降维。

(3) 能量分解与低秩近似

SVD 提供了一种矩阵的低秩近似：
$$\mathbf{A}\approx \sum _{i=1}^k{\sigma }_i{\mathbf{u}}_i{\mathbf{v}}_i^{\top },k<r$$

• 每个 ${\sigma }_i{\mathbf{u}}_i{\mathbf{v}}_i^{\top }$ 是一个秩-1 矩阵，${\sigma }_i$ 是该分量的“能量”。
• 奇异值的平方和等于 $\mathbf{A}$ 的 Frobenius 范数的平方：$\Vert \mathbf{A}{\Vert }_F^2={\sum }_i{\sigma }_i^2$。

物理含义：

• 奇异值反映了矩阵的“能量分布”，大的奇异值对应主要模式，小的奇异值对应噪声。
• 这种分解在物理系统中常用来分离信号和噪声。

---

3. SVD 在 EDESC 中的物理含义

在 EDESC 论文中，SVD 用于初始化子空间基矩阵 $\mathbf{D}$，具体在 Initialization_D 函数中，对每个簇的嵌入表示矩阵 ${\mathbf{Z}}_{\text{sep}[i]}\in {\mathbb{R}}^{n_i\times p}$（$n_i$ 是第 $i$ 个簇的样本数，$p$ 是嵌入维数）进行 SVD：

u, ss, v = np.linalg.svd(Z_seperate[i].transpose())

这里 ${\mathbf{Z}}_{\text{sep}[i]}^{\top }\in {\mathbb{R}}^{p\times n_i}$，SVD 分解为：
$${\mathbf{Z}}_{\text{sep}[i]}^{\top }={\mathbf{U}}_i{\mathbf{\Sigma }}_i{\mathbf{V}}_i^{\top }$$

• ${\mathbf{U}}_i\in {\mathbb{R}}^{p\times p}$：左奇异向量，表示嵌入空间的主方向。
• ${\mathbf{\Sigma }}_i\in {\mathbb{R}}^{p\times n_i}$：奇异值矩阵。
• ${\mathbf{V}}_i\in {\mathbb{R}}^{n_i\times n_i}$：右奇异向量，表示样本的主方向。

代码中取 ${\mathbf{U}}_i$ 的前 $d$ 列作为子空间基 ${\mathbf{D}}^{(i)}$：

U[:, i*d:(i+1)*d] = u[:, 0:d]

（注：代码实现有误，应使用 ${\mathbf{V}}_i$ 的前 $d$ 列，详见前文改进建议。）

物理含义：

1. 子空间基的提取：

   • ${\mathbf{Z}}_{\text{sep}[i]}$ 是第 $i$ 个簇的嵌入表示矩阵，SVD 分解提取其列空间的主方向。
   • ${\mathbf{U}}_i$ 的前 $d$ 列（对应最大奇异值）是 ${\mathbf{Z}}_{\text{sep}[i]}$ 列空间中最主要的 $d$ 个方向，物理上表示该簇数据分布的最重要子空间。
   • 奇异值 ${\sigma }_i$ 反映了每个方向上的“数据能量”，大的奇异值对应更重要的子空间方向。

2. 降维与去噪：

   • 选择前 $d$ 个奇异值对应的方向，相当于对 ${\mathbf{Z}}_{\text{sep}[i]}$ 进行降维，保留主要结构，去除噪声（小奇异值对应的方向）。
   • 物理上，这是在提取簇内数据的“本质特征”，忽略次要变化或噪声。

3. 正交性与稳定性：

   • ${\mathbf{U}}_i$ 的列是正交的，保证子空间基 ${\mathbf{D}}^{(i)}$ 的列正交，符合论文对 $\mathbf{D}$ 的正则化约束（${\mathbf{D}}^{\top }\mathbf{D}\odot \mathbf{I}=\mathbf{I}$）。
   • 这种正交性在物理上意味着子空间基是“独立”的方向，避免冗余。

---

4. 具体例子

假设我们有一个小型簇的数据矩阵 ${\mathbf{Z}}_{\text{sep}[i]}\in {\mathbb{R}}^{n_i\times p}$，$n_i=3$（3 个样本），$p=2$（嵌入维数为 2）：
$${\mathbf{Z}}_{\text{sep}[i]}=\left[\begin{array}{cc}1& 0\\ 1& 0\\ 0& 1\end{array}\right]$$

• 每行是一个样本的嵌入表示，形状为 $(3,2)$。

步骤 1：计算 ${\mathbf{Z}}_{\text{sep}[i]}^{\top }$

$${\mathbf{Z}}_{\text{sep}[i]}^{\top }=\left[\begin{array}{ccc}1& 1& 0\\ 0& 0& 1\end{array}\right]$$
形状为 $(p,n_i)=(2,3)$。

步骤 2：进行 SVD

对 ${\mathbf{Z}}_{\text{sep}[i]}^{\top }$ 进行 SVD：
$${\mathbf{Z}}_{\text{sep}[i]}^{\top }={\mathbf{U}}_i{\mathbf{\Sigma }}_i{\mathbf{V}}_i^{\top }$$
计算结果（可以通过 NumPy 验证）：

• 奇异值：${\sigma }_1=\sqrt{2}\approx 1.414$，${\sigma }_2=1$。
• 左奇异向量 ${\mathbf{U}}_i$（$(p,p)=(2,2)$）：
  $${\mathbf{U}}_i=\left[\begin{array}{cc}\sqrt{2}/2& 0\\ 0& 1\end{array}\right]$$
• 右奇异向量 ${\mathbf{V}}_i$（$(n_i,n_i)=(3,3)$）：
  $${\mathbf{V}}_i=\left[\begin{array}{ccc}\sqrt{2}/2& 0& -\sqrt{2}/2\\ \sqrt{2}/2& 0& \sqrt{2}/2\\ 0& 1& 0\end{array}\right]$$
• ${\mathbf{\Sigma }}_i$（$(2,3)$）：
  $${\mathbf{\Sigma }}_i=\left[\begin{array}{ccc}\sqrt{2}& 0& 0\\ 0& 1& 0\end{array}\right]$$

步骤 3：提取子空间基

假设子空间维数 $d=1$，取 ${\mathbf{U}}_i$ 的前 $d$ 列（论文中应为 ${\mathbf{V}}_i$，这里按代码逻辑）：
$${\mathbf{D}}^{(i)}={\mathbf{U}}_i[:,0:1]=\left[\begin{array}{c}\sqrt{2}/2\\ 0\end{array}\right]$$
（注：正确实现应取 ${\mathbf{V}}_i$ 的前 $d$ 列转置后，调整为 $(p,d)$ 形状。）

物理含义：

• 奇异值 ${\sigma }_1=\sqrt{2}$：表示数据在第一主方向上的“能量”或“方差”，${\sigma }_2=1$ 表示第二方向的能量。
• ${\mathbf{U}}_i$ 的第一列 $[\sqrt{2}/2,0{]}^{\top }$：表示数据的主要子空间方向。观察 ${\mathbf{Z}}_{\text{sep}[i]}$，样本 $[1,0]$ 和 $[1,0]$ 集中在 $x$ 轴方向，$[0,1]$ 引入了 $y$ 轴方向，第一主方向 $[\sqrt{2}/2,0]$ 反映了 $x$ 轴的主导性。
• 降维：选择 $d=1$ 即保留最大奇异值方向，忽略次要方向（${\sigma }_2=1$），相当于去噪，提取簇的本质子空间。

---

5. SVD 在 EDESC 中的整体作用

• 初始化 $\mathbf{D}$：SVD 提取每个簇的主要子空间方向，初始化 ${\mathbf{D}}^{(i)}$，为后续优化提供合理的起点。
• 投影与亲和度：${\mathbf{D}}^{(i)}$ 用于计算子空间亲和度 $s_{ij}$，通过 ${\mathbf{z}}_i^{\top }{\mathbf{D}}^{(j)}$ 的投影长度衡量相关性。
• 物理意义：SVD 捕捉了簇内数据的“主要模式”，奇异值反映了这些模式的“强度”，在子空间聚类中相当于分离信号（主子空间）与噪声（次要方向）。

---

6. 总结

SVD 的物理含义在于它将矩阵分解为正交变换和缩放，揭示数据的内在结构和能量分布。在 EDESC 中，SVD 用于提取子空间基，奇异值表示子空间的“重要性”，奇异向量定义子空间的“方向”。通过例子，我们看到 SVD 如何从数据中提取主要方向，反映簇内数据的分布特性，为子空间聚类提供了几何和物理意义上的依据。