搜广推校招面经六十二

一、MMoE（Multi-gate Mixture-of-Experts）和 MoE（Mixture of Experts）结构详解

1.1. MoE（Mixture of Experts）结构

MoE（专家混合）是一种 多专家（Multiple Experts） 结构，通过多个子模型（专家，Expert） 处理输入数据，并由一个 门控网络（Gate Network） 计算不同专家的权重进行组合。它能够提高模型的表达能力，并且在多任务学习（Multi-Task Learning, MTL）和大规模神经网络训练中广泛应用。

1.1.1. 结构

MoE 主要包含两个核心组件：

多个专家（Experts）：通常是多个 MLP（Multi-Layer Perceptron）或者 Transformer 结构，每个专家对输入数据进行不同的特征变换。
门控网络（Gating Network）：计算每个专家的权重，决定输入数据由哪些专家处理，并进行加权融合。

1.1.2. 具体缺点

多个任务共用一个gate，gate可能会让少数专家权重过高，而其他专家几乎不参与训练（梯度消失）。

1.2. MMoE（Multi-gate Mixture-of-Experts）结构

MMoE（Multi-gate Mixture-of-Experts，多门专家混合）是 MoE 在 多任务学习（Multi-Task Learning, MTL） 场景下的改进版本。相较于标准 MoE，它 为每个任务设计独立的门控网络，允许不同任务对专家分配不同权重，以提升任务间共享能力。

1.2.1. 具体细节

二、GBDT 内部如何选择特征

GBDT（Gradient Boosting Decision Tree，梯度提升决策树）在构建决策树时，通过最小化损失函数来选择最优的特征和分裂点。其特征选择过程如下：

2.1. 计算每个特征的分裂增益（Split Gain）

GBDT 在构建决策树的每个节点时，需要选择一个特征进行分裂。它会计算所有候选特征的 分裂增益（信息增益、均方误差减少量等），然后选择增益最大的特征进行分裂。

分裂增益的计算公式如下：
Gain = L parent − ( L left + L right ) \text{Gain} = L_{\text{parent}} - (L_{\text{left}} + L_{\text{right}}) Gain=Lparent−(Lleft+Lright)

其中：

L parent L_{\text{parent}} Lparent 是当前节点的损失
L left L_{\text{left}} Lleft 和 L right L_{\text{right}} Lright 是分裂后两个子节点的损失
增益越大（子节点的损失小于父节点），表示该特征的分裂能更好地减少损失

具体计算方法：

回归任务（均方误差，MSE）
Gain = ( G left 2 / H left ) + ( G right 2 / H right ) − ( G parent 2 / H parent ) 2 − λ \text{Gain} = \frac{(G_{\text{left}}^2 / H_{\text{left}}) + (G_{\text{right}}^2 / H_{\text{right}}) - (G_{\text{parent}}^2 / H_{\text{parent}})}{2} - \lambda Gain=2(Gleft2/Hleft)+(Gright2/Hright)−(Gparent2/Hparent)−λ
分类任务（交叉熵）
- 计算当前节点的基尼指数（Gini impurity）或信息增益
- 选择减少最大的信息熵的特征

其中：

G G G是梯度值（残差）
H H H 是二阶导数（Hessian，用于近似损失曲率）
λ \lambda λ 是正则化项，防止过拟合

2.2. GBDT 中的特征分裂方式

在 GBDT（Gradient Boosting Decision Tree）中，特征分裂的方式主要取决于特征类型。一般分为 数值型特征 和 类别型特征，对应不同的分裂策略。

2.2.1. 数值型特征的分裂方式

数值型特征（如年龄、收入、温度等）通常可以进行二元分裂，即：

选择一个分裂点 x s x_s xs，将数据集划分为：
- 左子节点： x ≤ x s x \leq x_s x≤xs
- 右子节点： x > x s x > x_s x>xs

(1) 遍历所有可能的分裂点

计算所有可能的分裂点（特征值的中点）
计算每个分裂点的增益
选择增益最大的分裂点

(2) 采用直方图加速法（Histogram-based Splitting）

先对特征值进行离散化，分桶（binning）
计算每个桶的统计信息（梯度和二阶梯度）
选择最优的分裂点（LightGBM、XGBoost 中采用）

2.2.2. 类别型特征的分裂方式

类别型特征（如性别、城市、产品类型）不能直接进行数值比较，需要特殊处理。

(1) One-Hot 编码后再进行二元分裂

