线性回归中的缩放定律

相关深入内容：

• 隐式正则化 — SGD的隐式L2正则化
• NTK理论 — 核Regime理论
• 缩放定律冗余理论 — 数据冗余视角

概述

线性回归是理解深度学习缩放定律的可解模型（Solvable Model）。通过在无限维线性回归Setup下严格推导泛化误差，可以揭示缩放定律的第一性原理。¹

核心发现

1. 严格泛化界：$R(M,N)=\Theta (M^{-(\beta -1)}+N^{-(\beta -1)/\beta })$
2. SGD隐式正则化：方差项被隐式压制
3. 幂律谱结构：${\lambda }_j\asymp j^{-\beta }$ 是缩放定律的根源

---

1. 问题Setup

1.1 线性模型定义

考虑参数维度为 $M$ 的线性模型：

$\hat{y}=⟨\mathbf{w},\mathbf{x}⟩,\mathbf{w}\in {\mathbb{R}}^M$

给定 $N$ 个训练样本 $({\mathbf{x}}_i,y_i)$，学习目标是：

${\min }_{\mathbf{w}\in {\mathbb{R}}^M}\frac{1}{N}{\sum }_{i=1}^N(y_i-⟨\mathbf{w},{\mathbf{x}}_i⟩{)}^2$

1.2 随机特征映射

为模拟神经网络，将输入通过随机映射 $\varphi :{\mathbb{R}}^d\to {\mathbb{R}}^M$：

$\varphi (\mathbf{x})=\sqrt{\frac{d}{M}}\cdot \sigma (\mathbf{Ux})$

其中 $\mathbf{U}\in {\mathbb{R}}^{d\times M}$ 元素独立同分布 $\mathcal{N}(0,1)$，$\sigma$ 是非线性激活函数。

输出模型：

$f(\mathbf{x};\mathbf{w})=⟨\mathbf{w},\varphi (\mathbf{x})⟩$

1.3 数据生成模型

设真实函数为：

$y_i=⟨{\mathbf{w}}^{\ast },\varphi ({\mathbf{x}}_i)⟩+{ϵ}_i$

其中 ${ϵ}_i\sim \mathcal{N}(0,{\sigma }^2)$ 是噪声。

---

2. 谱结构与幂律

2.1 协方差矩阵的谱

定义协方差矩阵：

$\Sigma =\mathbb{E}[\varphi (\mathbf{x})\varphi (\mathbf{x}{)}^T]\in {\mathbb{R}}^{M\times M}$

核心假设（幂律谱）：

${\lambda }_j(\Sigma )\asymp j^{-\beta },j=1,2,\dots$

其中 $\beta >1$ 是谱指数。

2.2 谱指数的物理意义

$\beta$ 范围	谱衰减速度	冗余程度	示例
$1<\beta \le 2$	慢	高冗余	高度相关数据
$\beta =2$	中等	中等	典型机器学习数据
$\beta >2$	快	低冗余	独立特征数据

2.3 谱的数值实现

import numpy as np
 
def generate_power_law_covariance(
    M: int,
    beta: float,
    base_variance: float = 1.0
) -> np.ndarray:
    """
    生成幂律谱的协方差矩阵
    
    参数:
    - M: 维度
    - beta: 谱指数
    - base_variance: 基础方差
    
    返回:
    - Sigma: M x M 协方差矩阵
    """
    # 生成特征值（幂律衰减）
    j = np.arange(1, M + 1)
    eigenvalues = base_variance * j ** (-beta)
    
    # 生成随机正交基
    U = np.linalg.qr(np.random.randn(M, M))[0]
    
    # 构造协方差矩阵
    Sigma = U @ np.diag(eigenvalues) @ U.T
    
    return Sigma
 
