0
0

ODMN亿级用户的用户生命周期价值预测：来自快手的工业级解决方案

摘要

用户生命周期价值（LTV）是指单个用户可以为企业带来的预期总收入。LTV在各种业务场景中广泛用于在获取新用户时做出运营决策。由于其数据分布的复杂性和可变性，建模LTV是一个具有挑战性的问题。现有的方法要么直接从后验特征分布中学习，要么利用对先验分布做出强假设的统计模型，这两者都无法捕捉到那些可变的分布。在本文中，我们提出了一整套工业级的LTV建模解决方案。具体来说，我们引入了一个订单依赖单调网络（ODMN），该网络建模了不同时间跨度LTV之间的有序依赖关系，从而大大提高了模型性能。我们进一步引入了基于分而治之思想的多分布多专家（MDME）模块，将严重不平衡的分布建模问题转化为一系列相对平衡的子分布建模问题，从而大大降低了建模复杂性。此外，我们引入了一种新的评估指标——互基尼系数（Mutual Gini），基于洛伦兹曲线更好地衡量估计值与真实标签之间的分布差异。ODMN框架已成功部署在快手的多个业务场景中，并取得了优异的性能。对真实工业数据的广泛实验表明，所提出的方法相比于最先进的基线模型（包括ZILN和两阶段XGBoost模型）具有显著优势。

1 引言

用户生命周期价值（LTV）是指公司在用户整个生命周期内从所有互动中获得的经济收益总和。随着现代经济的发展，公司越来越重视与客户建立和维持长期关系。在这种情况下，基于客户生命周期价值做出运营决策变得尤为重要。例如，市场营销人员需要准确预测客户未来较长时间内的总消费收入，从几个月到多年不等，以便进行合理的财务预算规划和客户关系管理（CRM）指导。此外，对于许多公司的增长运营和广告业务，还需要预测用户对平台的长期贡献，以计算投资回报率（ROI），从而指导最佳投放渠道的选择或根据质量进行竞价。

在过去的几年中，关于LTV建模的大量学术文献被发表，其中大多数可以分为两类。第一类方法利用历史经验或经典概率和统计模型 [1, 9, 12]。另一类是通过机器学习或深度学习直接建模LTV [2, 4, 14]。

尽管现有方法大大提高了LTV预测的性能，但仍然有两个主要挑战需要解决。首先，它们没有考虑如何更有效地处理LTV的复杂分布以获得更好的收益。传统方法基于均方误差（MSE）来衡量损失，但平方项对大值非常敏感。在基于随机梯度下降的训练算法中，容易生成大的梯度向量，影响模型的收敛性和稳定性。

图 1 展示了我们数据集中 LTV 的分布，说明了高价值用户的稀疏性和非典型的长尾问题。特别是，该分布具有一个上扬的尾部。

图1显示了快手增长业务的LTV分布，其中LTV定义为每个用户通过电子商务、广告和其他渠道在未来对快手的总收入贡献。这是一种非典型的长尾分布，使用上述方法难以很好地拟合。其次，它们还忽略了不同时间跨度LTV之间的有序依赖关系。在许多业务场景中，除了建模长期用户价值外，我们还关注短期用户价值以便及时调整运营决策，即我们需要建模多时间跨度的用户价值。例如， 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​、 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​、 
  43.  
  44.   
  45.    
  46.    
  47.      l 
  48.     
  49.    
  50.      t 
  51.     
  52.     
  53.     
  54.       v 
  55.      
  56.     
  57.       180 
  58.      
  59.     
  60.    
  61.   
  62.     ltv_{180} 
  63.    
  64.   
  65. ltv180​和 
  66.  
  67.   
  68.    
  69.    
  70.      l 
  71.     
  72.    
  73.      t 
  74.     
  75.     
  76.     
  77.       v 
  78.      
  79.     
  80.       365 
  81.      
  82.     
  83.    
  84.   
  85.     ltv_{365} 
  86.    
  87.   
  88. ltv365​分别代表用户在下一个月、季度、半年和一年内对平台的贡献值。有两点需要注意：

（1）从业务角度来看，不同时间跨度的LTV存在有序依赖关系，即 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.      ≤ 
  16.     
  17.    
  18.      l 
  19.     
  20.    
  21.      t 
  22.     
  23.     
  24.     
  25.       v 
  26.      
  27.     
  28.       90 
  29.      
  30.     
  31.    
  32.      ≤ 
  33.     
  34.    
  35.      l 
  36.     
  37.    
  38.      t 
  39.     
  40.     
  41.     
  42.       v 
  43.      
  44.     
  45.       180 
  46.      
  47.     
  48.    
  49.      ≤ 
  50.     
  51.    
  52.      l 
  53.     
  54.    
  55.      t 
  56.     
  57.     
  58.     
  59.       v 
  60.      
  61.     
  62.       365 
  63.      
  64.     
  65.    
  66.   
  67.     ltv_{30} \le ltv_{90} \le ltv_{180} \le ltv_{365} 
  68.    
  69.   
  70. ltv30​≤ltv90​≤ltv180​≤ltv365​。

（2）从建模难度来看，时间跨度越长，LTV的建模难度越大。显然， 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​预计比 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       365 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{365} 
  40.    
  41.   
  42. ltv365​更准确。

传统解决方案要么分别建模不同时间跨度的LTV，这代价高昂，要么通过多任务学习。然而，它们忽略了不同时间跨度LTV任务之间的有序依赖关系。一个典型的坏案例是模型估计的 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​可能大于 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​，这不符合业务预期。为了解决这个问题，我们提出了订单依赖单调网络（ODMN）框架，该框架显式建模了不同时间跨度LTV任务之间的有序依赖关系，并通过更易建模的短期LTV任务辅助学习更困难和复杂的长期LTV任务，从而大大提高了模型性能。此外，对于每个特定的LTV预测任务，我们提出了基于分而治之思想的多分布多专家（MDME）模块。通过分布分割和子分布分桶机制，将严重不平衡的分布建模问题转化为一系列更平衡的子分布建模问题，从而大大减轻了建模难度并增强了LTV预测的性能。

本文继续沿着使用机器学习方法，特别是深度学习模型来建模LTV的思路进行探索。总结起来，本文的主要贡献有四点：

  • 我们提出了一种新颖且有效的架构，称为订单依赖单调网络（ODMN），该架构主动捕捉不同时间跨度LTV之间的有序依赖关系，以增强预测性能。
  • 我们设计了一个名为多分布多专家（MDME）的模块，基于分而治之的思想，从粗粒度到细粒度处理LTV的复杂和不平衡分布，降低建模难度并提高性能。
  • 基于洛伦兹曲线提出了互基尼系数（Mutual Gini），首次定量衡量模型拟合不平衡标签分布的能力。
  • 本文中的方法具有很强的可扩展性，已部署到公司的在线业务中。离线实验和在线A/B测试均表明了我们方法的有效性。

2 相关工作

2.1 用户生命周期价值 (LTV) 预测

现有的 LTV 预测方法主要分为两大类。第一类是基于历史数据或经典概率统计模型的方法。RFM 框架 [6] 根据用户历史消费的最近一次消费时间、消费频率和消费金额对用户进行分组，以粗略计算用户购买或消费某物品的时间或频率。其基本假设是，消费频率较高的用户，如果最近消费相对较高，则在不久的将来更有可能再次消费。BTYD [16] 系列是一个非常经典的用户重复购买/流失的概率模型，假设用户的流失和购买行为都遵循某种随机过程，其中最著名的解决方案之一是 Pareto/NBD [6] 模型，常用于非契约性、连续消费场景（即用户可以随时购买）。该方法将建模两个参数分布，Pareto 分布用于二分类，预测用户是否仍然活跃，而负二项分布用于估计购买频率。这些方法大多是对用户消费习惯的粗粒度建模，如是否购买、购买频率等，未能提供对用户在长期内对平台贡献金额的细粒度建模。

第二类是通过机器学习或深度学习直接建模 LTV。早期方法更多依赖于手工制作的特征和树结构模型。最近，深度学习技术也应用于 LTV 预测。[4] 是一个两阶段的 XGBoost 模型，首先识别高质量用户，然后预测其 LTV。[14] 首先将用户分成若干组，并在每组内进行随机森林预测。ZILN [18] 假设 LTV 服从对数正态分布，利用 DNN 在特征交互和信息捕获方面的优势来拟合分布的均值和标准差，最终以对数正态分布的期望值作为 LTV 的估计值，但分布假设过于严格，导致其应用受限。[2] 表明，CNN 比 MLP 更有效地建模时间序列数据以进行 LTV 预测。[21] 关注如何使用小波变换和 GAT 从用户稀疏且变化的历史行为序列中学习更可靠的用户表示。然而，它们仍然基于简单的 MSE 损失来拟合 LTV 分布。

2.2 长尾建模

在现实世界中，大多数用户是低价值贡献者，因此 LTV 数据的分布极其不平衡，其中长尾分布是最常见的。众所周知，建模长尾分布是一个非常难以解决的问题。该领域的研究大致分为三类：类重平衡、信息增强和模块改进 [23]。

在类重平衡中，解决样本不平衡问题的最广泛使用的方法之一是重采样，包括随机过采样 (ROS) 和随机欠采样 (RUS)。ROS 随机重复尾类样本，而 RUS 随机丢弃头类样本。当类别极其不平衡时，ROS 往往会过拟合尾类，而 RUS 会降低头类模型的性能。另一个常见的方法是成本敏感学习，也称为重新加权。该方法为少数样本分配较大的权重，为多数样本分配较小的权重。然而，权重通常依赖于样本标签的先验分布，当分布变化时，需要重新确定样本权重。

信息增强主要通过迁移学习和数据增强来缓解长尾问题。对于迁移学习，包括头尾知识转移 [22]、知识蒸馏 [10] 和模型预训练 [5] 等方法，而数据增强是通过增加样本集的数量和质量来缓解数据不平衡问题，但扩展数据的质量难以保证。

模块改进是从网络结构优化的角度提高长尾分布的建模能力。大致可分为以下几类：

(1) 通过表示学习改进特征提取。

(2) 设计分类器以增强模型的分类能力。

(3) 解耦特征提取和分类器分类。

(4) 通过集成学习改进整个架构。

