fix mmoe

models/multitask/mmoe/census_infer_reader.py

-#   Copyright (c) 2020 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.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import print_function
-
-from paddlerec.core.reader import Reader
-
-
-class EvaluateReader(Reader):
-    def init(self):
-
-        pass
-
-    def generate_sample(self, line):
-        """
-        Read the data line by line and process it as a dictionary
-        """
-
-        def reader():
-            """
-            This function needs to be implemented by the user, based on data format
-            """
-            l = line.strip().split(',')
-            l = list(map(float, l))
-            label_income = []
-            label_marital = []
-            data = l[2:]
-            if int(l[1]) == 0:
-                label_income = [1, 0]
-            elif int(l[1]) == 1:
-                label_income = [0, 1]
-            if int(l[0]) == 0:
-                label_marital = [1, 0]
-            elif int(l[0]) == 1:
-                label_marital = [0, 1]
-            feature_name = ["input", "label_income", "label_marital"]
-            yield zip(feature_name, [data] + [label_income] + [label_marital])
-
-        return reader

models/multitask/mmoe/config.yaml

@@ -12,43 +12,57 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-evaluate:
-  reader:
-    batch_size: 1
-    class: "{workspace}/census_infer_reader.py"
-    test_data_path: "{workspace}/data/train"
+workspace: "paddlerec.models.multitask.mmoe"
 
-train:
-  trainer:
-    # for cluster training
-    strategy: "async"
+dataset:
+- name: dataset_train
+  batch_size: 1
+  type: QueueDataset
+  data_path: "{workspace}/data/train"
+  data_converter: "{workspace}/census_reader.py"
+- name: dataset_infer
+  batch_size: 1
+  type: QueueDataset
+  data_path: "{workspace}/data/train"
+  data_converter: "{workspace}/census_reader.py"
 
-  epochs: 3
-  workspace: "paddlerec.models.multitask.mmoe"
-  device: cpu
+hyper_parameters:
+  feature_size: 499
+  expert_num: 8
+  gate_num: 2
+  expert_size: 16
+  tower_size: 8
+  optimizer: 
+    class: adam
+    learning_rate: 0.001
+    strategy: async
 
-  reader:
-    batch_size: 1
-    class: "{workspace}/census_reader.py"
-    train_data_path: "{workspace}/data/train"
+#use infer_runner mode and modify 'phase' below if infer
+mode: train_runner
+#mode: infer_runner
 
-  model:
-    models: "{workspace}/model.py"
-    hyper_parameters:
-      feature_size: 499
-      expert_num: 8
-      gate_num: 2
-      expert_size: 16
-      tower_size: 8
-      learning_rate: 0.001
-      optimizer: adam
+runner:
+- name: train_runner
+  class: single_train
+  device: cpu
+  epochs: 3
+  save_checkpoint_interval: 2
+  save_inference_interval: 4
+  save_checkpoint_path: "increment"
+  save_inference_path: "inference"
+  print_interval: 10
+- name: infer_runner
+  class: single_infer
+  init_model_path: "increment/0"
+  device: cpu
+  epochs: 3
 
-  save:
-    increment:
-      dirname: "increment"
-      epoch_interval: 2
-      save_last: True
-    inference:
-      dirname: "inference"
-      epoch_interval: 4
-      save_last: True
+phase:
+- name: train
+  model: "{workspace}/model.py"
+  dataset_name: dataset_train
+  thread_num: 1
+    #- name: infer
+    #  model: "{workspace}/model.py"
+    #  dataset_name: dataset_infer
+    #  thread_num: 1

models/multitask/mmoe/model.py

@@ -22,53 +22,51 @@ class Model(ModelBase):
     def __init__(self, config):
         ModelBase.__init__(self, config)
 