def verify_spectrum(
    Sigma: np.ndarray,
    expected_beta: float,
    fit_range: tuple = (10, 1000)
) -> dict:
    """
    验证协方差矩阵的谱是否符合幂律
    """
    eigenvalues = np.linalg.eigvalsh(Sigma)
    eigenvalues = np.sort(eigenvalues)[::-1]
    
    # 拟合谱指数
    j = np.arange(1, len(eigenvalues) + 1)
    fit_j = j[fit_range[0]:fit_range[1]]
    fit_lambda = eigenvalues[fit_range[0]:fit_range[1]]
    
    log_j = np.log(fit_j)
    log_lambda = np.log(fit_lambda)
    
    fitted_beta = -np.polyfit(log_j, log_lambda, 1)[0]
    
    return {
        'expected_beta': expected_beta,
        'fitted_beta': fitted_beta,
        'relative_error': abs(fitted_beta - expected_beta) / expected_beta
    }

---

3. 核心理论结果

3.1 泛化误差的严格界

定理1（线性回归缩放定律）¹：

设数据协方差谱满足 ${\lambda }_j\asymp j^{-\beta }$，真实权重 ${\mathbf{w}}^{\ast }$ 服从高斯先验 $\mathcal{N}(0,{\mathbf{I}}_M)$，则单次随机梯度下降（SGD）的泛化误差满足：

$\mathbb{E}[R(\hat{\mathbf{w}})]=\Theta \left(M^{-(\beta -1)}+N^{-\frac{\beta -1}{\beta }}\right)$

3.2 结果解读

泛化误差 R(M, N)
    │
    │                    ╱  M^(-(β-1))
    │                 ╱
    │              ╱      ↗ N^(-(β-1)/β)
    │           ╱      ↗
    │        ╱       ↗
    │     ╱        ↗
    │  ╱         ↗
    └──────────────────────────────────→ M 或 N
    
    两项主导：取决于M和N的相对大小

3.3 两种Regime

Regime	条件	主导项	缩放指数
参数主导	$M\ll N^{\frac{1}{\beta }}$	$M^{-(\beta -1)}$	$\beta -1$
数据主导	$M\gg N^{\frac{1}{\beta }}$	$N^{-\frac{\beta -1}{\beta }}$	$(\beta -1)/\beta$

---

4. SGD的隐式正则化效应

4.1 问题背景

直觉上，增加参数 $M$ 应增加过拟合风险（方差增大）。然而理论结果表明，方差项被SGD的隐式正则化压制。

4.2 形式分析

泛化误差的标准分解：

$R(\hat{\mathbf{w}})=\underset{{\text{Bias}}^2}{\underbrace{\Vert P_{{\mathbf{w}}^{\ast }}(\hat{\mathbf{w}})-{\mathbf{w}}^{\ast }{\Vert }^2}}+\underset{\text{Variance}}{\underbrace{\text{Var}(\hat{\mathbf{w}})}}$

关键观察：

• 偏差项：随 $M$ 增大而减小（更多参数 → 更好拟合真实结构）
• 方差项：由于SGD的隐式正则化，不随 $M$ 线性增长

4.3 隐式正则化的数学刻画

定理2（隐式正则化）¹：

SGD对线性模型产生等效的正则化项：

${\hat{\mathbf{w}}}_{SGD}\approx \arg {\min }_{\mathbf{w}}\Vert \mathbf{y}-\Phi \mathbf{w}{\Vert }^2+{\lambda }_{eff}(M,N)\Vert \mathbf{w}{\Vert }^2$

其中有效正则化系数：

${\lambda }_{eff}\asymp \frac{M}{N}$

关键洞察：$M$ 增加同时导致：

1. 表达能力增强（有利）
2. 有效正则化减弱（不利）

两者平衡导致净缩放收益为 $M^{-(\beta -1)}$ 而非直觉的 $M^{-1}$。

4.4 代码实现

import numpy as np
 
