year change

Author: yoreG123

datasets/criteo_fgcnn/download.sh

@@ -1,3 +1,3 @@
 wget --no-check-certificate https://paddlerec.bj.bcebos.com/datasets/fgcnn/datapro.zip
 unzip -o datapro.zip	
-echo "Complete data download."	
+echo "Complete data download."

models/rank/fgcnn/config.yaml

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -48,4 +48,4 @@ hyper_parameters:
   pooling_width: [2, 2, 2, 2]
   stride: [1, 1]
   dnn_hidden_units: [100, 100, 100]
-  dnn_dropout: 0.0
+  dnn_dropout: 0.0

models/rank/fgcnn/config_bigdata.yaml

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -48,4 +48,4 @@ hyper_parameters:
   pooling_width: [2, 2, 2, 2]
   stride: [1, 1]
   dnn_hidden_units: [1000, 1000, 1000]
-  dnn_dropout: 0.0
+  dnn_dropout: 0.0

models/rank/fgcnn/dygraph_model.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,20 +23,25 @@ class DygraphModel():
     def create_model(self, config):
         sparse_input_slot = config.get('hyper_parameters.sparse_inputs_slots')
         dense_input_slot = config.get('hyper_parameters.dense_inputs_slots')
-        sparse_feature_size = config.get("hyper_parameters.sparse_feature_size")
+        sparse_feature_size = config.get(
+            "hyper_parameters.sparse_feature_size")
         feature_name = config.get("hyper_parameters.feature_name")
         feature_dim = config.get("hyper_parameters.feature_dim", 20)
-        conv_kernel_width = config.get("hyper_parameters.conv_kernel_width", (7, 7, 7, 7))
-        conv_filters = config.get("hyper_parameters.conv_filters", (14, 16, 18, 20))
+        conv_kernel_width = config.get("hyper_parameters.conv_kernel_width",
+                                       (7, 7, 7, 7))
+        conv_filters = config.get("hyper_parameters.conv_filters",
+                                  (14, 16, 18, 20))
         new_maps = config.get("hyper_parameters.new_maps", (3, 3, 3, 3))
-        pooling_width = config.get("hyper_parameters.pooling_width", (2, 2, 2, 2))
-        stride = config.get("hyper_parameters.stride", (1,1))
-        dnn_hidden_units = config.get("hyper_parameters.dnn_hidden_units", (128,))
+        pooling_width = config.get("hyper_parameters.pooling_width",
+                                   (2, 2, 2, 2))
+        stride = config.get("hyper_parameters.stride", (1, 1))
+        dnn_hidden_units = config.get("hyper_parameters.dnn_hidden_units",
+                                      (128, ))
         dnn_dropout = config.get("hyper_parameters.dnn_dropout", 0.0)
-        fgcnn_model = net.FGCNN(sparse_input_slot, sparse_feature_size,
-                                feature_name, feature_dim,dense_input_slot,
-                                conv_kernel_width, conv_filters, new_maps,
-                                pooling_width, stride, dnn_hidden_units, dnn_dropout)
+        fgcnn_model = net.FGCNN(
+            sparse_input_slot, sparse_feature_size, feature_name, feature_dim,
+            dense_input_slot, conv_kernel_width, conv_filters, new_maps,
+            pooling_width, stride, dnn_hidden_units, dnn_dropout)
 
         return fgcnn_model
 
@@ -47,9 +52,9 @@ def create_feeds(self, batch_data, config):
         inputs = batch_data[0]
         label = batch_data[1]
         return label, inputs
-        
 
