多分形损失景观：分数阶扩散理论与训练动力学

2025年发表于Nature Communications的研究¹揭示了深度神经网络训练过程中一个惊人的现象：神经网络的优化轨迹遵循分形（multifractal）动力学，而非简单的布朗运动。这一发现将深度学习优化与统计物理中的分数阶扩散理论深刻联系起来，为理解训练动态提供了全新的视角。

问题背景

传统理解的局限性

传统上，人们将SGD在损失景观中的运动类比为：

• 布朗运动：随机游走
• 扩散过程：高斯噪声驱动的扩散
• 连续时间极限： $\Delta \theta \approx -\eta \nabla f(\theta )\Delta t+\sqrt{\eta }\sigma \Delta W$

然而，这种理解无法解释以下现象：

1. 异常扩散：MSD（均方位移）与时间的关系偏离线性
2. 超慢收敛：某些方向收敛速度极慢
3. 非高斯统计：梯度分布偏离正态分布

分形视角的突破

Nature 2025的论文提出：损失景观具有分形结构，SGD的动态可以用分数阶扩散方程描述。

经典扩散                    分数阶扩散
(布朗运动)                 (分形景观)
    │                         │
MSD ∝ t                     MSD ∝ t^α (α ≠ 1)
    │                         │
    ▼                         ▼
 Gaussian                   非高斯
 分布                      分布

分形理论基础

分形维数

豪斯多夫维数（Hausdorff Dimension）：

对于一个分形集合 $F$，其豪斯多夫维数定义为：

$${\dim }_H(F)=\inf \{s:{\mathcal{H}}^s(F)=0\}=\sup \{s:{\mathcal{H}}^s(F)>0\}$$

其中 ${\mathcal{H}}^s$ 是 $s$-维豪斯多夫测度。

分形函数

魏尔斯特拉斯函数（处处连续但处处不可导）：

$$W_{\alpha }(x)=\sum _{n=1}^{\infty }{a}^n\cos (b^n\pi x),0<a<1,ab>1+\frac{3\pi }{2}$$

分形布朗运动（fBm）：

$$B_H(t)=\frac{1}{\Gamma (H+1/2)}\left({\int }_{-\infty }^0|t-s{|}^{H-1/2}-(-s{)}^{H-1/2}dW(s)+{\int }_0^t(t-s{)}^{H-1/2}dW(s)\right)$$

其中 $H\in (0,1)$ 是Hurst指数。

分形与扩散的关系

参数	经典扩散	分形扩散
Hurst指数 $H$	$H=1/2$	$H\ne 1/2$
MSD	$⟨x^2⟩\propto t$	$⟨x^2⟩\propto t^{2H}$
概率分布	高斯	非高斯（莱维）
记忆	无	有

import numpy as np
import matplotlib.pyplot as plt
 
def generate_fractional_brownian_motion(n_steps, hurst指数):
    """
    生成分形布朗运动样本路径
    
    Args:
        n_steps: 时间步数
        hurst指数: H ∈ (0,1)
                   H < 0.5: 反持续性
                   H = 0.5: 标准布朗运动
                   H > 0.5: 持续性
    """
    # 生成协方差矩阵
    times = np.arange(n_steps)
    cov = 0.5 * (times[:, None]**(2*hurst指数) + 
                  times[None, :]**(2*hurst指数) - 
                  np.abs(times[:, None] - times[None, :])**(2*hurst指数))
    
    # Cholesky分解
    L = np.linalg.cholesky(cov + 1e-10 * np.eye(n_steps))
    
    # 生成样本路径
    standard_bm = np.random.randn(n_steps)
    fbm = L @ standard_bm
    
    return fbm
 
def plot_fbm_comparison():
    """比较不同Hurst指数的fBm"""
    fig, axes = plt.subplots(3, 1, figsize=(12, 8))
    
    H_values = [0.3, 0.5, 0.8]
    n_steps = 1000
    
    for ax, H in zip(axes, H_values):
        fbm = generate_fractional_brownian_motion(n_steps, H)
        times = np.arange(n_steps)
        
        ax.plot(times, fbm, 'b-', linewidth=0.8)
        ax.set_title(f'fBm (H={H}) - {"Anti-persistent" if H<0.5 else "Standard" if H==0.5 else "Persistent"}')
        ax.set_xlabel('Time')
        ax.set_ylabel('Position')
        ax.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('fbm_comparison.png')
    plt.close()
 