class ImplicitRegularizationAnalysis:
    """
    分析SGD隐式正则化效应
    """
    
    def __init__(self, M: int, N: int, beta: float):
        self.M = M
        self.N = N
        self.beta = beta
    
    def compute_effective_regularization(self) -> float:
        """
        计算有效正则化系数
        """
        # 理论值
        lambda_eff = self.M / self.N
        return lambda_eff
    
    def predict_generalization_error(self) -> dict:
        """
        预测泛化误差
        """
        # 参数主导项
        bias_term = self.M ** (-(self.beta - 1))
        
        # 数据主导项  
        data_term = self.N ** (-(self.beta - 1) / self.beta)
        
        # 总误差
        total_error = bias_term + data_term
        
        return {
            'bias_term': bias_term,
            'data_term': data_term,
            'total_error': total_error,
            'dominant_regime': 'parameter' if self.M < self.N ** (1/self.beta) else 'data'
        }
    
    def verify_implicit_reg(self, n_trials: int = 100) -> dict:
        """
        通过模拟验证隐式正则化效应
        """
        errors = []
        
        for _ in range(n_trials):
            # 生成合成数据
            Sigma = generate_power_law_covariance(self.M, self.beta)
            X = np.random.multivariate_normal(np.zeros(self.M), Sigma, self.N)
            w_star = np.random.randn(self.M)
            y = X @ w_star + 0.1 * np.random.randn(self.N)
            
            # SGD训练
            w_hat = self._sgd_train(X, y, lr=0.01, epochs=100)
            
            # 测试误差
            X_test = np.random.multivariate_normal(np.zeros(self.M), Sigma, 1000)
            y_test = X_test @ w_star
            test_error = np.mean((X_test @ w_hat - y_test) ** 2)
            errors.append(test_error)
        
        return {
            'mean_error': np.mean(errors),
            'std_error': np.std(errors),
            'theoretical_prediction': self.predict_generalization_error()['total_error']
        }
    
    def _sgd_train(self, X, y, lr, epochs):
        """简化的SGD训练"""
        w = np.zeros(X.shape[1])
        for _ in range(epochs):
            idx = np.random.randint(len(y))
            w += lr * (y[idx] - X[idx] @ w) * X[idx]
        return w

---

5. 与神经网络缩放定律的联系

5.1 从线性到非线性

线性回归的缩放定律为神经网络提供理论基础：

量	线性回归	神经网络
参数量 $M$	权重维度	参数量 $N$
样本量 $N$	训练样本	训练token $D$
谱指数 $\beta$	数据谱	等效谱
泛化界	$M^{-(\beta -1)}+N^{-(\beta -1)/\beta }$	类似结构

5.2 关键类比

神经网络泛化误差的形式：

$R_{NN}\approx \Theta (N^{-{\alpha }_N}+D^{-{\alpha }_D})$

其中 ${\alpha }_N,{\alpha }_D$ 与数据的等效谱结构相关。

5.3 验证类比

def verify_neural_network_analogy(
    nn_loss_curves: dict,
    linear_model_predictions: dict
) -> dict:
    """
    验证线性模型对神经网络的类比预测
    """
    
    results = {}
    for model_name, curve in nn_loss_curves.items():
        # 提取关键点
        large_N_loss = curve['large_params']
        large_D_loss = curve['large_data']
        
        # 线性模型预测
        pred = linear_model_predictions[model_name]
        
        # 比较
        results[model_name] = {
            'nn_loss': large_N_loss,
            'linear_prediction': pred,
            'match': abs(large_N_loss - pred) / pred < 0.2
        }
    
    overall_match = all(r['match'] for r in results.values())
    
    return {
        'per_model_results': results,
        'analogy_valid': overall_match,
        'confidence': 'high' if overall_match else 'medium'
    }

---

6. 谱指数的估计方法

6.1 从学习曲线估计

