Wide&Deep Model、Wide Model（LR）、Deep Model、DeepFm Model、NFM Model复现笔记

声明：本模型复现笔记记录自己学习过程，如果有错误请各位老师批评指正。

本周复现了Wide&Deep Model、Wide Model、Deep Model、DeepFm Model、NFM Model

dataset：cretio数据集（选取了train 20000， test 5000）

Wide&Deep Model结合了Wide Model（LR）的记忆性和Deep Model的泛化能力，对于部署应用来说会提高用户的获取率和满意度，但是Wide&Deep的Wide part，需要专业的人员来发掘某些特征之间的共现关系，这就需要大量专业人工参与。

DeepFm Model 对Wide&Deep Model做了改进，对于Wide部分换成了FM Model具有了自动的特征组合能力。

NFM Model：是对FM、FFM的模型改进，FM、FFM其实就是一个二阶的特征交叉，它们会受到组合爆炸问题，限制了FM、FFM的表达能力。NFM 就利用DNN去拟合FM的二阶交叉特征。如果NFM一阶部分是线性模型，也可以看成是Wide&Deep的改进，只不过在Deep部分加了特征交叉池化层。

Wide&Deep Model

Wide部分的输入是原始特征（dense feature 和 经过Embeddings 的sparse feature）和交叉积特征转换数据

交叉积特征转换数据计算为：

Deep部分的输入是dense feature 和 经过Embeddings 的sparse feature

class Linear(nn.Module):
 
    def __init__(self, input_dim):
        super(Linear, self).__init__()
        self.Linear = nn.Linear(in_features = input_dim, out_features = 1)
        
    def forward(self, x):
        return self.Linear(x)
    
class Dnn(nn.Module):

    def __init__(self, hidden_units, dropout = 0.):
        super(Dnn, self).__init__()
        self.dnn_network = nn.ModuleList([nn.Linear(layer[0],layer[1]) for layer in list(zip(hidden_units[:-1] , hidden_units[1:]))])
        self.dropout = nn.Dropout(p = dropout)
        
    def forward(self, x):
        
        for linear in self.dnn_network:
            x = linear(x)
            x = self.dropout(x)
            x = F.relu(x)
            
        return x

class WideandDeep(nn.Module):

    def __init__(self, feature_columns, hidden_units, dnn_dropout = 0.):
        super(WideandDeep, self).__init__()
        self.dense_feature_cols, self.sparse_feature_cols = feature_columns
        
        #embedding 
        self.embed_layers = nn.ModuleDict({
            'embed_' + str(i):nn.Embedding(num_embeddings = feat['feat_num'], embedding_dim = feat['embed_dim'])
            for i ,feat in enumerate(self.sparse_feature_cols)
        })
        
        hidden_units.insert(0, len(self.dense_feature_cols) + len(self.sparse_feature_cols) * self.sparse_feature_cols[0]['embed_dim'])
        self.dropout = nn.Dropout(p = dnn_dropout)
        self.dnn_network = Dnn(hidden_units,dnn_dropout)
        self.Linear = Linear(len(self.dense_feature_cols) + 1)
        self.final_linear = nn.Linear(hidden_units[-1]+ 1, 1)
        
    def forward(self, x):
        dense_inputs , sparse_inputs = x[:,:len(self.dense_feature_cols)], x[:,len(self.dense_feature_cols):]
        sparse_inputs = sparse_inputs.long()
        sparse_embeds = [self.embed_layers['embed_'+str(i)](sparse_inputs[:,i]) for i in range(sparse_inputs.shape[1])]
        sparse_embeds = torch.cat(sparse_embeds, axis = -1)
        
        dnn_input = torch.cat([sparse_embeds, dense_inputs], axis=-1)
        
        #n = 190000
        #a = [print(sparse_inputs[:,i].max()) for i in range(sparse_inputs.shape[1])]
        
        sparse_one_hot = [F.one_hot(sparse_inputs[:,i],sparse_inputs[:,i].max()+1)  for i in range(sparse_inputs.shape[1]) ]

        sparse_one_hot = torch.cat(sparse_one_hot,axis=-1)
        
        sparse_one_hot = torch.tensor(sparse_one_hot)
        #print(sparse_one_hot.shape)
        sparse_one_hot = sparse_one_hot.reshape(dense_inputs.shape[0],-1)
        c = torch.zeros(dense_inputs.shape[0] ,sparse_one_hot.shape[1] )
        for i in range(0,dense_inputs.shape[0]):
            c[i][1456]=1
            c[i][16123]=1
        
        cross = torch.prod(torch.pow(sparse_one_hot,c),axis = 1)
        cross = cross.reshape(-1,1)
        dense_input = torch.cat([dense_inputs,cross],axis=-1)
        
        #wide
        wide_out = self.Linear(dense_input) # (,14)
        #print(wide_out.shape)
        #deep
        deep_out = self.dnn_network(dnn_input)#(,64)
        #print(deep_out.shape)
        output = torch.cat([wide_out, deep_out] ,axis = -1 )
        
        outputs = F.sigmoid(self.final_linear(output))
        
        return outputs

