回归模型手动拟合与优化算法实战指南

1. 从零开始理解回归模型的手动拟合

在数据科学和机器学习领域，回归分析是最基础也最强大的工具之一。虽然现在有各种现成的库可以一键拟合模型，但真正理解底层优化原理对于解决复杂问题和调试模型至关重要。我见过太多数据分析师只会调用sklearn的fit()方法，当模型表现不佳时完全无从下手。

手动实现回归模型拟合的核心在于优化算法——这是连接数学理论和实际应用的桥梁。不同于黑箱操作，手动拟合能让你对模型行为有完全的控制权，在特征工程、异常值处理和超参数调优等方面获得显著优势。当标准解法失效时（比如遇到非标准损失函数或特殊约束条件），这种能力将成为你的秘密武器。

2. 回归模型与优化算法的本质联系

2.1 回归问题的数学表述

任何回归模型都可以表示为：

ŷ = f(X;θ)

其中ŷ是我们的预测值，X是特征矩阵，θ代表模型参数。以最简单的线性回归为例：

ŷ = θ₀ + θ₁x₁ + θ₂x₂ + ... + θₙxₙ

模型拟合的目标是找到一组θ参数，使得预测值ŷ与实际观测值y之间的差异最小化。这个差异用损失函数L(θ)量化，最常见的是均方误差(MSE)：

L(θ) = 1/m * Σ(y⁽ⁱ⁾ - ŷ⁽ⁱ⁾)²

2.2 优化算法的作用机制

优化算法就是寻找使L(θ)最小化的θ值的过程。想象你站在多山地带，目标是找到海拔最低的谷底。优化算法就是你的导航系统，它告诉你下一步该往哪个方向走，走多远。

关键区别在于：

• 闭式解：像线性回归的正规方程，一步到位但受限多
• 迭代法：逐步逼近最优解，灵活但需调参
• 随机方法：引入随机性避免局部最优，计算成本高

重要提示：没有"最好"的优化算法，只有最适合特定问题和数据特征的算法。选择时需考虑数据规模、特征维度、损失函数性质等因素。

3. 五大经典优化算法实战

3.1 梯度下降法(Gradient Descent)

最基础的优化算法，核心思想是沿着负梯度方向更新参数：

θ := θ - α∇L(θ)

其中α是学习率。Python实现示例：

def gradient_descent(X, y, theta, alpha, iterations): m = len(y) cost_history = [] for _ in range(iterations): y_pred = X.dot(theta) error = y_pred - y gradient = (1/m) * X.T.dot(error) theta -= alpha * gradient cost = (1/(2*m)) * np.sum(error**2) cost_history.append(cost) return theta, cost_history

关键参数选择：

• 学习率α：通常从0.01开始尝试，可用学习率扫描法确定
• 迭代次数：配合早停机制(Early Stopping)使用
• 特征缩放：必须标准化/归一化，否则收敛困难

常见陷阱：

• 学习率过大导致震荡
• 学习率过小收敛缓慢
• 未处理共线性时可能发散

3.2 随机梯度下降(Stochastic GD)

每次迭代随机选择一个样本计算梯度，适合大数据集：

def stochastic_gd(X, y, theta, alpha, epochs): m = len(y) cost_history = [] for _ in range(epochs): for i in range(m): rand_idx = np.random.randint(m) xi = X[rand_idx:rand_idx+1] yi = y[rand_idx:rand_idx+1] y_pred = xi.dot(theta) error = y_pred - yi gradient = xi.T.dot(error) theta -= alpha * gradient cost = (1/(2*m)) * np.sum((X.dot(theta) - y)**2) cost_history.append(cost) return theta, cost_history

优势：

• 内存效率高
• 可在线学习
• 有机会跳出局部最优

劣势：

• 收敛路径不稳定
• 需要精心设计学习率衰减

3.3 小批量梯度下降(Mini-batch GD)

平衡了计算效率和稳定性，是深度学习中的标配：

def mini_batch_gd(X, y, theta, alpha, epochs, batch_size=32): m = len(y) cost_history = [] n_batches = int(m / batch_size) for _ in range(epochs): indices = np.random.permutation(m) X_shuffled = X[indices] y_shuffled = y[indices] for i in range(n_batches): start = i * batch_size end = start + batch_size xi = X_shuffled[start:end] yi = y_shuffled[start:end] y_pred = xi.dot(theta) error = y_pred - yi gradient = (1/batch_size) * xi.T.dot(error) theta -= alpha * gradient cost = (1/(2*m)) * np.sum((X.dot(theta) - y)**2) cost_history.append(cost) return theta, cost_history