def estimate_spectrum_beta_from_curves(
    param_losses: dict,  # {M: [loss at different N]}
    N_fixed: int = None
) -> dict:
    """
    从学习曲线估计谱指数 β
    
    通过固定 N，只变化 M，观察 loss ~ M^(-(β-1))
    """
    
    if N_fixed is None:
        # 使用所有数据点
        M_values = np.array(list(param_losses.keys()))
        losses = np.array([np.min(losses) for losses in param_losses.values()])
    else:
        # 固定 N
        M_values = np.array(list(param_losses.keys()))
        losses = np.array([losses[N_fixed] for losses in param_losses.values()])
    
    # 拟合：loss ~ M^(-(β-1)) => log(loss) ~ -(β-1) * log(M)
    log_M = np.log(M_values)
    log_loss = np.log(losses)
    
    slope = np.polyfit(log_M, log_loss, 1)[0]
    estimated_beta = 1 - slope
    
    return {
        'estimated_beta': estimated_beta,
        'r_squared': compute_r_squared(log_M, log_loss, slope),
        'interpretation': interpret_beta(estimated_beta)
    }
 
def interpret_beta(beta: float) -> str:
    """解释谱指数的含义"""
    if beta < 1.5:
        return "高冗余数据（特征高度相关）"
    elif beta < 2.5:
        return "中等冗余数据（典型机器学习场景）"
    else:
        return "低冗余数据（特征相对独立）"

6.2 直接估计方法