-    # define loss function by predicts and label
+# define loss function by predicts and label
+
     def create_loss(self, y_pred, label):
         loss = nn.functional.log_loss(
             y_pred, label=paddle.cast(
@@ -61,8 +66,7 @@ def create_loss(self, y_pred, label):
     def create_optimizer(self, dy_model, config):
         lr = config.get("hyper_parameters.optimizer.learning_rate", 1e-3)
         optimizer = paddle.optimizer.Adam(
-            parameters=dy_model.parameters(),
-            learning_rate=lr)
+            parameters=dy_model.parameters(), learning_rate=lr)
         return optimizer
 
     def create_metrics(self):
@@ -95,4 +99,4 @@ def infer_forward(self, dy_model, metrics_list, batch_data, config):
         metrics_list[0].update(preds=predict_2d.numpy(), labels=label.numpy())
         # print_dict format :{'loss': loss}
         print_dict = {'loss': loss}
-        return metrics_list, print_dict
+        return metrics_list, print_dict

models/rank/fgcnn/net.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,11 +19,12 @@
 import numpy as np
 import pdb
 
+
 class FGCNN(nn.Layer):
-    def __init__(self, sparse_num_field, sparse_feature_size,
-                 feature_name, feature_dim,dense_num_field, conv_kernel_width,
-                 conv_filters, new_maps, pooling_width, stride,
-                 dnn_hidden_units, dnn_dropout):
+    def __init__(self, sparse_num_field, sparse_feature_size, feature_name,
+                 feature_dim, dense_num_field, conv_kernel_width, conv_filters,
+                 new_maps, pooling_width, stride, dnn_hidden_units,
+                 dnn_dropout):
         '''
         Parameters
             vocab_size - 
@@ -44,19 +45,21 @@ def __init__(self, sparse_num_field, sparse_feature_size,
             EmbeddingLayer(
                 num_embeddings=self.sparse_feature_size,
                 embedding_dim=self.feature_dim,
-                feature_name=self.feature_name[i] + '_fg_emd'
-            ) for i in range(self.feature_num_filed)])
+                feature_name=self.feature_name[i] + '_fg_emd')
+            for i in range(self.feature_num_filed)
+        ])
         self.embedding = nn.LayerList([
             EmbeddingLayer(
                 num_embeddings=self.sparse_feature_size,
                 embedding_dim=self.feature_dim,
-                feature_name=self.feature_name[i] + '_emd'
-            ) for i in range(self.feature_num_filed)])
+                feature_name=self.feature_name[i] + '_emd')
+            for i in range(self.feature_num_filed)
+        ])
 
         self.fgcnn = FGCNNLayer(self.feature_num_filed, self.feature_dim,
-                                self.conv_filters, self.conv_kernel_width, 
+                                self.conv_filters, self.conv_kernel_width,
                                 self.new_maps, self.pooling_width, self.stride)
-        
+
         self.combined_feture_num = self.fgcnn.new_feture_num + self.feature_num_filed
         self.inner_product_layer = InnerProductLayer(self.combined_feture_num)
         self.dnn_input_dim = self.combined_feture_num * (self.combined_feture_num - 1) // 2\
@@ -66,8 +69,8 @@ def __init__(self, sparse_num_field, sparse_feature_size,
 
         self.fc_linear = self.add_sublayer(
             name='fc_linear',
-            sublayer=nn.Linear(in_features=dnn_hidden_units[-1], out_features=1)
-            )
+            sublayer=nn.Linear(
+                in_features=dnn_hidden_units[-1], out_features=1))
 
     def forward(self, inputs):
         # print('*************************************')
@@ -76,35 +79,39 @@ def forward(self, inputs):
         fg_input_list = []
         origin_input_list = []
         for i in range(self.feature_num_filed):
-            fg_input_list.append(self.fg_embedding[i](inputs[:, i].astype('int64')).reshape((-1, 1, self.feature_dim)))
-            origin_input_list.append(self.embedding[i](inputs[:, i].astype('int64')).reshape((-1, 1, self.feature_dim)))
+            fg_input_list.append(self.fg_embedding[i](inputs[:, i].astype(
+                'int64')).reshape((-1, 1, self.feature_dim)))
+            origin_input_list.append(self.embedding[i](inputs[:, i].astype(
+                'int64')).reshape((-1, 1, self.feature_dim)))
         fg_input = paddle.concat(fg_input_list, axis=1)
         origin_input = paddle.concat(origin_input_list, axis=1)
         new_features = self.fgcnn(fg_input)
         combined_input = paddle.concat([origin_input, new_features], axis=1)
         inner_product = self.inner_product_layer(combined_input)
         linear_signal = paddle.flatten(combined_input, start_axis=1)
-        dnn_input = paddle.concat([linear_signal,inner_product], axis=1)
+        dnn_input = paddle.concat([linear_signal, inner_product], axis=1)
         dnn_output = self.dnn(dnn_input)
         dnn_logit = self.fc_linear(dnn_output)
         y_pred = F.sigmoid(dnn_logit)
         return y_pred
 
+
 class EmbeddingLayer(nn.Layer):
     def __init__(self, num_embeddings, embedding_dim, feature_name):
         super(EmbeddingLayer, self).__init__()
         self.embedding = nn.Embedding(
             num_embeddings=num_embeddings,
             embedding_dim=embedding_dim,
             name=feature_name,
-            sparse=True
-        )
+            sparse=True)
 
     def forward(self, inputs):
         return self.embedding(inputs)
-    
+
+
 class FGCNNLayer(nn.Layer):
-    def __init__(self, feature_num_field, embedding_size, filters, kernel_width, new_maps, pooling_width, stride):
+    def __init__(self, feature_num_field, embedding_size, filters,
+                 kernel_width, new_maps, pooling_width, stride):
         super(FGCNNLayer, self).__init__()
         self.feature_num_field = feature_num_field
         self.embedding_size = embedding_size
@@ -114,53 +121,72 @@ def __init__(self, feature_num_field, embedding_size, filters, kernel_width, new
         self.pooling_width = pooling_width
         self.stride = stride
         self.init()
-        self.conv_pooling = nn.LayerList([nn.Sequential(
+        self.conv_pooling = nn.LayerList([
+            nn.Sequential(
                 nn.Conv2D(
-                    in_channels=self.in_channels_size[i], 
-                    out_channels=self.filters[i], 
-                    kernel_size=(self.kernel_width[i], 1), 
+                    in_channels=self.in_channels_size[i],
+                    out_channels=self.filters[i],
+                    kernel_size=(self.kernel_width[i], 1),
                     padding=(self.padding_size[i], 0),
                     stride=self.stride),
                 nn.BatchNorm2D(self.filters[i]),
                 nn.Tanh(),
                 nn.MaxPool2D(
-                    kernel_size=(self.pooling_width[i], 1), 
-                    stride=(self.pooling_width[i], 1)),
-            ) for i in range(len(self.filters))])
-        self.recombination = nn.LayerList([nn.Sequential(
+                    kernel_size=(self.pooling_width[i], 1),
+                    stride=(self.pooling_width[i], 1)), )
+            for i in range(len(self.filters))
+        ])
+        self.recombination = nn.LayerList([
+            nn.Sequential(
                 nn.Linear(
-                    in_features=self.filters[i] * self.pooling_shape[i] * self.embedding_size,
-                    out_features=self.pooling_shape[i] * self.embedding_size * self.new_maps[i],
+                    in_features=self.filters[i] * self.pooling_shape[i] *
+                    self.embedding_size,
+                    out_features=self.pooling_shape[i] * self.embedding_size *
+                    self.new_maps[i],
                     name='fgcnn_linear_%d' % i),
                 nn.Tanh()
                 # nn.ReLU()
-            ) for i in range(len(self.filters))])
+            ) for i in range(len(self.filters))
+        ])
 
     def forward(self, inputs):
         feature = inputs.unsqueeze(1)
         new_feature_list = []
         for i in range(0, len(self.filters)):
             feature = self.conv_pooling[i](feature)
-            result = self.recombination[i](paddle.flatten(feature, start_axis=1))
+            result = self.recombination[i](paddle.flatten(
+                feature, start_axis=1))
             new_feature_list.append(
-                paddle.reshape(x=result, shape=(-1, self.pooling_shape[i] * self.new_maps[i] , self.embedding_size)))
+                paddle.reshape(
+                    x=result,
+                    shape=(-1, self.pooling_shape[i] * self.new_maps[i],
+                           self.embedding_size)))
         new_features = paddle.concat(new_feature_list, axis=1)
         return new_features
 
     def init(self):
         # compute pooling shape
         self.pooling_shape = []
-        self.pooling_shape.append(self.feature_num_field // self.pooling_width[0])
+        self.pooling_shape.append(self.feature_num_field //
+                                  self.pooling_width[0])
         for i in range(1, len(self.filters)):
-            self.pooling_shape.append(self.pooling_shape[i-1] // self.pooling_width[i])
+            self.pooling_shape.append(self.pooling_shape[i - 1] //
+                                      self.pooling_width[i])
         # compute padding size
         self.padding_size = []
-        self.padding_size.append(((self.feature_num_field - 1) * self.stride[0] + self.kernel_width[0] - self.feature_num_field) // 2)
+        self.padding_size.append(
+            ((self.feature_num_field - 1) * self.stride[0] +
+             self.kernel_width[0] - self.feature_num_field) // 2)
         for i in range(1, len(self.filters)):
             self.padding_size.append(
-                ((self.pooling_shape[i-1] - 1) * self.stride[0] + self.kernel_width[i] - self.pooling_shape[i-1]) // 2)
-        self.in_channels_size = [1,] + list(self.filters)
-        self.new_feture_num = sum([self.pooling_shape[i] * self.new_maps[i] for i in range(len(self.filters))])
+                ((self.pooling_shape[i - 1] - 1) * self.stride[0] +
+                 self.kernel_width[i] - self.pooling_shape[i - 1]) // 2)
+        self.in_channels_size = [1, ] + list(self.filters)
+        self.new_feture_num = sum([
+            self.pooling_shape[i] * self.new_maps[i]
+            for i in range(len(self.filters))
+        ])
+
 
 class DNNLayer(nn.Layer):
     def __init__(self, inputs_dim, hidden_units, dropout_rate):
@@ -169,18 +195,22 @@ def __init__(self, inputs_dim, hidden_units, dropout_rate):
         self.dropout = nn.Dropout(dropout_rate)
 
         hidden_units = [inputs_dim] + list(hidden_units)
-        self.linears = nn.LayerList([nn.Sequential(
-            nn.Linear(
-                in_features=hidden_units[i], 
-                out_features=hidden_units[i + 1],
-                weight_attr=nn.initializer.Normal(mean=0, std=1e-4),
-                name='dnn_%d' % i),
-            nn.BatchNorm(hidden_units[i+1])
-            # nn.ReLU(hidden_units[i + 1],name='relu_%d' % i)
-            ) for i in range(len(hidden_units) - 1)])
-        
-        self.activation_layers = nn.LayerList(
-            [nn.ReLU(name='relu_%d'%i) for i in range(len(hidden_units) - 1)])
+        self.linears = nn.LayerList([
+            nn.Sequential(
+                nn.Linear(
+                    in_features=hidden_units[i],
+                    out_features=hidden_units[i + 1],
+                    weight_attr=nn.initializer.Normal(
+                        mean=0, std=1e-4),
+                    name='dnn_%d' % i),
+                nn.BatchNorm(hidden_units[i + 1])
+                # nn.ReLU(hidden_units[i + 1],name='relu_%d' % i)
+            ) for i in range(len(hidden_units) - 1)
+        ])
+
+        self.activation_layers = nn.LayerList([
+            nn.ReLU(name='relu_%d' % i) for i in range(len(hidden_units) - 1)
+        ])
 
     # @paddle.jit.to_static
     def forward(self, inputs):
@@ -190,24 +220,31 @@ def forward(self, inputs):
             inputs = self.dropout(inputs)
         return inputs
 
+
 class InnerProductLayer(nn.Layer):
     """ output: product_sum_pooling (bs x 1), 
                 Bi_interaction_pooling (bs * dim), 
                 inner_product (bs x f2/2), 
                 elementwise_product (bs x f2/2 x emb_dim)
     """
+
     def __init__(self, num_fields=None):
         super(InnerProductLayer, self).__init__()
         if num_fields is None:
             raise ValueError("num_fields is required")
         else:
             self.num_fields = num_fields
             self.interaction_units = int(num_fields * (num_fields - 1) / 2)
-            
+
     def forward(self, feature_emb):
-        onemask = paddle.ones(shape=[feature_emb.shape[0],self.num_fields, self.num_fields],dtype='int32')
-        tri = paddle.triu(onemask,1)
-        upper_triange_mask = paddle.cast(tri,'bool')
-        inner_product_matrix = paddle.bmm(feature_emb, paddle.transpose(feature_emb, perm=[0, 2, 1]))
-        flat_upper_triange = paddle.masked_select(inner_product_matrix, upper_triange_mask)
-        return flat_upper_triange.reshape([-1, self.interaction_units])
+        onemask = paddle.ones(
+            shape=[feature_emb.shape[0], self.num_fields, self.num_fields],
+            dtype='int32')
+        tri = paddle.triu(onemask, 1)
+        upper_triange_mask = paddle.cast(tri, 'bool')
+        inner_product_matrix = paddle.bmm(feature_emb,
+                                          paddle.transpose(
+                                              feature_emb, perm=[0, 2, 1]))
+        flat_upper_triange = paddle.masked_select(inner_product_matrix,
+                                                  upper_triange_mask)
+        return flat_upper_triange.reshape([-1, self.interaction_units])

models/rank/fgcnn/reader.py

@@ -1,4 +1,4 @@
-#   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#   Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 from paddle.io import IterableDataset
 import h5py
 
+
 class RecDataset(IterableDataset):
     def __init__(self, file_list, config):
         super(RecDataset, self).__init__()
@@ -34,4 +35,3 @@ def __iter__(self):
                 output_list.append(l[0:39].astype('int64'))
                 output_list.append(l[39:].astype('int64'))
                 yield output_list
-