批次大小选择：

• 小批量(32-256)：通常最佳
• 大批量：更稳定但易陷局部最优
• 极小批量(1)：即SGD

3.4 动量法(Momentum)

引入速度变量加速收敛并减少震荡：

def momentum_gd(X, y, theta, alpha, beta, iterations): m = len(y) cost_history = [] v = np.zeros(theta.shape) for _ in range(iterations): y_pred = X.dot(theta) error = y_pred - y gradient = (1/m) * X.T.dot(error) v = beta * v + (1 - beta) * gradient theta -= alpha * v cost = (1/(2*m)) * np.sum(error**2) cost_history.append(cost) return theta, cost_history

超参数建议：

• β通常取0.9
• 可尝试Nesterov加速变种
• 学习率可比标准GD大10倍

3.5 Adam优化器

结合动量与自适应学习率的先进方法：

def adam(X, y, theta, alpha, beta1, beta2, eps, iterations): m = len(y) cost_history = [] mt = np.zeros(theta.shape) vt = np.zeros(theta.shape) for t in range(1, iterations+1): y_pred = X.dot(theta) error = y_pred - y gradient = (1/m) * X.T.dot(error) mt = beta1 * mt + (1 - beta1) * gradient vt = beta2 * vt + (1 - beta2) * gradient**2 mt_hat = mt / (1 - beta1**t) vt_hat = vt / (1 - beta2**t) theta -= alpha * mt_hat / (np.sqrt(vt_hat) + eps) cost = (1/(2*m)) * np.sum(error**2) cost_history.append(cost) return theta, cost_history

默认参数：

• α=0.001
• β₁=0.9
• β₂=0.999
• ε=1e-8

4. 高级优化技巧与实战策略

4.1 学习率调度策略

静态学习率常导致次优结果，动态调整策略包括：

• 步长衰减：每k步减半
• 指数衰减：α = α₀ * e^(-kt)
• 余弦退火：周期性变化

# 余弦退火示例 def cosine_annealing(alpha_min, alpha_max, t, T): return alpha_min + 0.5*(alpha_max - alpha_min)*(1 + np.cos(np.pi*t/T)) # 在优化循环中 alpha_t = cosine_annealing(1e-5, 1e-3, epoch, total_epochs)

4.2 特征工程与优化效率

优化效果与特征质量直接相关：

• 去除无关特征：用L1正则化筛选
• 多项式特征：需配合适当的正则化
• 交互特征：注意尺度问题

实战经验：在应用复杂优化算法前，先用简单的特征相关性分析（如Pearson系数）过滤明显无关的特征，可大幅提升优化效率。

4.3 损失函数的选择与定制

不同问题需要不同的损失函数：

• Huber损失：对异常值鲁棒
• Log-Cosh损失：平滑近似MAE
• 分位数损失：预测区间估计

def huber_loss(y_true, y_pred, delta=1.0): error = y_true - y_pred abs_error = np.abs(error) quadratic = np.minimum(abs_error, delta) linear = abs_error - quadratic return 0.5 * quadratic**2 + delta * linear

4.4 正则化技术的实现

防止过拟合的关键技术：

• L2正则化：在损失函数中添加 λ||θ||²
• L1正则化：添加 λ||θ||₁
• 弹性网络：结合L1+L2

# L2正则化梯度计算 gradient = (1/m) * X.T.dot(error) + (lambda_/m) * theta

5. 诊断与调试优化过程

5.1 收敛性分析

通过监控指标判断优化状态：

• 损失曲线：应平稳下降
• 参数变化量：后期应减小
• 梯度范数：趋近于零

# 计算梯度范数 grad_norm = np.linalg.norm(gradient)

5.2 常见问题排查表

5.3 优化算法选择指南

根据问题特点选择算法：

6. 超越传统回归的优化案例

6.1 逻辑回归的优化实现

虽然名为"回归"，实为分类模型，需使用交叉熵损失：

