搜广推校招面经一百零四

虾皮推荐算法一面

一、看你简历中写到了DeepFM，讲一下FM怎么实现的

FM 的核心思想就是用向量内积来学习特征之间的 二阶交互（如性别 × 购买记录）

FM通过以下公式优化交叉项的计算：
$$\sum _{i=1}^n\sum _{j=i+1}^n⟨v_i,v_j⟩x_i{x}_j=\frac{1}{2}\left({\left(\sum _{i=1}^n{v}_i{x}_i\right)}^2-\sum _{i=1}^n(v_i{x}_i{)}^2\right)$$
这种优化将计算复杂度从 $O(n^2)$ 降低到 $O(n)$，极大地提高了计算效率。

import torch
import torch.nn as nn
class FM(nn.Module):
    def __init__(self, field_dims, embed_dim=8):
        """
        参数：
        - field_dims: List[int]，每个类别特征的取值范围大小。
        - embed_dim: int，嵌入向量维度。
        """
        super().__init__()
        self.num_fields = len(field_dims)
        self.embed_dim = embed_dim
        self.offsets = nn.Parameter(
            torch.tensor([0] + field_dims[:-1]).cumsum(dim=0), requires_grad=False
        )
        total_dim = int(sum(field_dims))
        
        # 一阶权重
        self.linear_weight = nn.Embedding(total_dim, 1)
        self.bias = nn.Parameter(torch.zeros(1))
        
        # 嵌入向量
        self.embedding = nn.Embedding(total_dim, embed_dim)

    def forward(self, x_cat):
        # x_cat: [B, F]
        x = x_cat + self.offsets  # 对齐到大 embedding 空间
        # 一阶项
        linear_part = self.linear_weight(x).sum(dim=1) + self.bias  # [B,1]
        # 二阶项
        v = self.embedding(x)  # [B,F,E]
        sum_of_emb = v.sum(dim=1)  # [B,E]
        square_of_sum = sum_of_emb * sum_of_emb
        sum_of_square = (v * v).sum(dim=1)
        data = v * v
        second_order = 0.5 * (square_of_sum - sum_of_square).sum(dim=1, keepdim=True)
        return linear_part + second_order  # [B,1]


if __name__ == "__main__":
    field_dims = [1000, 500, 100]
    model = FM(field_dims, embed_dim=8)
    # batch 输入
    x_cat = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.long)
    logit = model(x_cat)
    prob = torch.sigmoid(logit)
    print("Logits:", logit)
    print("Pred prob:", prob)

二、介绍一下常用的优化器。

神经网络的优化器（Optimizer）是用于更新模型参数（如权重和偏差）的算法，核心目标是最小化损失函数：

2.1 基础的优化器

• 随机梯度下降（SGD, Stochastic Gradient Descent）
  • 公式：$$\theta =\theta -\eta \cdot \nabla L(\theta )$$
    • $\eta$：学习率
    • $\nabla L(\theta )$：损失函数 𝐿(𝜃) 对参数 𝜃 的梯度

2.2 带动量的优化算法

• 动量梯度下降（Momentum SGD）
  • 公式：$$\begin{gathered} v_t=\beta v_{t-1}+(1-\beta )\nabla L(\theta ) \\ \theta =\theta -\eta v_t \end{gathered}$$
  • 通过指数加权平均（EMA）的方法，缓解震荡问题；
  • 在陡峭方向收敛更快，在平坦方向减小震荡
• Nesterov 动量（NAG, Nesterov Accelerated Gradient）
  • 公式$$\begin{gathered} v_t=\beta v_{t-1}+(1-\beta )\nabla L(\theta -\eta v_{t-1}) \\ \theta =\theta -\eta v_t \end{gathered}$$
  • 计算梯度时使用“提前一步”的权重，收敛更快
  • 比普通 Momentum 具有更好的泛化能力

2.3 自适应学习率优化算法