对类别变量进行 One-Hot 编码
将每个类别视为一个独立的二元变量，以类似于数值特征的方式进行分裂
问题：
如果类别种类过多，会导致维度爆炸

(2) 目标编码（Target Encoding）

计算每个类别对应的目标变量均值
用均值替换类别变量，使其变为数值特征
再按数值特征方式分裂
问题：
容易发生数据泄露（需要使用交叉验证策略）

(3) 最优排序分裂（Optimal Categorical Split）

计算所有类别的梯度和二阶梯度
通过动态规划或贪心算法找到最优的类别组合
使得分裂后的增益最大

LightGBM 默认支持类别特征的最优排序分裂

三、接着上个问题继续问：连续特征的信息熵计算

在决策树和 GBDT 处理中，我们可以使用 信息熵（Entropy） 来衡量特征的分裂效果。对于连续特征，信息熵的计算步骤如下：

3.1. 信息熵的定义

信息熵（Entropy） 用于衡量数据的不确定性，定义如下：
H ( X ) = − ∑ i p i log ⁡ 2 p i H(X) = -\sum_{i} p_i \log_2 p_i H(X)=−i∑pilog2pi

其中：

p i p_i pi 是类别 i i i 的概率，即该类别样本数占总样本数的比例。

信息熵越大，表示数据的混乱程度越高；信息熵越小，表示数据越纯净。

3.2. 计算连续特征的信息熵

对于一个连续特征，我们不能直接计算信息熵，而是需要 找到一个最优的分裂点，然后计算分裂后的信息熵。

(1) 选择分裂点

设连续特征 ( X ) 的取值如下：
X = [ 10 , 12 , 14 , 50 , 52 , 54 ] X = [10, 12, 14, 50, 52, 54] X=[10,12,14,50,52,54]

类别标签 ( Y ) 为：
Y = [ A , A , A , B , B , B ] Y = [A, A, A, B, B, B] Y=[A,A,A,B,B,B]

可能的分裂点（取相邻数值的均值）：
s 1 = 10 + 12 2 = 11 , s 2 = 12 + 14 2 = 13 , s 3 = 14 + 50 2 = 32 , ... s_1 = \frac{10+12}{2} = 11, \quad s_2 = \frac{12+14}{2} = 13, \quad s_3 = \frac{14+50}{2} = 32, \quad \dots s1=210+12=11,s2=212+14=13,s3=214+50=32,...

(2) 计算分裂前的信息熵

计算原始数据的信息熵：

类别 A 的概率：( p_A = 3/6 = 0.5 )
类别 B 的概率：( p_B = 3/6 = 0.5 )

信息熵：
H ( X ) = − ( 0.5 log ⁡ 2 0.5 + 0.5 log ⁡ 2 0.5 ) = 1 H(X) = - (0.5 \log_2 0.5 + 0.5 \log_2 0.5) = 1 H(X)=−(0.5log20.5+0.5log20.5)=1

(3) 计算分裂后的信息熵

对于某个分裂点 ( s )：

左子集 ： X ≤ s X \leq s X≤s
右子集 ： X > s X > s X>s

假设选择 ( s = 32 )，那么：

左子集：( X = [10, 12, 14] )，类别 A 100%，熵 = 0
右子集：( X = [50, 52, 54] )，类别 B 100%，熵 = 0

分裂后加权信息熵：
H split = 3 6 × 0 + 3 6 × 0 = 0 H_{\text{split}} = \frac{3}{6} \times 0 + \frac{3}{6} \times 0 = 0 Hsplit=63×0+63×0=0

(4) 计算信息增益

信息增益定义为：
Gain = H ( X ) − H split \text{Gain} = H(X) - H_{\text{split}} Gain=H(X)−Hsplit

对于 ( s = 32 )：
Gain = 1 − 0 = 1 \text{Gain} = 1 - 0 = 1 Gain=1−0=1

如果换一个分裂点，信息增益可能会不同，我们选择增益最大的分裂点作为最优分裂点。

3.3. 结论

连续特征不能直接计算信息熵，而是需要通过分裂点进行计算。
遍历所有可能的分裂点，计算分裂后的信息熵。
选择信息增益最大的分裂点作为最优分裂点。
在 GBDT、决策树中，常用信息增益或增益比（Gain Ratio）来选择特征和分裂点。

四、树分裂的公式讲一下

在决策树（如CART）中，分裂是通过选择一个特征及其对应的分裂点来最大化信息增益或最小化损失（如均方误差）。我们通常使用基尼指数 （Gini impurity）、信息增益 或均方误差来评估每个分裂点的优劣。