def sigmoid(z): return 1 / (1 + np.exp(-z)) def logistic_gd(X, y, theta, alpha, iterations): m = len(y) cost_history = [] for _ in range(iterations): z = X.dot(theta) h = sigmoid(z) gradient = (1/m) * X.T.dot(h - y) theta -= alpha * gradient cost = (-1/m) * np.sum(y*np.log(h) + (1-y)*np.log(1-h)) cost_history.append(cost) return theta, cost_history

6.2 鲁棒回归实践

当数据存在异常值时，Huber回归表现更优：

def huber_gradient(X, y, theta, delta): error = y - X.dot(theta) mask = np.abs(error) <= delta gradient = np.zeros_like(theta) gradient -= X[mask].T.dot(error[mask]) gradient -= delta * X[~mask].T.dot(np.sign(error[~mask])) return gradient / len(y)

6.3 自定义损失函数案例

假设我们需要对高估和低估施加不同惩罚：

def asymmetric_loss(y_true, y_pred, a=0.5): error = y_true - y_pred return np.where(error > 0, a*error**2, (1-a)*error**2) def asymmetric_gradient(X, y, theta, a): y_pred = X.dot(theta) error = y - y_pred mask = error > 0 gradient = np.zeros_like(theta) gradient -= 2 * a * X[mask].T.dot(error[mask]) gradient -= 2 * (1-a) * X[~mask].T.dot(error[~mask]) return gradient / len(y)

7. 性能优化与加速技巧

7.1 数值计算优化

• 使用向量化操作替代循环
• 利用广播机制减少临时内存
• 选择BLAS加速的线性代数库

# 低效实现 gradient = np.zeros(X.shape[1]) for i in range(X.shape[0]): gradient += X[i] * (y_pred[i] - y[i]) gradient /= m # 高效实现 gradient = X.T.dot(y_pred - y) / m

7.2 并行计算策略

• 数据并行：拆分batch到多个核心
• 参数服务器：分布式更新
• GPU加速：cuBLAS/cuDNN

# 使用joblib并行计算mini-batch from joblib import Parallel, delayed def parallel_mini_batch(X, y, theta, alpha, n_cores=4): batches = np.array_split(X, n_cores), np.array_split(y, n_cores) results = Parallel(n_jobs=n_cores)( delayed(process_batch)(xi, yi, theta.copy()) for xi, yi in zip(*batches) ) gradients = [r[0] for r in results] return np.mean(gradients, axis=0)

7.3 内存优化技巧

对于超大规模数据：

• 使用内存映射文件
• 采用外存算法
• 增量学习

# 使用h5py处理大文件 import h5py with h5py.File('bigdata.h5', 'r') as f: X = f['features'] y = f['target'] for i in range(0, len(y), batch_size): X_batch = X[i:i+batch_size] y_batch = y[i:i+batch_size] # 处理当前batch

8. 工程化实践与生产部署

8.1 模型保存与加载

优化后的模型需要持久化：

import pickle # 保存 with open('optimized_model.pkl', 'wb') as f: pickle.dump({ 'theta': theta, 'feature_mean': X_mean, 'feature_std': X_std }, f) # 加载 with open('optimized_model.pkl', 'rb') as f: model = pickle.load(f)

8.2 生产环境优化

• 量化参数：float64→float32
• 消除分支预测
• 预计算不变部分

# 预计算优化示例 class OptimizedLinearRegression: def __init__(self, theta): self.theta = theta self.bias = theta[0] self.weights = theta[1:] def predict(self, X): return X.dot(self.weights) + self.bias

8.3 监控与再训练

建立持续优化机制：

• 数据漂移检测
• 模型性能监控
• 自动化再训练流程

def detect_drift(new_X, old_mean, old_std, threshold=3): new_mean = np.mean(new_X, axis=0) new_std = np.std(new_X, axis=0) z_score = np.abs((new_mean - old_mean) / old_std) return np.any(z_score > threshold)

9. 前沿优化算法探索

9.1 二阶优化方法

虽然计算成本高，但收敛速度快：

• Newton-Raphson方法
• 拟牛顿法(BFGS/L-BFGS)
• 共轭梯度法

from scipy.optimize import fmin_l_bfgs_b def l_bfgs_optimize(X, y, initial_theta): def loss_and_grad(theta): y_pred = X.dot(theta) error = y_pred - y loss = (1/(2*len(y))) * error.T.dot(error) grad = (1/len(y)) * X.T.dot(error) return loss, grad return fmin_l_bfgs_b(loss_and_grad, initial_theta)

9.2 元启发式算法