• Adagrad（Adaptive Gradient）

  • 公式：$$\begin{gathered} G_t=G_{t-1}+\nabla L(\theta )\odot \nabla L(\theta ) \\ \theta =\theta -\frac{\eta }{\sqrt{G_t}+ϵ}\nabla L(\theta ) \end{gathered}$$
  • 特点
    • 自适应调整不同参数的学习率
    • 主要问题是随着时间推移，学习率不断减小，最终趋近于 0

• RMSprop（Root Mean Square Propagation）

  • 公式：
    $$\begin{gathered} G_t=\beta G_{t-1}+(1-\beta )\nabla L(\theta )\odot \nabla L(\theta ) \\ \theta =\theta -\frac{\eta }{\sqrt{G_t}+ϵ}\nabla L(\theta ) \end{gathered}$$
  • 特点
    • 解决了 Adagrad 学习率衰减过快的问题
    • 适用于时序任务

• Adam（Adaptive Moment Estimation）
  $$\begin{gathered} m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)\nabla L(\theta ) \\ {v}_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)\nabla L(\theta )\odot \nabla L(\theta ) \\ \widehat{m_t}=\frac{m_t}{1-{\beta }_1^t},\widehat{v_t}=\frac{v_t}{1-{\beta }_2^t} \\ \theta =\theta -\frac{\eta }{\sqrt{\widehat{v_t}}+ϵ}\widehat{m_t} \end{gathered}$$

• AdamW（Weight Decay Adam）

  • 公式：
    $$\theta =\theta -\eta \left(\frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+ϵ}+\lambda \theta \right)$$
  • 特点：
    • AdamW 在 Adam 的基础上增加了 权重衰减（Weight Decay）

3.4. 其他优化算法

• AdaDelta
  进一步改进 RMSprop，使学习率自适应变化
  $$\Delta {\theta }_t=-\frac{\sqrt{\Delta {\theta }_{t-1}^2+ϵ}}{\sqrt{G_t+ϵ}}\nabla L(\theta )$$
• Nadam（Nesterov-accelerated Adam）
  结合 Adam 和 NAG 的优化方法：
  $$\begin{gathered} m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)\nabla L(\theta ) \\ \widehat{m_t}=\frac{m_t}{1-{\beta }_1^t} \\ \theta =\theta -\eta \left(\frac{{\beta }_1\widehat{m_t}+(1-{\beta }_1)\nabla L(\theta )}{\sqrt{\widehat{v_t}}+ϵ}\right) \end{gathered}$$
• Lion（EvoLved Sign Momentum）
  $$\begin{gathered} m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)\nabla L(\theta ) \\ \theta =\theta -\eta (\text{sign}(m_t)+\lambda \theta ) \end{gathered}$$

三、谈到对回归任务做多分桶，是如何实现的

为每个样本根据分桶规则（等频、等距）打上分桶标签，输出分类结果和回归结果

3.1. 后处理校正（最常用），强行约束结果

3.2. 用分类结果指导回归

$$y_{\text{final}}=\sum _{c}p(c)\cdot \text{center}(c)+\Delta y_{\text{reg}}$$

• $p(c)$ ：分类预测的概率
• $\text{center}(c)$ ：桶 $c$ 的中心值
• $\Delta y_{\text{reg}}$ ：回归分支的修正项

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.preprocessing import KBinsDiscretizer
from sklearn.model_selection import train_test_split
import numpy as np

# ===== 1. 造数据 =====
np.random.seed(42)
X = np.random.rand(500, 5)
y = 10 * X[:, 0] + 5 * X[:, 1]**2 + np.random.randn(500)

# ===== 2. 分桶 =====
n_bins = 5
discretizer = KBinsDiscretizer(n_bins=n_bins, encode="ordinal", strategy="quantile")
y_class = discretizer.fit_transform(y.reshape(-1, 1)).astype(int).ravel()

# train/test
X_train, X_test, y_class_train, y_class_test, y_reg_train, y_reg_test = train_test_split(
    X, y_class, y, test_size=0.2, random_state=42
)