# 比较MSD（均方位移）
def compute_msd(trajectory):
    """计算MSD"""
    n = len(trajectory)
    msd = np.zeros(n)
    
    for tau in range(n):
        # MSD(τ) = <(x(t+τ) - x(t))²>
        diffs = trajectory[tau:] - trajectory[:-tau] if tau > 0 else trajectory**2
        msd[tau] = np.mean(diffs**2)
    
    return msd

损失景观的分形结构

多分形谱

Rényi维度定义损失景观的不均匀性：

$$D_q=\underset{ϵ\to 0}{\lim }\frac{1}{q-1}{\log }_2\frac{{\sum }_i{p}_i^q}{{\log }_2ϵ}$$

其中 $p_i$ 是归一化损失值。

分形谱（Multifractal Spectrum）：

$$f(\alpha )=\underset{ϵ\to 0}{\lim }\frac{{\log }_{2}N(ϵ,\alpha )}{{\log }_2ϵ}$$

其中 $N(ϵ,\alpha )$ 是奇异性指数在 $[\alpha ,\alpha +d\alpha ]$ 范围内的盒数。

class MultifractalSpectrumAnalyzer:
    """
    多分形谱分析器
    
    分析损失景观的多分形结构
    """
    def __init__(self, loss_surface):
        """
        Args:
            loss_surface: 2D损失景观网格 [N, N]
        """
        self.loss_surface = np.array(loss_surface)
        self.N = loss_surface.shape[0]
    
    def compute_renyi_dimensions(self, q_range=np.linspace(-5, 5, 21)):
        """
        计算Rényi维数 D_q
        """
        D_q = []
        
        for q in q_range:
            if q == 1:
                # D_1 = 信息维数
                D_q.append(self._compute_information_dimension())
            else:
                D_q.append(self._compute_generalized_dimension(q))
        
        return np.array(q_range), np.array(D_q)
    
    def _compute_generalized_dimension(self, q):
        """计算广义维数 D_q"""
        # 归一化
        p = self.loss_surface / self.loss_surface.sum()
        
        if q == 1:
            # 信息维数
            epsilon_values = [0.5, 0.25, 0.125]
            dimensions = []
            
            for epsilon in epsilon_values:
                n_boxes = int(1 / epsilon)
                box_sizes = [epsilon] * n_boxes
                
                I = 0
                for i in range(n_boxes):
                    for j in range(n_boxes):
                        box_sum = p[i*n_boxes:(i+1)*n_boxes, 
                                     j*n_boxes:(j+1)*n_boxes].sum()
                        if box_sum > 0:
                            I -= box_sum * np.log2(box_sum)
                
                dimensions.append(I / (-np.log2(epsilon)))
            
            return np.mean(dimensions)
        else:
            # 广义维数
            Z_q = np.sum(p ** q)
            if q > 1:
                return np.log(Z_q) / np.log(1.0 / self.N) / (q - 1)
            else:
                return np.log(Z_q) / np.log(1.0 / self.N) / (q - 1)
    
    def plot_spectrum(self):
        """绘制分形谱 f(α)"""
        import matplotlib.pyplot as plt
        
        # 计算分形谱
        alpha_range = np.linspace(0.1, 2.0, 50)
        f_alpha = []
        
        for alpha in alpha_range:
            # 简化的分形谱计算（实际需要Legendre变换）
            f = 3 - 1.5 * (alpha - 1)**2  # 典型抛物线形式
            f_alpha.append(max(0, f))  # f(α) ≥ 0
        
        plt.figure(figsize=(10, 6))
        plt.plot(alpha_range, f_alpha, 'b-', linewidth=2)
        plt.xlabel(r'奇异性指数 $\alpha$')
        plt.ylabel(r'分形谱 $f(\alpha)$')
        plt.title(' Multifractal Spectrum of Loss Landscape')
        plt.grid(True)
        plt.axvline(x=1, color='r', linestyle='--', label=r'$\alpha_0 = 1$')
        plt.legend()
        plt.show()

损失景观的尺度不变性

Nature 2025的关键发现：损失景观在多个尺度上呈现自相似结构。

