MIND模型

Multi-Interest Network with Dynamic Routing for Recommendation at Tmall

1.胶囊网络

将图像倒立，识别率会下降，将眼睛和嘴调换位置，仍能识别为人，所以CNN缺乏对相对空间位置的表达。

非洲还是澳大利亚？转换坐标系，其实是非洲。

low level capsule转化为high level capsule, 每个low level相当于表示实体的不同部分， high level表示整个实体。

三角形的第1个分量表示方向，整个 范数表示实体存在的置信度。

1.1胶囊网络和传统的神经网络的区别

传统的神经网络：（1）标量输入到标量输出的过程。（2）累积求和->激活函数输出

胶囊神经网络：（1）向量输入到向量输出的过程。（3）放射变换(向量乘以矩阵转化为另一个 向量)->通过c做线性加权求和->挤压（squash）->输出v。其中c是通过dynamic routing机制动态决定的。

$\frac{\Vert s{\Vert }^2}{1+\Vert s{\Vert }^2}$： squash类似sigmoid变换的函数，当s的 向量特别长，接近无穷时，将它压缩为1，当s为0时为0.

$\frac{s}{\Vert s\Vert }$为标准化的过程。

$b_{11}和b_{21}$初始化0，b可以理解为agreement（选举的意思，类似总统选举），其中$u_1和u_2$类似总统候选人。b经过softmax生成和为1的权重。经过squash会生成$a_1$, $a_1$和$u_1$的夹角比较接近，就b（agreement）就会靠近$u_1$，update agreement。类似kmeans中心点的计算。v的范数表示confidence。范数很大，表示概率很大。

训练过程： 如果是minist数据集，假设训练的正样本为1，我门希望为的1范数会比较大，其他的范数比较小。

2. MIND

参考文献： https://arxiv.org/pdf/1904.08030.pdf

2.1问题的公式表示

匹配阶段的主要目标就是对每个用户$u\in \mathcal{U}$在几十亿item池子中$\mathcal{I}$，候选集的数量大约几千左右。

每个样本可以用$\left({\mathcal{I}}_u,{\mathcal{P}}_u,{\mathcal{F}}_i\right)$表示，其中${\mathcal{I}}_u$表示与用户交互的item（或者说用户的行为）。${\mathcal{P}}_u$表示用户的基本信息（例如：用户的性别、年龄）。${\mathcal{F}}_i$表示目标 item（例如：item id和category id）。

将原始特征映射为用户表示：
$${\mathrm{V}}_u=f_{\text{user }}\left(I_u,{\mathcal{P}}_u\right)\text{\hspace{1em}(1)}$$

其中：${\mathrm{V}}_u=\left({\overrightarrow{\mathbf{v}}}_u^1,\dots ,{\overrightarrow{\mathbf{v}}}_u^K\right)\in {\mathbb{R}}^{d\times K}$用来表示用户$u$的向量，$d$表示向量维度，$K$表示用户表示的数量，$K=1$表示只有一个向量被使用 ，就像YouTube DNN。

target item $i$的向量表示为：
$${\overrightarrow{\mathbf{e}}}_i=f_{\text{item }}\left({\mathcal{F}}_i\right)\text{\hspace{1em}(2)}$$
其中：${\vec{e}}_i\in {\mathbb{R}}^{d\times 1}$表示item $i$ 的一个向量。

Top N候选集计算：
$$f_{\text{score }}\left({\mathrm{V}}_u,{\overrightarrow{\mathbf{e}}}_i\right)=\underset{1\le k\le K}{\max }{\overrightarrow{\mathbf{e}}}_i^{\mathrm{T}}{\overrightarrow{\mathbf{v}}}_u^k\text{\hspace{1em}(3)}$$
$N$表示候选集的数量。

2.2嵌入和池化层

MIND的 输入特征包括3部分：用户属性特征${\mathcal{P}}_u$、用户的行为特征${\mathcal{I}}_u$和标签item${\mathcal{F}}_i$
${\mathcal{P}}_u$(性别、年龄)进行concatenate。

${\mathcal{F}}_i$（品牌id, shop id）传入average pooling 层，形成item embedding 为${\vec{e}}_i$。

