PCA与自编码器的联系

1. 概述

主成分分析（PCA）和自编码器（Autoencoder）都是降维技术，但它们来自不同的传统：PCA源于统计学，而自编码器来自神经网络领域。¹

核心发现：

线性自编码器（激活函数为线性）与PCA在数学上等价
深度自编码器可以学习非线性流形，超越PCA的线性限制

本文深入探讨这种联系，从理论证明到实践应用。

2. 线性自编码器与PCA的等价性

2.1 线性自编码器

单层隐藏层的线性自编码器定义为：

\overset{x}{^} = W_{2} (W_{1} x + b_{1}) + b_{2}

假设输入已中心化且使用相同的权重矩阵 $W_{2} = W_{1}^{T}$ ，则：

\overset{x}{^} = W^{T} W x

这正是PCA投影的形式！

2.2 数学证明

设输入数据矩阵 $X \in R^{n \times D}$ ，编码器权重 $W \in R^{D \times K}$ （ $K < D$ ）。

重构误差：

L = ∥ X - X W W^{T} ∥_{F}^{2}

定理（Plaut, 2018）：²

对于中心化的数据，训练单层线性自编码器（编码维度为 $K$ ），其最优权重 $W$ 的列空间与数据协方差矩阵 $X^{T} X$ 的前 $K$ 个主成分方向张成的空间相同。

证明思路：

编码： $H = X W$ ，其中 $H \in R^{n \times K}$ 是编码表示
重构： $\hat{X} = H W^{T} = X W W^{T}$
优化目标最小化重构误差等价于最大化 $tr (H^{T} H) = tr (W^{T} X^{T} X W)$
由Rayleigh商理论， $W$ 的列应取 $X^{T} X$ 的前 $K$ 个特征向量

import numpy as np
import torch
import torch.nn as nn
 
def linear_autoencoder_pca_equivalence():
    """
    验证线性自编码器与PCA的等价性
    """
    np.random.seed(42)
    torch.manual_seed(42)
    
    # 生成低维数据
    n, D, K = 500, 10, 3
    
    # 生成具有内在维度K的数据
    Z = np.random.randn(n, K)
    A = np.random.randn(K, D)
    X = Z @ A + np.random.randn(n, D) * 0.1
    
    # ============ 经典PCA ============
    X_centered = X - X.mean(axis=0)
    
    # SVD分解
    U, s, Vt = np.linalg.svd(X_centered, full_matrices=False)
    pca_components = Vt[:K]  # PCA主成分方向
    
    # ============ 线性自编码器 ============
    class LinearAutoencoder(nn.Module):
        def __init__(self, input_dim, hidden_dim):
            super().__init__()
            self.encoder = nn.Linear(input_dim, hidden_dim, bias=False)
            self.decoder = nn.Linear(hidden_dim, input_dim, bias=False)
            # 权重共享
            self.encoder.weight.data = torch.zeros(hidden_dim, input_dim)
            self.decoder.weight.data = torch.zeros(input_dim, hidden_dim)
        
        def forward(self, x):
            h = self.encoder(x)
            return self.decoder(h)
        
        def set_weights(self, W):
            self.encoder.weight.data = torch.tensor(W.T, dtype=torch.float32)
            self.decoder.weight.data = torch.tensor(W, dtype=torch.float32)
    
    model = LinearAutoencoder(D, K)
    
    # 优化
    optimizer = torch.optim.LBFGS(model.parameters(), max_iter=1000)
    X_tensor = torch.tensor(X_centered, dtype=torch.float32)
    
    def closure():
        optimizer.zero_grad()
        X_recon = model(X_tensor)
        loss = torch.mean((X_recon - X_tensor) ** 2)
        loss.backward()
        return loss
    
    optimizer.step(closure)
    
    # 自编码器学到的权重
    ae_weights = model.encoder.weight.data.numpy()
    
    # ============ 比较 ============
    print("PCA主成分方向 (V[:K]):")
    print(pca_components[:3])
    
    print("\n线性自编码器权重 (W):")
    print(ae_weights[:3])
    
    # 检查是否张成相同的子空间
    # 方法：检查Gram矩阵是否相同
    from scipy.linalg import subspace_angles
    angles = subspace_angles(pca_components.T, ae_weights.T)
    print(f"\n子空间夹角: {np.degrees(angles)}")
    print(f"（接近0度表示子空间相同）")
    
    # 检查重构误差
    X_pca_recon = X_centered @ pca_components.T @ pca_components
    X_ae_recon = X_centered @ ae_weights.T @ ae_weights
    X_recon = model(X_tensor).detach().numpy()
    
    print(f"\nPCA重构误差: {np.mean((X_centered - X_pca_recon)**2):.6f}")
    print(f"自编码器重构误差: {np.mean((X_centered - X_ae_recon)**2):.6f}")
 