重点难点：Wide部分的交叉积特征转换数据不容易复现，我通过观察数据，找到了一个组合特征。
这是实现交叉积特征转换数据的主要代码：
流程：所有sparse feature转成one_hot编码 ，设置C矩阵（函数中做指数），利用torch.pow和torch.prod完成函数运算，最后拼接到wide的输入。

		sparse_one_hot = [F.one_hot(sparse_inputs[:,i],sparse_inputs[:,i].max()+1)  for i in range(sparse_inputs.shape[1]) ]

        sparse_one_hot = torch.cat(sparse_one_hot,axis=-1)
        
        sparse_one_hot = torch.tensor(sparse_one_hot)
        #print(sparse_one_hot.shape)
        sparse_one_hot = sparse_one_hot.reshape(dense_inputs.shape[0],-1)
        c = torch.zeros(dense_inputs.shape[0] ,sparse_one_hot.shape[1] )
        for i in range(0,dense_inputs.shape[0]):
            c[i][1456]=1
            c[i][16123]=1
        
        cross = torch.prod(torch.pow(sparse_one_hot,c),axis = 1)
        cross = cross.reshape(-1,1)
        dense_input = torch.cat([dense_inputs,cross],axis=-1)
        
        #wide
        wide_out = self.Linear(dense_input) # (,14)

效果：batch_size= 256，数据小容易过拟合，加入了L2正则化（0.005），dropout（0.3）

Wide Mode

仅仅是LR，输入数据是dense feature 和 经过embedding层的sparse feature

class Linear(nn.Module):

    def __init__(self, feature_columns, dnn_dropout = 0.):
        super(Linear, self).__init__()
        
        self.dense_feature_cols,self.sparse_feature_cols = feature_columns
        #embedding
        self.embed_layers = nn.ModuleDict({
            'embed_'+str(i):nn.Embedding(num_embeddings = feat['feat_num'], embedding_dim = feat["embed_dim"])
             for i, feat in enumerate(self.sparse_feature_cols)
        })
        input_dim = len(self.dense_feature_cols) + len(self.sparse_feature_cols) * self.sparse_feature_cols[0]['embed_dim']
        self.Linear = nn.Linear(in_features = input_dim, out_features = 1)
        
    def forward(self, x):
        dense_inputs ,sparse_inputs = x[:,:len(self.dense_feature_cols)],x[:,len(self.dense_feature_cols):]
        sparse_inputs =  sparse_inputs.long()
        sparse_embeds = [self.embed_layers['embed_'+str(i)](sparse_inputs[:,i]) 
                        for i in range(sparse_inputs.shape[1])]
        sparse_embeds = torch.cat(sparse_embeds, axis = -1)
        
        wide_inputs = torch.cat([dense_inputs,sparse_embeds] , axis = -1)
        outputs = self.Linear(wide_inputs)
        return F.sigmoid(outputs)

效果： batch_size= 256，L2正则化（0.005），dropout（0.3）

Deep Model:

class Dnn(nn.Module):
  
    def __init__(self, feature_columns, hidden_units, dnn_dropout = 0.):
        super(Dnn, self).__init__()
        
        self.dense_feature_cols,self.sparse_feature_cols = feature_columns
        #embedding
        self.embed_layers = nn.ModuleDict({
            'embed_'+str(i):nn.Embedding(num_embeddings = feat['feat_num'], embedding_dim = feat["embed_dim"])
             for i, feat in enumerate(self.sparse_feature_cols)
        })
        hidden_units.insert(0,len(self.dense_feature_cols) + len(self.sparse_feature_cols) * self.sparse_feature_cols[0]['embed_dim'])
        self.dnn_network = nn.ModuleList([nn.Linear(layer[0],layer[1]) for layer in list(zip(hidden_units[:-1], hidden_units[1:]))])
        self.dropout = nn.Dropout(p = dnn_dropout)
        self.final_linear = nn.Linear(hidden_units[-1], 1 )
        
    def forward(self, x):
        dense_inputs ,sparse_inputs = x[:,:len(self.dense_feature_cols)],x[:,len(self.dense_feature_cols):]
        sparse_inputs =  sparse_inputs.long()
        sparse_embeds = [self.embed_layers['embed_'+str(i)](sparse_inputs[:,i]) 
                        for i in range(sparse_inputs.shape[1])]
        sparse_embeds = torch.cat(sparse_embeds, axis = -1)
        
        dnn_inputs = torch.cat([dense_inputs,sparse_embeds] , axis = -1)
        
        for layer in self.dnn_network:
            dnn_inputs = layer(dnn_inputs)
            dnn_inputs = F.relu(dnn_inputs)
        
        output =  F.sigmoid(self.final_linear(dnn_inputs))
        return output

