神经热力学与统计物理

概述

深度学习与统计物理之间存在深刻的联系。神经网络可以被视为一种特殊的物理系统，其损失景观（Loss Landscape）、表示学习和泛化能力都可以用统计物理的语言来描述和理解。¹

本文系统梳理神经热力学与统计物理的核心内容：

神经网络作为物理系统的类比
能量景观与损失曲面分析
相变与涌现现象
信息瓶颈的热力学解释
拓扑与几何视角

从物理系统到神经网络

类比框架

统计物理研究大量粒子的集体行为，深度学习研究大量参数的协同学习。这种类比可以从多个层面建立：

物理概念	神经网络对应
粒子	神经元/参数
粒子间相互作用	权重连接
自由能	损失函数
温度	学习率/噪声
相变	泛化/过拟合转变
熵	表示多样性

Hopfield网络与Ising模型

Hopfield网络是连接神经科学与统计物理的最早桥梁之一。离散Hopfield网络的能量函数为：

E = - \frac{1}{2} i, j \sum W_{ij} s_{i} s_{j} - i \sum b_{i} s_{i}

其中 $s_{i} \in {- 1, + 1}$ 是神经元状态， $W_{ij}$ 是权重， $b_{i}$ 是偏置。

这与Ising模型的哈密顿量完全一致：

H = - J ⟨ i, j ⟩ \sum s_{i} s_{j} - h i \sum s_{i}

现代神经网络的统计物理扩展

对于现代神经网络（MLP、Transformer等），我们可以定义类似的”伪能量函数”：

import torch
import torch.nn.functional as F
import numpy as np
 
class NeuralNetworkEnergy:
    """
    神经网络的统计物理视角：计算等效能量
    
    将神经网络的前向传播解释为某种能量最小化过程
    """
    def __init__(self, model):
        self.model = model
        self.device = next(model.parameters()).device
    
    def compute_hamiltonian(self, x, y=None):
        """
        计算神经网络的等效哈密顿量
        
        H = -log p(x) ∝ ∑ activations - log priors
        """
        h = 0.0
        
        # 通过网络前向传播，记录每个层的激活
        h_current = x
        
        for name, module in self.model.named_modules():
            if isinstance(module, torch.nn.Linear):
                # 线性层的贡献：-W·hh^T 的迹（近似）
                W = module.weight.data
                h_linear = -torch.sum(W @ h_current * h_current) / h_current.numel()
                h += h_linear
                
                # 前向传播到下一层
                h_current = module(h_current)
                
                # 应用激活函数
                if isinstance(module, torch.nn.ReLU):
                    h_current = F.relu(h_current)
        
        # 添加偏置惩罚
        for name, param in self.model.named_parameters():
            if 'bias' in name:
                h += 0.01 * torch.sum(param ** 2)
        
        return h / x.numel()
    
    def compute_free_energy(self, x, temperature=1.0, n_samples=100):
        """
        计算自由能：F = -T log Z
        
        使用重要性采样近似配分函数
        """
        # 能量样本
        energies = []
        
        with torch.no_grad():
            for _ in range(n_samples):
                # 添加随机噪声模拟温度
                x_noisy = x + temperature * torch.randn_like(x)
                E = self.compute_hamiltonian(x_noisy)
                energies.append(E.item())
        
        energies = torch.tensor(energies)
        
        # 自由能估计：F ≈ -T log Z ≈ -T log(∑ exp(-E/T))
        log_Z = torch.logsumexp(-energies / temperature, dim=0)
        F = -temperature * log_Z
        
        return F.item(), energies.mean().item()
    
    def compute_entropy(self, x, temperature=1.0, n_samples=100):
        """
        计算表示熵：S = -∑ p log p
        
        估计输出分布的熵
        """
        with torch.no_grad():
            outputs = []
            
            for _ in range(n_samples):
                # 多次前向传播（dropout等随机性）
                output = self.model(x)
                outputs.append(output)
            
            outputs = torch.stack(outputs)
            
            # 计算均值和方差
            mean = outputs.mean(dim=0)
            var = outputs.var(dim=0)
            
            # 假设高斯分布，计算熵
            entropy = 0.5 * torch.log(2 * np.pi * np.e * var + 1e-8)
            entropy = entropy.sum()
        
        return entropy.item()
    
    def compute_partition_function_estimate(self, x, temperature=1.0, n_samples=1000):
        """
        估计配分函数 Z = ∑ exp(-E/T)
        
        使用退火重要性采样（AIS）
        """
        # 初始化
        beta_0 = 0.0  # 高温
        beta_1 = 1.0 / temperature  # 目标温度
        
        # 生成中间温度序列
        n_steps = 100
        betas = torch.linspace(beta_0, beta_1, n_steps)
        
        # 初始化样本
        x_sample = x.clone()
        
        # AIS采样
        log_weights = torch.zeros(n_samples)
        
        for i in range(n_steps - 1):
            beta_curr = betas[i]
            beta_next = betas[i + 1]
            
            # Metropolis-Hastings更新
            for _ in range(10):
                # 提议新样本
                x_prop = x_sample + 0.1 * torch.randn_like(x_sample)
                
                # 计算接受率
                E_curr = self.compute_hamiltonian(x_sample)
                E_prop = self.compute_hamiltonian(x_prop)
                
                alpha = min(1, torch.exp(-(beta_next - beta_curr) * (E_prop - E_curr)))
                
                if torch.rand(1) < alpha:
                    x_sample = x_prop
            
            # 更新权重
            E_sample = self.compute_hamiltonian(x_sample)
            log_weights += -betas[i] * E_sample
        
        # 估计配分函数
        log_Z = torch.logsumexp(log_weights, dim=0) - torch.log(torch.tensor(n_samples))
        
        return torch.exp(log_Z).item()
 
 