4.1. 基尼指数（Gini Impurity）

基尼指数用于衡量数据集的纯度。对于一个节点 t t t，基尼指数的计算公式为：
G ( t ) = 1 − ∑ k = 1 K p k 2 G(t) = 1 - \sum_{k=1}^{K} p_k^2 G(t)=1−k=1∑Kpk2

其中：

p k p_k pk 是当前节点中类别 k k k 的比例。
K K K 是类别的总数。

分裂标准：我们选择分裂后基尼指数最小的特征和分裂点。

节点纯度的变化 ：假设我们将数据集 ( D ) 按某个特征分成了两个子集 ( D_L ) 和 ( D_R )（分别是左子树和右子树），那么分裂后的基尼指数是这两个子集基尼指数的加权平均：
G split = ∣ D L ∣ ∣ D ∣ G ( D L ) + ∣ D R ∣ ∣ D ∣ G ( D R ) G_{\text{split}} = \frac{|D_L|}{|D|} G(D_L) + \frac{|D_R|}{|D|} G(D_R) Gsplit=∣D∣∣DL∣G(DL)+∣D∣∣DR∣G(DR)

选择基尼指数最小的分裂点。

4.2. 信息增益（Entropy and Information Gain）

信息增益衡量的是分裂前后信息的不确定性减少量。在决策树中，我们使用信息增益来选择最佳分裂点。首先，计算节点 t t t 的信息熵 （Entropy）：
H ( t ) = − ∑ k = 1 K p k log ⁡ 2 p k H(t) = - \sum_{k=1}^{K} p_k \log_2 p_k H(t)=−k=1∑Kpklog2pk

其中：

p k p_k pk 是当前节点中类别 k k k 的比例。
K K K 是类别的总数。

信息增益公式：假设我们将数据集 ( D ) 按某个特征分成了两个子集 ( D_L ) 和 ( D_R )，信息增益计算公式为：

IG ( D , split ) = H ( D ) − ( ∣ D L ∣ ∣ D ∣ H ( D L ) + ∣ D R ∣ ∣ D ∣ H ( D R ) ) \text{IG}(D, \text{split}) = H(D) - \left( \frac{|D_L|}{|D|} H(D_L) + \frac{|D_R|}{|D|} H(D_R) \right) IG(D,split)=H(D)−(∣D∣∣DL∣H(DL)+∣D∣∣DR∣H(DR))

选择最优分裂：选择信息增益最大的特征和分裂点。

4.3. 均方误差（MSE）- 回归树

对于回归问题，常用均方误差（MSE）来度量分裂后的数据集的纯度。均方误差的计算公式为：

MSE ( t ) = 1 ∣ t ∣ ∑ i = 1 ∣ t ∣ ( y i − y ^ t ) 2 \text{MSE}(t) = \frac{1}{|t|} \sum_{i=1}^{|t|} (y_i - \hat{y}_t)^2 MSE(t)=∣t∣1i=1∑∣t∣(yi−y^t)2

基尼指数：用于分类问题，衡量类别纯度，选择基尼指数最小的分裂点。
信息增益：用于分类问题，衡量分裂后信息的不确定性减少量，选择信息增益最大的分裂点。
均方误差（MSE）：用于回归问题，选择能够最小化误差的分裂点。

分裂的关键是根据目标函数（基尼指数、信息增益或均方误差等）来选择最优的特征和分裂点，从而有效地降低预测误差。

4.4 GBDT（Gradient Boosting Decision Tree）的最小单元是回归树

最重要的是：GBDT（Gradient Boosting Decision Tree）的最小单元是回归树，尽管它可以用于分类任务。在 GBDT 中，每棵树本质上是一个回归树，即它通过拟合数据的残差（即预测值和真实值之间的差异）来更新模型。

五、72. 编辑距离（力扣hot100_多维动态规划）

思路：动态规划
之前也有遇到考过这个题，感觉回溯类型的题套路都差不多，就是不好写对
代码：

python 复制代码

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        n, m = len(word1), len(word2)
        @cache
        def dfs(i, j):  # 两个字符从后往前需要的操纵
            if i<0:
                return j+1
            if j<0:
                return i+1
            if word1[i] == word2[j]:
                return dfs(i-1, j-1)
            return min(dfs(i-1, j), dfs(i, j-1), dfs(i-1, j-1)) + 1
        return dfs(n-1, m-1)