linear_autoencoder_pca_equivalence()

2.3 激活函数的影响

激活函数	效果
恒等函数	完全等价于PCA
ReLU	等价于非负PCA（半RP）
Sigmoid	等价于概率PCA的EM估计
Dropout	正则化版本，略微偏离PCA

def activation_vs_pca():
    """
    测试不同激活函数对自编码器的影响
    """
    np.random.seed(42)
    n, D, K = 500, 10, 3
    
    # 生成数据
    Z = np.random.randn(n, K)
    A = np.random.randn(K, D)
    X = Z @ A + np.random.randn(n, D) * 0.1
    X_centered = X - X.mean(axis=0)
    
    results = {}
    
    # 1. 线性自编码器
    class LinearAE(nn.Module):
        def __init__(self, D, K):
            super().__init__()
            self.encoder = nn.Linear(D, K, bias=False)
            self.decoder = nn.Linear(K, D, bias=False)
        def forward(self, x):
            return self.decoder(self.encoder(x))
    
    # 2. ReLU自编码器
    class ReLUAE(nn.Module):
        def __init__(self, D, K):
            super().__init__()
            self.encoder = nn.Sequential(
                nn.Linear(D, K, bias=False),
                nn.ReLU()
            )
            self.decoder = nn.Linear(K, D, bias=False)
        def forward(self, x):
            return self.decoder(self.encoder(x))
    
    # 3. 带偏置的线性自编码器
    class LinearAEWithBias(nn.Module):
        def __init__(self, D, K):
            super().__init__()
            self.encoder = nn.Linear(D, K)
            self.decoder = nn.Linear(K, D)
        def forward(self, x):
            h = self.encoder(x)
            return self.decoder(h)
    
    for name, model_class in [
        ('线性(无偏置)', LinearAE),
        ('线性(有偏置)', LinearAEWithBias),
        ('ReLU', ReLUAE)
    ]:
        model = model_class(D, K)
        optimizer = torch.optim.LBFGS(model.parameters(), max_iter=500)
        
        X_tensor = torch.tensor(X_centered, dtype=torch.float32)
        
        def closure():
            optimizer.zero_grad()
            loss = torch.mean((model(X_tensor) - X_tensor) ** 2)
            loss.backward()
            return loss
        
        optimizer.step(closure)
        
        with torch.no_grad():
            X_recon = model(X_tensor).numpy()
            recon_error = np.mean((X_centered - X_recon) ** 2)
            results[name] = recon_error
    
    # PCA基线
    U, s, Vt = np.linalg.svd(X_centered, full_matrices=False)
    X_pca_recon = X_centered @ Vt[:K].T @ Vt[:K]
    pca_error = np.mean((X_centered - X_pca_recon) ** 2)
    results['PCA'] = pca_error
    
    print("重构误差比较:")
    for name, error in results.items():
        print(f"  {name}: {error:.6f}")
 
activation_vs_pca()

3. 深度自编码器：从线性到非线性

3.1 Hinton的开创性工作

2006年，Hinton和Salakhutdinov在Science上发表论文，证明深度自编码器可以比PCA更好地降维。³

关键发现：

深度自编码器能学习数据的非线性流形结构
在MNIST数据集上，深度自编码器的重构误差显著低于PCA

import torch
import torch.nn as nn
 
