### 一. 概述

DCN是一个可以同时高效学习低维特征交叉和高维非线性特征的深度模型，不需要人工特征工程的同时需要的计算资源非常低。

DCN的模型结构如下图所示
可以看到DCN分成4部分。最底下是**Embedding and stacking layer**，中间部分是**Cross network**和**Deep network**，最上面是**Combination output layer**。下面分别对每个部分进行讲解



![image.png](https://www.brucewu1234.com/static/img/1ec9ce577e3876d8e18bc1ffb33063de.image.webp)




### 二. Embedding and stacking layer

这一层是模型的输入层。我们知道输入的特征分为稠密和稀疏特征

对于稀疏特征，我们一般采用one hot encoding的方式进行编码，然后再经过一层embedding将one hot embedding转换成稠密向量。

最后，将稠密特征和经过转换的稀疏特征对应的稠密向量concat起来组成模型的最终输入，也就是图中的$$x_0$$。

输入层实际示例图如下：
![image.png](https://www.brucewu1234.com/static/img/cee91210ac0066abe0d087314e221ae5.image.webp)



### 三. Cross Network

在cross network里面我们主要使用以下的公式进行一层一层的叠加，完成特征的显示高效交叉：
![image.png](https://www.brucewu1234.com/static/img/ea9acc19899741c8e3884d782466619c.image.webp)

可视化如下图所示



![image.png](https://www.brucewu1234.com/static/img/9142dc602bba7ba39692e780a2bf0a11.image.webp)w和b是我们要学习的参数，可以看到在cross network里面，输入和输出的维度是一样的。

为什么这么设计？cross network为1层的时候，我们可以得到的最高是2维的特征交叉；cross network为2层的时候，我们得到的是最高3维的特征交叉；cross network为3层的时候，我们得到的是最高4维的特征交叉；以此类推...

举个例子，假如让偏置b为0，$$x_0$$的长度为2。那么第一层的cross layer的输出为：

![image.png](https://www.brucewu1234.com/static/img/def474028729eebab2734e2bc3539800.image.webp)

第二层如下：


![image.png](https://www.brucewu1234.com/static/img/95d006754d0fdcb19fcefe58c034b954.image.webp)

从上面两个公式的红色部分可以看到，X1相当于两个特征交叉，X2最多则有三个特征交叉，所以我们说，Cross Network的交叉度是多项式级别的。

因此cross network以一种参数共享的方式，通过对叠加层数的控制，可以高效地学习出低维的特征交叉组合，避免了人工特征工程。

可能有人会问，Deep Network也有特征交叉的能力，为什么要单独设计Cross Network，这个观察是对的，Deep Network确实有一定交叉能力，但存在一些效率和显式程度上的不足。Cross Network则是一种补足方式。下面来探讨一下二者在特征交叉方面的区别<br>
1. 交叉的“显式” vs “隐式”
- Cross Network（显式交叉）：
    - Cross Network的设计非常直接，它的核心公式是：
$x_{l+1} = x_0 x_l^T w_l + b_l + x_l$
    - 这个公式意味着，每一层都在显式地计算输入特征$$x_0$$和当前层特征$$x_l$$的外积，通过层数累加，可完成更多特征的直接交叉，这是一种有意识的、受控的、高效的交叉方式。
    - 它可以被认为是一种参数化的、向量形式的FM（Factorization Machines）泛化，能够自动学习特定交叉特征的重要性。
    - 优势：对于某些特别重要的、有明确物理意义的特征组合（例如“用户年龄”和“保险产品类型”），Cross Network可以非常高效且直接地将其建模出来。
- Deep Network（隐式交叉）：
    - Deep Network通过多层感知机和激活函数（如ReLU）来学习非线性关系。
    - 它的交叉是隐式的、黑盒的。我们不知道它具体在哪些层、以何种方式组合了哪些特征。交叉是在神经元的多层非线性变换中“涌现”出来的。
    - 劣势：为了学到同样重要的高阶特征交叉，Deep Network可能需要更宽或更深的网络，以及更多的数据和计算资源。它可能无法像Cross Network那样“精准”且“高效”地捕获某些特定交叉。
2. 参数效率和模型容量
- Cross Network 的参数非常少，主要就是每层的向量$$w_l$$和$$b_l$$。它的设计目的是用最少的参数专门负责“特征交叉”这件事。Cross Network可以在$$L$$层内，高效地生成输入特征最高$$L+1$$阶的交叉特征
- Deep Network 的参数更多（全连接层），它负责的是学习更普适、更复杂的非线性模式，其中既包含了特征交叉，也包含了其他复杂的变换。一个经典的$$L$$层DNN，其隐式特征交叉的阶数同样为$$L+1$$阶，但要学习到同样程度的高阶交叉，DNN通常需要更深的网络或更多的参数，学习起来更“费力”。

**总结**

| 特性 | Cross Network	 | Deep Network |
| --- | --- | --- |
| 交叉方式 | 显式、受控 | 隐式、黑盒 |
| 主要职责 | 专门、高效地学习特征交叉 | 学习所有复杂的非线性模式 |
| 效率 | 参数少，高效生成高阶交叉 | 参数多，学习高阶交叉相对低效 |
| 角色 | 专家（特征交叉专家） | 通才（通用函数逼近器） |


### 四. Deep Network
deep network部分就是传统的全连接前馈神经网络，用来学习高维非线性特征交叉组合。公式如下所示


![image.png](https://www.brucewu1234.com/static/img/87c22c94fe0bca0252ea6c1646a66ab8.image.webp)

### 五. Combination Output Layer

最后，将cross network和deep network的输出concat起来，通过一个logit层，对于一个二分类问题，公式如下图所示


![image.png](https://www.brucewu1234.com/static/img/42a424931ba9b74d413d09eebb99207c.image.webp)

损失函数为


![image.png](https://www.brucewu1234.com/static/img/422051d38039e4f5caf41e3c9c8ad82d.image.webp)

公式最右边一项为l2正则


**文章参考**

[[深度模型] Deep & Cross Network (DCN)](https://zhuanlan.zhihu.com/p/138358291)<br>
[[深度模型] Deep & Cross Network (DCN)](https://zhuanlan.zhihu.com/p/389444680)

vanblog配置问题

1、CPU密集型
CPython中使用到了GIL，多线程的时候锁相互竞争，且多核优势不能发挥，选用Python多进程效率更
高。即使用ProcessPoolExecutor
2、IO密集型
在Python中适合是用多线程，可以减少多进程间IO的序列化开销。且在IO等待的时候，切换到其他线程
继续执行，效率不错。即ThreadPoolExecutor


ThreadPoolExecutor 和 ProcessPoolExecutor 都是python中的并发执行框架，但它们之间有一些区别：
线程 vs 进程：ThreadPoolExecutor 使用线程池来执行任务，而 ProcessPoolExecutor 使用进程池来执行任务。因为线程是在同一个进程内运行的，所以线程之间共享了进程的内存空间，这意味着线程之间的通信和数据共享比进程更容易。但是，由于 Python 的全局解释器锁（GIL）的存在，同一时刻只有一个线程可以执行 Python 代码，这意味着在 CPU 密集型任务中，多线程并不能真正发挥多核 CPU 的优势。而进程之间是相互独立的，不受 GIL 的限制，可以充分利用多核 CPU 资源。


适用场景：由于 GIL 的限制，ThreadPoolExecutor 更适合于 I/O 密集型任务，如网络请求、文件读写等操作，而 ProcessPoolExecutor 更适合于 CPU 密集型任务，如大量计算、图像处理等操作。

系统资源消耗：由于进程之间是相互独立的，ProcessPoolExecutor 需要更多的系统资源来维护进程之间的通信和数据共享，而 ThreadPoolExecutor 只需要维护线程之间的通信和数据共享，所以在系统资源有限的情况下，ThreadPoolExecutor 更加适合。

ThreadPoolExecutor代码示例
```python
from concurrent.futures import ThreadPoolExecutor
import concurrent
def func():
  pass
with ThreadPoolExecutor(max_workers=15) as executor:
      tasks = {}
      case_number = 0
      finished = 0
      for idx, row in df.iterrows():
          tasks[executor.submit(func, session, row['col1'])] = (row['col2'], row['col3'])
          case_number += 1
        split_part_num = case_number // 200
        for future in concurrent.futures.as_completed(tasks):
            cate_id_list, cate_name_list, confidence_list = future.result()
          request_id, row_list = tasks[future]
          name, code = tasks[future]
          if len(cate_name_list.split(';')) >= 1:
              res_cate_name = cate_name_list.split(';')[0]
              res_cate_id = cate_id_list.split(';')[0]
              # res_confidence = confidence_list.split(';')[0]
              res_confidence = confidence_list[0]
              cate_path = back_tree[res_cate_id]
              res_data.append([name, code, res_cate_id, res_cate_name, cate_path, res_confidence])
          else:
              res_data.append(['', '', '', ''])
          finished += 1
          if finished % split_part_num == 0:
              print("【 total finished:{}% 】".format(0.5 * finished / split_part_num))
      print('done')
```