def analyze_network_thermodynamics(model, data_loader):
    """
    分析神经网络的统计物理特性
    """
    analyzer = NeuralNetworkEnergy(model)
    
    # 收集不同温度下的统计量
    temperatures = [0.1, 0.5, 1.0, 2.0, 5.0]
    results = {
        'temperature': [],
        'energy': [],
        'free_energy': [],
        'entropy': []
    }
    
    for temp in temperatures:
        # 采样数据
        x, _ = next(iter(data_loader))
        x = x.to(analyzer.device)
        if x.ndim == 4:
            x = x.view(x.size(0), -1)
        
        # 计算统计量
        energy = analyzer.compute_hamiltonian(x)
        free_energy, _ = analyzer.compute_free_energy(x, temperature=temp)
        entropy = analyzer.compute_entropy(x, temperature=temp)
        
        results['temperature'].append(temp)
        results['energy'].append(energy.item())
        results['free_energy'].append(free_energy)
        results['entropy'].append(entropy)
    
    return results

能量景观与损失曲面

损失景观的拓扑

深度神经网络的损失景观具有复杂的拓扑结构。Goodfellow等人的研究表明，梯度下降倾向于收敛到”平坦”的极小值，这些极小值具有更好的泛化能力。

定义平坦度（Flatness）为：

Flatness (θ^{*}) = ∥ δ ∥ \leq ϵ sup L (θ^{*} + δ) - L (θ^{*})

能量 Landscape 分析

对于分类任务，损失景观可以被理解为一种能量函数：

E_{θ} (x, y) = - lo g p_{θ} (y ∣ x) = - lo g \frac{e ^{f_{y} (x)}}{\sum _{j} e ^{f_{j} (x)}}

其中 $f_{j} (x)$ 是网络对类别 $j$ 的logit输出。

模式耦合与能量壁垒

深层网络学习到的表示形成”能量盆”（Energy Basins），不同类别之间存在能量壁垒：

import torch
import numpy as np
from scipy.ndimage import gaussian_filter
 