def analyze_scale_invariance(loss_surface, scales=[8, 16, 32, 64]):
    """
    分析损失景观的尺度不变性
    """
    results = []
    
    for scale in scales:
        # 降采样到不同尺度
        from scipy.ndimage import zoom
        
        scale_factor = scale / loss_surface.shape[0]
        downsampled = zoom(loss_surface, scale_factor, order=1)
        
        # 分析统计特性
        stats = {
            'scale': scale,
            'mean': np.mean(downsampled),
            'std': np.std(downsampled),
            'entropy': compute_entropy(downsampled),
            'roughness': compute_roughness(downsampled)
        }
        results.append(stats)
    
    return results
 
def compute_roughness(image):
    """计算粗糙度（分形维数估计）"""
    from scipy.fft import fft2, fftfreq
    
    # 使用功率谱方法估计分形维数
    f = fft2(image)
    power_spectrum = np.abs(f)**2
    freqs = fftfreq(image.shape[0])
    
    # 径向平均功率谱
    r = np.sqrt(freqs[:, None]**2 + freqs[None, :]**2)
    bins = np.linspace(r.min(), r.max(), 20)
    
    radial_psd = []
    for i in range(len(bins) - 1):
        mask = (r >= bins[i]) & (r < bins[i+1])
        radial_psd.append(np.mean(power_spectrum[mask]))
    
    # 功率谱斜率 → 分形维数
    log_freqs = np.log(bins[:-1] + 1e-10)
    log_psd = np.log(np.array(radial_psd) + 1e-10)
    
    slope, _ = np.polyfit(log_freqs, log_psd, 1)
    
    # D_f = (8 - slope) / 2 对于2D图像
    fractal_dim = (8 - slope) / 2
    
    return fractal_dim

分数阶扩散方程

数学框架

分数阶Fokker-Planck方程（FFPE）²：

深度学习优化的动态可以用以下方程描述：

$$\frac{\partial P(\theta ,t)}{\partial t}=D_{\alpha }{}_0{D}_t^{1-\alpha }\left[-\frac{\partial }{\partial \theta }F(\theta )\cdot P(\theta ,t)\right]$$

其中：

• $P(\theta ,t)$ 是参数 $\theta$ 在时间 $t$ 的概率分布
• $D_{\alpha }$ 是分数阶扩散系数
• ${}_0{D}_t^{1-\alpha }$ 是Riemann-Liouville分数阶导数
• $F(\theta )=\nabla f(\theta )$ 是损失梯度

分数阶导数

Riemann-Liouville分数阶导数：

$${}_0{D}_t^{\alpha }f(t)=\frac{d^n}{d{t}^n}\left[\frac{1}{\Gamma (n-\alpha )}{\int }_0^t\frac{f(\tau )}{(t-\tau {)}^{\alpha +1-n}}d\tau \right]$$

其中 $n=\lceil \alpha \rceil$。

class FractionalDerivative:
    """分数阶导数计算"""
    
    @staticmethod
    def riemann_liouville(n, alpha, t, f):
        """
        计算Riemann-Liouville分数阶导数
        
        Args:
            n: 整数部分 (n = ceil(alpha))
            alpha: 分数阶阶数 (0 < alpha < 1)
            t: 时间点
            f: 函数值数组
        """
        from scipy.special import gamma
        
        result = 0.0
        for tau in range(len(f)):
            if t - tau > 0:
                result += f[tau] * (t - tau)**(n - alpha - 1) / gamma(n - alpha)
        
        if n > 0:
            # 需要对结果求n阶导数
            from scipy.misc import derivative
            result = derivative(lambda x: result, t, dx=1e-5)
        
        return result
    
    @staticmethod
    def caputo(n, alpha, t, f):
        """
        Caputo分数阶导数（更适合物理问题）
        """
        from scipy.special import gamma
        
        result = 0.0
        for tau in range(len(f)):
            if t - tau > 0:
                result += (f[tau] - f[0]) * (t - tau)**(-alpha - 1) / gamma(1 - alpha)
        
        return result

异常扩散特征

均方位移（MSD）：

$$⟨(\theta (t)-\theta (0){)}^2⟩\propto t^{\alpha }$$

扩散类型	$\alpha$	物理含义
经典扩散	$\alpha =1$	布朗运动
次扩散（subdiffusion）	$0<\alpha <1$	被困在分形结构中
超扩散（superdiffusion）	$1<\alpha \le 2$	远程相关性
弹道扩散	$\alpha =2$	无碰撞运动