我们的工作继续沿用通过机器学习/深度学习建模 LTV 的方向。我们从不平衡分布处理的角度有效地建模 LTV，并首次建模多时间跨度 LTV 的有序依赖关系，为 LTV 建模领域做出了重要的技术贡献。

3 方法

在本节中，我们将介绍一种新的 LTV 建模方法——有序依赖单调网络 (ODMN)，该方法同时建模多个时间跨度的 LTV 目标。如图 2 所示，它是一个经典的共享底层多任务学习框架，可以根据业务情况和需求升级为更复杂的结构，如多门专家混合 (MMoE) [11] 或渐进分层提取 (PLE) [13]。这些骨干网络超出了本文的重点。

3.1 问题表述

给定用户在固定时间窗口 (例如 7 天) 内的特征向量 ( x )，预测其在接下来的 ( N ) 天内将为平台带来的价值 (( LTV_N ))。显然，

  1.       L 
  2.      
  3.     
  4.       T 
  5.      
  6.      
  7.      
  8.        V 
  9.       
  10.       
  11.       
  12.         N 
  13.        
  14.       
  15.         − 
  16.        
  17.       
  18.         Δ 
  19.        
  20.       
  21.      
  22.     
  23.       ≤ 
  24.      
  25.     
  26.       ⋯ 
  27.      
  28.     
  29.       ≤ 
  30.      
  31.     
  32.       L 
  33.      
  34.     
  35.       T 
  36.      
  37.      
  38.      
  39.        V 
  40.       
  41.      
  42.        N 
  43.       
  44.      
  45.     
  46.       ≤ 
  47.      
  48.     
  49.       ⋯ 
  50.      
  51.     
  52.       ≤ 
  53.      
  54.     
  55.       L 
  56.      
  57.     
  58.       T 
  59.      
  60.      
  61.      
  62.        V 
  63.       
  64.       
  65.       
  66.         N 
  67.        
  68.       
  69.         + 
  70.        
  71.       
  72.         Δ 
  73.        
  74.       
  75.      
  76.     
  77.    
  78.      LTV_{N-\Delta} \leq \cdots \leq LTV_N \leq \cdots \leq LTV_{N+\Delta} 
  79.     
  80.    
  81.  LTVN−Δ​≤⋯≤LTVN​≤⋯≤LTVN+Δ​

多任务框架需要基于输入特征 ( x ) 同时预测 ( T ) 个不同时间跨度的 LTV：

  1.        y 
  2.       
  3.      
  4.        ^ 
  5.       
  6.      
  7.     
  8.       = 
  9.      
  10.     
  11.       f 
  12.      
  13.     
  14.       ( 
  15.      
  16.     
  17.       L 
  18.      
  19.     
  20.       T 
  21.      
  22.      
  23.      
  24.        V 
  25.       
  26.       
  27.       
  28.         N 
  29.        
  30.       
  31.         1 
  32.        
  33.       
  34.      
  35.     
  36.       , 
  37.      
  38.     
  39.       L 
  40.      
  41.     
  42.       T 
  43.      
  44.      
  45.      
  46.        V 
  47.       
  48.       
  49.       
  50.         N 
  51.        
  52.       
  53.         2 
  54.        
  55.       
  56.      
  57.     
  58.       , 
  59.      
  60.     
  61.       ⋯ 
  62.       
  63.     
  64.       , 
  65.      
  66.     
  67.       L 
  68.      
  69.     
  70.       T 
  71.      
  72.      
  73.      
  74.        V 
  75.       
  76.       
  77.       
  78.         N 
  79.        
  80.       
  81.         t 
  82.        
  83.       
  84.      
  85.     
  86.       , 
  87.      
  88.     
  89.       ⋯ 
  90.       
  91.     
  92.       , 
  93.      
  94.     
  95.       L 
  96.      
  97.     
  98.       T 
  99.      
  100.      
  101.      
  102.        V 
  103.       
  104.       
  105.       
  106.         N 
  107.        
  108.       
  109.         T 
  110.        
  111.       
  112.      
  113.     
  114.       ∣ 
  115.      
  116.     
  117.       x 
  118.      
  119.     
  120.       ) 
  121.      
  122.     
  123.    
  124.      \hat{y} = f(LTV_{N1}, LTV_{N2}, \cdots, LTV_{Nt}, \cdots, LTV_{NT} | x) 
  125.     
  126.    
  127.  y^​=f(LTVN1​,LTVN2​,⋯,LTVNt​,⋯,LTVNT​∣x)
  129.   
  130.    
  131.     
  132.     
  133.       1 
  134.      
  135.     
  136.       ≤ 
  137.      
  138.     
  139.       t 
  140.      
  141.     
  142.       ≤ 
  143.      
  144.     
  145.       T 
  146.      
  147.     
  148.       ， 
  149.      
  150.     
  151.       N 
  152.      
  153.     
  154.       1 
  155.      
  156.     
  157.       < 
  158.      
  159.     
  160.       N 
  161.      
  162.     
  163.       2 
  164.      
  165.     
  166.       < 
  167.      
  168.     
  169.       ⋯ 
  170.      
  171.     
  172.       < 
  173.      
  174.     
  175.       N 
  176.      
  177.     
  178.       t 
  179.      
  180.     
  181.       < 
  182.      
  183.     
  184.       ⋯ 
  185.      
  186.     
  187.       < 
  188.      
  189.     
  190.       N 
  191.      
  192.     
  193.       T 
  194.      
  195.     
  196.    
  197.      1 \leq t \leq T，N1 < N2 < \cdots < Nt < \cdots < NT 
  198.     
  199.    
  200.  1≤t≤T，N1<N2<⋯<Nt<⋯<NT

3.2 共享嵌入层和用户表示编码器

模型输入的特征主要包括用户画像特征、在一段时间窗口内的历史行为信息 (例如 7 天) 等。对于用户的历史行为信息，我们将其组织为天级序列格式，例如“活跃时长”：[13, 7, 70, 23, 44, 12, 9]，表示用户在过去 7 天内每天与快手 APP 互动的活跃分钟数。从实际效果来看，天级序列格式的行为特征可以带来更多的信息增益。同时，为了提高模型的泛化能力，我们在特征选择时不考虑高度个性化的特征，如 ( user_id )、( item_id )。在离线数据分析中，我们发现某些业务场景的 LTV 由于用户的周期性行为具有典型的周期性波动。例如，用户在周末的消费倾向增加，而在工作日减少。此外，LTV 对季节性或异常事件也更为敏感。例如，在节假日或电商购物节期间，用户的消费倾向显著增加。模型需要捕捉这些信号，因此我们将这些周期性、季节性或异常事件信息作为输入特征的一部分。无论是在营销、广告还是其他业务中，我们经常关注来自不同渠道的用户的 LTV 预测表现，因此可以添加一些与渠道相关的信息来增强模型对渠道维度 LTV 的预测能力。借鉴 RFM 方法的思想，我们还引入了一些与用户历史消费相关的最近性、频率和货币价值作为特征。

*图 2 展示了我们提出的 ODMN 的整体结构。每个时间段的 LTV 由 MDME 模块建模， 

  1.        o 
  2.       
  3.      
  4.        t 
  5.       
  6.      
  7.     
  8.    
  9.      o_t 
  10.     
  11.    
  12.  ot​ 表示归一化的桶多项分布。Mono 单元是一个具有非负参数的 MLP（多层感知器），可以捕捉上游任务的归一化多项分布的变化趋势。然后，下游任务可以感知上游任务的分布变化，从而进行相应的分布调整。*

如图 2 所示，给定输入特征 

  1.      x 
  2.     
  3.    
  4.   
  5.     x 
  6.    
  7.   
  8. x，我们通过共享嵌入层将每个条目  
  9.  
  10.   
  11.    
  12.     
  13.     
  14.       x 
  15.      
  16.     
  17.       i 
  18.      
  19.     
  20.    
  21.      ( 
  22.     
  23.     
  24.     
  25.       x 
  26.      
  27.     
  28.       i 
  29.      
  30.     
  31.    
  32.      ∈ 
  33.     
  34.    
  35.      x 
  36.     
  37.    
  38.      , 
  39.     
  40.    
  41.      1 
  42.     
  43.    
  44.      ≤ 
  45.     
  46.    
  47.      ∣ 
  48.     
  49.    
  50.      x 
  51.     
  52.    
  53.      ∣ 
  54.     
  55.    
  56.      ) 
  57.     
  58.    
  59.   
  60.     x_i( x_i \in x, 1 \leq |x|) 
  61.    
  62.   
  63. xi​(xi​∈x,1≤∣x∣) 嵌入到低维稠密向量表示  
  64.  
  65.   
  66.    
  67.     
  68.     
  69.       v 
  70.      
  71.     
  72.       i 
  73.      
  74.     
  75.    
  76.   
  77.     v_i 
  78.    
  79.   
  80. vi​ 中。其中，稠密类型的特征将首先离散化，对于一些长尾分布的稠密特征，我们倾向于按等频处理。每个特征条目的嵌入向量将连接在一起，作为最终的用户表示  
  81.  
  82.   
  83.    
  84.    
  85.      v 
  86.     
  87.    
  88.      = 
  89.     
  90.    
  91.      [ 
  92.     
  93.     
  94.     
  95.       v 
  96.      
  97.     
  98.       1 
  99.      
  100.     
  101.    
  102.      ; 
  103.     
  104.     
  105.     
  106.       v 
  107.      
  108.     
  109.       1 
  110.      
  111.     
  112.    
  113.      ; 
  114.     
  115.    
  116.      ⋯ 
  117.      
  118.    
  119.      ; 
  120.     
  121.     
  122.     
  123.       v 
  124.      
  125.      
  126.      
  127.        ∣ 
  128.       
  129.      
  130.        x 
  131.       
  132.      
  133.        ∣ 
  134.       
  135.      
  136.     
  137.    
  138.      ] 
  139.     
  140.    
  141.   
  142.     v = [v_1; v_1; \cdots; v_{|x|}] 
  143.    
  144.   
  145. v=[v1​;v1​;⋯;v∣x∣​]，其中  
  146.  
  147.   
  148.    
  149.    
  150.      [ 
  151.     
  152.    
  153.      ⋅ 
  154.     
  155.    
  156.      ; 
  157.     
  158.    
  159.      ⋅ 
  160.     
  161.    
  162.      ] 
  163.     
  164.    
  165.   
  166.     [ \cdot ; \cdot ] 
  167.    
  168.   
  169. [⋅;⋅] 表示两个向量的连接。通过更复杂的特征交叉 (例如 DeepFM [8], DCN [17]) 或用户行为序列建模 (例如 Transformer [15], Bert [3]) 可以获得更好的用户表示，但这不是本文的重点。