class EnergyLandscapeAnalyzer:
    """
    损失能量景观分析器
    
    用于可视化和分析损失函数的能量 landscape
    """
    def __init__(self, model, device='cuda'):
        self.model = model
        self.device = device
        self.model.eval()
    
    def compute_loss_along_direction(self, x, y, direction, range_min=-1.0, 
                                     range_max=1.0, n_points=50):
        """
        沿某个方向计算损失变化
        """
        losses = []
        alphas = torch.linspace(range_min, range_max, n_points)
        
        with torch.no_grad():
            for alpha in alphas:
                # 沿方向扰动
                x_perturbed = x + alpha * direction.to(self.device)
                
                # 计算损失
                output = self.model(x_perturbed)
                loss = F.cross_entropy(output, y.to(self.device))
                losses.append(loss.item())
        
        return alphas.numpy(), np.array(losses)
    
    def find_saddle_points(self, x, y, n_restarts=10):
        """
        寻找损失景观中的鞍点
        """
        saddle_points = []
        
        for _ in range(n_restarts):
            # 随机初始化
            direction = torch.randn_like(x).to(self.device)
            direction = direction / direction.norm()
            
            # 使用NEB-like方法寻找路径
            alphas = torch.linspace(-1.0, 1.0, 20)
            losses = []
            
            for alpha in alphas:
                x_perturbed = x + alpha * direction
                with torch.no_grad():
                    output = self.model(x_perturbed)
                    loss = F.cross_entropy(output, y.to(self.device))
                losses.append(loss.item())
            
            # 找到局部最大值（鞍点候选）
            for i in range(1, len(losses) - 1):
                if losses[i] > losses[i-1] and losses[i] > losses[i+1]:
                    saddle_points.append({
                        'alpha': alphas[i].item(),
                        'loss': losses[i],
                        'direction': direction.cpu()
                    })
        
        return saddle_points
    
    def compute_curvature_eigenvalues(self, x, y):
        """
        计算Hessian的特征值分布（用于分析极小值平坦度）
        """
        self.model.train()
        
        # 前向传播
        output = self.model(x)
        loss = F.cross_entropy(output, y)
        
        # 计算梯度
        grads = torch.autograd.grad(loss, self.model.parameters(), 
                                   create_graph=True)
        
        # 计算Hessian-vector products
        eigenvalues = []
        n_params = sum(p.numel() for p in self.model.parameters())
        
        for _ in range(100):  # 采样100个随机方向
            v = [torch.randn_like(p) for p in self.model.parameters()]
            
            # Hv
            Hv = torch.autograd.grad(grads, self.model.parameters(),
                                     grad_outputs=v, retain_graph=True)
            
            # 近似特征值
            Hv_flat = torch.cat([h.flatten() for h in Hv if h is not None])
            v_flat = torch.cat([vv.flatten() for vv in v if vv is not None])
            
            eigenvalue = torch.dot(Hv_flat, v_flat) / torch.dot(v_flat, v_flat)
            eigenvalues.append(eigenvalue.item())
        
        self.model.eval()
        return np.array(eigenvalues)
    
    def visualize_landscape_2d(self, x, y, dim1_range=(-1, 1), 
                               dim2_range=(-1, 1), n_grid=50):
        """
        可视化2D损失景观
        """
        # 沿两个随机方向创建网格
        dir1 = torch.randn_like(x).to(self.device)
        dir1 = dir1 / dir1.norm()
        dir2 = torch.randn_like(x).to(self.device)
        dir2 = dir2 / dir2.norm()
        
        # Gram-Schmidt正交化
        dir2 = dir2 - torch.dot(dir2.flatten(), dir1.flatten()) * dir1
        dir2 = dir2 / dir2.norm()
        
        # 创建网格
        alphas = torch.linspace(dim1_range[0], dim1_range[1], n_grid)
        betas = torch.linspace(dim2_range[0], dim2_range[1], n_grid)
        
        loss_grid = np.zeros((n_grid, n_grid))
        
        with torch.no_grad():
            for i, alpha in enumerate(alphas):
                for j, beta in enumerate(betas):
                    x_perturbed = x + alpha * dir1 + beta * dir2
                    output = self.model(x_perturbed)
                    loss = F.cross_entropy(output, y.to(self.device))
                    loss_grid[i, j] = loss.item()
        
        return loss_grid, alphas.numpy(), betas.numpy()

相变与涌现

神经网络中的相变

深度学习中的许多现象可以理解为相变：

1. 容量相变

定义有效容量 $Φ (N, d)$ ，存在临界宽度 $N_{c} (d)$ 使得：

Phase 1: N < N_{c} : 欠拟合，可学习性差

Phase 2: N > N_{c} : 过拟合风险，但表达能力足够

临界宽度与输入维度 $d$ 的关系为：

N_{c} \sim d^{α}, α \in [1, 2]

2. 泛化相变

对于随机标签数据，泛化误差会经历相变：

