From 56b07f6154b963979cff8d82581e956a044a60e8 Mon Sep 17 00:00:00 2001 From: frankwhzhang Date: Mon, 25 May 2020 17:33:37 +0800 Subject: [PATCH] merge init_slot into new model style --- core/model.py | 30 +++++++++++++++++++- models/rank/dnn/model.py | 60 +++++++++++++++------------------------- 2 files changed, 52 insertions(+), 38 deletions(-) diff --git a/core/model.py b/core/model.py index fd0b22fe..847a5d23 100755 --- a/core/model.py +++ b/core/model.py @@ -134,7 +134,35 @@ class Model(object): return self._build_optimizer(optimizer, learning_rate) def input_data(self, is_infer=False): - return None + sparse_slots = envs.get_global_env("sparse_slots", None, + "train.reader") + dense_slots = envs.get_global_env("dense_slots", None, "train.reader") + if sparse_slots is not None or dense_slots is not None: + sparse_slots = sparse_slots.strip().split(" ") + dense_slots = dense_slots.strip().split(" ") + dense_slots_shape = [[ + int(j) for j in i.split(":")[1].strip("[]").split(",") + ] for i in dense_slots] + dense_slots = [i.split(":")[0] for i in dense_slots] + self._dense_data_var = [] + data_var_ = [] + for i in range(len(dense_slots)): + l = fluid.layers.data( + name=dense_slots[i], + shape=dense_slots_shape[i], + dtype="float32") + data_var_.append(l) + self._dense_data_var.append(l) + self._sparse_data_var = [] + for name in sparse_slots: + l = fluid.layers.data( + name=name, shape=[1], lod_level=1, dtype="int64") + data_var_.append(l) + self._sparse_data_var.append(l) + return data_var_ + + else: + return None def net(self, is_infer=False): return None diff --git a/models/rank/dnn/model.py b/models/rank/dnn/model.py index 0df06f95..644bbd7c 100755 --- a/models/rank/dnn/model.py +++ b/models/rank/dnn/model.py @@ -24,40 +24,33 @@ class Model(ModelBase): def __init__(self, config): ModelBase.__init__(self, config) - def input(self): + def _init_hyper_parameters(self): + self.is_distributed = True if envs.get_trainer( + ) == "CtrTrainer" else False + self.sparse_feature_number = envs.get_global_env( + "hyper_parameters.sparse_feature_number", None, self._namespace) + self.sparse_feature_dim = envs.get_global_env( + "hyper_parameters.sparse_feature_dim", None, self._namespace) + self.learning_rate = envs.get_global_env( + "hyper_parameters.learning_rate", None, self._namespace) + + def net(self, input, is_infer=False): self.sparse_inputs = self._sparse_data_var[1:] self.dense_input = self._dense_data_var[0] self.label_input = self._sparse_data_var[0] - def net(self): - is_distributed = True if envs.get_trainer() == "CtrTrainer" else False - sparse_feature_number = envs.get_global_env( - "hyper_parameters.sparse_feature_number", None, self._namespace) - sparse_feature_dim = envs.get_global_env( - "hyper_parameters.sparse_feature_dim", None, self._namespace) - def embedding_layer(input): emb = fluid.layers.embedding( input=input, is_sparse=True, - is_distributed=is_distributed, - size=[sparse_feature_number, sparse_feature_dim], + is_distributed=self.is_distributed, + size=[self.sparse_feature_number, self.sparse_feature_dim], param_attr=fluid.ParamAttr( name="SparseFeatFactors", initializer=fluid.initializer.Uniform()), ) emb_sum = fluid.layers.sequence_pool(input=emb, pool_type='sum') return emb_sum - def fc(input, output_size): - output = fluid.layers.fc( - input=input, - size=output_size, - act='relu', - param_attr=fluid.ParamAttr( - initializer=fluid.initializer.Normal( - scale=1.0 / math.sqrt(input.shape[1])))) - return output - sparse_embed_seq = list(map(embedding_layer, self.sparse_inputs)) concated = fluid.layers.concat( sparse_embed_seq + [self.dense_input], axis=1) @@ -67,7 +60,14 @@ class Model(ModelBase): self._namespace) for size in hidden_layers: - fcs.append(fc(fcs[-1], size)) + output = fluid.layers.fc( + input=fcs[-1], + size=size, + act='relu', + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Normal( + scale=1.0 / math.sqrt(fcs[-1].shape[1])))) + fcs.append(output) predict = fluid.layers.fc( input=fcs[-1], @@ -78,13 +78,10 @@ class Model(ModelBase): self.predict = predict - def avg_loss(self): cost = fluid.layers.cross_entropy( input=self.predict, label=self.label_input) avg_cost = fluid.layers.reduce_mean(cost) self._cost = avg_cost - - def metrics(self): auc, batch_auc, _ = fluid.layers.auc(input=self.predict, label=self.label_input, num_thresholds=2**12, @@ -92,20 +89,9 @@ class Model(ModelBase): self._metrics["AUC"] = auc self._metrics["BATCH_AUC"] = batch_auc - def train_net(self): - self._init_slots() - self.input() - self.net() - self.avg_loss() - self.metrics() - def optimizer(self): - learning_rate = envs.get_global_env("hyper_parameters.learning_rate", - None, self._namespace) - optimizer = fluid.optimizer.Adam(learning_rate, lazy_mode=True) + optimizer = fluid.optimizer.Adam(self.learning_rate, lazy_mode=True) return optimizer def infer_net(self): - self._init_slots() - self.input() - self.net() + pass -- GitLab