class DeepAutoencoder(nn.Module):
    """
    深度自编码器
    
    可以学习非线性流形结构
    """
    def __init__(self, input_dim, hidden_dims):
        """
        Args:
            input_dim: 输入维度
            hidden_dims: 编码器每层的维度，如 [512, 256, 128, 64]
        """
        super().__init__()
        
        # 编码器
        encoder_layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            encoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.ReLU()
            ])
            prev_dim = h_dim
        self.encoder = nn.Sequential(*encoder_layers)
        
        # 解码器（镜像结构）
        decoder_layers = []
        for h_dim in reversed(hidden_dims[:-1]):
            decoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.ReLU()
            ])
            prev_dim = h_dim
        decoder_layers.append(nn.Linear(prev_dim, input_dim))
        self.decoder = nn.Sequential(*decoder_layers)
        
        self.bottleneck_dim = hidden_dims[-1]
    
    def encode(self, x):
        return self.encoder(x)
    
    def decode(self, z):
        return self.decoder(z)
    
    def forward(self, x):
        z = self.encode(x)
        return self.decode(z)
 
def compare_pca_vs_deep_autoencoder():
    """
    比较PCA与深度自编码器在非线性数据上的表现
    """
    np.random.seed(42)
    torch.manual_seed(42)
    
    # 生成瑞士卷数据（强非线性）
    from sklearn.datasets import make_swiss_roll
    X, color = make_swiss_roll(n_samples=1000, noise=0.2, random_state=42)
    X = X[:, [1, 2]]  # 使用2D投影
    
    X_tensor = torch.tensor(X, dtype=torch.float32)
    
    # PCA降维
    pca = PCA(n_components=1)
    X_pca = pca.fit_transform(X)
    X_pca_recon = pca.inverse_transform(X_pca)
    pca_error = np.mean((X - X_pca_recon) ** 2)
    
    # 深度自编码器
    model = DeepAutoencoder(input_dim=2, hidden_dims=[64, 32, 16, 8])
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = nn.MSELoss()
    
    dataset = torch.utils.data.TensorDataset(X_tensor, X_tensor)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True)
    
    for epoch in range(200):
        total_loss = 0
        for batch_x, _ in dataloader:
            recon = model(batch_x)
            loss = criterion(recon, batch_x)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        if (epoch + 1) % 50 == 0:
            print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.6f}")
    
    with torch.no_grad():
        X_ae_recon = model(X_tensor).numpy()
        ae_error = np.mean((X - X_ae_recon) ** 2)
    
    print(f"\n重构误差:")
    print(f"  PCA: {pca_error:.6f}")
    print(f"  深度自编码器: {ae_error:.6f}")
    print(f"  （非线性数据上，自编码器通常表现更好）")
 
compare_pca_vs_deep_autoencoder()

3.2 非线性流形学习

深度自编码器能够捕捉数据的流形结构，这是PCA无法做到的。

流形假设：现实世界的高维数据通常分布在低维流形上。

特性	PCA	深度自编码器
投影方式	线性	非线性
流形结构	不能保持	可以保持
全局结构	保持	可能扭曲
局部结构	可能丢失	可通过正则化保持

def manifold_learning_comparison():
    """
    比较PCA与自编码器在学习流形结构上的差异
    """
    import matplotlib.pyplot as plt
    from sklearn.datasets import make_circles
    
    np.random.seed(42)
    torch.manual_seed(42)
    
    # 生成同心圆数据（强非线性）
    X, y = make_circles(n_samples=500, noise=0.05, factor=0.5, random_state=42)
    
    # PCA
    pca = PCA(n_components=1)
    X_pca = pca.fit_transform(X)
    
    # 自编码器
    model = DeepAutoencoder(2, [32, 16, 8])
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    X_tensor = torch.tensor(X, dtype=torch.float32)
    for epoch in range(300):
        recon = model(X_tensor)
        loss = torch.mean((recon - X_tensor) ** 2)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    with torch.no_grad():
        X_ae = model.encode(X_tensor).numpy()
        X_ae_recon = model(X_tensor).numpy()
    
    fig, axes = plt.subplots(2, 3, figsize=(15, 8))
    
    # 原始数据
    axes[0, 0].scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', s=10)
    axes[0, 0].set_title('原始数据')
    
    # PCA 1D嵌入
    axes[0, 1].scatter(X_pca[:, 0], np.zeros(len(X_pca)), c=y, cmap='coolwarm', s=10)
    axes[0, 1].set_title('PCA 1D投影')
    
    # 自编码器 3D嵌入
    axes[0, 2].scatter(X_ae[:, 0], X_ae[:, 1], c=y, cmap='coolwarm', s=10)
    axes[0, 2].set_title('自编码器 8D嵌入')
    
    # PCA重构
    X_pca_recon = pca.inverse_transform(X_pca)
    axes[1, 0].scatter(X_pca_recon[:, 0], X_pca_recon[:, 1], c=y, cmap='coolwarm', s=10)
    axes[1, 0].set_title(f'PCA重构 (误差: {np.mean((X-X_pca_recon)**2):.4f})')
    
    # 自编码器重构
    axes[1, 1].scatter(X_ae_recon[:, 0], X_ae_recon[:, 1], c=y, cmap='coolwarm', s=10)
    axes[1, 1].set_title(f'自编码器重构 (误差: {np.mean((X-X_ae_recon)**2):.4f})')
    
    # 嵌入空间的结构
    # PCA：颜色混乱，同类点分散
    # 自编码器：颜色聚集，同类点集中