-    def MMOE(self, is_infer=False):
-        feature_size = envs.get_global_env("hyper_parameters.feature_size",
-                                           None, self._namespace)
-        expert_num = envs.get_global_env("hyper_parameters.expert_num", None,
-                                         self._namespace)
-        gate_num = envs.get_global_env("hyper_parameters.gate_num", None,
-                                       self._namespace)
-        expert_size = envs.get_global_env("hyper_parameters.expert_size", None,
-                                          self._namespace)
-        tower_size = envs.get_global_env("hyper_parameters.tower_size", None,
-                                         self._namespace)
-
-        input_data = fluid.data(
-            name="input", shape=[-1, feature_size], dtype="float32")
+    def _init_hyper_parameters(self):
+        self.feature_size = envs.get_global_env(
+            "hyper_parameters.feature_size")
+        self.expert_num = envs.get_global_env("hyper_parameters.expert_num")
+        self.gate_num = envs.get_global_env("hyper_parameters.gate_num")
+        self.expert_size = envs.get_global_env("hyper_parameters.expert_size")
+        self.tower_size = envs.get_global_env("hyper_parameters.tower_size")
+
+    def input_data(self, is_infer=False, **kwargs):
+        inputs = fluid.data(
+            name="input", shape=[-1, self.feature_size], dtype="float32")
         label_income = fluid.data(
             name="label_income", shape=[-1, 2], dtype="float32", lod_level=0)
         label_marital = fluid.data(
             name="label_marital", shape=[-1, 2], dtype="float32", lod_level=0)
         if is_infer:
-            self._infer_data_var = [input_data, label_income, label_marital]
-            self._infer_data_loader = fluid.io.DataLoader.from_generator(
-                feed_list=self._infer_data_var,
-                capacity=64,
-                use_double_buffer=False,
-                iterable=False)
-
-        self._data_var.extend([input_data, label_income, label_marital])
+            return [inputs, label_income, label_marital]
+        else:
+            return [inputs, label_income, label_marital]
+
+    def net(self, inputs, is_infer=False):
+        input_data = inputs[0]
+        label_income = inputs[1]
+        label_marital = inputs[2]
+
         # f_{i}(x) = activation(W_{i} * x + b), where activation is ReLU according to the paper
         expert_outputs = []
-        for i in range(0, expert_num):
+        for i in range(0, self.expert_num):
             expert_output = fluid.layers.fc(
                 input=input_data,
-                size=expert_size,
+                size=self.expert_size,
                 act='relu',
                 bias_attr=fluid.ParamAttr(learning_rate=1.0),
                 name='expert_' + str(i))
             expert_outputs.append(expert_output)
         expert_concat = fluid.layers.concat(expert_outputs, axis=1)
-        expert_concat = fluid.layers.reshape(expert_concat,
-                                             [-1, expert_num, expert_size])
+        expert_concat = fluid.layers.reshape(
+            expert_concat, [-1, self.expert_num, self.expert_size])
 
         # g^{k}(x) = activation(W_{gk} * x + b), where activation is softmax according to the paper
         output_layers = []
-        for i in range(0, gate_num):
+        for i in range(0, self.gate_num):
             cur_gate = fluid.layers.fc(
                 input=input_data,
-                size=expert_num,
+                size=self.expert_num,
                 act='softmax',
                 bias_attr=fluid.ParamAttr(learning_rate=1.0),
                 name='gate_' + str(i))
@@ -78,7 +76,7 @@ class Model(ModelBase):
             cur_gate_expert = fluid.layers.reduce_sum(cur_gate_expert, dim=1)
             # Build tower layer
             cur_tower = fluid.layers.fc(input=cur_gate_expert,
-                                        size=tower_size,
+                                        size=self.tower_size,
                                         act='relu',
                                         name='task_layer_' + str(i))
             out = fluid.layers.fc(input=cur_tower,
@@ -127,8 +125,5 @@ class Model(ModelBase):
         self._metrics["AUC_marital"] = auc_marital
         self._metrics["BATCH_AUC_marital"] = batch_auc_2
 
-    def train_net(self):
-        self.MMOE()
-
     def infer_net(self):
-        self.MMOE(is_infer=True)
+        pass