def direct_spectrum_estimation(
    data_matrix: np.ndarray,  # N x d 数据矩阵
    method: str = 'covariance'
) -> dict:
    """
    直接估计数据谱指数
    """
    
    if method == 'covariance':
        # 方法1：协方差矩阵特征值
        cov = np.cov(data_matrix.T)
        eigenvalues = np.linalg.eigvalsh(cov)
        eigenvalues = np.sort(eigenvalues)[::-1]
    
    elif method == 'gram':
        # 方法2：Gram矩阵特征值（可能更稳定）
        gram = data_matrix @ data_matrix.T
        eigenvalues = np.linalg.eigvalsh(gram)
        eigenvalues = np.sort(eigenvalues)[::-1]
    
    # 拟合谱指数
    j = np.arange(1, len(eigenvalues) + 1)
    fit_range = slice(len(eigenvalues)//4, len(eigenvalues)//2)  # 中间区域更稳定
    log_j = np.log(j[fit_range])
    log_lambda = np.log(eigenvalues[fit_range] + 1e-10)
    
    beta = -np.polyfit(log_j, log_lambda, 1)[0]
    
    return {
        'beta': beta,
        'top_eigenvalues': eigenvalues[:10],
        'effective_rank': compute_effective_rank(eigenvalues)
    }
 
def compute_effective_rank(eigenvalues: np.ndarray) -> float:
    """计算有效秩"""
    total = np.sum(eigenvalues)
    probs = eigenvalues / total
    return np.exp(-np.sum(probs * np.log(probs + 1e-10)))

---

7. 扩展：高斯先验之外的推广

7.1 稀疏先验

若真实权重 ${\mathbf{w}}^{\ast }$ 是 $s$-稀疏 的：

$\Vert {\mathbf{w}}^{\ast }{\Vert }_0=s$

定理3（稀疏先验下的缩放）：

$R\asymp \frac{s}{M^{\beta -1}}+N^{-\frac{\beta -1}{\beta }}$

洞察：稀疏性改善缩放指数。

7.2 低秩先验

若真实权重位于 $r$ 维子空间：

定理4（低秩先验下的缩放）：

$R\asymp \frac{r}{M^{\beta -1}}+N^{-\frac{\beta -1}{\beta }}$

7.3 分层先验

def hierarchical_prior_scaling(
    M: int,
    N: int,
    beta: float,
    hierarchy_depth: int = 3,
    hierarchy_sparsity: list = None
) -> dict:
    """
    分层先验下的缩放分析
    """
    
    if hierarchy_sparsity is None:
        hierarchy_sparsity = [0.1, 0.3, 0.5][:hierarchy_depth]
    
    # 估计有效稀疏度
    effective_sparsity = 1
    for s in hierarchy_sparsity:
        effective_sparsity *= s
    
    # 分层先验改善缩放
    improvement_factor = 1 / effective_sparsity
    
    return {
        'base_error': M**(-(beta-1)) + N**(-(beta-1)/beta),
        'hierarchical_error': (effective_sparsity * M)**(-(beta-1)) + N**(-(beta-1)/beta),
        'improvement': improvement_factor,
        'interpretation': '分层先验可显著改善稀疏区域的缩放'
    }

---

8. 实践应用

8.1 资源分配决策

def optimal_resource_allocation(
    total_compute: float,
    estimated_beta: float,
    task_type: str = 'standard'
) -> dict:
    """
    基于线性回归理论的最优资源分配
    
    假设每个样本训练需要 ~2M FLOPs（一次前向+反向）
    """
    
    compute_per_sample = 2 * total_compute
    
    # 遍历不同的 M-N 组合
    best_config = None
    best_error = float('inf')
    
    M_range = np.logspace(4, 9, 100)
    
    for M in M_range:
        N = compute_per_sample / (2 * M)  # 约束: 2*M*N = total_compute
        
        # 计算理论误差
        bias_term = M ** (-(estimated_beta - 1))
        data_term = N ** (-(estimated_beta - 1) / estimated_beta)
        error = bias_term + data_term
        
        if error < best_error:
            best_error = error
            best_config = {
                'M': M,
                'N': N,
                'error': error
            }
    
    return {
        'optimal_M': best_config['M'],
        'optimal_N': best_config['N'],
        'expected_error': best_config['error'],
        'compute_utilization': '100%'
    }

8.2 何时增加参数的判断

def should_increase_parameters(
    current_M: int,
    current_N: int,
    estimated_beta: float,
    target_improvement: float = 0.1
) -> dict:
    """
    判断是否应该增加参数
    """
    
    # 当前误差
    current_error = current_M**(-(estimated_beta-1)) + current_N**(-(estimated_beta-1)/estimated_beta)
    
    # 增加参数后的误差（假设N不变）
    new_M = current_M * 2
    new_error_double_M = new_M**(-(estimated_beta-1)) + current_N**(-(estimated_beta-1)/estimated_beta)
    
    # 判断
    improvement = (current_error - new_error_double_M) / current_error
    
    return {
        'current_error': current_error,
        'error_after_doubling_M': new_error_double_M,
        'expected_improvement': improvement,
        'should_increase': improvement > target_improvement,
        'recommendation': '增加参数' if improvement > target_improvement else '考虑增加数据'
    }

---

9. 与深度学习的对应关系

9.1 映射表

线性回归	神经网络
参数量 $M$	模型参数 $N$
样本量 $N$	训练token $D$
谱指数 $\beta$	等效谱指数
特征值 ${\lambda }_j$	频率功率谱
SGD噪声	梯度噪声
隐式正则化	隐式L2正则化

9.2 理论验证

def validate_linear_to_nn_mapping(
    nn_experiments: list,
    linear_predictions: list
) -> dict:
    """
    验证线性模型理论对神经网络的预测能力
    """
    
    results = []
    for nn_exp, lin_pred in zip(nn_experiments, linear_predictions):
        ratio = nn_exp['test_loss'] / lin_pred['predicted_loss']
        results.append(ratio)
    
    mean_ratio = np.mean(results)
    std_ratio = np.std(results)
    
    return {
        'mean_ratio': mean_ratio,
        'std_ratio': std_ratio,
        'theory_accurate': 0.8 < mean_ratio < 1.2,
        'interpretation': f'理论预测{'准确' if 0.8 < mean_ratio < 1.2 else '存在偏差'}'
    }

---

10. 参考

Footnotes

1. Zhang, Y., et al. (2024). Scaling Laws in Linear Regression: Compute, Parameters, and Data. NeurIPS 2024. https://proceedings.neurips.cc/paper_files/v4/079017-1937 ↩ ↩² ↩³