4. 变分自编码器（VAE）与概率PCA

变分自编码器（VAE）可以看作概率PCA的深度非线性扩展。

4.1 概率PCA回顾

概率PCA的生成模型：

p (x) = \int p (x ∣ z) p (z) d z = N (x ∣ μ, W W^{T} + σ^{2} I)

4.2 VAE的扩展

VAE将线性映射 $W$ 替换为神经网络 $μ_{θ} (x)$ 和 $σ_{θ} (x)$ ：

p (z ∣ x) = N (z ∣ μ_{θ} (x), diag (σ_{θ}^{2} (x)))

class VAE(nn.Module):
    """
    变分自编码器
    
    是概率PCA的非线性扩展
    """
    def __init__(self, input_dim, latent_dim, hidden_dims=[256, 128]):
        super().__init__()
        self.latent_dim = latent_dim
        
        # 编码器：q(z|x)
        encoder_layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            encoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.ReLU()
            ])
            prev_dim = h_dim
        encoder_layers.append(nn.Linear(prev_dim, latent_dim * 2))  # mu和log_var
        self.encoder = nn.Sequential(*encoder_layers)
        
        # 解码器：p(x|z)
        decoder_layers = []
        prev_dim = latent_dim
        for h_dim in reversed(hidden_dims):
            decoder_layers.extend([
                nn.Linear(prev_dim, h_dim),
                nn.ReLU()
            ])
            prev_dim = h_dim
        decoder_layers.append(nn.Linear(prev_dim, input_dim))
        self.decoder = nn.Sequential(*decoder_layers)
    
    def encode(self, x):
        h = self.encoder(x)
        mu, log_var = h.chunk(2, dim=-1)
        return mu, log_var
    
    def reparameterize(self, mu, log_var):
        std = torch.exp(0.5 * log_var)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def decode(self, z):
        return self.decoder(z)
    
    def forward(self, x):
        mu, log_var = self.encode(x)
        z = self.reparameterize(mu, log_var)
        recon = self.decode(z)
        return recon, mu, log_var
    
    def loss(self, x, recon_x, mu, log_var):
        # 重构损失
        recon_loss = nn.functional.mse_loss(recon_x, x, reduction='sum')
        
        # KL散度
        kl_loss = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
        
        return recon_loss + kl_loss
 
