Algorithms on 二三事

Mixture of Experts 的数学原理（~2026 文献综述）

Tue, 12 May 2026 13:23:57 +0000

引言

在第一篇文章 MLP 与 BP 算法的数学原理中，我们简单地推导并实践了神经网络的基础——BP 算法。

在第二篇文章经典注意力与经典 Transformer 的数学原理中，我们梳理了从 RNN & BPTT、Seq2Seq、注意力机制再到经典 Transformer 的时间线，并详细地在其底层数学原理的层次上进行了推导与分析。

本文将在前两篇文章的基础上，借助多篇或经典或前沿的文献梳理 MoE（Mixture of Experts，混合专家模型）的基础理论。如果说，BP 算法使得我们能够构造可训练的前馈神经网络，注意力与 Transformer 使得我们拥有了一种强大的序列模型范式，那么 MoE 就是 Transformer 从「小模型」真正迈向「大模型」的关键一招。

Dense Scaling 的瓶颈

在大模型领域，有一条被称为 Scaling Law（缩放定律，参见 2020 年 Kaplan 等人的研究 Scaling Laws for Neural Language Models）的经验定律：模型性能（例如训练损失）随投入资源（例如参数量）的增加而平滑提升，且遵循幂律关系。这是在众多大型实验室的实践中得出的经验总结。

$$ Loss(C) \approx \left( \frac{C_{\text{min}}}{C} \right)^{\alpha} \tag{1} $$

其中 $C$ 表示训练计算量（FLOPs），$\alpha$ 为缩放指数（通常取值 $0.05\sim0.1$），$C_{\text{min}}$ 则为一个常数。Scaling Law 表明，要提升模型的性能，一个可行的方案就是提高模型的参数规模。但同时 Scaling Law 也为我们估计了一个残酷的代价：要使损失降低 $n$ 倍，需要付出 $n^{\frac1{\alpha}}$ 倍的计算开销。即，参数规模的边际收益是递减的，但我们又不得不面对这个现实。

经典注意力与经典 Transformer 的数学原理

Sun, 22 Mar 2026 22:55:00 +0000

* 本文的部分示意图使用了 AI 辅助创作，其余有明确标注的示意图则引用自参考文献。

若无特别说明，本文中的单个向量默认视为列向量。比如，在 RNN、BPTT 与 Bahdanau Attention 部分，$\boldsymbol{x}_t,\boldsymbol{h}_t,\boldsymbol{s}_t,\boldsymbol{a}_t$ 等单个向量都按列向量书写。

而在 attention 与 Transformer 章节的矩阵记号中，为便于书写整段序列的矩阵乘法，序列矩阵统一按行堆叠：若第 $i$ 个 token 的表示向量为列向量 $\boldsymbol{x}_i$，则矩阵 $\boldsymbol{X}$ 的第 $i$ 行为 $\boldsymbol{x}_i^T$。相应地，$\boldsymbol{Q},\boldsymbol{K},\boldsymbol{V}$ 的第 $i$ 行分别记为 $\boldsymbol{q}_i^T,\boldsymbol{k}_i^T,\boldsymbol{v}_i^T$。

Token 指模型处理数据的最小单位。在 CV（Computer Vision，计算机视觉）中常指图像切分后的 patch，在音频中指离散化的特征片段，而在 NLP（Natural Language Processing，自然语言处理）中则是指文本分词（字、词或子词）。本文后续所指的 token 均可以被理解为 NLP 范畴下的文本单元，token embedding 则是通过嵌入层将 token ID 映射至连续向量空间中的稠密语义表示。

RNN

背景引入

在前文 MLP 与 BP 算法的数学原理中，我们从数学上推导了普通 FFN（Feed-Forward Network，前馈神经网络）的误差反向传播算法，并最终编码实现了一个能够训练并完成分类任务的 MLP。

MLP（Multi-Layer Perceptron，多层感知机）是最经典、最基础的一种前馈神经网络，它只接受固定维度的张量 $\boldsymbol{x}$，并在经过内部若干层全连接层的非线性变换 $f(\boldsymbol{x})=\varphi(\boldsymbol{Wx}+\boldsymbol{b})$ 后，最终输出固定维度的张量 $\boldsymbol{y}$。对于能够确定输入与输出张量维度的任务，例如图像识别、缺陷检测等，输入输出张量维度固定是能够接受的。但是，对于序列数据，特别是那些具有强时间相关性的序列数据，譬如股票指数的时间序列、自然语言等，MLP 便显得力不从心了，主要体现在：

输入维度固定，意味着无法处理可变长序列；
固定维度与无记忆性的假设，使得模型更难捕捉到序列元素间的依赖关系。

一个简单的改进就是 RNN（Recurrent Neural Network，循环神经网络）。RNN 是一种基本的序列模型，下面介绍 RNN，并做简要的数学推导。

MLP 与 BP 算法的数学原理

Sun, 08 Dec 2024 06:10:23 +0000

关于自动微分机制的数学证明放在文末，首先给出自动微分的程序实现。因为是我笔算进行推导的，可能存在谬误。

