add forward

models/contentunderstanding/tagspace/static_model.py

@@ -57,7 +57,7 @@ def net(self, input, is_infer=False):
             self.vocab_text_size, self.vocab_tag_size, self.emb_dim,
             self.hid_dim, self.win_size, self.margin, self.neg_size,
             self.text_len)
-        cos_pos, cos_neg = tagspace_model(input)
+        cos_pos, cos_neg = tagspace_model.forward(input)
         # calculate hinge loss
         loss_part1 = paddle.subtract(
             paddle.full(

models/demo/movie_recommand/rank/static_model.py

@@ -67,8 +67,8 @@ def net(self, input, is_infer=False):
             self.batch_size = self.config.get("runner.train_batch_size")
         rank_model = DNNLayer(self.sparse_feature_number,
                               self.sparse_feature_dim, self.hidden_layers)
-        predict = rank_model(self.batch_size, self.user_sparse_inputs,
-                             self.mov_sparse_inputs, self.label_input)
+        predict = rank_model.forward(self.batch_size, self.user_sparse_inputs,
+                                     self.mov_sparse_inputs, self.label_input)
 
         self.inference_target_var = predict
         if is_infer:

models/demo/movie_recommand/recall/static_model.py

@@ -67,8 +67,9 @@ def net(self, input, is_infer=False):
             self.batch_size = self.config.get("runner.train_batch_size")
         recall_model = DNNLayer(self.sparse_feature_number,
                                 self.sparse_feature_dim, self.hidden_layers)
-        predict = recall_model(self.batch_size, self.user_sparse_inputs,
-                               self.mov_sparse_inputs, self.label_input)
+        predict = recall_model.forward(
+            self.batch_size, self.user_sparse_inputs, self.mov_sparse_inputs,
+            self.label_input)
 
         self.inference_target_var = predict
         if is_infer:

models/match/dssm/static_model.py

@@ -56,7 +56,7 @@ def create_feeds(self, is_infer=False):
     def net(self, input, is_infer=False):
         dssm_model = DSSMLayer(self.trigram_d, self.neg_num, self.slice_end,
                                self.hidden_layers, self.hidden_acts)
-        R_Q_D_p, hit_prob = dssm_model(input, is_infer)
+        R_Q_D_p, hit_prob = dssm_model.forward(input, is_infer)
 
         self.inference_target_var = R_Q_D_p
         self.prune_target_var = dssm_model.query_fc

models/match/match-pyramid/static_model.py

@@ -63,7 +63,7 @@ def net(self, input, is_infer=False):
             self.conv_filter, self.conv_act, self.hidden_size, self.out_size,
             self.pool_size, self.pool_stride, self.pool_padding,
             self.pool_type, self.hidden_act)
-        prediction = pyramid_model(input)
+        prediction = pyramid_model.forward(input)
 
         if is_infer:
             fetch_dict = {'prediction': prediction}

models/match/multiview-simnet/static_model.py

@@ -75,7 +75,7 @@ def net(self, input, is_infer=False):
             self.title_encode_dim, self.emb_size, self.emb_dim,
             self.hidden_size, self.margin, self.query_len, self.pos_len,
             self.neg_len)
-        cos_pos, cos_neg = simnet_model(inputs, is_infer)
+        cos_pos, cos_neg = simnet_model.forward(inputs, is_infer)
 
         self.inference_target_var = cos_pos
         if is_infer:

models/multitask/maml/dygraph_model.py

@@ -80,12 +80,12 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
             for j in range(update_step):
                 #内循环
                 task_optimizer.clear_grad()  # 梯度清零
-                y_hat = task_net(x_spt[i])  # (setsz, ways) [5,5]
+                y_hat = task_net.forward(x_spt[i])  # (setsz, ways) [5,5]
                 loss_spt = F.cross_entropy(y_hat, y_spt[i])
                 loss_spt.backward()
                 task_optimizer.step()
 
-            y_hat = task_net(x_qry[i])
+            y_hat = task_net.forward(x_qry[i])
             loss_qry = F.cross_entropy(y_hat, y_qry[i])
             loss_qry.backward()
             for k in task_net.parameters():