${\mathcal{I}}_u$用户的行为序列，${\mathrm{E}}_u=\left\{{\overrightarrow{\mathbf{e}}}_j,j\in I_u\right\}$。

2.3 多兴趣提取层

对用户的历史行为进行聚类

2.3.1 动态路由

假设有两个capsules, low-level capsules c ⃗ i l ∈ R N l × 1 , i ∈ { 1 , … , m } \vec{c}_{i}^{l} \in \mathbb{R}^{N_{l} \times 1}, i \in\{1, \ldots, m\} c il​∈RNl​×1,i∈{1,…,m} 和high-level capsules c ⃗ j h ∈ R N h × 1 , j ∈ { 1 , … , n } \vec{c}_{j}^{h} \in \mathbb{R}^{N_{h} \times 1}, j \in \{1, \ldots, n\} c jh​∈RNh​×1,j∈{1,…,n}

low-level capsule $i$和 high-level capsule $j$之间的logit $b_{ij}$计算公式如下：
$$b_{ij}={\left({\vec{c}}_j^h\right)}^T{\mathrm{S}}_{ij}{\vec{c}}_i^l\text{\hspace{1em}(4)}$$
其中，${\mathrm{S}}_{ij}\in {\mathbb{R}}^{N_h\times N_l}$是需要学习的双线性映射矩阵。

candidate vector for high-level capsule j
$${\vec{z}}_j^h=\sum _{i=1}^m{w}_{ij}{\mathrm{S}}_{ij}{\overrightarrow{\mathbf{c}}}_i^l\text{\hspace{1em}(5)}$$
$w_{ij}$是连接low-level和high-level之间的权重，计算方式如下：
$$w_{ij}=\frac{\exp b_{ij}}{{\sum }_{k=1}^m\exp b_{ik}}\text{\hspace{1em}(6)}$$
quash 函数应用于high-level capsules， 计算方式如下：
$${\vec{c}}_j^h=\mathrm{squash}\left({\vec{z}}_j^h\right)=\frac{{\Vert {\vec{z}}_j^h\Vert }^2}{1+{\Vert \mid z_j^h\Vert }^2}\frac{{\vec{z}}_j^h}{\Vert {\vec{z}}_j^h\Vert }\text{\hspace{1em}(7)}$$
$b_{ij}$初始化为0， 当路由结束，${\vec{c}}_j^h$可以固定下来，作为下一层的输入。

使用Shared bilinear mapping matrix主要考虑两点：从低阶的用户行为胶囊中学习高阶的用户兴趣胶囊（1）用户行为是变长的，我们希望模型更加通用。（2）我们希望用户行为和用户兴趣能够在一个向量空间中。
b i j = u ⃗ j T   S e → i , i ∈ I u , j ∈ { 1 , … , K } (8) b_{i j}=\vec{u}_{j}^{T} \mathrm{~S} \overrightarrow{\boldsymbol{e}}_{i}, \quad i \in I_{u}, j \in\{1, \ldots, K\}\tag{8} bij​=u jT​ Se i​,i∈Iu​,j∈{1,…,K}(8)
${\vec{e}}_i\in {\mathbb{R}}^d$表示item $i$的用户行为，${\vec{u}}_j\in {\mathbb{R}}^d$表示用户兴趣胶囊$j$。$S\in {\mathbb{R}}^{d\times d}$是用户行为胶囊和用户兴趣胶囊之间的共享矩阵。

**初始化routing logits：**如果矩阵初始化为0，会导致用户兴趣相同，因此采用高斯分布进行初始化。

动态用户兴趣的数量：
$$K_u^{\prime }=\max \left(1,\min \left(K,{\log }_2\left(\left|I_u\right|\right)\right)\right)\text{\hspace{1em}(9)}$$

def build(self, input_shape):
    self.routing_logits = self.add_weight(shape=[1, self.k_max, self.max_len],
                                          initializer=RandomNormal(stddev=self.init_std),
                                          trainable=False, name="B", dtype=tf.float32)
    self.bilinear_mapping_matrix = self.add_weight(shape=[self.input_units, self.out_units],
                                                   initializer=RandomNormal(stddev=self.init_std),
                                                   name="S", dtype=tf.float32)
    super(CapsuleLayer, self).build(input_shape)