# 比较：概率PCA vs VAE
def compare_probabilistic_pca_vs_vae():
    """
    概率PCA与VAE的比较
    """
    np.random.seed(42)
    torch.manual_seed(42)
    
    # 生成混合高斯数据
    n = 500
    Z = np.vstack([
        np.random.randn(n//3, 2) + [-2, -2],
        np.random.randn(n//3, 2) + [2, -2],
        np.random.randn(n//3, 2) + [0, 2]
    ])
    
    X = Z + np.random.randn(*Z.shape) * 0.3
    
    # 概率PCA
    from sklearn.decomposition import PCA
    pca = PCA(n_components=2)
    X_pca = pca.fit_transform(X)
    
    # VAE
    vae = VAE(input_dim=2, latent_dim=2, hidden_dims=[64, 32])
    optimizer = torch.optim.Adam(vae.parameters(), lr=0.001)
    
    X_tensor = torch.tensor(X, dtype=torch.float32)
    for epoch in range(500):
        recon, mu, log_var = vae(X_tensor)
        loss = vae.loss(X_tensor, recon, mu, log_var)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    with torch.no_grad():
        mu, _ = vae.encode(X_tensor)
        X_vae = mu.numpy()
    
    print("概率PCA隐空间结构：")
    print(f"  隐变量均值范围: [{X_pca[:, 0].min():.2f}, {X_pca[:, 0].max():.2f}]")
    
    print("\nVAE隐空间结构：")
    print(f"  隐变量均值范围: [{X_vae[:, 0].min():.2f}, {X_vae[:, 0].max():.2f}]")
    print(f"  隐变量标准差: {torch.exp(0.5 * vae.encode(X_tensor)[1]).mean().item():.3f}")

5. 去噪自编码器与PCA正则化

去噪自编码器（DAE）通过在输入中添加噪声来学习更鲁棒的表示。

5.1 关系推导

设添加的噪声为 $ϵ \sim N (0, σ^{2} I)$ ，去噪目标为：

L = E_{x, ϵ} [∥ x - f (x + ϵ) ∥^{2}]

这等价于最小化 $x$ 与 $f (x)$ 在噪声扰动下的差异。

当 $f$ 是线性投影时，这与PCA有如下联系：

当噪声是各向同性高斯噪声时，去噪自编码器学习到的子空间与PCA相同
但表示的鲁棒性更好

class DenoisingAutoencoder(nn.Module):
    """
    去噪自编码器
    
    学习对噪声鲁棒的表示
    """
    def __init__(self, input_dim, hidden_dim, noise_level=0.1):
        super().__init__()
        self.noise_level = noise_level
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim)
        )
        self.decoder = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim)
        )
    
    def forward(self, x, add_noise=True):
        if add_noise and self.training:
            noise = torch.randn_like(x) * self.noise_level
            x_noisy = x + noise
        else:
            x_noisy = x
        
        h = self.encoder(x_noisy)
        return self.decoder(h), h
 
def compare_dae_vs_pca():
    """
    比较去噪自编码器与PCA的抗噪声能力
    """
    np.random.seed(42)
    torch.manual_seed(42)
    
    n, D, K = 500, 20, 5
    
    # 生成数据
    Z = np.random.randn(n, K)
    A = np.random.randn(K, D)
    X = Z @ A + np.random.randn(n, D) * 0.1
    X_centered = X - X.mean(axis=0)
    
    # 添加测试噪声
    noise_levels = [0.0, 0.1, 0.2, 0.5]
    
    results = {'PCA': [], 'DAE': []}
    
    for noise_level in noise_levels:
        X_noisy = X_centered + np.random.randn(*X_centered.shape) * noise_level
        
        # PCA
        pca = PCA(n_components=K)
        X_pca = pca.fit_transform(X_centered)
        X_pca_recon = pca.inverse_transform(X_pca)
        
        # 测试集（带噪声）
        X_pca_test_recon = pca.transform(X_noisy) @ pca.components_
        pca_error = np.mean((X_centered - X_pca_test_recon) ** 2)
        
        # DAE
        dae = DenoisingAutoencoder(D, K)
        optimizer = torch.optim.Adam(dae.parameters(), lr=0.01)
        
        X_tensor = torch.tensor(X_centered, dtype=torch.float32)
        for epoch in range(200):
            recon, _ = dae(X_tensor, add_noise=True)
            loss = torch.mean((recon - X_tensor) ** 2)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        with torch.no_grad():
            # 用干净数据测试
            recon_clean, _ = dae(X_tensor, add_noise=False)
            dae_error_clean = torch.mean((recon_clean - X_tensor) ** 2).item()
            
            # 用带噪声数据测试
            recon_noisy, _ = dae(torch.tensor(X_noisy, dtype=torch.float32), add_noise=False)
            dae_error_noisy = torch.mean((recon_noisy - torch.tensor(X_centered, dtype=torch.float32)) ** 2).item()
        
        results['PCA'].append(pca_error)
        results['DAE'].append(dae_error_noisy)
    
    print("噪声鲁棒性比较:")
    print(f"{'噪声级别':<10} {'PCA误差':<12} {'DAE误差':<12}")
    print("-" * 34)
    for i, nl in enumerate(noise_levels):
        print(f"{nl:<10} {results['PCA'][i]:<12.4f} {results['DAE'][i]:<12.4f}")

6. 应用场景与实践指南

6.1 选择合适的降维方法