@@ -127,12 +127,12 @@ def infer_forward(self, dy_model, metrics_list, batch_data, config):
                                               parameters=task_net.parameters())
         for j in range(update_step):
             task_optimizer.clear_grad()
-            y_hat = task_net(x_spt)
+            y_hat = task_net.forward(x_spt)
             loss_spt = F.cross_entropy(y_hat, y_spt)
             loss_spt.backward()
             task_optimizer.step()
 
-        y_hat = task_net(x_qry)
+        y_hat = task_net.forward(x_qry)
         pred_qry = F.softmax(y_hat, axis=1).argmax(axis=1)
         correct = paddle.equal(pred_qry, y_qry).numpy().sum().item()
         correct_list.append(correct)

models/multitask/mmoe/static_model.py

@@ -51,7 +51,7 @@ def net(self, inputs, is_infer=False):
 
         MMoE = MMoELayer(self.feature_size, self.expert_num, self.expert_size,
                          self.tower_size, self.gate_num)
-        pred_income, pred_marital = MMoE(input_data)
+        pred_income, pred_marital = MMoE.forward(input_data)
 
         pred_income_1 = paddle.slice(
             pred_income, axes=[1], starts=[1], ends=[2])

models/multitask/ple/static_model.py

@@ -54,7 +54,7 @@ def net(self, inputs, is_infer=False):
         PLE = PLELayer(self.feature_size, self.task_num, self.exp_per_task,
                        self.shared_num, self.expert_size, self.tower_size,
                        self.level_number)
-        pred_income, pred_marital = PLE(input_data)
+        pred_income, pred_marital = PLE.forward(input_data)
 
         pred_income_1 = paddle.slice(
             pred_income, axes=[1], starts=[1], ends=[2])

models/multitask/share_bottom/static_model.py

@@ -50,7 +50,7 @@ def net(self, inputs, is_infer=False):
 
         ShareBottom = ShareBottomLayer(self.feature_size, self.task_num,
                                        self.bottom_size, self.tower_size)
-        pred_income, pred_marital = ShareBottom(input_data)
+        pred_income, pred_marital = ShareBottom.forward(input_data)
 
         pred_income_1 = paddle.slice(
             pred_income, axes=[1], starts=[1], ends=[2])

models/rank/bert4rec/dygraph_model.py

@@ -84,7 +84,8 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
         src_ids, pos_ids, sent_ids, input_mask, mask_pos, mask_label = self.create_feeds(
             batch_data, config)
 
-        prediction = dy_model(src_ids, pos_ids, sent_ids, input_mask, mask_pos)
+        prediction = dy_model.forward(src_ids, pos_ids, sent_ids, input_mask,
+                                      mask_pos)
         loss = self.create_loss(prediction, mask_label)
 
         print_dict = {'loss': loss}
@@ -113,7 +114,8 @@ def evaluate_rec_ndcg_mrr_batch(ratings,
             batch_data[:-1], config)
         batch_size = config.get("runner.data_batch_size")
         candiate = batch_data[-1]
-        prediction = dy_model(src_ids, pos_ids, sent_ids, input_mask, mask_pos)
+        prediction = dy_model.forward(src_ids, pos_ids, sent_ids, input_mask,
+                                      mask_pos)
         pred_ratings = []
         self.test_count += 1
         for i in range(batch_size):

models/rank/bst/static_model.py

@@ -117,9 +117,9 @@ def net(self, input, is_infer=False):
             self.prepostprocess_dropout, self.d_inner_hid, self.relu_dropout,
             self.layer_sizes)
 
-        pred = bst_model(self.user_input, self.hist_input, self.cate_input,
-                         self.pos_input, self.target_input,
-                         self.target_cate_input, self.target_pos_input)
+        pred = bst_model.forward(
+            self.user_input, self.hist_input, self.cate_input, self.pos_input,
+            self.target_input, self.target_cate_input, self.target_pos_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/dcn/static_model.py

@@ -83,7 +83,7 @@ def net(self, input, is_infer=False):
             self.clip_by_norm, self.l2_reg_cross, self.is_sparse)
         print("----self.dense_input-----", self.dense_input)
         print("----self.sparse_inputs----", self.sparse_inputs)