适用于非凸、不连续问题：

• 遗传算法
• 粒子群优化
• 模拟退火

# 粒子群优化示例 class Particle: def __init__(self, dim): self.position = np.random.randn(dim) self.velocity = np.zeros(dim) self.best_pos = self.position.copy() self.best_score = float('inf') def pso_optimize(X, y, n_particles=30, max_iter=100): particles = [Particle(X.shape[1]) for _ in range(n_particles)] global_best_pos = np.zeros(X.shape[1]) global_best_score = float('inf') for _ in range(max_iter): for p in particles: y_pred = X.dot(p.position) score = np.mean((y_pred - y)**2) if score < p.best_score: p.best_score = score p.best_pos = p.position.copy() if score < global_best_score: global_best_score = score global_best_pos = p.position.copy() for p in particles: # 更新速度和位置 r1, r2 = np.random.rand(2) p.velocity = (0.5*p.velocity + 2*r1*(p.best_pos - p.position) + 2*r2*(global_best_pos - p.position)) p.position += p.velocity return global_best_pos

9.3 概率优化方法

处理不确定性建模：

• 贝叶斯优化
• 蒙特卡洛方法
• 变分推断

# 贝叶斯优化框架示例 from skopt import gp_minimize def bayesian_optimize(X, y): space = [ (1e-6, 1e-1, 'log-uniform'), # alpha (0.5, 0.99), # beta1 (0.9, 0.9999), # beta2 ] def objective(params): alpha, beta1, beta2 = params theta = np.zeros(X.shape[1]) _, cost_history = adam(X, y, theta, alpha, beta1, beta2, 1e-8, 100) return cost_history[-1] res = gp_minimize(objective, space, n_calls=50, random_state=0) return res.x

10. 从理论到实践的完整案例

10.1 房价预测项目全流程

1. 数据准备
   • 加载波士顿房价数据集
   • 处理缺失值和异常值
   • 特征工程：多项式特征、交互项

from sklearn.datasets import load_boston from sklearn.preprocessing import StandardScaler, PolynomialFeatures boston = load_boston() X, y = boston.data, boston.target # 特征工程 poly = PolynomialFeatures(degree=2, include_bias=False) X_poly = poly.fit_transform(X) X_scaled = StandardScaler().fit_transform(X_poly)

2. 优化算法实现
   • 选择Adam优化器
   • 自定义早停机制
   • 实现k折交叉验证

def kfold_adam(X, y, n_splits=5, epochs=1000, patience=20): kf = KFold(n_splits=n_splits) scores = [] best_theta = None best_score = float('inf') for train_idx, val_idx in kf.split(X): X_train, X_val = X[train_idx], X[val_idx] y_train, y_val = y[train_idx], y[val_idx] theta = np.zeros(X.shape[1]) theta, cost_history = adam(X_train, y_train, theta, 0.01, 0.9, 0.999, 1e-8, epochs) val_score = np.mean((X_val.dot(theta) - y_val)**2) scores.append(val_score) if val_score < best_score: best_score = val_score best_theta = theta.copy() return best_theta, np.mean(scores)

3. 模型评估与调优
   • 分析学习曲线
   • 调整正则化强度
   • 特征重要性分析

def analyze_features(theta, feature_names): importance = np.abs(theta) sorted_idx = np.argsort(importance)[::-1] print("Feature Importance:") for i in sorted_idx: print(f"{feature_names[i]}: {importance[i]:.4f}")

10.2 优化过程可视化技巧

绘制关键指标帮助理解优化行为：

import matplotlib.pyplot as plt def plot_optimization(cost_history, grad_norms): plt.figure(figsize=(12, 4)) plt.subplot(121) plt.plot(cost_history) plt.title('Loss Curve') plt.xlabel('Iteration') plt.ylabel('MSE') plt.subplot(122) plt.plot(grad_norms) plt.title('Gradient Norm') plt.xlabel('Iteration') plt.yscale('log') plt.tight_layout() plt.show()

10.3 完整项目结构建议

专业项目应包含以下模块：

project/ ├── data/ # 原始数据 ├── notebooks/ # 探索性分析 ├── src/ │ ├── preprocessing.py # 特征工程 │ ├── optimizers.py # 优化算法实现 │ └── models.py # 模型定义 ├── configs/ # 超参数配置 └── tests/ # 单元测试

11. 优化算法选择的决策框架