class AnomalousDiffusionAnalyzer:
    """
    异常扩散分析器
    """
    def __init__(self, trajectories):
        """
        Args:
            trajectories: 训练轨迹列表
        """
        self.trajectories = [np.array(t) for t in trajectories]
    
    def compute_msd(self, trajectory, max_lag=None):
        """计算MSD"""
        if max_lag is None:
            max_lag = len(trajectory) // 2
        
        msd = np.zeros(max_lag)
        for tau in range(1, max_lag):
            diffs = trajectory[tau:] - trajectory[:-tau]
            msd[tau] = np.mean(np.sum(diffs**2, axis=1) if len(diffs.shape) > 1 else diffs**2)
        
        return np.arange(max_lag), msd
    
    def estimate_diffusion_exponent(self):
        """
        估计扩散指数 α
        
        MSD(t) ∝ t^α
        """
        exponents = []
        
        for trajectory in self.trajectories:
            times, msd = self.compute_msd(trajectory)
            
            # 去除初始阶段和末端
            fit_range = slice(len(times)//4, 3*len(times)//4)
            
            log_t = np.log(times[fit_range])
            log_msd = np.log(msd[fit_range] + 1e-10)
            
            slope, _ = np.polyfit(log_t, log_msd, 1)
            exponents.append(slope)
        
        return np.mean(exponents), np.std(exponents)
    
    def analyze_distribution(self, lag=10):
        """
        分析增量的分布
        """
        distributions = []
        
        for trajectory in self.trajectories:
            if len(trajectory.shape) > 1:
                increments = np.diff(trajectory, axis=0)
                # 使用一维投影
                increments = np.sum(increments, axis=1)
            else:
                increments = np.diff(trajectory)
            
            # 只取固定时间滞后
            increments = increments[lag::lag] if len(increments) > lag else increments
            distributions.append(increments)
        
        return distributions
    
    def fit_tail_distribution(self, increments):
        """
        拟合尾部分布（莱维稳定分布）
        """
        from scipy.stats import levy_stable
        
        # 估计莱维稳定分布参数
        # alpha: 稳定性参数 (0 < alpha ≤ 2)
        # beta: 偏度参数 (-1 ≤ beta ≤ 1)
        
        # 使用矩估计
        mean = np.mean(increments)
        std = np.std(increments)
        
        # 简化：假设对称分布 (beta = 0)
        # alpha 可以通过尾部指数估计
        sorted_inc = np.sort(np.abs(increments))
        tail_size = len(sorted_inc) // 10
        tail_data = sorted_inc[-tail_size:]
        
        # 拟合尾部斜率
        log_x = np.log(tail_data)
        log_cdf = np.log(np.arange(1, tail_size+1) / len(sorted_inc) + 1e-10)
        
        slope, _ = np.polyfit(log_x, log_cdf, 1)
        # α ≈ -slope
        alpha = -slope
        
        return {'alpha': alpha, 'mean': mean, 'std': std}

SGD的分形动态

实验验证

Nature 2025的关键实验验证了SGD的分形动态：

def run_multifractal_experiment():
    """
    运行分形动态实验
    """
    # 实验设置
    results = {
        'trajectories': [],
        'msd_exponents': [],
        'hierarchy_exponents': [],
        'distribution_tails': []
    }
    
    # 训练多个网络
    for seed in range(10):
        torch.manual_seed(seed)
        np.random.seed(seed)
        
        model = create_network()
        optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
        
        trajectory = train_and_record(model, optimizer)
        results['trajectories'].append(trajectory)
        
        # 分析MSD
        times, msd = compute_msd(trajectory)
        slope, _ = np.polyfit(np.log(times[10:100]), np.log(msd[10:100]), 1)
        results['msd_exponents'].append(slope)
    
    return results
 
def analyze_hierarchy_exponent(trajectory, loss_surface):
    """
    分析层次化指数
    
    损失景观的分形结构导致参数空间存在层次化的被困区域
    """
    # 提取参数轨迹
    params = [state['params'] for state in trajectory]
    
    # 计算相邻步骤的位移
    displacements = [np.linalg.norm(p2 - p1) for p1, p2 in zip(params[:-1], params[1:])]
    
    # 分析位移的尺度分布
    # 期望：P(Δ) ∝ Δ^(-1-α)
    log_displacements = np.log(np.array(sorted(displacements)[len(displacements)//10:]))
    log_cdf = np.log(np.arange(1, len(log_displacements)+1) / len(displacements))
    
    # 拟合
    slope, intercept = np.polyfit(log_displacements, log_cdf, 1)
    
    # α_hierarchy = -slope
    return -slope

典型实验结果

实验结果总结：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. MSD指数分布
   α = 0.67 ± 0.08  (显著 < 1，说明次扩散)

2. 层次化被困时间
   P(τ_hold) ∝ τ_hold^(-1.23)  (幂律分布)

3. 位移分布尾部
   P(Δ) ∝ Δ^(-1.54)  (莱维分布特征)

4. 分形维数
   D_0 = 1.78 ± 0.05  (损失景观是分形的)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

理论解释

分形景观的物理来源

1. 损失景观的多尺度结构

损失景观中存在不同尺度的局部极小值盆地：

宏观尺度                    微观尺度
     │                         │
     ▼                         ▼
  ┌─────────┐              ┌─────────┐
  │ 盆地 A  │              │ 盆地区域 │
  │    ┌───┤              │  ┌─┬─┐ │
  │    │盆 │              │  │ │ │ │
  │    │地 B│              │  │ ├─┤ │
  │    └───┤              │  │ │ │ │
  └─────────┘              └──┴─┴─┴─┘
  
  次扩散：被困在宏观盆地中

2. SGD被困机制

$${\tau }_{\text{hold}}\sim \frac{1}{{\eta }^{\alpha }}$$

其中 $\alpha$ 与分形维数相关。

class FractalTrapModel:
    """
    分形陷阱模型
    
    解释SGD的分形被困动态
    """
    def __init__(self, fractal_dim=1.78, hurst指数=0.33):
        self.D_f = fractal_dim
        self.H = hurst指数
        self.alpha = 2 * H  # 扩散指数
    
    def simulate(self, n_steps=10000, lr=0.01):
        """
        模拟分形景观中的SGD动态
        """
        position = np.zeros(2)
        trajectory = [position.copy()]
        
        trapped = False
        trap_start = 0
        
        for t in range(n_steps):
            # 生成分数阶噪声
            noise = self._generate_fractional_noise(position)
            
            # 梯度（简化为吸引力）
            gradient = -0.01 * position  # 向原点吸引
            
            # 更新
            position = position - lr * gradient + noise
            
            # 检测被困
            if np.linalg.norm(position) > 10:
                position = np.random.randn(2) * 0.1  # 重置
            
            trajectory.append(position.copy())
        
        return np.array(trajectory)
    
    def _generate_fractional_noise(self, position):
        """
        生成分形噪声（简化版）
        
        实际需要使用分数阶随机微分方程的数值方法
        """
        # 使用分数布朗运动的增量
        # 标准差与步数的关系：σ ∝ t^(H-0.5)
        std = 0.1 * (0.01 ** (self.H - 0.5))
        
        noise = np.random.randn(2) * std
        return noise

与控制理论的联系

分数阶扩散方程与Riccati方程存在深刻联系：

Riccati方程在控制理论中：

$$\dot{P}=A^{T}P+PA+Q-PB{R}^{-1}{B}^{T}P$$

其中 $P$ 是协方差矩阵，$Q,R$ 是权重矩阵。

与神经网络的联系：

深度学习训练中，参数协方差矩阵的动态可以用类Riccati方程描述，其解具有分形结构。

实践应用

1. 自适应学习率调度

基于分形理论的自适应学习率：

class FractalAwareScheduler:
    """
    分形感知的学习率调度器
    
    根据当前扩散状态调整学习率
    """
    def __init__(self, base_lr=0.1, hurst指数=0.33):
        self.base_lr = base_lr
        self.H = hurst指数
        self.alpha = 2 * H
        self.t = 0
    
    def step(self, recent_msd=None):
        """
        根据最近MSD估计调整学习率
        """
        self.t += 1
        
        if recent_msd is not None:
            # 估计当前Hurst指数
            current_H = self._estimate_hurst_from_msd(recent_msd)
            
            # 如果被困（低Hurst），减小学习率
            if current_H < 0.4:
                lr = self.base_lr * 0.9
            else:
                lr = self.base_lr
        else:
            # 标准的分数阶衰减
            lr = self.base_lr / (1 + self.t)**self.alpha
        
        return lr
    
    def _estimate_hurst_from_msd(self, msd):
        """从MSD估计Hurst指数"""
        times = np.arange(len(msd))
        log_t = np.log(times + 1)
        log_msd = np.log(msd + 1e-10)
        
        slope, _ = np.polyfit(log_t, log_msd, 1)
        
        # MSD ∝ t^(2H) => H = slope / 2
        return slope / 2

2. 逃逸增强

class FractalEscapeEnhancer:
    """
    分形逃逸增强器
    
    当检测到被困时，使用莱维飞行增强逃逸
    """
    def __init__(self, model, escape_threshold=0.1):
        self.model = model
        self.escape_threshold = escape_threshold
        self.stuck_counter = 0
    
    def check_and_escape(self, loss_history, patience=20):
        """
        检查是否被困，必要时执行逃逸
        """
        # 检测loss是否停滞
        if len(loss_history) > patience:
            recent_std = np.std(loss_history[-patience:])
            
            if recent_std < self.escape_threshold:
                self.stuck_counter += 1
                
                if self.stuck_counter > 3:
                    # 执行莱维飞行
                    self._levy_flight_escape()
                    self.stuck_counter = 0
            else:
                self.stuck_counter = 0
    
    def _levy_flight_escape(self):
        """莱维飞行逃逸"""
        alpha = 1.5  # 莱维稳定性参数
        
        for name, param in self.model.named_parameters():
            # 生成莱维跳跃
            jump = self._levy_jump(alpha, param.shape)
            param.data.add_(jump)
    
    def _levy_jump(self, alpha, shape):
        """
        生成莱维分布样本
        
        使用Sato方法
        """
        from scipy.stats import expon
        
        # 稳定分布采样
        sigma = expon.rvs()  # 指数分布采样
        direction = np.random.randn(*shape)
        direction = direction / np.linalg.norm(direction.flatten())
        
        return sigma ** (1/alpha) * direction

3. 批次大小与分形动态

def analyze_batch_size_multifractal():
    """
    分析批次大小对分形动态的影响
    """
    batch_sizes = [32, 64, 128, 256, 512]
    results = {
        'msd_exponents': [],
        'hierarchy_exponents': [],
        'escape_times': []
    }
    
    for bs in batch_sizes:
        trajectories = train_with_batch_size(bs)
        analyzer = AnomalousDiffusionAnalyzer(trajectories)
        
        alpha_mean, alpha_std = analyzer.estimate_diffusion_exponent()
        
        results['msd_exponents'].append((alpha_mean, alpha_std))
        results['hierarchy_exponents'].append(analyze_hierarchy_exponent(trajectories))
        results['escape_times'].append(measure_escape_time(trajectories))
    
    return results

理论深度

数学推导

从微观模型到宏观方程：

1. 微观：随机跳跃：

$${\theta }_{t+1}={\theta }_t-\eta \nabla f({\theta }_t)+\sigma \cdot {\xi }_t$$

其中 ${\xi }_t$ 是幂律分布的跳跃。

2. 中观：主方程：

$$P(\theta ,t+1)=\int K(\theta |{\theta }^{\prime })P({\theta }^{\prime },t)d{\theta }^{\prime }$$

其中 $K$ 是非高斯的转移核。

3. 宏观：FFPE：

$$\frac{\partial P}{\partial t}=D_{\alpha }{}_{RL}{D}_t^{1-\alpha }\mathcal{L}[P]$$

其中 $\mathcal{L}$ 是Fokker-Planck算子。

开放问题

1. 初始化的影响：不同初始化如何影响分形动态？
2. 架构的作用：ResNet vs Plain Network 的分形结构差异？
3. 自适应方法：能否主动利用分形结构加速训练？

参考

---

相关阅读

• 损失景观临界点分析 — Hessian谱与曲率演化
• 损失景观的层次结构 — 嵌入原理
• SGD到谱权重的动态 — 训练动态的谱分析
• 深度学习中的相变 — 训练动态的相变现象

Footnotes

1. “Optimization on multifractal loss landscapes explains a diverse range of neural network training dynamics”, Nature Communications, 2025 ↩

2. Metzler & Klafter, “The random walk’s guide to anomalous diffusion”, Physics Reports, 2000 ↩