def call(self, inputs, **kwargs):
    behavior_embddings, seq_len = inputs
    batch_size = tf.shape(behavior_embddings)[0]
    seq_len_tile = tf.tile(seq_len, [1, self.k_max])

    for i in range(self.iteration_times):
        mask = tf.sequence_mask(seq_len_tile, self.max_len)
        pad = tf.ones_like(mask, dtype=tf.float32) * (-2 ** 32 + 1)
        routing_logits_with_padding = tf.where(mask, tf.tile(self.routing_logits, [batch_size, 1, 1]), pad)
        weight = tf.nn.softmax(routing_logits_with_padding)
        behavior_embdding_mapping = tf.tensordot(behavior_embddings, self.bilinear_mapping_matrix, axes=1)
        Z = tf.matmul(weight, behavior_embdding_mapping)
        interest_capsules = squash(Z)
        delta_routing_logits = reduce_sum(
            tf.matmul(interest_capsules, tf.transpose(behavior_embdding_mapping, perm=[0, 2, 1])),
            axis=0, keep_dims=True
        )
        self.routing_logits.assign_add(delta_routing_logits)
    interest_capsules = tf.reshape(interest_capsules, [-1, self.k_max, self.out_units])
    return interest_capsules

2.3.2 Label-aware Attention

根据 用户的兴趣胶囊和item向量进行attention计算，对item进行加权。label是query, 兴趣胶囊是keys和values。user u的输出向量和item i计算方式如下：
$$\begin{array}{rl}{\vec{v}}_u& =\text{ Attention }\left({\vec{e}}_i,{\mathrm{V}}_u,{\mathrm{V}}_u\right)\\ & ={\mathrm{V}}_u\mathrm{softmax}\left(\mathrm{pow}\left({\mathrm{V}}_u^{\mathrm{T}}{\vec{e}}_i,p\right)\right)\end{array}$$
其中, $p$是调整attention分布的参数，当p为0时， attention是平均的。$p$越大，趋近于无穷时，value更加关注权重最大的值，忽略其他的项。

def call(self, inputs, training=None, **kwargs):
    keys = inputs[0]
    query = inputs[1]
    weight = reduce_sum(keys * query, axis=-1, keep_dims=True)
    weight = tf.pow(weight, self.pow_p)  # [x,k_max,1]

    if len(inputs) == 3:
        k_user = tf.cast(tf.maximum(
            1.,
            tf.minimum(
                tf.cast(self.k_max, dtype="float32"),  # k_max
                tf.log1p(tf.cast(inputs[2], dtype="float32")) / tf.log(2.)  # hist_len
            )
        ), dtype="int64")
        seq_mask = tf.transpose(tf.sequence_mask(k_user, self.k_max), [0, 2, 1])
        padding = tf.ones_like(seq_mask, dtype=tf.float32) * (-2 ** 32 + 1)  # [x,k_max,1]
        weight = tf.where(seq_mask, weight, padding)

    weight = softmax(weight, dim=1, name="weight")
    output = reduce_sum(keys * weight, axis=1)

    return output

2.3.3 Training&Serving

得到用户的向量${\vec{v}}_u$和标签的向量${\vec{e}}_i$， 计算用户和标签的之间的交互的概率
$$\mathrm{Pr}(i\mid u)=\mathrm{Pr}\left({\vec{e}}_i\mid {\vec{v}}_u\right)=\frac{\exp \left({\vec{v}}_u^{\mathrm{T}}{\vec{e}}_i\right)}{{\sum }_{j\in I}\exp \left({\vec{v}}_u^{\mathrm{T}}{\vec{e}}_j\right)}\text{\hspace{1em}(10)}$$
训练的目标函数：
$$L=\sum _{(u,i)\in \mathcal{D}}\log \mathrm{Pr}(i\mid u)\text{\hspace{1em}(11)}$$
其中$\mathcal{D}$是包括用户和item的训练数据