-        pred, l2_loss = dcn_model(self.sparse_inputs, self.dense_input)
+        pred, l2_loss = dcn_model.forward(self.sparse_inputs, self.dense_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/deepfefm/static_model.py

@@ -75,7 +75,7 @@ def net(self, input, is_infer=False):
             self.sparse_feature_number, self.sparse_feature_dim,
             self.dense_input_dim, sparse_number, self.fc_sizes)
 
-        pred = deepfefm_model(self.sparse_inputs, self.dense_input)
+        pred = deepfefm_model.forward(self.sparse_inputs, self.dense_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/deepfm/net.py

@@ -40,9 +40,9 @@ def __init__(self, sparse_feature_number, sparse_feature_dim,
 
     def forward(self, sparse_inputs, dense_inputs):
 
-        y_first_order, y_second_order, feat_embeddings = self.fm(sparse_inputs,
-                                                                 dense_inputs)
-        y_dnn = self.dnn(feat_embeddings)
+        y_first_order, y_second_order, feat_embeddings = self.fm.forward(
+            sparse_inputs, dense_inputs)
+        y_dnn = self.dnn.forward(feat_embeddings)
 
         predict = F.sigmoid(y_first_order + y_second_order + y_dnn)
 

models/rank/deepfm/static_model.py

@@ -75,7 +75,7 @@ def net(self, input, is_infer=False):
             self.sparse_feature_number, self.sparse_feature_dim,
             self.dense_input_dim, sparse_number, self.fc_sizes)
 
-        pred = deepfm_model(self.sparse_inputs, self.dense_input)
+        pred = deepfm_model.forward(self.sparse_inputs, self.dense_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/dien/dygraph_model.py

@@ -87,10 +87,10 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
         hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask, target_item_seq, target_cat_seq, neg_hist_item_seq, neg_hist_cat_seq = self.create_feeds(
             batch_data, config)
 
-        raw_pred, aux_loss = dy_model(hist_item_seq, hist_cat_seq, target_item,
-                                      target_cat, label, mask, target_item_seq,
-                                      target_cat_seq, neg_hist_item_seq,
-                                      neg_hist_cat_seq)
+        raw_pred, aux_loss = dy_model.forward(
+            hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask,
+            target_item_seq, target_cat_seq, neg_hist_item_seq,
+            neg_hist_cat_seq)
 
         loss = self.create_loss(raw_pred, label)
         cost = loss + aux_loss
@@ -105,10 +105,10 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
     def infer_forward(self, dy_model, metrics_list, batch_data, config):
         hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask, target_item_seq, target_cat_seq, neg_hist_item_seq, neg_hist_cat_seq = self.create_feeds(
             batch_data, config)
-        raw_pred, aux_loss = dy_model(hist_item_seq, hist_cat_seq, target_item,
-                                      target_cat, label, mask, target_item_seq,
-                                      target_cat_seq, neg_hist_item_seq,
-                                      neg_hist_cat_seq)
+        raw_pred, aux_loss = dy_model.forward(
+            hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask,
+            target_item_seq, target_cat_seq, neg_hist_item_seq,
+            neg_hist_cat_seq)
 
         predict = paddle.nn.functional.sigmoid(raw_pred)
         predict_2d = paddle.concat(x=[1 - predict, predict], axis=1)

models/rank/dien/static_model.py

@@ -108,7 +108,7 @@ def net(self, inputs, is_infer=False):
             self.item_emb_size, self.cat_emb_size, self.act, self.is_sparse,
             self.use_DataLoader, self.item_count, self.cat_count)
 
-        logit, aux_loss = dien_model(
+        logit, aux_loss = dien_model.forward(
             self.hist_item_seq, self.hist_cat_seq, self.target_item,
             self.target_cat, self.label, self.mask, self.target_item_seq,
             self.target_cat_seq, self.neg_hist_item_seq, self.neg_hist_cat_seq)

models/rank/difm/static_model.py

@@ -92,7 +92,7 @@ def net(self, input, is_infer=False):
             att_factor_dim=self.att_factor_dim,
             att_head_num=self.att_head_num)
 
-        pred = difm_model(self.sparse_inputs, self.dense_input)
+        pred = difm_model.forward(self.sparse_inputs, self.dense_input)
         raw_predict_2d = paddle.concat(x=[1 - pred, pred], axis=1)
 
         cost = paddle.nn.functional.cross_entropy(

models/rank/din/dygraph_model.py

@@ -86,9 +86,9 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
         hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask, target_item_seq, target_cat_seq = self.create_feeds(
             batch_data, config)
 
-        raw_pred = dy_model(hist_item_seq, hist_cat_seq, target_item,
-                            target_cat, label, mask, target_item_seq,
-                            target_cat_seq)
+        raw_pred = dy_model.forward(hist_item_seq, hist_cat_seq, target_item,
+                                    target_cat, label, mask, target_item_seq,
+                                    target_cat_seq)
         loss = self.create_loss(raw_pred, label)
         predict = paddle.nn.functional.sigmoid(raw_pred)
         predict_2d = paddle.concat([1 - predict, predict], 1)
@@ -102,9 +102,9 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
     def infer_forward(self, dy_model, metrics_list, batch_data, config):
         hist_item_seq, hist_cat_seq, target_item, target_cat, label, mask, target_item_seq, target_cat_seq = self.create_feeds(
             batch_data, config)
-        raw_pred = dy_model(hist_item_seq, hist_cat_seq, target_item,
-                            target_cat, label, mask, target_item_seq,
-                            target_cat_seq)
+        raw_pred = dy_model.forward(hist_item_seq, hist_cat_seq, target_item,
+                                    target_cat, label, mask, target_item_seq,
+                                    target_cat_seq)
 
         predict = paddle.nn.functional.sigmoid(raw_pred)
         predict_2d = paddle.concat([1 - predict, predict], 1)

models/rank/din/static_model.py

@@ -94,10 +94,10 @@ def net(self, inputs, is_infer=False):
                              self.is_sparse, self.use_DataLoader,
                              self.item_count, self.cat_count)
 
-        raw_predict = din_model(self.hist_item_seq, self.hist_cat_seq,
-                                self.target_item, self.target_cat, self.label,
-                                self.mask, self.target_item_seq,
-                                self.target_cat_seq)
+        raw_predict = din_model.forward(
+            self.hist_item_seq, self.hist_cat_seq, self.target_item,
+            self.target_cat, self.label, self.mask, self.target_item_seq,
+            self.target_cat_seq)
 
         avg_loss = paddle.nn.functional.binary_cross_entropy_with_logits(
             raw_predict, self.label, reduction='mean')

models/rank/dlrm/static_model.py

@@ -87,7 +87,8 @@ def net(self, input, is_infer=False):
             num_field=self.num_field,
             self_interaction=False)
 