# 转 tensor
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test  = torch.tensor(X_test, dtype=torch.float32)
y_class_train = torch.tensor(y_class_train, dtype=torch.long)
y_class_test  = torch.tensor(y_class_test, dtype=torch.long)
y_reg_train   = torch.tensor(y_reg_train, dtype=torch.float32).view(-1,1)
y_reg_test    = torch.tensor(y_reg_test, dtype=torch.float32).view(-1,1)

# ===== 3. 定义 MLP 模型 =====
class MultiTaskMLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, n_classes):
        super().__init__()
        # 共享层
        self.shared = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU()
        )
        # 分类头
        self.class_head = nn.Linear(hidden_dim, n_classes)
        # 回归头
        self.reg_head = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        h = self.shared(x)
        class_out = self.class_head(h)   # logits
        reg_out = self.reg_head(h)       # continuous
        return class_out, reg_out

# ===== 4. 初始化模型 =====
model = MultiTaskMLP(input_dim=5, hidden_dim=64, n_classes=n_bins)
criterion_cls = nn.CrossEntropyLoss()
criterion_reg = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# ===== 5. 训练 =====
epochs = 100
for epoch in range(epochs):
    model.train()
    optimizer.zero_grad()
    out_cls, out_reg = model(X_train)
    loss_cls = criterion_cls(out_cls, y_class_train)
    loss_reg = criterion_reg(out_reg, y_reg_train)
    loss = loss_cls + loss_reg  # 联合loss

    loss.backward()
    optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f"Epoch {epoch+1}/{epochs}, Loss={loss.item():.4f}, "
              f"Cls={loss_cls.item():.4f}, Reg={loss_reg.item():.4f}")

# ===== 6. 评估 =====
model.eval()
with torch.no_grad():
    pred_cls, pred_reg = model(X_test)
    acc = (pred_cls.argmax(1) == y_class_test).float().mean().item()
    mse = criterion_reg(pred_reg, y_reg_test).item()

print("桶分类准确率:", acc)
print("连续值预测 MSE:", mse)

3.3. 给回归头的loss添加约束项（）

def consistency_loss(pred_reg, pred_cls, bin_edges):
    pred_bucket = torch.argmax(pred_cls, dim=1)
    bin_edges = torch.tensor(bin_edges, dtype=torch.float32, device=pred_reg.device)
    low = bin_edges[pred_bucket]
    high = bin_edges[pred_bucket + 1]
    y_val = pred_reg.squeeze(1)
    # relu : max(0,x)
    penalty = torch.relu(low - y_val) + torch.relu(y_val - high)  
    return penalty.mean()

# ===== 5. 训练 =====
bin_edges = discretizer.bin_edges_[0]  # 取第 0 个特征的 bin_edges
print(bin_edges)
epochs = 100
for epoch in range(epochs):
    model.train()
    optimizer.zero_grad()
    out_cls, out_reg = model(X_train)
    loss_cls = criterion_cls(out_cls, y_class_train)
    loss_reg = criterion_reg(out_reg, y_reg_train)
    loss_cons = consistency_loss(out_reg, out_cls, bin_edges) # 约束项
    loss = loss_cls + loss_reg + loss_cons
    
    loss.backward()
    optimizer.step()

    if (epoch+1) % 10 == 0:
        print(f"Epoch {epoch+1}/{epochs}, Loss={loss.item():.4f}, "
              f"Cls={loss_cls.item():.4f}, Reg={loss_reg.item():.4f}")

# ===== 6. 评估 =====
model.eval()
with torch.no_grad():
    pred_cls, pred_reg = model(X_test)
    acc = (pred_cls.argmax(1) == y_class_test).float().mean().item()
    mse = criterion_reg(pred_reg, y_reg_test).item()

print("桶分类准确率:", acc)
print("连续值预测 MSE:", mse)

四、除了梯度下降，还有哪些参数求解算法？

在机器学习和深度学习中，除了梯度下降（Gradient Descent）之外，还有多种用于参数求解的算法，具体如下：

4.1. 用牛顿法和梯度下降法求解 sqrt(x)

见【搜广推校招面经八十】