3.3 多分布多专家模块

对于每个特定的 LTV 预测任务，我们设计了一个新模块 MDME（多分布多专家），其核心思想是分而治之。通过将复杂问题分解为若干更简单的子问题，每个子问题都可以轻松解决。直接建模 LTV 确实会带来很多麻烦，其中最重要的是由于样本分布不平衡，很难很好地学习尾部样本。这里提到的样本分布是指 LTV 值的分布。理论上，模型从更平衡的样本分布中学习比从不平衡的样本分布中学习要少一些挑战 [20]。受此启发，我们尝试根据 LTV 分布将整个样本集“切割”成若干段，从而大大缓解每个段中 LTV 分布的不平衡程度。

图 3 展示了 MDME 模块的结构细节。DSM 表示分布分割模块，用于分割整个 LTV 分布。SDM 表示子分布建模模块。DSM 中的 DCT 和 DOT 分别表示分布分类塔和分布序数塔。SDM 中的 BCT、BOT 和 BBT 分别表示桶分类塔、桶序数塔和桶偏差塔。详情请参见第 3.3 节。

图 3 显示了 MDME 的结构。整个端到端的学习过程分为三个阶段。首先，分布分割模块 (DSM) 实现 LTV 分布的分割，即子分布多分类。具体来说，根据 LTV 值将样本集分为若干子分布。对于一些在样本集中占比非常高的 LTV 值，可以将其视为一个独立的子分布，就像零膨胀长尾分布中的 0 一样。分布分割后，每个样本将只属于一个子分布。我们需要学习样本与子分布之间的映射关系，这是一种典型的多分类问题。在这个阶段，样本标签被定义为子分布编号。其次，我们继续坚持分而治之的基本原则，使用子分布建模模块 (SDM) 进一步根据子分布内样本的实际 LTV 值将每个子分布划分为若干桶，然后将子分布建模转化为多桶分类问题。通过调整桶宽，我们可以调整落入每个桶的样本数量，从而使每个桶中的样本数量大致相等。在这个阶段，样本标签是桶编号。类似于分布分割，子分布中样本占比高的 LTV 值可以作为独立的桶编号，即相应的桶宽为 1。经过两个阶段的标签重新定义，整个 LTV 分布的建模难度大大降低，建模粒度已减少到每个桶。此时，每个桶中的样本 LTV 分布已经相对平衡。最后一个阶段是在桶内学习偏差以实现精细的 LTV 建模，这也是由 SDM 处理的。我们对桶内样本的 LTV 值进行最小-最大归一化，使 LTV 值范围压缩到 0 和 1 之间，我们将其定义为偏差系数。然后基于 MSE 回归偏差系数。由于 MSE 对极值非常敏感，归一化可以限制标签的值范围和损失的大小，从而减少对其他任务学习的干扰。总之，对于每个样本，首先由 DSM 确定目标子分布，然后由对应目标子分布的 SDM 估计目标桶和桶内的偏差系数，以获得最终的 LTV。整个过程实现了从粗粒度到细粒度的 LTV 预测。

DSM 包括分布分类塔 (DCT) 和分布序数塔 (DOT)，SDM 由桶分类塔 (BCT)、桶序数塔 (BOT) 和桶偏差塔 (BBT) 组成，其中 DCT 和 BCT 结构相似，分别实现子分布的多分类和子分布内桶的多分类。DCT 和 BCT 的输出层激活函数都是 softmax，它们生成子分布多项式分布和桶多项式分布。我们使用 DCT 中每个子分布的估计概率作为子分布内每个桶多项式分布的权重，以获得整个 LTV 的归一化桶多项式分布，记为 

  1.       o 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     o_t 
  10.    
  11.   
  12. ot​，其中  
  13.  
  14.   
  15.    
  16.    
  17.      t 
  18.     
  19.    
  20.   
  21.     t 
  22.    
  23.   
  24. t 表示第  
  25.  
  26.   
  27.    
  28.    
  29.      t 
  30.     
  31.    
  32.   
  33.     t 
  34.    
  35.   
  36. t 个 LTV 预测任务。ODMN 框架通过单调单元对上游输出的归一化桶多项式分布进行线性变换，并将变换结果直接添加到下游 DCT 和 BCT 的输出 logits 中，可以影响下游任务的输出分布，使得一旦上游输出的归一化桶多项式分布发生偏移，下游任务可以及时捕捉到这一信号，输出分布也会相应地朝同一方向偏移。归一化桶多项式分布和单调单元将在下一小节介绍。此外，子分布之间和桶之间显然存在相对顺序关系。我们发现，引入显式学习这种关系的模块可以进一步提高分类和排序的准确性。因此，DOT 和 BOT 基于序数回归 [7] 设计，用于建模这种顺序关系，其输出层激活函数设置为 sigmoid，DOT 和 BOT 的估计值将分别用作软标签，通过蒸馏引导 DCT 和 BCT 的学习。在 DCT 和 BCT 确定目标子分布和相应目标桶之后，BBT 通过基于 MSE 拟合每个桶内 LTV 的归一化偏差来实现精细回归，BBT 输出层的 logits 数量设置为桶宽大于 1 的桶数量，选择 sigmoid 作为输出层的激活函数以限制估计值在零和一之间。假设第  
  37.  
  38.   
  39.    
  40.    
  41.      t 
  42.     
  43.    
  44.   
  45.     t 
  46.    
  47.   
  48. t 个任务将 LTV 划分为  
  49.  
  50.   
  51.    
  52.     
  53.     
  54.       S 
  55.      
  56.     
  57.       t 
  58.      
  59.     
  60.    
  61.   
  62.     S_t 
  63.    
  64.   
  65. St​ 个子分布，对于每个子分布  
  66.  
  67.   
  68.    
  69.     
  70.     
  71.       s 
  72.      
  73.     
  74.       t 
  75.      
  76.     
  77.    
  78.      ( 
  79.     
  80.    
  81.      1 
  82.     
  83.    
  84.      ≤ 
  85.     
  86.     
  87.     
  88.       s 
  89.      
  90.     
  91.       t 
  92.      
  93.     
  94.    
  95.      ≤ 
  96.     
  97.     
  98.     
  99.       S 
  100.      
  101.     
  102.       t 
  103.      
  104.     
  105.    
  106.      ) 
  107.     
  108.    
  109.   
  110.     s_t(1 ≤ s_t ≤ S_t) 
  111.    
  112.   
  113. st​(1≤st​≤St​)，每个塔模块的输出函数定义为：