Python version: 3.12.4
numpy version: 1.26.4
sklearn version: 1.3.0

计算图定义

计算图（computational graph）是一种被用于pytorch与tensorflow中进行自动微分以实现误差的反向传播、进而计算各参数梯度的技术，这使得我们可以方便地使用梯度更新神经网络的参数。其中，pytorch使用动态计算图设计，tensorflow使用静态计算图设计。

我们的实现中，计算图与自动微分系统被“嵌入”在了层的定义。pytorch在源码中定义了计算图基类，通过重载运算符等方法实现计算图的生成。

import numpy as np
from sklearn.datasets import make_moons


class Linear:
 def __init__(self, inputFeatures, outputFeatures, bias=True):
 self.weights = np.random.rand(inputFeatures, outputFeatures)
 self.bias = np.random.rand(outputFeatures)
 
 def __call__(self, x):
 self.input = x
 self.output = x @ self.weights
 if self.bias is not False:
 self.output += self.bias
 return self.output
 
 def paramenters(self):
 if self.bias is not False:
 return [self.output, self.bias]
 return [self.output]
 
 def backward(self, grad_output, learning_rate):
 grad_input = grad_output @ self.weights.T
 grad_weights = self.input.T @ grad_output
 grad_bias = np.sum(grad_output, axis=0) if self.bias is not None else None
 
 self.weights -= learning_rate * grad_weights
 if self.bias is not None:
 self.bias -= learning_rate * grad_bias

 return grad_input


class Sigmoid:
 def __call__(self, x):
 self.output = 1 / (1 + np.exp(-x))
 return self.output

 def backward(self, grad_output, learning_rate):
 grad_input = grad_output * self.output * (1 - self.output)
 return grad_input


class Softmax:
 def __call__(self, x):
 self.output = np.exp(x - np.max(x, axis=1, keepdims=True))
 self.output /= np.sum(self.output, axis=1, keepdims=True)
 return self.output

 # def backward(self, grad_output, learning_rate):
 # grad_input = grad_output.copy()
 # batch_size = grad_output.shape[0]

 # for i in range(batch_size):
 # y = self.output[i][:, None]
 # jacobian = np.diag(y) - np.outer(y, y)
 # grad_input[i] = jacobian @ grad_output[i]

 # return grad_input


class Sequential:
 def __init__(self, layers):
 self.layers = layers
 
 def __call__(self, x):
 for layer in self.layers:
 x = layer(x)
 self.output = x
 return self.output
 
 def predict_proba(self, x):
 logits = self(x)
 e_x = np.exp(logits - np.max(logits))
 return e_x / e_x.sum(axis=0, keepdims=True)
 
 def paramenters(self):
 return [p for layer in self.layers for p in layer.paramenters()]

基于计算图的MLP定义

class MLP:
 def __init__(self):
 self.model = Sequential([
 Linear(2, 4), Sigmoid(),
 Linear(4, 4), Sigmoid(),
 Linear(4, 2)
 ])
 self.softmax = Softmax()
 
 def __call__(self, x):
 return self.model(x)

 def forward(self, x):
 return self.model(x)

 def backwardAndGradientDescent(self, x, y, learning_rate):
 '''
 x: input darta vector, like [[0.5, -1.2], [0.7, 0.3], [-0.2, 0.8]]
 y: labels vector, like [0, 1, 0]
 '''
 batch_size = x.shape[0]
 logits = self.forward(x)

 grad_output = logits.copy()
 grad_output[range(batch_size), y] -= 1 # cross entropy gradient
 grad_output /= batch_size

 for layer in reversed(self.model.layers):
 grad_output = layer.backward(grad_output, learning_rate)
 
 def probability(self, x):
 '''
 x: input darta vector, like [[0.5, -1.2], [0.7, 0.3], [-0.2, 0.8]]
 return: probability vector, like [[0.88, 0.12], [0.45, 0.55], [0.31, 0.69]]
 '''
 batch_size = x.shape[0]
 logits = self.forward(x)
 return self.softmax(logits)

 def classify(self, x):
 return np.argmax(self.probability(x), axis=1)

训练过程

X, y = make_moons(n_samples=1000, noise=0.1)
batch_size= 50
max_steps = 50000
learning_rate = 0.05
mlp = MLP()
lossRecord = []

for step in range(max_steps):
 indices = np.arange(X.shape[0])
 np.random.shuffle(indices)
 X, y = X[indices], y[indices]

 for i in range(0, X.shape[0], batch_size):
 X_batch = X[i:i+batch_size]
 y_batch = y[i:i+batch_size]
 mlp.backwardAndGradientDescent(X_batch, y_batch, learning_rate)

 if step % 10000 == 0:
 output_batch = mlp.forward(X_batch)
 epsilon = 1e-12
 loss = -np.mean(np.log(output_batch[range(batch_size), y_batch] + epsilon))
 lossRecord.append(loss)
 print(f"Step {step}, Loss: {loss}")

打印：