-        raw_predict_2d = dlrm_model(self.sparse_inputs, self.dense_input)
+        raw_predict_2d = dlrm_model.forward(self.sparse_inputs,
+                                            self.dense_input)
 
         cost = paddle.nn.functional.cross_entropy(
             input=raw_predict_2d, label=self.label_input)

models/rank/dmr/dygraph_model.py

@@ -85,7 +85,7 @@ def create_metrics(self):
     def train_forward(self, dy_model, metrics_list, batch_data, config):
         label, input_tensor = self.create_feeds(batch_data, config)
 
-        pred, loss = dy_model(input_tensor, False)
+        pred, loss = dy_model.forward(input_tensor, False)
         # update metrics
         predict_2d = paddle.concat(x=[1 - pred, pred], axis=1)
         metrics_list[0].update(preds=predict_2d.numpy(), labels=label.numpy())
@@ -97,7 +97,7 @@ def train_forward(self, dy_model, metrics_list, batch_data, config):
     def infer_forward(self, dy_model, metrics_list, batch_data, config):
         label, input_tensor = self.create_feeds(batch_data, config)
 
-        pred, loss = dy_model(input_tensor, True)
+        pred, loss = dy_model.forward(input_tensor, True)
         # update metrics
         predict_2d = paddle.concat(x=[1 - pred, pred], axis=1)
         metrics_list[0].update(preds=predict_2d.numpy(), labels=label.numpy())

models/rank/dmr/static_model.py

@@ -81,7 +81,7 @@ def net(self, input, is_infer=False):
             self.customer_size, self.brand_size, self.btag_size, self.pid_size,
             self.main_embedding_size, self.other_embedding_size)
 