效果：batch_size= 256，L2正则化（0.005），dropout（0.3）

Wide&Deep Model VS Wide Model VS Deep Model

Wide&Deep Model 、 Wide Model 、 Deep Model 训练损失比较

Wide&Deep Model 、 Wide Model 、 Deep Model 训练AUC比较

Wide&Deep Model 、 Wide Model 、 Deep Model 测试集损失比较

Wide&Deep Model 、 Wide Model 、 Deep Model 测试集AUC比较

结论：Wide&Deep结合了记忆性和泛化性确实比朴素LR和朴素DNN效果好一点，论文中给出的三者的AUC几乎一样，文章中给出说明是利用cross-product feature去增加在线用户获取率，提高1%的效率对于大的互联网公司来说就可以获得巨大收益。

DeepFM

DeepFM对于Wide&Deep模型的改进是用FM替换了原来的Wide部分，加强了浅层网络部分特征组合的能力。同时，FM部分和DNN部分共享相同的EMbedding层。
左侧的FM部分对不同的特征域的EMbedding进行了两两交叉，即将Embedding向量当作原FM中的特征向量V。

class FM(nn.Module):

    def __init__(self, latent_dim, fea_num):
        
        super(FM, self).__init__()
        
        self.latent_dim = latent_dim
        
        self.w0 = nn.Parameter(torch.zeros([1,]))
        self.w1 = nn.Parameter(torch.rand([fea_num, 1]))
        self.w2 = nn.Parameter(torch.rand([fea_num, latent_dim]))
        
    def forward(self, inputs):   
        # 一阶
        first_order = self.w0 + torch.mm(inputs, self.w1)      
        # 二阶 
        second_order = 1/2 * torch.sum(torch.pow(torch.mm(inputs, self.w2), 2) - torch.mm(torch.pow(inputs,2), torch.pow(self.w2, 2)),dim = 1,keepdim = True)        
        
        return first_order + second_order 

class Dnn(nn.Module):
    def __init__(self, hidden_units, dropout=0.):
        super(Dnn, self).__init__()
        
        self.dnn_network = nn.ModuleList([nn.Linear(layer[0], layer[1]) for layer in list(zip(hidden_units[:-1], hidden_units[1:]))])
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, x):  
        for linear in self.dnn_network:
            x = linear(x)
            x = F.relu(x)    
        x = self.dropout(x) 
        return x

class DeepFM(nn.Module):
    def __init__(self, feature_columns, hidden_units, dnn_dropout=0.):
    
        super(DeepFM, self).__init__()
        self.dense_feature_cols, self.sparse_feature_cols = feature_columns
        
        # embedding
        self.embed_layers = nn.ModuleDict({
            'embed_' + str(i): nn.Embedding(num_embeddings=feat['feat_num'], embedding_dim=feat['embed_dim'])
            for i, feat in enumerate(self.sparse_feature_cols)
        })
        

        self.fea_num = len(self.dense_feature_cols) + len(self.sparse_feature_cols)*self.sparse_feature_cols[0]['embed_dim']
        hidden_units.insert(0, self.fea_num)
        
        self.fm = FM(self.sparse_feature_cols[0]['embed_dim'], self.fea_num)     
        self.dnn_network = Dnn(hidden_units, dnn_dropout)
        self.nn_final_linear = nn.Linear(hidden_units[-1], 1)
    
    def forward(self, x):
        dense_inputs, sparse_inputs = x[:, :len(self.dense_feature_cols)], x[:, len(self.dense_feature_cols):]
        sparse_inputs = sparse_inputs.long()       
        sparse_embeds = [self.embed_layers['embed_'+str(i)](sparse_inputs[:, i]) for i in range(sparse_inputs.shape[1])]
        sparse_embeds = torch.cat(sparse_embeds, dim=-1)
        

        x = torch.cat([sparse_embeds, dense_inputs], dim=-1)
        # Wide
        wide_outputs = self.fm(x)
        # deep
        deep_outputs = self.nn_final_linear(self.dnn_network(x))
 
        outputs = F.sigmoid(torch.add(wide_outputs, deep_outputs))
        
        return outputs

