关键词：PNN，推荐算法，FM，DNN

内容摘要

• PNN介绍和结构简述
• 基于内积的IPNN
• 基于外积的OPNN
• 基于内外积融合的PNN*
• PNN和FM，FNN，DeepFM的联系
• PNN的三种形式在PyTorch下的实践

PNN介绍和结构简述

PNN（Product-based Neural Networks）是2016年提出的一种基于向量乘积和多层感知机的推荐排序算法，他将FM和DNN串行结合，即先利用FM的向量乘积形式来表征二阶交叉信息，再输入给DNN这种全连接形式，使得二阶信息叠加非线性能力，期望这种组合能够学到更高阶的交叉信息。

PNN的网络结构如下

数据从最下层的input输入到最上层的CTR输出，其中Embedding Layer和Product Layer是FM，L1和L2 Fully Connected是DNN，Product Layer层对FM的内积做了拓展，不仅支持向量内积，还支持向量外积，内外积融合一共三种向量积表征方式。

原始onehot输入经过Embedding Layer转化为隐向量，在Product Layer中计算出一阶特征z和交叉特征p，其中z是所有隐向量和常数1相乘，本质上就是将上一个嵌入层的embedding照搬过来，将所有特征的embedding进行拼接组合成z部分。

p部分是所有特征的两两向量乘积运算，只计算半三角因此一共有field_num×(field_num-1)个输出结果，其中field_num是特征域数量，根据乘积的方式不同有三种策略

• 内积 IPNN：一对向量进行内积点乘输出一个标量，因此图中p部分的一个圈代表一个值
• 外积 OPPN：A向量转置和B向量进行矩阵相乘，若隐向量的维度为M，则输出一个M×M的矩阵，为了能使矩阵做信息浓缩输入到下一层，PNN引入了同样是是M×M形状的可学习的权重矩阵W，对应位置的两矩阵做哈达马积（element-wise乘法）再求和输出一个标量，因此外积的策略下p部分的一个圈也代表一个值
• 内外积融合 PNN*：将内积的输出向量，和外积的输出向量进行拼接，作为p部分的最终输出，此时输出维度为原来的两倍为field_num×(field_num-1)×2

p部分的结果和z部分再拼接形成了最终DNN的输入，经过两层隐藏层sigmoid输入二分类交叉熵完成模型损失迭代。

PNN和FM，FNN，DeepFM的联系

PNN和FM：

若删除PNN的两层DNN，采用内积Product，所有p的标量相加，则PNN退化为FM，本质上PNN是将FM的内积结果不直接相加输出，而是作为中间结果继续灌入多层感知机做训练。

PNN和FNN：

FNN也是将FM的结果作为DNN的输入，而FNN是两阶段模型，先训练一个FM得到每个特征的嵌入向量，再将所有嵌入向量拼接输入到全连接层，如果删除PNN的Product Layer，PNN退化为FNN。

PNN和DeepFM：

两者都是将FM融入和深度学习的算法策略，PNN是FM和MLP的串行，MLP依赖于FM的输出，而DeepFM是FM和MLP的并行，FM和MLP共享底层联合训练。

PNN的三种形式在PyTorch下的实践

本次实践的数据集和上一篇特征交叉系列：完全理解FM因子分解机原理，配代码实战一致，采用用户的购买记录流水作为训练数据，用户侧特征是年龄，性别，会员年限等离散特征，商品侧特征采用商品的二级类目，产地，品牌三个离散特征，随机构造负样本，一共有10个特征域，全部是离散特征，对于枚举值过多的特征采用hash分箱，得到一共72个特征。

通过PyTorch构造PNN网络结构如下

class Embedding(nn.Module):
    def __init__(self, feat_num, emb_size):
        super(Embedding, self).__init__()
        self.emb = nn.Embedding(feat_num, emb_size)
        nn.init.xavier_normal_(self.emb.weight.data)

    def forward(self, x):
        # [None, field_num] => [None, field_num, emb_size]
        return self.emb(x)


class InnerProductLayer(nn.Module):
    def __init__(self, field_num):
        super(InnerProductLayer, self).__init__()
        self.field_num = field_num

    def forward(self, x):
        # [None, field_num, emb_size]
        p_index = []
        q_index = []
        for i in range(self.field_num - 1):
            for j in range(i + 1, self.field_num):
                p_index.append(i)
                q_index.append(j)
        # [None, pair_size, emb_size] * [None, pair_size, emb_size] => [None, pair_size, emb_size] => [None, pair_size]
        return torch.sum(x[:, p_index] * x[:, q_index], dim=2)
    
    
