快手推荐算法

一、实习项目介绍

BN的可学习参数？作用？

BN 主要用于在训练时对输入进行标准化，以减少内部协变量偏移（Internal Covariate Shift）。Batch Normalization（BN）的可学习参数主要包括两类：

• 缩放参数$\gamma$：用于对归一化后的值进行线性缩放，形状与输入的通道数一致（通常是一个向量）。
• 平移参数$\beta$：用于对归一化后的值进行平移，形状与输入的通道数一致（通常是一个向量）。
• 公式
  KaTeX parse error: Undefined control sequence: \ at position 75: …epsilon}} \\ \̲ ̲ \\ 重新缩放和平移（可学…
  • $\gamma$（scale）和 $\beta$（shift）是 BN 层的可学习参数
  • $ϵ$ 是一个很小的数值如 $10^{-5}$，用于防止除零错误

一、Wide&Deep、WideFM、DeepFM三者的区别，这一系列模型是为了解决什么问题。

Wide&Deep、WideFM、DeepFM 以及后续的各种推荐模型，都是为了解决推荐系统中的 特征交互建模 和 泛化能力 之间的权衡问题

• Wide&Deep
  Google 2016 年提出 Wide & Deep 模型，希望在模型中 同时考虑低阶特征组合（Wide）和高阶特征组合（Deep）
  • Wide部分：通过人工特征工程和交叉特征（如 $f(x)=w_1{x}_1+w_2{x}_2+w_3{x}_1{x}_2$）来捕捉 历史规则 和 特定的组合特征。
  • Deep部分：通过嵌入（Embedding）+ 多层神经网络（MLP）自动学习 复杂的特征交互关系。
  • 最终输出： Wide 和 Deep 的输出结果做 加权求和，形成最终的预测。
• WideFM
  FM（Factorization Machine）本身就是一个可以自动学习低阶特征交互的模型，因此 WideFM 直接用 FM 取代 Wide，让低阶特征交互自动学习，而不是人工构造。但仍然是两个子模型独立学习特征交互
• DeepFM
  DeepFM 进一步优化：让 FM 和 DNN 共享同一个特征嵌入，避免信息割裂。

模型对比总结

二、DeepFM 之后的发展

2.1. xDeepFM（2018）的介绍

xDeepFM（eXtreme Deep Factorization Machine） 是在 DeepFM 之后提出的一种推荐系统模型，主要用于 自动学习高阶特征交互，弥补 FM 只能建模二阶交互的缺陷。
xDeepFM 在 DeepFM 的基础上增加了 CIN（Compressed Interaction Network） 结构，用于 显式建模高阶特征交互。整个模型包含三个部分：CIN、DNN、Linear。最终，CIN、DNN 和 Linear 部分的输出做加权求和，得到最终的预测结果。

• CIN（Compressed Interaction Network）
  核心思想： 直接计算显式的高阶特征交互。
  计算公式：$X_{h+1}=f(X_h,X_0)$
  伪代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F

class CIN(nn.Module):
    def __init__(self, field_size, embedding_dim, hidden_layers):
        """
        CIN 模块
        :param field_size: 特征数量 N
        :param embedding_dim: 每个特征的 embedding 维度 k
        :param hidden_layers: CIN 隐藏层的神经元数（每层的交互特征数量）
        """
        super(CIN, self).__init__()
        self.field_size = field_size  # 特征数量
        self.embedding_dim = embedding_dim  # 每个特征的 embedding 维度
        self.hidden_layers = hidden_layers  # CIN 的层数

        # 定义 CIN 各层的权重
        self.cin_layers = nn.ModuleList()
        for i, layer_size in enumerate(hidden_layers):
            self.cin_layers.append(nn.Linear(self.field_size * hidden_layers[i-1] if i > 0 else self.field_size * self.field_size,layer_size, bias=False))

    def forward(self, X_emb):
        """
        :param X_emb: 输入的 embedding, 形状为 (batch_size, N, k)
        :return: CIN 输出
        """
        batch_size = X_emb.shape[0]
        X_0 = X_emb  # 原始 embedding
        X_h = X_0  # 第一层输入 X_h
        result_list = []
        for layer in self.cin_layers:
            # 计算特征交互 (batch_size, N, k) → (batch_size, k, N)
            X_h_T = X_h.transpose(1, 2)  # 转置为 (batch_size, k, N)
            X_interaction = torch.matmul(X_0, X_h_T)  # (batch_size, N, N)
            # 变换成 (batch_size, N*N)
            X_interaction_flat = X_interaction.view(batch_size, -1)
            # 通过 CIN 层
            X_h = layer(X_interaction_flat)
            X_h = F.relu(X_h)
            result_list.append(X_h)  # 记录每一层输出
        # 将所有 CIN 层的输出拼接
        X_cin_out = torch.cat(result_list, dim=1)  # (batch_size, sum(hidden_layers))
        return X_cin_out

2.2. AutoInt（2019）

AutoInt（Automatic Feature Interaction Learning via Self-Attentive Neural Networks）是 2019 年提出的一种用于特征交互建模的深度学习模型。其核心思想是用自注意力（Self-Attention）机制自动学习特征交互，避免手工构造高阶特征，同时比 DNN 更高效、更具可解释性。

2.3. DCN（Deep & Cross Network）

DCN（Deep & Cross Network）是一种用于特征交互建模的深度学习模型。结合 显式特征交叉（Cross Network, CN） 和 深度神经网络（Deep Network, DNN），同时学习高阶特征组合和深度特征表示。
Cross Network的公式如下：
$$x_{h+1}=x_0.(w_h.x_h)+b_h+x_h$$
Cross Network伪代码如下：

class CrossLayer(nn.Module):
    """定义单个交叉层"""
    def __init__(self, input_dim):
        super(CrossLayer, self).__init__()
        self.weight = nn.Parameter(torch.randn(input_dim))
        self.bias = nn.Parameter(torch.zeros(1))
    def forward(self, x0, xl):
        return x0 * (xl @ self.weight.unsqueeze(-1)) + self.bias + xl

三、算法题1-二叉树的直径

二叉树的直径就是最长节点链长度减一。采用深度优先搜索。

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        def depth(node):
            if not node:                      # 访问到空节点了，返回0
                return 0
            L = depth(node.left)              # 左儿子为根的子树的深度
            R = depth(node.right)             # 右儿子为根的子树的深度
            self.ans = max(self.ans, L + R + 1)      # 计算d_node即L+R+1 并更新ans
            return max(L, R) + 1                     # 返回该节点为根的子树的深度
        depth(root)
        return self.ans - 1