效果：batch_size= 256，L2正则化（0.006），dropout（0.4）

DeepFM VS Wide&Deep

结论： DeepFM具有自动进行特征组合的能力，效果还是比wide&deep效果要好。但是epoch=4前 wide&deep优于DeepFM的原因：我认为是FM的随机初始化导致的auc比wide&deep低。

NFM Model

NFM是对FM、FFM的模型改进，FM、FFM其实就是一个二阶的特征交叉，它们会受到组合爆炸问题，限制了FM、FFM的表达能力。

之前看到过一句话“深度学习网络理论上有拟合任何复杂函数的能力”，就是用DNN来拟合表达能力更强的函数。

NFM 就利用DNN去拟合FM的二阶交叉特征。

如果NFM一阶部分是线性模型，也可以看成是Wide&Deep的改进，只不过在Deep部分加了特征交叉池化层。
模型的其他层都与前面一样含义，新添加的是Bi-interaction Pooling layer。

Bi-interaction Pooling layer:

其中前一层中的Embeding层Vx = [ x1v1,x2v2,…,xnvn ]

在进行两两Embedding向量的元素积操作后，对交叉特征向量取和，得到池化层的输出向量。

然后再把该向量输入到下一层的DNN中，进行进一步的交叉特征。

注意： 设计模型时不要忘了一阶函数。

class Dnn(nn.Module):
    def __init__(self, hidden_units, dropout=0.):
        
        super(Dnn, self).__init__()
        
        self.dnn_network = nn.ModuleList([nn.Linear(layer[0], layer[1]) for layer in list(zip(hidden_units[:-1], hidden_units[1:]))])
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, x):  
        for linear in self.dnn_network:
            x = linear(x)
            x = F.relu(x)    
        x = self.dropout(x) 
        return x

class NFM(nn.Module):
    def __init__(self, feature_columns, hidden_units, dnn_dropout=0.):
        
        super(NFM, self).__init__()
        self.dense_feature_cols, self.sparse_feature_cols = feature_columns
        
        # embedding
        self.embed_layers = nn.ModuleDict({
            'embed_' + str(i): nn.Embedding(num_embeddings=feat['feat_num'], embedding_dim=feat['embed_dim'])
            for i, feat in enumerate(self.sparse_feature_cols)
        })
        
       
        self.fea_num = len(self.dense_feature_cols) + self.sparse_feature_cols[0]['embed_dim']
        hidden_units.insert(0, self.fea_num)
        
        self.bn = nn.BatchNorm1d(self.fea_num)     
        self.dnn_network = Dnn(hidden_units, dnn_dropout)
        input_dim  = len(self.dense_feature_cols)  + len(self.sparse_feature_cols) * self.sparse_feature_cols[0]['embed_dim']
        self.Linear = nn.Linear(input_dim,32)
        self.nn_final_linear = nn.Linear(hidden_units[-1], 1)
    
    def forward(self, x):
        dense_inputs, sparse_inputs = x[:, :len(self.dense_feature_cols)], x[:, len(self.dense_feature_cols):]
        sparse_inputs = sparse_inputs.long()      
        sparse_embeds = [self.embed_layers['embed_'+str(i)](sparse_inputs[:, i]) for i in range(sparse_inputs.shape[1])]
        L_sparse_embeds = torch.cat( sparse_embeds,axis = -1)
        sparse_embeds = torch.stack(sparse_embeds)     
        sparse_embeds = sparse_embeds.permute((1, 0, 2))
       
        embed_cross = 1/2 * (
            torch.pow(torch.sum(sparse_embeds, dim=1),2) - torch.sum(torch.pow(sparse_embeds, 2), dim=1)
        )  
        
        #wide
        lr_input = torch.cat([dense_inputs,L_sparse_embeds],axis = -1)
        lr_output = self.Linear(lr_input)
        #print(lr_output.shape)
        # deep
        x = torch.cat([embed_cross, dense_inputs], dim=-1)
        
        x = self.bn(x)
        
        dnn_outputs = self.nn_final_linear(self.dnn_network(x)+ lr_output)
        #joint 
        outputs = F.sigmoid(dnn_outputs )
        
        return outputs

效果：batch_size= 256，L2正则化（0.003），dropout（0.25）

NFM VS DeepFM VS Wide&Deep

Wide&Deep、DeepFM模型是使用的拼接操作，而不是Bi-Interaction.
拼接操作最大的缺点是他并没有考虑任何特征组合信息，全部依靠后面的DNN去学习特征组合，但是DNN的学习优化非常困难。
使用Bi-Interaction就考虑到了二阶组合特征，使得输入到DNN层中数据包含更多的信息，减轻了DNN的学习困难。