KaTeX parse error: Expected 'EOF', got '' at position 65: …DCT}(\text{stop_̲gradient}(o{t-…

KaTeX parse error: Expected 'EOF', got '' at position 73: …BCT}(\text{stop_̲gradient}(o{t-…

  1.        p 
  2.       
  3.      
  4.        t 
  5.       
  6.      
  7.        o 
  8.       
  9.      
  10.     
  11.       = 
  12.      
  13.     
  14.       sigmoid 
  15.      
  16.     
  17.       ( 
  18.      
  19.      
  20.      
  21.        g 
  22.       
  23.      
  24.        t 
  25.       
  26.       
  27.       
  28.         D 
  29.        
  30.       
  31.         O 
  32.        
  33.       
  34.         T 
  35.        
  36.       
  37.      
  38.     
  39.       ( 
  40.      
  41.     
  42.       v 
  43.      
  44.     
  45.       ) 
  46.      
  47.     
  48.       ) 
  49.      
  50.     
  51.    
  52.      p_t^o = \text{sigmoid}(g_t^{DOT}(v)) 
  53.     
  54.    
  55.  pto​=sigmoid(gtDOT​(v))
  58.   
  59.    
  60.     
  61.      
  62.      
  63.        q 
  64.       
  65.       
  66.       
  67.         s 
  68.        
  69.       
  70.         t 
  71.        
  72.       
  73.      
  74.        o 
  75.       
  76.      
  77.     
  78.       = 
  79.      
  80.     
  81.       sigmoid 
  82.      
  83.     
  84.       ( 
  85.      
  86.      
  87.      
  88.        g 
  89.       
  90.       
  91.       
  92.         s 
  93.        
  94.       
  95.         t 
  96.        
  97.       
  98.       
  99.       
  100.         B 
  101.        
  102.       
  103.         O 
  104.        
  105.       
  106.         T 
  107.        
  108.       
  109.      
  110.     
  111.       ( 
  112.      
  113.     
  114.       v 
  115.      
  116.     
  117.       ) 
  118.      
  119.     
  120.       ) 
  121.      
  122.     
  123.    
  124.      q_{s_t}^o = \text{sigmoid}(g_{s_t}^{BOT}(v)) 
  125.     
  126.    
  127.  qst​o​=sigmoid(gst​BOT​(v))
  130.   
  131.    
  132.     
  133.      
  134.      
  135.        q 
  136.       
  137.       
  138.       
  139.         s 
  140.        
  141.       
  142.         t 
  143.        
  144.       
  145.      
  146.        b 
  147.       
  148.      
  149.     
  150.       = 
  151.      
  152.     
  153.       sigmoid 
  154.      
  155.     
  156.       ( 
  157.      
  158.      
  159.      
  160.        h 
  161.       
  162.       
  163.       
  164.         s 
  165.        
  166.       
  167.         t 
  168.        
  169.       
  170.       
  171.       
  172.         B 
  173.        
  174.       
  175.         B 
  176.        
  177.       
  178.         T 
  179.        
  180.       
  181.      
  182.     
  183.       ( 
  184.      
  185.     
  186.       v 
  187.      
  188.     
  189.       ) 
  190.      
  191.     
  192.       ) 
  193.      
  194.     
  195.    
  196.      q_{s_t}^b = \text{sigmoid}(h_{s_t}^{BBT}(v)) 
  197.     
  198.    
  199.  qst​b​=sigmoid(hst​BBT​(v))

其中， 

  1.       f 
  2.      
  3.     
  4.       t 
  5.      
  6.      
  7.      
  8.        D 
  9.       
  10.      
  11.        C 
  12.       
  13.      
  14.        T 
  15.       
  16.      
  17.     
  18.    
  19.      ( 
  20.     
  21.    
  22.      ⋅ 
  23.     
  24.    
  25.      ) 
  26.     
  27.    
  28.   
  29.     f_t^{DCT}(·) 
  30.    
  31.   
  32. ftDCT​(⋅) 和  
  33.  
  34.   
  35.    
  36.     
  37.     
  38.       g 
  39.      
  40.     
  41.       t 
  42.      
  43.      
  44.      
  45.        D 
  46.       
  47.      
  48.        O 
  49.       
  50.      
  51.        T 
  52.       
  53.      
  54.     
  55.    
  56.      ( 
  57.     
  58.    
  59.      ⋅ 
  60.     
  61.    
  62.      ) 
  63.     
  64.    
  65.   
  66.     g_t^{DOT}(·) 
  67.    
  68.   
  69. gtDOT​(⋅) 分别是第  
  70.  
  71.   
  72.    
  73.    
  74.      t 
  75.     
  76.    
  77.   
  78.     t 
  79.    
  80.   
  81. t 个任务的 DCT 和 DOT 模块的函数， 
  82.  
  83.   
  84.    
  85.     
  86.     
  87.       p 
  88.      
  89.     
  90.       t 
  91.      
  92.     
  93.       c 
  94.      
  95.     
  96.    
  97.   
  98.     p_t^c 
  99.    
  100.   
  101. ptc​ 和  
  102.  
  103.   
  104.    
  105.     
  106.     
  107.       p 
  108.      
  109.     
  110.       t 
  111.      
  112.     
  113.       o 
  114.      
  115.     
  116.    
  117.   
  118.     p_t^o 
  119.    
  120.   
  121. pto​ 属于  
  122.  
  123.   
  124.    
  125.     
  126.     
  127.       R 
  128.      
  129.     
  130.       k 
  131.      
  132.     
  133.    
  134.   
  135.     R_k 
  136.    
  137.   
  138. Rk​， 
  139.  
  140.   
  141.    
  142.    
  143.      k 
  144.     
  145.    
  146.   
  147.     k 
  148.    
  149.   
  150. k 是塔输出的维度，即划分的子分布数。 
  151.  
  152.   
  153.    
  154.     
  155.     
  156.       f 
  157.      
  158.      
  159.      
  160.        s 
  161.       
  162.      
  163.        t 
  164.       
  165.      
  166.      
  167.      
  168.        B 
  169.       
  170.      
  171.        C 
  172.       
  173.      
  174.        T 
  175.       
  176.      
  177.     
  178.    
  179.      ( 
  180.     
  181.    
  182.      ⋅ 
  183.     
  184.    
  185.      ) 
  186.     
  187.    
  188.   
  189.     f_{s_t}^{BCT}(·) 
  190.    
  191.   
  192. fst​BCT​(⋅)、 
  193.  
  194.   
  195.    
  196.     
  197.     
  198.       g 
  199.      
  200.      
  201.      
  202.        s 
  203.       
  204.      
  205.        t 
  206.       
  207.      
  208.      
  209.      
  210.        B 
  211.       
  212.      
  213.        O 
  214.       
  215.      
  216.        T 
  217.       
  218.      
  219.     
  220.    
  221.      ( 
  222.     
  223.    
  224.      ⋅ 
  225.     
  226.    
  227.      ) 
  228.     
  229.    
  230.   
  231.     g_{s_t}^{BOT}(·) 
  232.    
  233.   
  234. gst​BOT​(⋅)、 
  235.  
  236.   
  237.    
  238.     
  239.     
  240.       h 
  241.      
  242.      
  243.      
  244.        s 
  245.       
  246.      
  247.        t 
  248.       
  249.      
  250.      
  251.      
  252.        B 
  253.       
  254.      
  255.        B 
  256.       
  257.      
  258.        T 
  259.       
  260.      
  261.     
  262.    
  263.      ( 
  264.     
  265.    
  266.      ⋅ 
  267.     
  268.    
  269.      ) 
  270.     
  271.    
  272.   
  273.     h_{s_t}^{BBT}(·) 
  274.    
  275.   
  276. hst​BBT​(⋅) 分别是子分布  
  277.  
  278.   
  279.    
  280.     
  281.     
  282.       s 
  283.      
  284.     
  285.       t 
  286.      
  287.     
  288.    
  289.   
  290.     s_t 
  291.    
  292.   
  293. st​ 下的 BCT、BOT 和 BBT 模块的函数。 
  294.  
  295.   
  296.    
  297.     
  298.     
  299.       q 
  300.      
  301.      
  302.      
  303.        s 
  304.       
  305.      
  306.        t 
  307.       
  308.      
  309.     
  310.       c 
  311.      
  312.     
  313.    
  314.   
  315.     q_{s_t}^c 
  316.    
  317.   
  318. qst​c​ 和  
  319.  
  320.   
  321.    
  322.     
  323.     
  324.       q 
  325.      
  326.      
  327.      
  328.        s 
  329.       
  330.      
  331.        t 
  332.       
  333.      
  334.     
  335.       o 
  336.      
  337.     
  338.    
  339.   
  340.     q_{s_t}^o 
  341.    
  342.   
  343. qst​o​ 属于  
  344.  
  345.   
  346.    
  347.     
  348.     
  349.       R 
  350.      
  351.     
  352.       m 
  353.      
  354.     
  355.    
  356.   
  357.     R_m 
  358.    
  359.   
  360. Rm​， 
  361.  
  362.   
  363.    
  364.     
  365.     
  366.       q 
  367.      
  368.      
  369.      
  370.        s 
  371.       
  372.      
  373.        t 
  374.       
  375.      
  376.     
  377.       b 
  378.      
  379.     
  380.    
  381.   
  382.     q_{s_t}^b 
  383.    
  384.   
  385. qst​b​ 属于  
  386.  
  387.   
  388.    
  389.     
  390.     
  391.       R 
  392.      
  393.     
  394.       r 
  395.      
  396.     
  397.    
  398.   
  399.     R_r 
  400.    
  401.   
  402. Rr​， 
  403.  
  404.   
  405.    
  406.    
  407.      m 
  408.     
  409.    
  410.   
  411.     m 
  412.    
  413.   
  414. m 是子分布中划分的桶数， 
  415.  
  416.   
  417.    
  418.    
  419.      r 
  420.     
  421.    
  422.   
  423.     r 
  424.    
  425.   
  426. r 是子分布中桶宽大于 1 的桶数，显然  
  427.  
  428.   
  429.    
  430.    
  431.      m 
  432.     
  433.    
  434.      ≥ 
  435.     
  436.    
  437.      r 
  438.     
  439.    
  440.   
  441.     m \geq r 
  442.    
  443.   
  444. m≥r。 
  445.  
  446.   
  447.    
  448.     
  449.     
  450.       o 
  451.      
  452.      
  453.      
  454.        t 
  455.       
  456.      
  457.        − 
  458.       
  459.      
  460.        1 
  461.       
  462.      
  463.     
  464.    
  465.   
  466.     o_{t-1} 
  467.    
  468.   
  469. ot−1​ 是上游任务输出的归一化桶多项式分布，经过单调函数的变换后直接单调地影响当前任务的输出分布。

MDME 结构实现了从粗粒度到细粒度的 LTV 建模。给定用户表示向量，由 DCT 模块预测概率最高的子分布设为目标子分布，然后目标子分布的 BCT 模块输出概率最高的目标桶。同时，我们获得目标桶的左边界和桶宽。最后，BBT 模块输出目标桶内的偏差系数，我们可以计算估计的 LTV 值：

  1.        u 
  2.       
  3.      
  4.        t 
  5.       
  6.      
  7.     
  8.       = 
  9.      
  10.     
  11.       argmax 
  12.      
  13.     
  14.       ( 
  15.      
  16.      
  17.      
  18.        q 
  19.       
  20.       
  21.       
  22.         s 
  23.        
  24.       
  25.         t 
  26.        
  27.       
  28.      
  29.        c 
  30.       
  31.      
  32.     
  33.       ) 
  34.      
  35.     
  36.    
  37.      u_t = \text{argmax}(q_{s_t}^c) 
  38.     
  39.    
  40.  ut​=argmax(qst​c​)

KaTeX parse error: Expected 'EOF', got '' at position 24: …t} = \text{left_̲boundary}{u_t}…

  1.       u 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     u_t 
  10.    
  11.   
  12. ut​ 是分布  
  13.  
  14.   
  15.    
  16.     
  17.     
  18.       q 
  19.      
  20.      
  21.      
  22.        s 
  23.       
  24.      
  25.        t 
  26.       
  27.      
  28.     
  29.       c 
  30.      
  31.     
  32.    
  33.   
  34.     q_{s_t}^c 
  35.    
  36.   
  37. qst​c​ 中概率最大的桶编号。值得一提的是，MDME 模块可以作为一个独立的模型来估计 LTV，并且仍然能够实现良好的性能。

3.4 归一化多项式分布和单调单元

不同时间跨度的用户生命周期价值（LTV）满足有序关系，例如 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.      ≤ 
  16.     
  17.    
  18.      l 
  19.     
  20.    
  21.      t 
  22.     
  23.     
  24.     
  25.       v 
  26.      
  27.     
  28.       90 
  29.      
  30.     
  31.    
  32.      ≤ 
  33.     
  34.    
  35.      l 
  36.     
  37.    
  38.      t 
  39.     
  40.     
  41.     
  42.       v 
  43.      
  44.     
  45.       180 
  46.      
  47.     
  48.    
  49.      ≤ 
  50.     
  51.    
  52.      l 
  53.     
  54.    
  55.      t 
  56.     
  57.     
  58.     
  59.       v 
  60.      
  61.     
  62.       365 
  63.      
  64.     
  65.    
  66.   
  67.     ltv_{30} \leq ltv_{90} \leq ltv_{180} \leq ltv_{365} 
  68.    
  69.   
  70. ltv30​≤ltv90​≤ltv180​≤ltv365​，这是由业务决定的。传统的建模策略是利用独立模型来估计一个目标，或者基于多任务学习同时学习多个时间跨度的 LTV。然而，它们没有充分利用不同时间跨度 LTV 之间的有序依赖关系。我们认为，建模这种有序依赖关系可以有效地提高模型性能。这里，通过几个具有非负隐藏层参数的多层感知器，我们称之为单调单元（Mono Unit），将上游和下游 LTV 预测任务的输出层串联起来，使得前一个任务输出的分布信息可以单调地直接影响后一个任务的输出分布。Mono Unit 之所以连接到每个任务网络的输出层，是因为理论上越接近输出层，隐藏层能够获取的任务相关信息越丰富 [19]。

具体来说，任务需要输出一个归一化的桶多项式分布。MDME 模块对不平衡的 LTV 分布进行“粗到细”的处理。通过分布分割和子分布分桶，大大降低了 LTV 建模的难度。这两个阶段将 LTV 建模转化为桶多分类问题，我们可以基于这两个阶段输出的多项式分布计算归一化的桶多项式分布 

  1.       o 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.    
  8.   
  9.     o_t 
  10.    
  11.   
  12. ot​。

第 

  1.      t 
  2.     
  3.    
  4.      − 
  5.     
  6.    
  7.      1 
  8.     
  9.    
  10.   
  11.     t-1 
  12.    
  13.   
  14. t−1 个任务输出的归一化桶多项式分布直接与 DCT 模块的输出 logits 和  
  15.  
  16.   
  17.    
  18.     
  19.     
  20.       S 
  21.      
  22.     
  23.       t 
  24.      
  25.     
  26.    
  27.   
  28.     S_t 
  29.    
  30.   
  31. St​ 个 BCT 模块的输出 logits 分别进行“加法”操作，经过  
  32.  
  33.   
  34.    
  35.    
  36.      ( 
  37.     
  38.     
  39.     
  40.       S 
  41.      
  42.     
  43.       t 
  44.      
  45.     
  46.    
  47.      + 
  48.     
  49.    
  50.      1 
  51.     
  52.    
  53.      ) 
  54.     
  55.    
  56.   
  57.     (S_t+1) 
  58.    
  59.   
  60. (St​+1) 个 Mono Units 的处理。Mono Unit 可以捕捉上游任务输出多项式分布的变化趋势，然后影响下游任务的输出分布。理论上，短期 LTV 的建模难度小于长期 LTV。通过多项式分布映射和捕捉机制，短期 LTV 可以用来辅助长期 LTV 的建模，从而降低后续任务的建模难度。同时，需要在上游和下游任务之间进行梯度截断，以减少下游任务对上游任务的影响。

ODMN 框架通过建模不同时间跨度 LTV 的有序依赖关系，进一步提高了性能和预测准确性，实现了软单调约束。从建模难度的角度来看，Mono Unit 的设计使得简单任务能够辅助复杂任务的学习，从而缓解长期 LTV 的建模难度。

3.5 精细校准和 MTL 的联合优化

对于每个 MDME 模块，与 DSM 模块相关的损失包括子分布多分类交叉熵损失 

  1.       L 
  2.      
  3.     
  4.       t 
  5.      
  6.     
  7.       c 
  8.      
  9.     
  10.    
  11.   
  12.     L_t^c 
  13.    
  14.   
  15. Ltc​、子分布序数回归损失  
  16.  
  17.   
  18.    
  19.     
  20.     
  21.       L 
  22.      
  23.     
  24.       t 
  25.      
  26.     
  27.       o 
  28.      
  29.     
  30.    
  31.   
  32.     L_t^o 
  33.    
  34.   
  35. Lto​ 和子分布蒸馏分类交叉熵损失  
  36.  
  37.   
  38.    
  39.     
  40.     
  41.       L 
  42.      
  43.     
  44.       t 
  45.      
  46.      
  47.      
  48.        d 
  49.       
  50.      
  51.        i 
  52.       
  53.      
  54.        s 
  55.       
  56.      
  57.     
  58.    
  59.   
  60.     L_t^{dis} 
  61.    
  62.   
  63. Ltdis​。每个 SDM 模块的损失包括桶多分类交叉熵损失  
  64.  
  65.   
  66.    
  67.     
  68.     
  69.       L 
  70.      
  71.      
  72.      
  73.        s 
  74.       
  75.      
  76.        t 
  77.       
  78.      
  79.     
  80.       c 
  81.      
  82.     
  83.    
  84.   
  85.     L_{s_t}^c 
  86.    
  87.   
  88. Lst​c​、桶序数回归损失  
  89.  
  90.   
  91.    
  92.     
  93.     
  94.       L 
  95.      
  96.      
  97.      
  98.        s 
  99.       
  100.      
  101.        t 
  102.       
  103.      
  104.     
  105.       o 
  106.      
  107.     
  108.    
  109.   
  110.     L_{s_t}^o 
  111.    
  112.   
  113. Lst​o​、桶蒸馏分类交叉熵损失  
  114.  
  115.   
  116.    
  117.     
  118.     
  119.       L 
  120.      
  121.      
  122.      
  123.        s 
  124.       
  125.      
  126.        t 
  127.       
  128.      
  129.      
  130.      
  131.        d 
  132.       
  133.      
  134.        i 
  135.       
  136.      
  137.        s 
  138.       
  139.      
  140.     
  141.    
  142.   
  143.     L_{s_t}^{dis} 
  144.    
  145.   
  146. Lst​dis​ 和桶偏差回归损失  
  147.  
  148.   
  149.    
  150.     
  151.     
  152.       L 
  153.      
  154.      
  155.      
  156.        s 
  157.       
  158.      
  159.        t 
  160.       
  161.      
  162.     
  163.       b 
  164.      
  165.     
  166.    
  167.   
  168.     L_{s_t}^b 
  169.    
  170.   
  171. Lst​b​。序数回归损失的定义如下：
  174.   
  175.    
  176.     
  177.      
  178.      
  179.        L 
  180.       
  181.      
  182.        o 
  183.       
  184.      
  185.     
  186.       ( 
  187.      
  188.     
  189.       θ 
  190.      
  191.     
  192.       ) 
  193.      
  194.     
  195.       = 
  196.      
  197.     
  198.       − 
  199.      
  200.      
  201.      
  202.        1 
  203.       
  204.      
  205.        B 
  206.       
  207.      
  208.      
  209.      
  210.        ∑ 
  211.       
  212.       
  213.       
  214.         ( 
  215.        
  216.       
  217.         x 
  218.        
  219.       
  220.         , 
  221.        
  222.        
  223.        
  224.          y 
  225.         
  226.        
  227.          t 
  228.         
  229.        
  230.       
  231.         ) 
  232.        
  233.       
  234.         ∈ 
  235.        
  236.       
  237.         D 
  238.        
  239.       
  240.      
  241.      
  242.      
  243.        ( 
  244.       
  245.       
  246.       
  247.         ∑ 
  248.        
  249.        
  250.        
  251.          u 
  252.         
  253.        
  254.          = 
  255.         
  256.        
  257.          0 
  258.         
  259.        
  260.        
  261.         
  262.         
  263.           y 
  264.          
  265.         
  266.           t 
  267.          
  268.         
  269.        
  270.          − 
  271.         
  272.        
  273.          1 
  274.         
  275.        
  276.       
  277.      
  278.        log 
  279.       
  280.      
  281.        ⁡ 
  282.       
  283.       
  284.       
  285.         P 
  286.        
  287.       
  288.         u 
  289.        
  290.       
  291.      
  292.        + 
  293.       
  294.       
  295.       
  296.         ∑ 
  297.        
  298.        
  299.        
  300.          u 
  301.         
  302.        
  303.          = 
  304.         
  305.         
  306.         
  307.           y 
  308.          
  309.         
  310.           t 
  311.          
  312.         
  313.        
  314.        
  315.        
  316.          U 
  317.         
  318.        
  319.          − 
  320.         
  321.        
  322.          1 
  323.         
  324.        
  325.       
  326.      
  327.        log 
  328.       
  329.      
  330.        ⁡ 
  331.       
  332.      
  333.        ( 
  334.       
  335.      
  336.        1 
  337.       
  338.      
  339.        − 
  340.       
  341.       
  342.       
  343.         P 
  344.        
  345.       
  346.         u 
  347.        
  348.       
  349.      
  350.        ) 
  351.       
  352.      
  353.        ) 
  354.       
  355.      
  356.     
  357.    
  358.      L_o(\theta) = -\frac{1}{B} \sum_{(x,y_t) \in D} \left( \sum_{u=0}^{y_t-1} \log P_u + \sum_{u=y_t}^{U-1} \log (1 - P_u) \right) 
  359.     
  360.    
  361.  Lo​(θ)=−B1​(x,yt​)∈D∑​(u=0∑yt​−1​logPu​+u=yt​∑U−1​log(1−Pu​))
  364.   
  365.    
  366.     
  367.      
  368.      
  369.        P 
  370.       
  371.      
  372.        u 
  373.       
  374.      
  375.     
  376.       = 
  377.      
  378.     
  379.       P 
  380.      
  381.     
  382.       ( 
  383.      
  384.      
  385.      
  386.        l 
  387.       
  388.      
  389.        ^ 
  390.       
  391.      
  392.     
  393.       > 
  394.      
  395.     
  396.       u 
  397.      
  398.     
  399.       ∣ 
  400.      
  401.     
  402.       θ 
  403.      
  404.     
  405.       ) 
  406.      
  407.     
  408.    
  409.      P_u = P(\hat{l} > u | \theta) 
  410.     
  411.    
  412.  Pu​=P(l^>u∣θ)
  415.   
  416.    
  417.     
  418.      
  419.      
  420.        l 
  421.       
  422.      
  423.        ^ 
  424.       
  425.      
  426.     
  427.       = 
  428.      
  429.      
  430.      
  431.        ∑ 
  432.       
  433.       
  434.       
  435.         u 
  436.        
  437.       
  438.         = 
  439.        
  440.       
  441.         0 
  442.        
  443.       
  444.       
  445.       
  446.         U 
  447.        
  448.       
  449.         − 
  450.        
  451.       
  452.         1 
  453.        
  454.       
  455.      
  456.     
  457.       η 
  458.      
  459.     
  460.       ( 
  461.      
  462.      
  463.      
  464.        P 
  465.       
  466.      
  467.        u 
  468.       
  469.      
  470.     
  471.       ≥ 
  472.      
  473.     
  474.       0.5 
  475.      
  476.     
  477.       ) 
  478.      
  479.     
  480.    
  481.      \hat{l} = \sum_{u=0}^{U-1} \eta(P_u \geq 0.5) 
  482.     
  483.    
  484.  l^=u=0∑U−1​η(Pu​≥0.5)

其中， 

  1.      B 
  2.     
  3.    
  4.   
  5.     B 
  6.    
  7.   
  8. B 是批次中的样本数量， 
  9.  
  10.   
  11.    
  12.    
  13.      U 
  14.     
  15.    
  16.   
  17.     U 
  18.    
  19.   
  20. U 是输出 logits 的大小， 
  21.  
  22.   
  23.    
  24.     
  25.     
  26.       y 
  27.      
  28.     
  29.       t 
  30.      
  31.     
  32.    
  33.   
  34.     y_t 
  35.    
  36.   
  37. yt​ 是样本对应的真实标签， 
  38.  
  39.   
  40.    
  41.     
  42.     
  43.       l 
  44.      
  45.     
  46.       ^ 
  47.      
  48.     
  49.    
  50.   
  51.     \hat{l} 
  52.    
  53.   
  54. l^ 是序数回归的估计值。 
  55.  
  56.   
  57.    
  58.    
  59.      η 
  60.     
  61.    
  62.      ( 
  63.     
  64.    
  65.      ⋅ 
  66.     
  67.    
  68.      ) 
  69.     
  70.    
  71.   
  72.     \eta(\cdot) 
  73.    
  74.   
  75. η(⋅) 是指示函数，使得  
  76.  
  77.   
  78.    
  79.    
  80.      η 
  81.     
  82.    
  83.      ( 
  84.     
  85.    
  86.      true 
  87.     
  88.    
  89.      ) 
  90.     
  91.    
  92.      = 
  93.     
  94.    
  95.      1 
  96.     
  97.    
  98.   
  99.     \eta(\text{true}) = 1 
  100.    
  101.   
  102. η(true)=1 和  
  103.  
  104.   
  105.    
  106.    
  107.      η 
  108.     
  109.    
  110.      ( 
  111.     
  112.    
  113.      false 
  114.     
  115.    
  116.      ) 
  117.     
  118.    
  119.      = 
  120.     
  121.    
  122.      0 
  123.     
  124.    
  125.   
  126.     \eta(\text{false}) = 0 
  127.    
  128.   
  129. η(false)=0， 
  130.  
  131.   
  132.    
  133.    
  134.      u 
  135.     
  136.    
  137.   
  138.     u 
  139.    
  140.   
  141. u 是桶编号。 
  142.  
  143.   
  144.    
  145.     
  146.     
  147.       P 
  148.      
  149.     
  150.       u 
  151.      
  152.     
  153.    
  154.   
  155.     P_u 
  156.    
  157.   
  158. Pu​ 是预测的序数回归值大于实际桶编号的概率。需要注意的是，DSM 模块的学习需要使用所有样本，但对于 SDM 模块，只使用属于子分布或桶的样本来隔离训练样本。Mono Unit 捕捉上游任务输出的桶多项式分布的变化趋势，然后影响下游任务的输出分布，从而实现粗粒度形式的软单调约束。为了进一步建模上游和下游任务之间的单调约束关系，我们对每个任务的估计 LTV 值进行精细校准。具体来说，如果上游任务估计的短期 LTV 大于相邻下游任务估计的长期 LTV，则引入惩罚损失：
  161.   
  162.    
  163.     
  164.      
  165.      
  166.        L 
  167.       
  168.      
  169.        t 
  170.       
  171.       
  172.       
  173.         c 
  174.        
  175.       
  176.         a 
  177.        
  178.       
  179.         l 
  180.        
  181.       
  182.         i 
  183.        
  184.       
  185.      
  186.     
  187.       = 
  188.      
  189.      
  190.      
  191.        1 
  192.       
  193.      
  194.        B 
  195.       
  196.      
  197.      
  198.      
  199.        ∑ 
  200.       
  201.       
  202.       
  203.         ( 
  204.        
  205.       
  206.         x 
  207.        
  208.       
  209.         , 
  210.        
  211.        
  212.        
  213.          y 
  214.         
  215.        
  216.          t 
  217.         
  218.        
  219.       
  220.         ) 
  221.        
  222.       
  223.         ∈ 
  224.        
  225.       
  226.         D 
  227.        
  228.       
  229.      
  230.      
  231.      
  232.        ∑ 
  233.       
  234.       
  235.       
  236.         t 
  237.        
  238.       
  239.         = 
  240.        
  241.       
  242.         1 
  243.        
  244.       
  245.       
  246.       
  247.         T 
  248.        
  249.       
  250.         − 
  251.        
  252.       
  253.         1 
  254.        
  255.       
  256.      
  257.     
  258.       max 
  259.      
  260.     
  261.       ⁡ 
  262.      
  263.     
  264.       ( 
  265.      
  266.      
  267.       
  268.       
  269.         y 
  270.        
  271.       
  272.         ^ 
  273.        
  274.       
  275.      
  276.        t 
  277.       
  278.      
  279.     
  280.       − 
  281.      
  282.      
  283.       
  284.       
  285.         y 
  286.        
  287.       
  288.         ^ 
  289.        
  290.       
  291.       
  292.       
  293.         t 
  294.        
  295.       
  296.         + 
  297.        
  298.       
  299.         1 
  300.        
  301.       
  302.      
  303.     
  304.       , 
  305.      
  306.     
  307.       0 
  308.      
  309.     
  310.       ) 
  311.      
  312.     
  313.    
  314.      L_t^{cali} = \frac{1}{B} \sum_{(x,y_t) \in D} \sum_{t=1}^{T-1} \max(\hat{y}_t - \hat{y}_{t+1}, 0) 
  315.     
  316.    
  317.  Ltcali​=B1​(x,yt​)∈D∑​t=1∑T−1​max(y^​t​−y^​t+1​,0)

总之，ODMN 的损失函数定义如下， 

  1.      α 
  2.     
  3.    
  4.   
  5.     \alpha 
  6.    
  7.   
  8. α 控制精细有序依赖校准损失的强度， 
  9.  
  10.   
  11.    
  12.    
  13.      β 
  14.     
  15.    
  16.   
  17.     \beta 
  18.    
  19.   
  20. β 和  
  21.  
  22.   
  23.    
  24.     
  25.     
  26.       γ 
  27.      
  28.      
  29.      
  30.        s 
  31.       
  32.      
  33.        t 
  34.       
  35.      
  36.     
  37.    
  38.   
  39.     \gamma_{s_t} 
  40.    
  41.   
  42. γst​​ 确定每个蒸馏损失的贡献：
  45.   
  46.    
  47.     
  48.     
  49.       L 
  50.      
  51.     
  52.       = 
  53.      
  54.      
  55.      
  56.        ∑ 
  57.       
  58.       
  59.       
  60.         t 
  61.        
  62.       
  63.         = 
  64.        
  65.       
  66.         1 
  67.        
  68.       
  69.      
  70.        T 
  71.       
  72.      
  73.      
  74.      
  75.        L 
  76.       
  77.      
  78.        t 
  79.       
  80.      
  81.     
  82.       + 
  83.      
  84.     
  85.       α 
  86.      
  87.     
  88.       ⋅ 
  89.      
  90.      
  91.      
  92.        L 
  93.       
  94.      
  95.        t 
  96.       
  97.       
  98.       
  99.         c 
  100.        
  101.       
  102.         a 
  103.        
  104.       
  105.         l 
  106.        
  107.       
  108.         i 
  109.        
  110.       
  111.      
  112.     
  113.    
  114.      L = \sum_{t=1}^{T} L_t + \alpha \cdot L_t^{cali} 
  115.     
  116.    
  117.  L=t=1∑T​Lt​+α⋅Ltcali​
  120.   
  121.    
  122.     
  123.      
  124.      
  125.        L 
  126.       
  127.      
  128.        t 
  129.       
  130.      
  131.     
  132.       = 
  133.      
  134.      
  135.      
  136.        L 
  137.       
  138.      
  139.        t 
  140.       
  141.      
  142.        c 
  143.       
  144.      
  145.     
  146.       + 
  147.      
  148.      
  149.      
  150.        L 
  151.       
  152.      
  153.        t 
  154.       
  155.      
  156.        o 
  157.       
  158.      
  159.     
  160.       + 
  161.      
  162.     
  163.       β 
  164.      
  165.     
  166.       ⋅ 
  167.      
  168.      
  169.      
  170.        L 
  171.       
  172.      
  173.        t 
  174.       
  175.       
  176.       
  177.         d 
  178.        
  179.       
  180.         i 
  181.        
  182.       
  183.         s 
  184.        
  185.       
  186.      
  187.     
  188.       + 
  189.      
  190.      
  191.      
  192.        ∑ 
  193.       
  194.       
  195.        
  196.        
  197.          s 
  198.         
  199.        
  200.          t 
  201.         
  202.        
  203.       
  204.         = 
  205.        
  206.       
  207.         1 
  208.        
  209.       
  210.       
  211.       
  212.         S 
  213.        
  214.       
  215.         t 
  216.        
  217.       
  218.      
  219.      
  220.      
  221.        ( 
  222.       
  223.       
  224.       
  225.         L 
  226.        
  227.        
  228.        
  229.          s 
  230.         
  231.        
  232.          t 
  233.         
  234.        
  235.       
  236.         c 
  237.        
  238.       
  239.      
  240.        + 
  241.       
  242.       
  243.       
  244.         L 
  245.        
  246.        
  247.        
  248.          s 
  249.         
  250.        
  251.          t 
  252.         
  253.        
  254.       
  255.         o 
  256.        
  257.       
  258.      
  259.        + 
  260.       
  261.       
  262.       
  263.         γ 
  264.        
  265.        
  266.        
  267.          s 
  268.         
  269.        
  270.          t 
  271.         
  272.        
  273.       
  274.      
  275.        ⋅ 
  276.       
  277.       
  278.       
  279.         L 
  280.        
  281.        
  282.        
  283.          s 
  284.         
  285.        
  286.          t 
  287.         
  288.        
  289.        
  290.        
  291.          d 
  292.         
  293.        
  294.          i 
  295.         
  296.        
  297.          s 
  298.         
  299.        
  300.       
  301.      
  302.        + 
  303.       
  304.       
  305.       
  306.         L 
  307.        
  308.        
  309.        
  310.          s 
  311.         
  312.        
  313.          t 
  314.         
  315.        
  316.       
  317.         b 
  318.        
  319.       
  320.      
  321.        ) 
  322.       
  323.      
  324.     
  325.    
  326.      L_t = L_t^c + L_t^o + \beta \cdot L_t^{dis} + \sum_{s_t=1}^{S_t} \left( L_{s_t}^c + L_{s_t}^o + \gamma_{s_t} \cdot L_{s_t}^{dis} + L_{s_t}^b \right) 
  327.     
  328.    
  329.  Lt​=Ltc​+Lto​+β⋅Ltdis​+st​=1∑St​​(Lst​c​+Lst​o​+γst​​⋅Lst​dis​+Lst​b​)

4 评估指标

4.1 常见评估指标

我们采用归一化均方根误差（NRMSE）和归一化平均绝对误差（NMAE），如文献 [21] 所定义，作为评估指标的一部分。平均偏差误差的绝对值（AMBE）是另一个重要指标，可以捕捉预测中的平均偏差。需要注意的是，这三个指标越低，性能越好。然而，上述指标无法衡量模型区分高价值用户和低价值用户的能力，也无法反映模型对真实不平衡分布的拟合情况。

图 4 展示了真实标签和模型预测的洛伦兹曲线，横轴是用户数量的累积百分比，纵轴是用户贡献的 LTV 的累积百分比。需要注意的是，原始定义是按真实 LTV 升序排序，为了更直观地解释高价值客户，我们将其改为按真实 LTV 降序排序。

ZILN [18] 引入了基于洛伦兹曲线和基尼系数的归一化模型基尼系数。其中，洛伦兹曲线（图 4）是描述高价值用户和低价值用户分布的直观工具。洛伦兹曲线的横轴是用户数量的累积百分比，纵轴是用户贡献的 LTV 的累积百分比。模型估计值曲线与真实值曲线的拟合程度反映了模型对不平衡分布的拟合能力。基尼系数是一个判别性指标，估计的基尼系数越大，模型的区分能力越强。对于一个不平衡的数据集，假设总样本量为 

  1.      N 
  2.     
  3.    
  4.   
  5.     N 
  6.    
  7.   
  8. N， 
  9.  
  10.   
  11.    
  12.     
  13.     
  14.       N 
  15.      
  16.     
  17.       i 
  18.      
  19.     
  20.    
  21.   
  22.     N_i 
  23.    
  24.   
  25. Ni​ 是类别  
  26.  
  27.   
  28.    
  29.    
  30.      i 
  31.     
  32.    
  33.   
  34.     i 
  35.    
  36.   
  37. i 的样本量， 
  38.  
  39.   
  40.    
  41.    
  42.      C 
  43.     
  44.    
  45.   
  46.     C 
  47.    
  48.   
  49. C 是总类别数，那么基尼系数可以定义为：
  52.   
  53.    
  54.     
  55.     
  56.       I 
  57.      
  58.     
  59.       G 
  60.      
  61.     
  62.       i 
  63.      
  64.     
  65.       n 
  66.      
  67.     
  68.       i 
  69.      
  70.     
  71.       = 
  72.      
  73.      
  74.      
  75.        ∑ 
  76.       
  77.       
  78.       
  79.         i 
  80.        
  81.       
  82.         = 
  83.        
  84.       
  85.         1 
  86.        
  87.       
  88.      
  89.        C 
  90.       
  91.      
  92.      
  93.       
  94.       
  95.         ( 
  96.        
  97.       
  98.         2 
  99.        
  100.       
  101.         i 
  102.        
  103.       
  104.         − 
  105.        
  106.       
  107.         C 
  108.        
  109.       
  110.         − 
  111.        
  112.       
  113.         1 
  114.        
  115.       
  116.         ) 
  117.        
  118.        
  119.        
  120.          N 
  121.         
  122.        
  123.          i 
  124.         
  125.        
  126.       
  127.       
  128.       
  129.         C 
  130.        
  131.        
  132.        
  133.          ∑ 
  134.         
  135.         
  136.         
  137.           i 
  138.          
  139.         
  140.           = 
  141.          
  142.         
  143.           1 
  144.          
  145.         
  146.        
  147.          C 
  148.         
  149.        
  150.        
  151.        
  152.          N 
  153.         
  154.        
  155.          i 
  156.         
  157.        
  158.       
  159.      
  160.     
  161.    
  162.      IGini = \sum_{i=1}^{C} \frac{(2i - C - 1) N_i}{C \sum_{i=1}^{C} N_i} 
  163.     
  164.    
  165.  IGini=i=1∑C​C∑i=1C​Ni​(2i−C−1)Ni​​

模型基尼系数与真实基尼系数的比值产生归一化模型基尼系数，该系数衡量估计值曲线与真实值曲线的拟合程度。然而，归一化模型基尼系数忽略了曲线可能交叉的情况。如图 4 所示，当比值为 1 时，曲线可能并未重叠。

4.2 互基尼系数

在本文中，我们提出了一种新的评估指标，称为互基尼系数（Mutual Gini），它可以基于洛伦兹曲线定量衡量曲线之间的差异。如图 4 所示，绿色曲线是真实标签的洛伦兹曲线，红色曲线是估计值的洛伦兹曲线，互基尼系数定义为绿色曲线和红色曲线之间的面积 

  1.      A 
  2.     
  3.    
  4.   
  5.     A 
  6.    
  7.   
  8. A。互基尼系数越小，模型对真实不平衡分布的拟合越好。互基尼系数的计算如下：
  11.   
  12.    
  13.     
  14.     
  15.       M 
  16.      
  17.     
  18.       u 
  19.      
  20.     
  21.       t 
  22.      
  23.     
  24.       u 
  25.      
  26.     
  27.       a 
  28.      
  29.     
  30.       l 
  31.      
  32.     
  33.       _ 
  34.      
  35.     
  36.       G 
  37.      
  38.     
  39.       i 
  40.      
  41.     
  42.       n 
  43.      
  44.     
  45.       i 
  46.      
  47.     
  48.       = 
  49.      
  50.      
  51.      
  52.        ∫ 
  53.       
  54.      
  55.        0 
  56.       
  57.      
  58.        1 
  59.       
  60.      
  61.     
  62.       ∣ 
  63.      
  64.     
  65.       Φ 
  66.      
  67.     
  68.       ( 
  69.      
  70.     
  71.       x 
  72.      
  73.     
  74.       ) 
  75.      
  76.     
  77.       − 
  78.      
  79.     
  80.       Ψ 
  81.      
  82.     
  83.       ( 
  84.      
  85.     
  86.       x 
  87.      
  88.     
  89.       ) 
  90.      
  91.     
  92.       ∣ 
  93.       
  94.     
  95.       d 
  96.      
  97.     
  98.       x 
  99.      
  100.     
  101.    
  102.      Mutual\_Gini = \int_{0}^{1} |\Phi(x) - \Psi(x)| \, dx 
  103.     
  104.    
  105.  Mutual_Gini=∫01​∣Φ(x)−Ψ(x)∣dx
  108.  
  109.   
  110.    
  111.    
  112.      Φ 
  113.     
  114.    
  115.      ( 
  116.     
  117.    
  118.      x 
  119.     
  120.    
  121.      ) 
  122.     
  123.    
  124.   
  125.     \Phi(x) 
  126.    
  127.   
  128. Φ(x) 和  
  129.  
  130.   
  131.    
  132.    
  133.      Ψ 
  134.     
  135.    
  136.      ( 
  137.     
  138.    
  139.      x 
  140.     
  141.    
  142.      ) 
  143.     
  144.    
  145.   
  146.     \Psi(x) 
  147.    
  148.   
  149. Ψ(x) 分别是真实标签和估计值的洛伦兹曲线。如我们所见，互基尼系数的定义帮助我们衡量 LTV 分布的整体准确性，而不是 LTV 预测的逐点损失。这非常关键，因为我们通常依赖于这种分布来做出实际操作决策。

5 实验

在本节中，我们对提出的框架与基线模型在真实工业数据上的表现进行实验评估。首先介绍数据集和实验设置。此外，我们引入了一个新的评估指标——互基尼系数（Mutual Gini），我们认为它可以准确衡量模型对真实不平衡分布的拟合性能。最后，将展示实验结果和分析。

5.1 实验设置

5.1.1 数据集

本实验的数据集来自快手的用户增长业务。快手是一家主要业务为移动短视频的公司。截至2021年11月，快手的日活跃用户（DAU）达到3.2亿，月活跃用户（MAU）超过10亿。我们抽样了1.8亿新用户作为实验数据集，这些数据来自多个用户获取渠道，如新移动设备的预装、应用商店下载、裂变等。数据集的特征包括用户档案数据、渠道相关信息和用户注册快手应用后7天内的行为信息。此外，我们还收集了一些周期性、季节性或异常事件信息作为特征的一部分。特征分为分类类型和数值类型，标签定义为新用户在注册快手应用后的下一个月、季度、半年和一年的活跃天数。也就是说，基于新用户前7天的行为数据和用户属性，我们需要同时估计 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​、 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​、 
  43.  
  44.   
  45.    
  46.    
  47.      l 
  48.     
  49.    
  50.      t 
  51.     
  52.     
  53.     
  54.       v 
  55.      
  56.     
  57.       180 
  58.      
  59.     
  60.    
  61.   
  62.     ltv_{180} 
  63.    
  64.   
  65. ltv180​、 
  66.  
  67.   
  68.    
  69.    
  70.      l 
  71.     
  72.    
  73.      t 
  74.     
  75.     
  76.     
  77.       v 
  78.      
  79.     
  80.       365 
  81.      
  82.     
  83.    
  84.   
  85.     ltv_{365} 
  86.    
  87.   
  88. ltv365​。如图1所示，这是数据集的  
  89.  
  90.   
  91.    
  92.    
  93.      l 
  94.     
  95.    
  96.      t 
  97.     
  98.     
  99.     
  100.       v 
  101.      
  102.     
  103.       365 
  104.      
  105.     
  106.    
  107.   
  108.     ltv_{365} 
  109.    
  110.   
  111. ltv365​ 分布。
5.1.2 实验设置

为了验证模型的性能，我们评估了模型对长期和短期 LTV（例如 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​、 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​、 
  43.  
  44.   
  45.    
  46.    
  47.      l 
  48.     
  49.    
  50.      t 
  51.     
  52.     
  53.     
  54.       v 
  55.      
  56.     
  57.       180 
  58.      
  59.     
  60.    
  61.   
  62.     ltv_{180} 
  63.    
  64.   
  65. ltv180​、 
  66.  
  67.   
  68.    
  69.    
  70.      l 
  71.     
  72.    
  73.      t 
  74.     
  75.     
  76.     
  77.       v 
  78.      
  79.     
  80.       365 
  81.      
  82.     
  83.    
  84.   
  85.     ltv_{365} 
  86.    
  87.   
  88. ltv365​）的预测。我们使用的优化器是 Adam，批量大小经验设定为512，网络参数的学习率为0.05，嵌入的学习率设定为0.1。排序依赖校准损失权重  
  89.  
  90.   
  91.    
  92.    
  93.      α 
  94.     
  95.    
  96.   
  97.     \alpha 
  98.    
  99.   
  100. α 设为1，序数回归蒸馏损失权重  
  101.  
  102.   
  103.    
  104.    
  105.      β 
  106.     
  107.    
  108.   
  109.     \beta 
  110.    
  111.   
  112. β 和  
  113.  
  114.   
  115.    
  116.    
  117.      γ 
  118.     
  119.    
  120.   
  121.     \gamma 
  122.    
  123.   
  124. γ 均设为0.5。在所有 MDME 模块中，子分布的数量为2，切点取决于具体分布。每个子分布的桶数也取决于子分布的不平衡程度。经验上，子分布的数量和每个子分布中的桶数对最终性能有影响，但影响不大。

5.2 性能比较

在这里，我们选择了两种著名的方法作为基线，即 (1) Two-Stage [4] 和 (2) ZILN [18]。没有利用 TSUR [21] 和其他方法作为基线的原因是，它们专注于用户表示学习，可以与我们的框架兼容以获得更好的模型性能。

  • Two-Stage [4] 使用两步法预测 LTV，首先分类用户是否为高级用户，然后预测用户带来的货币价值。
  • ZILN [18] 假设零膨胀长尾 LTV 服从对数正态分布，并利用 DNN 在特征交互和信息捕获中的优势来拟合分布的均值和标准差，最终使用对数正态分布的期望值作为估计的 LTV。

表1：在接下来的30天、90天、180天和365天的LTV预测中的性能比较。最佳结果用粗体标出。基尼系数不是很好地反映模型在拟合不平衡分布上的性能差异的选择，但我们仍然展示了它。

表1展示了所有基线和我们的模型在 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​、 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​、 
  43.  
  44.   
  45.    
  46.    
  47.      l 
  48.     
  49.    
  50.      t 
  51.     
  52.     
  53.     
  54.       v 
  55.      
  56.     
  57.       180 
  58.      
  59.     
  60.    
  61.   
  62.     ltv_{180} 
  63.    
  64.   
  65. ltv180​、 
  66.  
  67.   
  68.    
  69.    
  70.      l 
  71.     
  72.    
  73.      t 
  74.     
  75.     
  76.     
  77.       v 
  78.      
  79.     
  80.       365 
  81.      
  82.     
  83.    
  84.   
  85.     ltv_{365} 
  86.    
  87.   
  88. ltv365​ 预测上的结果。首先，Two-Stage 方法在每个评估指标上表现最差。其次，ZILN 表现较好，但其在 AMBE 上的表现较差，ZILN 和 Two-Stage 方法在互基尼系数上的表现都很差，这意味着它们不能很好地拟合不平衡的 LTV 分布，虽然我们不认为基尼系数是衡量模型性能的好指标。最后，与上述两种方法相比，ODMN 在所有指标上都有显著提高，表现最佳。

5.3 消融研究

在本节中，我们进行消融实验以验证模型中不同模块的影响。实验从两个方向进行，一个是单一时间粒度的 LTV 建模以验证 MDME 模块，另一个是验证 ODMN 框架对多时间跨度 LTV 的建模。

5.3.1 MDME

由于 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       365 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{365} 
  17.    
  18.   
  19. ltv365​ 更难建模，我们通过预测  
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       365 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{365} 
  40.    
  41.   
  42. ltv365​ 来检查 MDME 核心模块或结构的效果。比较了 MDME 的四个变体，包括：(A) NM 表示 Naive MDME，仅依赖分布分割和分桶机制，没有桶偏差回归和序数回归蒸馏，取估计桶的左右边界的均值作为最终估计的 LTV。(B) NMB 表示结合 Naive MDME 和桶偏差回归来预测 LTV。© NMO 表示结合 Naive MDME 和序数回归蒸馏来预测 LTV。(D) MDME 表示我们设计的完整模块。

在表2中，每个变体的性能排名大致可以总结为：NM < NMB < NMO < MDME。我们可以得出三个核心结论：(1) 在每个子分布中引入 BBT 在一定程度上减少了均值偏差。(2) 通过序数回归的辅助蒸馏，互基尼、NRMSE 和 NMAE 等指标大幅减少，表明模型更好地学习了子分布之间和桶之间的有序关系。(3) MDME 整体表现最佳。

5.3.2 ODMN

我们可以通过同时估计 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​、 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       90 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{90} 
  40.    
  41.   
  42. ltv90​、 
  43.  
  44.   
  45.    
  46.    
  47.      l 
  48.     
  49.    
  50.      t 
  51.     
  52.     
  53.     
  54.       v 
  55.      
  56.     
  57.       180 
  58.      
  59.     
  60.    
  61.   
  62.     ltv_{180} 
  63.    
  64.   
  65. ltv180​ 和  
  66.  
  67.   
  68.    
  69.    
  70.      l 
  71.     
  72.    
  73.      t 
  74.     
  75.     
  76.     
  77.       v 
  78.      
  79.     
  80.       365 
  81.      
  82.     
  83.    
  84.   
  85.     ltv_{365} 
  86.    
  87.   
  88. ltv365​ 来验证 ODMN 核心模块的实用性。有四个变体：(E) S 表示使用常规共享底层多任务学习来预测多个 LTV 目标，每个任务由 MDME 建模。(F) SM 表示结合 S 和 Mono 单元来预测多个 LTV 目标。(G) SC 表示结合 S 和排序依赖校准损失来预测多个 LTV 目标。(H) ODMN 表示我们提出的完整框架。

表3展示了 ODMN 四个变体的性能。常规多任务学习的改进有限。Mono 单元及其相关结构在捕捉长期和短期 LTV 之间的单调约束方面确实发挥了重要作用。细粒度的排序依赖校准损失进一步增强了这种单调约束关系。此外，还有一些符合预期的事实。从 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​ 到  
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       365 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{365} 
  40.    
  41.   
  42. ltv365​，基尼系数的增加表明 LTV 分布的不平衡程度增加，建模难度也相应增加。然而，与短期 LTV 相比，长期 LTV 有更大的改进空间，这表明短期 LTV 确实可以在 ODMN 中辅助长期 LTV 建模，证明了框架的有效性。

5.4 在线 A/B 测试

为了进一步验证模型的有效性，我们在快手用户增长的广告中进行了 A/B 测试。具体来说，我们将10%的流量作为对照组，10%的流量作为实验组，使用不同的模型来估计用户的 

  1.      l 
  2.     
  3.    
  4.      t 
  5.     
  6.     
  7.     
  8.       v 
  9.      
  10.     
  11.       30 
  12.      
  13.     
  14.    
  15.   
  16.     ltv_{30} 
  17.    
  18.   
  19. ltv30​，并向 ROI 最高的用户投放广告。为了方便观察实验结果， 
  20.  
  21.   
  22.    
  23.    
  24.      l 
  25.     
  26.    
  27.      t 
  28.     
  29.     
  30.     
  31.       v 
  32.      
  33.     
  34.       30 
  35.      
  36.     
  37.    
  38.   
  39.     ltv_{30} 
  40.    
  41.   
  42. ltv30​ 估计中的建模标签设置为用户在30天后将带给平台的价值。之后的投放策略与两个组相同（因公司隐私省略）。我们累计了7天、14天和30天的实验数据，并计算了两个组的 ROI（投资回报率，因公司隐私省略）。在模型方面，我们选择了性能最好的 ZILN 作为基线，并使用我们的方法作为实验组的模型。

出于公司隐私，只提供我们方法相对于基线的 ROI 改进值，如表4所示。显然，我们的方法表现更好，这进一步证明了所提模型的有效性。

我们的模型已完全部署在快手用户增长业务中。我们采用日级训练和全量用户预测的方法。然后，我们将用户的估计 LTV 保存在缓存中，以便在线实时获取。

6 结论

在本文中，我们提出了一种用于 LTV 建模的排序依赖单调网络（ODMN），充分利用了长期和短期 LTV 之间的有序依赖关系。通过捕捉短期 LTV 输出的桶多项分布的变化趋势，并直接影响长期 LTV 输出分布，我们以粗粒度的方式实现了软单调约束。此外，排序依赖校准损失的利用进一步增强了单调约束关系。对于特定 LTV 的建模，我们提出了一种基于分而治之思想的新型 MDME 模块，逐步划分不平衡的 LTV 分布以缓解不平衡程度。序数回归辅助蒸馏进一步提高了子分布之间和桶之间的排序和分类准确性，大大提高了模型的性能。最后，为了准确衡量模型拟合真实不平衡分布的能力，我们提出了基于洛伦兹曲线的互基尼系数指标。

我们的方法在真实工业数据集上的离线实验和在线应用中都取得了显著的收益，证明了该方法的有效性。

标签： 机器学习 游戏AI应用 预测用户付费
本文转载自: https://blog.csdn.net/hahoo2009/article/details/140532600
版权归原作者 游戏数据科学 所有， 如有侵权，请联系我们删除。
登录后发布评论

“ODMN亿级用户的用户生命周期价值预测：来自快手的工业级解决方案”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
2 相关工作3 方法