def choose_method(manifold_type, data_size, interpretability_needed):
    """
    根据数据特性选择降维方法
    """
    recommendations = []
    
    if manifold_type == 'linear':
        recommendations.append('PCA（简单高效）')
        if interpretability_needed:
            recommendations.append('线性自编码器（可解释权重）')
    
    elif manifold_type == 'mildly_nonlinear':
        recommendations.append('核PCA（选择RBF核）')
        recommendations.append('深度自编码器（小规模）')
    
    elif manifold_type == 'strongly_nonlinear':
        recommendations.append('深度自编码器（学习复杂流形）')
        recommendations.append('变分自编码器（需要生成能力）')
    
    if data_size > 100000:
        recommendations.append('增量PCA（大规模数据）')
    
    return recommendations
 
# 示例
print(choose_method('linear', 5000, True))
# ['PCA（简单高效）', '线性自编码器（可解释权重）']
 
print(choose_method('strongly_nonlinear', 50000, False))
# ['深度自编码器（学习复杂流形）', '变分自编码器（需要生成能力）']

6.2 预训练初始化

深度自编码器可用于无监督预训练：

def pretrain_with_autoencoder(model, data, hidden_dims):
    """
    使用自编码器进行预训练初始化
    
    步骤：
    1. 训练自编码器学习数据表示
    2. 使用编码器权重初始化模型的对应层
    """
    input_dim = data.shape[1]
    
    # 逐层贪婪训练
    pretrained_weights = []
    current_input = data
    
    for i, hidden_dim in enumerate(hidden_dims):
        print(f"训练第 {i+1} 层 (维度: {current_input.shape[1]} -> {hidden_dim})")
        
        # 训练单层自编码器
        ae = nn.Sequential(
            nn.Linear(current_input.shape[1], hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, current_input.shape[1])
        )
        
        optimizer = torch.optim.Adam(ae.parameters(), lr=0.001)
        X_tensor = torch.tensor(current_input, dtype=torch.float32)
        
        for epoch in range(100):
            recon = ae(X_tensor)
            loss = torch.mean((recon - X_tensor) ** 2)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        # 保存编码器权重
        pretrained_weights.append(ae[0].weight.data.numpy())
        
        # 计算下一层输入
        with torch.no_grad():
            current_input = ae[0](X_tensor).numpy()
    
    return pretrained_weights

6.3 表示分析工具

def analyze_representation_quality(representations, labels):
    """
    分析降维后表示的质量
    """
    from sklearn.metrics import silhouette_score
    from sklearn.neighbors import NearestNeighbors
    
    results = {}
    
    # 1. 聚类质量（轮廓系数）
    if len(np.unique(labels)) > 1:
        results['silhouette_score'] = silhouette_score(representations, labels)
    
    # 2. 局部保留度（ trustworthiness）
    k = 5
    nn_original = NearestNeighbors(n_neighbors=k)
    nn_reduced = NearestNeighbors(n_neighbors=k)
    
    # 假设有原始高维数据和降维后的数据
    # results['trustworthiness'] = trustworthiness(original, reduced, k)
    
    # 3. 重建误差
    # results['reconstruction_error'] = compute_reconstruction_error(model, data)
    
    return results
 
def visualize_representations(representations, labels, method_name):
    """
    可视化降维结果
    """
    import matplotlib.pyplot as plt
    from sklearn.manifold import TSNE
    
    if representations.shape[1] > 2:
        # 使用t-SNE进一步降到2D
        tsne = TSNE(n_components=2, random_state=42)
        reps_2d = tsne.fit_transform(representations)
    else:
        reps_2d = representations
    
    plt.figure(figsize=(8, 6))
    scatter = plt.scatter(reps_2d[:, 0], reps_2d[:, 1], c=labels, cmap='tab10', s=10)
    plt.colorbar(scatter)
    plt.title(f'{method_name}表示可视化')
    plt.xlabel('Dimension 1')
    plt.ylabel('Dimension 2')
    plt.show()

7. 理论深度：表达能力比较

7.1 逼近论视角

方法	表达能力	理论保证
PCA	线性子空间	最优线性 $L_{2}$ 逼近
核PCA	再生核Hilbert空间	非线性结构学习
深度自编码器	复合非线性映射	万能逼近定理
VAE	潜在流形	渐近完备性

7.2 维度与复杂度