N \to \infty lim Gen Error = {0, 1 - 1/ k, 真实标签 k- 分类随机标签

3. 序参量

定义序参量（Order Parameter）刻画相变：

重叠参数： $m = \frac{1}{N} \sum_{i} ⟨ h_{i} ⟩$
响应函数： $χ = \frac{\partial m}{\partial h}$
自旋玻璃序参量： $q = \frac{1}{N} \sum_{i} ⟨ h_{i} ⟩^{2}$

涌现现象的热力学

涌现（Emergence）是深度学习的重要特征，可以用统计物理的语言理解。

设 $h = (h_{1}, \dots, h_{N})$ 为 $N$ 个神经元激活，涌现能力对应序参量的非平凡取值：

m^{*} = f (m^{*}; θ)

其中 $f$ 是自洽方程， $θ$ 是网络参数。

class EmergenceAnalyzer:
    """
    涌现现象分析器
    
    检测和分析神经网络中的涌现行为
    """
    def __init__(self, model):
        self.model = model
        self.activations = {}
        self.hooks = []
    
    def register_hooks(self):
        """注册前向传播钩子"""
        def get_activation(name):
            def hook(module, input, output):
                self.activations[name] = output.detach()
            return hook
        
        for name, module in self.model.named_modules():
            if isinstance(module, (torch.nn.ReLU, torch.nn.GELU)):
                self.hooks.append(module.register_forward_hook(get_activation(name)))
    
    def compute_order_parameter(self, layer_name):
        """
        计算给定层的序参量（平均激活）
        """
        if layer_name not in self.activations:
            return None
        
        activation = self.activations[layer_name]
        
        # 平均激活作为序参量
        m = activation.mean().item()
        
        # 激活方差
        var = activation.var().item()
        
        # 稀疏度（零激活比例）
        sparsity = (activation == 0).float().mean().item()
        
        return {
            'mean_activation': m,
            'variance': var,
            'sparsity': sparsity,
            'effective_dimensionality': 1 / (var / (m**2 + 1e-8) + 1)
        }
    
    def detect_phase_transition(self, dataseries):
        """
        检测数据序列中的相变
        
        使用重整化群方法
        """
        n = len(dataseries)
        
        # 计算不同尺度的序参量
        scales = [2, 4, 8, 16, 32]
        order_params = []
        
        for scale in scales:
            if n < scale:
                continue
            
            # 分块平均
            blocks = []
            for i in range(0, n - n % scale, scale):
                block = dataseries[i:i+scale]
                blocks.append(np.mean(block))
            
            # 计算块间方差
            block_var = np.var(blocks)
            order_params.append(block_var)
        
        return scales[:len(order_params)], order_params
    
    def analyze_emergence_with_scale(self, model, train_loader, 
                                      layer_names=['layer1', 'layer2', 'layer3']):
        """
        分析不同训练阶段的涌现行为
        """
        self.register_hooks()
        
        results = {
            'train_step': [],
            'layer_metrics': {name: [] for name in layer_names}
        }
        
        # 模拟训练过程
        optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
        
        for step, (x, y) in enumerate(train_loader):
            # 前向传播
            output = model(x)
            
            # 记录每个层的序参量
            for name in layer_names:
                metrics = self.compute_order_parameter(name)
                if metrics:
                    results['layer_metrics'][name].append(metrics)
            
            results['train_step'].append(step)
            
            # 反向传播
            loss = F.cross_entropy(output, y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            if step >= 100:
                break
        
        return results

信息瓶颈的热力学解释

信息瓶颈理论回顾

信息瓶颈（Information Bottleneck, IB）方法寻求在压缩与信息保留之间的最优权衡：

p (t ∣ x) min I (X; T) - β I (T; Y)

其中 $T$ 是瓶颈表示。

IB作为热力学过程

IB优化可以解释为自由能最小化：

设 $p (x)$ 为输入分布， $r (t)$ 为瓶颈边缘分布。定义自由能：

F [r] = 内部能量 E_{x \sim p, t \sim r} [lo g r (t) - lo g p (t ∣ x)] + β \cdot 压缩惩罚 I (X; T)

最小化 $F$ 等价于 IB 目标。

最大熵原理与正则化

学习到的表示满足最大熵原则：

H (T) = - E [lo g p (t)] \to max

subject to 保留 $I (T; Y)$ 。

这与统计物理中的最大熵分布一致，如Boltzmann分布。

class InformationBottleneckThermodynamics:
    """
    信息瓶颈的热力学分析
    """
    def __init__(self, model, beta=1.0):
        self.model = model
        self.beta = beta
    
    def estimate_mutual_information(self, x, y, n_samples=1000):
        """
        估计 I(X;Y) 使用 k-NN 估计器
        """
        from sklearn.neighbors import NearestNeighbors
        
        x_np = x.cpu().numpy()
        y_np = y.cpu().numpy()
        
        # 联合分布的 k-NN 距离
        joint = np.concatenate([x_np, y_np.reshape(-1, 1)], axis=1)
        nbrs_joint = NearestNeighbors(n_neighbors=5).fit(joint)
        d_joint = nbrs_joint.kneighbors()[0].mean(axis=1)
        
        # 边缘分布的 k-NN 距离
        nbrs_x = NearestNeighbors(n_neighbors=5).fit(x_np)
        d_x = nbrs_x.kneighbors()[0].mean(axis=1)
        
        # MI 估计
        d = x_np.shape[1]
        I_XY = d * np.log(d_joint / d_x).mean()
        
        return max(0, I_XY)
    
    def compute_thermodynamic_quantities(self, x, t, y):
        """
        计算热力学量
        """
        # 内部能量
        p_t_given_x = self.model(x)  # 简化的表示分布
        
        # 熵 H(T)
        H_T = -torch.mean(torch.log(p_t_given_x + 1e-8))
        
        # 自由能
        F = -self.beta * torch.mean(torch.log(p_t_given_x)) + \
            (1 - self.beta) * torch.mean(torch.log(p_t_given_x))
        
        # 焓
        H = F - self.beta * H_T
        
        return {
            'entropy': H_T.item(),
            'free_energy': F.item(),
            'enthalpy': H.item()
        }

拓扑与几何视角

拓扑数据分析（TDA）

使用持续同调（Persistent Homology）分析损失景观的拓扑：

class TopologicalLossLandscape:
    """
    损失景观的拓扑分析
    """
    def __init__(self, model):
        self.model = model
    
    def compute_persistence_diagram(self, x, y, n_directions=50):
        """
        计算损失景观的持续同调
        
        检测连通分量（0维）和回路（1维）的出现和消失
        """
        # 生成随机方向
        d = x.numel()
        directions = torch.randn(n_directions, d)
        directions = directions / directions.norm(dim=1, keepdim=True)
        
        # 沿每个方向计算损失
        loss_profile = []
        
        for direction in directions:
            losses = []
            alphas = torch.linspace(-1, 1, 20)
            
            for alpha in alphas:
                x_perturbed = x + alpha * direction.view(x.shape)
                with torch.no_grad():
                    output = self.model(x_perturbed)
                    loss = F.cross_entropy(output, y)
                losses.append(loss.item())
            
            loss_profile.append(losses)
        
        # 简化的持续性计算
        persistence_0 = self._compute_connected_components(loss_profile)
        persistence_1 = self._compute_loops(loss_profile)
        
        return {
            'persistence_0': persistence_0,  # 连通分量
            'persistence_1': persistence_1    # 回路
        }
    
    def _compute_connected_components(self, loss_profile):
        """
        计算连通分量的持续性
        """
        # 简化的连通分量计数
        threshold = np.mean(loss_profile) + np.std(loss_profile)
        
        components = []
        for profile in loss_profile:
            n_components = sum(1 for p in profile if p < threshold)
            components.append(n_components)
        
        return np.array(components)
    
    def _compute_loops(self, loss_profile):
        """
        检测回路（高损失区域的孔洞）
        """
        # 简化的回路检测
        # 实际上需要使用Ripser等库
        loops = []
        
        for profile in loss_profile:
            profile_arr = np.array(profile)
            
            # 检测局部最大值
            local_max = 0
            for i in range(1, len(profile_arr) - 1):
                if profile_arr[i] > profile_arr[i-1] and \
                   profile_arr[i] > profile_arr[i+1]:
                    local_max += 1
            
            loops.append(local_max)
        
        return np.array(loops)

曲率与黎曼几何

神经网络的损失景观可以视为黎曼流形，曲率由Hessian特征值刻画：

R_{ijk l} = \partial_{i} \partial_{j} K_{k l} - \partial_{j} \partial_{i} K_{k l}

其中 $K$ 是核函数（如NTK）。

实践应用

温度退火策略

基于统计物理的退火策略：

def simulated_annealing_training(model, train_loader, 
                                 initial_temp=1.0, 
                                 final_temp=0.01,
                                 cooling_rate=0.995):
    """
    模拟退火训练
    
    将"温度"概念用于学习率或噪声的退火
    """
    temperature = initial_temp
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    
    for epoch in range(1000):
        total_loss = 0
        
        for x, y in train_loader:
            # 添加噪声（温度相关）
            x_noisy = x + temperature * torch.randn_like(x)
            
            # 前向传播
            output = model(x_noisy)
            loss = F.cross_entropy(output, y)
            
            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        # 冷却
        temperature *= cooling_rate
        temperature = max(temperature, final_temp)
        
        if epoch % 10 == 0:
            print(f"Epoch {epoch}, Loss: {total_loss:.4f}, Temp: {temperature:.4f}")
    
    return model

自适应温度正则化

class ThermodynamicRegularizer:
    """
    热力学正则化器
    
    基于熵和自由能的启发式正则化
    """
    def __init__(self, target_entropy=None, entropy_weight=0.1):
        self.target_entropy = target_entropy
        self.entropy_weight = entropy_weight
    
    def compute_loss(self, model, x, y, lambda_reg=0.01):
        """
        计算带热力学正则化的损失
        """
        output = model(x)
        ce_loss = F.cross_entropy(output, y)
        
        # 计算激活熵
        probs = F.softmax(output, dim=1)
        entropy = -torch.sum(probs * torch.log(probs + 1e-8), dim=1).mean()
        
        # 熵正则化
        if self.target_entropy is not None:
            entropy_loss = (entropy - self.target_entropy) ** 2
        else:
            entropy_loss = -self.entropy_weight * entropy
        
        return ce_loss + lambda_reg * entropy_loss

数学附录

核心公式速查

概念	公式	说明
能量函数	$E = - \frac{1}{2} \sum_{i, j} W_{ij} s_{i} s_{j}$	Hopfield网络能量
配分函数	$Z = \sum_{i} e^{- E_{i} / T}$	统计配分
自由能	$F = - T lo g Z$	Helmholtz自由能
熵	$S = - \sum_{i} p_{i} lo g p_{i}$	Shannon熵
Boltzmann分布	$p_{i} = e^{- E_{i} / T} / Z$	平衡分布
序参量	$m = \frac{1}{N} \sum_{i} s_{i}$	平均磁化
平坦度	$Flatness (θ^{}) = sup_{∥ δ ∥ \leq ϵ} L (θ^{} + δ)$	极小值平坦度

物理常数类比

物理量	神经网络对应	单位
温度 $T$	学习率 $η$	-
能量 $E$	损失 $L$	-
熵 $S$	表示多样性	nats
自由能 $F$	正则化损失	-
热容 $C$	Hessian谱宽	-

Metaphor

探索

神经热力学与统计物理

概述

从物理系统到神经网络

类比框架

Hopfield网络与Ising模型

现代神经网络的统计物理扩展

能量景观与损失曲面

损失景观的拓扑

能量 Landscape 分析

模式耦合与能量壁垒

相变与涌现

神经网络中的相变

1. 容量相变

2. 泛化相变

3. 序参量

涌现现象的热力学

信息瓶颈的热力学解释

信息瓶颈理论回顾

IB作为热力学过程

最大熵原理与正则化

拓扑与几何视角

拓扑数据分析（TDA）

曲率与黎曼几何

实践应用

温度退火策略

自适应温度正则化

数学附录

核心公式速查

物理常数类比

参考文献

相关主题

关系图谱

目录

反向链接

Metaphor

探索

神经热力学与统计物理

概述

从物理系统到神经网络

类比框架

Hopfield网络与Ising模型

现代神经网络的统计物理扩展

能量景观与损失曲面

损失景观的拓扑

能量 Landscape 分析

模式耦合与能量壁垒

相变与涌现

神经网络中的相变

1. 容量相变

2. 泛化相变

3. 序参量

涌现现象的热力学

信息瓶颈的热力学解释

信息瓶颈理论回顾

IB作为热力学过程

最大熵原理与正则化

拓扑与几何视角

拓扑数据分析（TDA）

曲率与黎曼几何

实践应用

温度退火策略

自适应温度正则化

数学附录

核心公式速查

物理常数类比

参考文献

相关主题

Footnotes

关系图谱

目录

反向链接