11.1 问题诊断流程图

graph TD A[开始] --> B{数据规模} B -->|小数据(n<1k)| C[使用L-BFGS] B -->|中等数据| D{特征稀疏性?} D -->|是| E[使用FTRL或AdaGrad] D -->|否| F[使用Adam或NAG] B -->|大数据| G[使用SGD变种] G --> H{需要并行?} H -->|是| I[异步SGD] H -->|否| J[带动量的Mini-batch]

11.2 算法特性对比表

11.3 行业应用案例参考

• 金融风控：FTRL算法处理稀疏特征
• 推荐系统：自适应学习率方法
• 医疗影像：带动量的SGD
• 时间序列：Rprop算法

12. 优化算法的数学基础深入

12.1 收敛性证明概要

以梯度下降为例，假设：

• 损失函数L是凸函数
• 梯度∇L是Lipschitz连续
• 学习率α < 2/L

则经过k次迭代后：

L(θₖ) - L(θ*) ≤ (1/2αk)||θ₀ - θ*||²

其中θ*是最优参数。

12.2 学习率理论分析

最优学习率应满足：

α < 2 / L_max

其中L_max是Hessian矩阵的最大特征值。实践中可采用线搜索：

def line_search(X, y, theta, direction, max_alpha=1, c=0.5, tau=0.9): alpha = max_alpha current_loss = compute_loss(X, y, theta) while alpha > 1e-10: new_theta = theta + alpha * direction new_loss = compute_loss(X, y, new_theta) if new_loss < current_loss + c * alpha * direction.T.dot(gradient): return alpha alpha *= tau return alpha

12.3 优化地形可视化

理解损失曲面有助于算法选择：

from mpl_toolkits.mplot3d import Axes3D def plot_loss_surface(X, y, theta1_range, theta2_range): T1, T2 = np.meshgrid(theta1_range, theta2_range) Z = np.zeros_like(T1) for i in range(T1.shape[0]): for j in range(T1.shape[1]): theta = np.array([T1[i,j], T2[i,j]]) Z[i,j] = compute_loss(X, y, theta) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.plot_surface(T1, T2, Z, cmap='viridis') ax.set_xlabel('Theta1') ax.set_ylabel('Theta2') ax.set_zlabel('Loss') plt.show()

13. 分布式优化架构设计

13.1 参数服务器模式

graph TB subgraph Workers W1[计算梯度] W2[计算梯度] W3[计算梯度] end subgraph Server S[参数聚合] end W1 -->|推送梯度| S W2 -->|推送梯度| S W3 -->|推送梯度| S S -->|广播参数| W1 S -->|广播参数| W2 S -->|广播参数| W3

13.2 Ring-AllReduce模式

更适合GPU集群：

1. 将参数分成n块
2. 每个worker负责一块的聚合
3. 通过环形通信传递数据

优势：

• 带宽最优
• 无中心节点瓶颈
• 自动负载均衡

13.3 异步更新策略

• 完全异步：无锁，可能过时
• 延迟补偿：考虑梯度延迟
• 弹性平均：容忍节点差异

# 异步SGD伪代码 def worker(q, param_server): while True: X_batch, y_batch = q.get() grad = compute_gradient(X_batch, y_batch, param_server.get_params()) param_server.apply_gradient(grad)

14. 优化库的内部实现剖析

14.1 TensorFlow优化器核心

class Optimizer: def __init__(self, learning_rate): self._lr = learning_rate def apply_gradients(self, grads_and_vars): for grad, var in grads_and_vars: self._apply_dense(grad, var) def _apply_dense(self, grad, var): raise NotImplementedError class Adam(Optimizer): def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8): super().__init__(lr) self._beta1 = beta1 self._beta2 = beta2 self._epsilon = epsilon self._m = None # 一阶矩估计 self._v = None # 二阶矩估计 self._t = 0 # 时间步 def _apply_dense(self, grad, var): if self._m is None: self._m = np.zeros_like(var) self._v = np.zeros_like(var) self._t += 1 self._m = self._beta1 * self._m + (1 - self._beta1) * grad self._v = self._beta2 * self._v + (1 - self._beta2) * grad**2 m_hat = self._m / (1 - self._beta1**self._t) v_hat = self._v / (1 - self._beta2**self._t) var -= self._lr * m_hat / (np.sqrt(v_hat) + self._epsilon)