-        pred, loss = DMR_model(inputs, is_infer)
+        pred, loss = DMR_model.forward(inputs, is_infer)
 
         predict_2d = paddle.concat(x=[1 - pred, pred], axis=1)
         auc, batch_auc, _ = paddle.static.auc(input=predict_2d,

models/rank/dnn/static_model.py

@@ -77,7 +77,8 @@ def net(self, input, is_infer=False):
             self.fc_sizes,
             sync_mode=self.sync_mode)
 
-        raw_predict_2d = dnn_model(self.sparse_inputs, self.dense_input)
+        raw_predict_2d = dnn_model.forward(self.sparse_inputs,
+                                           self.dense_input)
 
         predict_2d = paddle.nn.functional.softmax(raw_predict_2d)
 

models/rank/dnn/static_model_lod.py

@@ -101,7 +101,7 @@ def embedding_layer(input):
             self.sparse_feature_number, self.sparse_feature_dim,
             self.dense_input_dim, sparse_number, self.fc_sizes)
 
-        raw_predict_2d = dnn_model(sparse_embs, self.dense_input)
+        raw_predict_2d = dnn_model.forward(sparse_embs, self.dense_input)
 
         predict_2d = paddle.nn.functional.softmax(raw_predict_2d)
 

models/rank/ffm/net.py

@@ -38,7 +38,8 @@ def __init__(self, sparse_feature_number, sparse_feature_dim,
 
     def forward(self, sparse_inputs, dense_inputs):
 
-        y_first_order, y_second_order = self.ffm(sparse_inputs, dense_inputs)
+        y_first_order, y_second_order = self.ffm.forward(sparse_inputs,
+                                                         dense_inputs)
 
         predict = F.sigmoid(y_first_order + y_second_order + self.bias)
 

models/rank/ffm/static_model.py

@@ -70,7 +70,7 @@ def net(self, input, is_infer=False):
                              self.sparse_feature_dim, self.dense_input_dim,
                              sparse_number)
 
-        pred = ffm_model(self.sparse_inputs, self.dense_input)
+        pred = ffm_model.forward(self.sparse_inputs, self.dense_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/fm/net.py

@@ -37,7 +37,8 @@ def __init__(self, sparse_feature_number, sparse_feature_dim,
 
     def forward(self, sparse_inputs, dense_inputs):
 
-        y_first_order, y_second_order = self.fm(sparse_inputs, dense_inputs)
+        y_first_order, y_second_order = self.fm.forward(sparse_inputs,
+                                                        dense_inputs)
 
         predict = F.sigmoid(y_first_order + y_second_order + self.bias)
 

models/rank/fm/static_model.py

@@ -69,7 +69,7 @@ def net(self, input, is_infer=False):
         fm_model = FMLayer(self.sparse_feature_number, self.sparse_feature_dim,
                            self.dense_input_dim, sparse_number)
 
-        pred = fm_model(self.sparse_inputs, self.dense_input)
+        pred = fm_model.forward(self.sparse_inputs, self.dense_input)
 
         #pred = F.sigmoid(prediction)
 

models/rank/gatenet/static_model.py

@@ -84,7 +84,7 @@ def net(self, input, is_infer=False):
                                  sparse_number, self.fc_sizes,
                                  self.use_embedding_gate, self.use_hidden_gate)
 
-        raw_pred = dnn_model(self.sparse_inputs, self.dense_input)
+        raw_pred = dnn_model.forward(self.sparse_inputs, self.dense_input)
 
         predict_2d = paddle.concat(x=[1 - raw_pred, raw_pred], axis=1)
 

models/rank/logistic_regression/static_model.py

@@ -59,7 +59,7 @@ def net(self, inputs, is_infer=False):
         LR_model = LRLayer(self.sparse_feature_number, init_value_, self.reg,
                            self.num_field)
 
-        self.predict = LR_model(feat_idx, feat_value)
+        self.predict = LR_model.forward(feat_idx, feat_value)
 
         predict_2d = paddle.concat(x=[1 - self.predict, self.predict], axis=1)
         label_int = paddle.cast(self.label, 'int64')