def complexity_analysis():
    """
    不同方法的参数复杂度分析
    """
    results = []
    
    # PCA: 只需存储K个特征向量
    for D, K in [(100, 10), (1000, 100), (10000, 500)]:
        pca_params = K * D  # K个D维向量
        results.append({
            'method': 'PCA',
            'dims': f'{D}->{K}',
            'params': pca_params,
            'inference': 'O(DK)'
        })
    
    # 线性自编码器: W1: D×K, W2: K×D
    for D, K in [(100, 10), (1000, 100), (10000, 500)]:
        ae_params = 2 * D * K
        results.append({
            'method': '线性AE',
            'dims': f'{D}->{K}',
            'params': ae_params,
            'inference': 'O(DK)'
        })
    
    # 深度自编码器
    for D, hidden, K in [(100, [64, 32], 10)]:
        total = D * 64 + 64 * 32 + 32 * K + K * 32 + 32 * 64 + 64 * D
        results.append({
            'method': f'深度AE{hidden}',
            'dims': f'{D}->{hidden}',
            'params': total,
            'inference': 'O(D·max(hidden))'
        })
    
    return results

8. 总结

方法对比总览

方面	PCA	线性AE	核PCA	深度AE	VAE
线性/非线性	线性	线性	非线性	非线性	非线性
概率解释	无	无	无	无	有
生成能力	弱	弱	弱	一般	强
可解释性	高	高	低	低	中
计算效率	高	高	中	中	中
表达能力	受限	受限	较强	强	强

选择指南

开始
  │
  ├─ 数据是线性的？
  │     ├─ 是 → PCA 或 线性AE
  │     └─ 否 → 继续
  │
  ├─ 需要生成模型？
  │     ├─ 是 → VAE
  │     └─ 否 → 继续
  │
  ├─ 数据规模大？
  │     ├─ 是 → 增量PCA 或 深度AE
  │     └─ 否 → 深度AE 或 核PCA
  │
  └─ 需要可解释性？
        ├─ 是 → PCA
        └─ 否 → 自编码器家族

核心要点

线性自编码器 = PCA：在数学上严格等价
深度自编码器 > PCA：可以学习非线性流形
VAE = 概率PCA的深度扩展：具有生成能力
去噪正则化：提高表示的鲁棒性
逐层预训练：深度网络的有效初始化策略

参考资料

Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press. Chapter 14: Autoencoders. ↩
Plaut, E. (2018). From Principal Subspaces to Principal Components with Linear Autoencoders. arXiv:1804.10253. ↩
Hinton, G. E., & Salakhutdinov, R. R. (2006). Reducing the Dimensionality of Data with Neural Networks. Science, 313(5786), 504-507. ↩

Metaphor

探索

PCA与自编码器的联系

1. 概述

2. 线性自编码器与PCA的等价性

2.1 线性自编码器

2.2 数学证明

2.3 激活函数的影响

3. 深度自编码器：从线性到非线性

3.1 Hinton的开创性工作

3.2 非线性流形学习

4. 变分自编码器（VAE）与概率PCA

4.1 概率PCA回顾

4.2 VAE的扩展

5. 去噪自编码器与PCA正则化

5.1 关系推导

6. 应用场景与实践指南

6.1 选择合适的降维方法

6.2 预训练初始化

6.3 表示分析工具

7. 理论深度：表达能力比较

7.1 逼近论视角

7.2 维度与复杂度

8. 总结

方法对比总览

选择指南

核心要点

参考资料

关系图谱

目录

Metaphor

探索

PCA与自编码器的联系

1. 概述

2. 线性自编码器与PCA的等价性

2.1 线性自编码器

2.2 数学证明

2.3 激活函数的影响

3. 深度自编码器：从线性到非线性

3.1 Hinton的开创性工作

3.2 非线性流形学习

4. 变分自编码器（VAE）与概率PCA

4.1 概率PCA回顾

4.2 VAE的扩展

5. 去噪自编码器与PCA正则化

5.1 关系推导

6. 应用场景与实践指南

6.1 选择合适的降维方法

6.2 预训练初始化

6.3 表示分析工具

7. 理论深度：表达能力比较

7.1 逼近论视角

7.2 维度与复杂度

8. 总结

方法对比总览

选择指南

核心要点

参考资料

Footnotes

关系图谱

目录