class OuterProductLayer(nn.Module):
    def __init__(self, field_num, emb_size):
        super(OuterProductLayer, self).__init__()
        self.field_num = field_num
        self.pair_size = int(field_num * (field_num - 1) / 2)
        self.w = nn.Parameter(torch.zeros(self.pair_size, emb_size, emb_size))
        nn.init.xavier_normal_(self.w.data)

    def forward(self, x):
        # TODO 更优的写法
        """
        kernel = self.w.permute(2, 0, 1)
        kp = torch.sum(p.unsqueeze(1) * kernel, dim=-1).permute(0, 2, 1)
        return torch.sum(kp * q, -1)
        """
        # [None, field_num, emb_size]
        p_index = []
        q_index = []
        for i in range(self.field_num - 1):
            for j in range(i + 1, self.field_num):
                p_index.append(i)
                q_index.append(j)
        p = x[:, p_index]
        q = x[:, q_index]
        # [None, pair_size, emb_size, 1] * [None, pair_size, 1, emb_size] => [None, pair_size, emb_size, emb_size]
        pq = torch.unsqueeze(p, dim=-1) * torch.unsqueeze(q, dim=-2)
        return torch.sum(torch.sum(pq * self.w, dim=-1), dim=-1)


class InnerOuterProductLayer(nn.Module):
    def __init__(self, field_num, emb_size):
        super(InnerOuterProductLayer, self).__init__()
        self.inner = InnerProductLayer(field_num)
        self.outer = OuterProductLayer(field_num, emb_size)

    def forward(self, x):
        return torch.concat([self.inner(x), self.outer(x)], dim=1)


class PNN(nn.Module):
    def __init__(self, field_num, feat_num, emb_size, fc_dims=(64, 16), dropout=0.1, method="inner"):
        super(PNN, self).__init__()
        if method == 'inner':
            self.pn = InnerProductLayer(field_num)
        elif method == 'outer':
            self.pn = OuterProductLayer(field_num, emb_size)
        elif method == 'all':
            self.pn = InnerOuterProductLayer(field_num, emb_size)
        else:
            raise ValueError('unknown product type: ' + method)
        self.field_num = field_num
        self.emb_size = emb_size
        self.embedding = Embedding(feat_num, emb_size)
        cross_out_dim = int(field_num * (field_num - 1) / 2)
        if method == 'all':
            cross_out_dim *= 2
        fc_input_dim = cross_out_dim + field_num * emb_size
        fc_layers = []
        for fc_dim in fc_dims:
            fc_layers.append(torch.nn.Linear(fc_input_dim, fc_dim))
            fc_layers.append(torch.nn.BatchNorm1d(fc_dim))
            fc_layers.append(torch.nn.ReLU())
            fc_layers.append(torch.nn.Dropout(p=dropout))
            fc_input_dim = fc_dim
        fc_layers.append(nn.Linear(fc_input_dim, 1))
        self.mlp = nn.Sequential(*fc_layers)

    def forward(self, x):
        # [None, field_num] => [None, field_num, emb_size]
        emb = self.embedding(x)
        # [None, field_num * emb_size]
        linear = emb.reshape(-1, self.field_num * self.emb_size)
        # [None, field_num * (field_num - 1) / 2]
        cross = self.pn(emb)
        fc_input = torch.concat([linear, cross], dim=1)
        out = torch.sigmoid(self.mlp(fc_input))
        return out.squeeze(dim=1)

在PNN模型主模块中定义了inner，outer，all三种方式分别对应内积，外积，内外积融合，其中内外积融合分别调用内积和外积的子模块，将结果进行拼接作为输出结果。

本例全部是离散分箱变量，所有有值的特征都是1，因此只要输入有值位置的索引即可，一条输入例如

>>> train_data[0]
Out[120]: (tensor([ 2, 10, 14, 18, 34, 39, 47, 51, 58, 64]), tensor(0))

其中x的长度10代表10个特征域，每个域的值是特征的全局位置索引，从0到71，一共72个特征，索引的目的是在模型中通过nn.Embedding映射到对应的隐向量。
采用10次验证集AUC不上升作为早停依据，IPNN，OPNN，PNN*的验证集平均AUC如下，加入FM作为baseline做对比

从结果来看PNN模型利用并拓展了FM，AUC确实比FM有明显提升（+0.05），而三种不同的PNN向量积策略中，内外积融合的PNN*效果最好，外积效果略优于内积。