14.2 PyTorch优化器设计

PyTorch采用更灵活的设计：

• 参数分组：不同参数不同超参
• 状态字典：保存优化器状态
• 钩子机制：自定义行为

class MyOptimizer(torch.optim.Optimizer): def __init__(self, params, lr=1e-3): defaults = dict(lr=lr) super().__init__(params, defaults) @torch.no_grad() def step(self): for group in self.param_groups: for p in group['params']: if p.grad is None: continue grad = p.grad state = self.state[p] # 初始化状态 if len(state) == 0: state['step'] = 0 state['momentum'] = torch.zeros_like(p) state['step'] += 1 momentum = state['momentum'] # 更新规则 momentum.mul_(0.9).add_(grad, alpha=0.1) p.add_(momentum, alpha=-group['lr'])

14.3 自定义优化器最佳实践

1. 继承基础优化器类
2. 实现核心更新逻辑
3. 维护优化器状态
4. 支持序列化
5. 添加文档字符串

class MyAdam(tf.keras.optimizers.legacy.Optimizer): def __init__(self, learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-7, name="MyAdam"): super().__init__(name=name) self._set_hyper('learning_rate', learning_rate) self._set_hyper('beta_1', beta_1) self._set_hyper('beta_2', beta_2) self.epsilon = epsilon def _create_slots(self, var_list): for var in var_list: self.add_slot(var, 'm') self.add_slot(var, 'v') def _resource_apply_dense(self, grad, var): var_dtype = var.dtype.base_dtype lr_t = self._decayed_lr(var_dtype) beta_1_t = self._get_hyper('beta_1', var_dtype) beta_2_t = self._get_hyper('beta_2', var_dtype) m = self.get_slot(var, 'm') v = self.get_slot(var, 'v') m.assign(beta_1_t * m + (1 - beta_1_t) * grad) v.assign(beta_2_t * v + (1 - beta_2_t) * tf.square(grad)) m_hat = m / (1 - beta_1_t ** (self.iterations + 1)) v_hat = v / (1 - beta_2_t ** (self.iterations + 1)) var.assign_sub(lr_t * m_hat / (tf.sqrt(v_hat) + self.epsilon)) def get_config(self): base_config = super().get_config() return { **base_config, "learning_rate": self._serialize_hyperparameter("learning_rate"), "beta_1": self._serialize_hyperparameter("beta_1"), "beta_2": self._serialize_hyperparameter("beta_2"), "epsilon": self.epsilon, }

15. 优化算法的硬件加速

15.1 GPU优化技巧

• 合并内存访问
• 使用共享内存
• 避免线程发散
• 优化块大小

# CUDA核函数示例 @cuda.jit def sgd_kernel(gradients, params, lr, n): i = cuda.grid(1) if i < n: params[i] -= lr * gradients[i]

15.2 TPU专用优化

• 使用XLA编译
• 向量化操作
• 批处理最大化
• 减少条件分支

# TPU上的JAX实现 import jax import jax.numpy as jnp @jax.jit def tpu_adam(params, grads, m, v, t, lr=0.001, b1=0.9, b2=0.999, eps=1e-8): t += 1 m = b1 * m + (1 - b1) * grads v = b2 * v + (1 - b2) * jnp.square(grads) m_hat = m / (1 - b1**t) v_hat = v / (1 - b2**t) return params - lr * m_hat / (jnp.sqrt(v_hat) + eps), m, v, t

15.3 量化训练技术

• 8位整数训练
• 混合精度训练
• 梯度量化

# 混合精度训练示例 from torch.cuda.amp import autocast, GradScaler scaler = GradScaler() for inputs, targets in data_loader: optimizer.zero_grad() with autocast(): outputs = model(inputs) loss = criterion(outputs, targets) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

16. 优化理论前沿进展

16.1 自适应优化算法新方向

• AdaHessian：二阶自适应方法
• Sophia：曲率感知优化
• Lion：符号动量方法

# Lion优化器简化实现 class Lion: def __init__(self, lr=1e-4, beta1=0.9, beta2=0.99): self.lr = lr self.beta1 = beta1 self.beta2 = beta2 self.m = None def step(self, grad, params): if self.m is None: self.m = np.zeros_like(params) self.m = self.beta1 * self.m + (1 - self.beta1) * grad update = np.sign(self.beta2 * self.m + (1 - self.beta2) * grad) params -= self.l