easy-cs-rec-custommodel 0.8.6__py2.py3-none-any.whl

easy_rec/python/model/dat.py

@@ -0,0 +1,138 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import tensorflow as tf
+
+from easy_rec.python.layers import dnn
+from easy_rec.python.model.match_model import MatchModel
+from easy_rec.python.protos.dat_pb2 import DAT as DATConfig
+from easy_rec.python.protos.loss_pb2 import LossType
+from easy_rec.python.utils.proto_util import copy_obj
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class DAT(MatchModel):
+  """Dual Augmented Two-tower Model."""
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DAT, self).__init__(model_config, feature_configs, features, labels,
+                              is_training)
+    assert self._model_config.WhichOneof('model') == 'dat', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+
+    feature_group_names = [
+        fg.group_name for fg in self._model_config.feature_groups
+    ]
+    assert 'user' in feature_group_names, 'user feature group not found'
+    assert 'item' in feature_group_names, 'item feature group not found'
+    assert 'user_id_augment' in feature_group_names, 'user_id_augment feature group not found'
+    assert 'item_id_augment' in feature_group_names, 'item_id_augment feature group not found'
+
+    self._model_config = self._model_config.dat
+    assert isinstance(self._model_config, DATConfig)
+
+    self.user_tower = copy_obj(self._model_config.user_tower)
+    self.user_deep_feature, _ = self._input_layer(self._feature_dict, 'user')
+    self.user_augmented_vec, _ = self._input_layer(self._feature_dict,
+                                                   'user_id_augment')
+
+    self.item_tower = copy_obj(self._model_config.item_tower)
+    self.item_deep_feature, _ = self._input_layer(self._feature_dict, 'item')
+    self.item_augmented_vec, _ = self._input_layer(self._feature_dict,
+                                                   'item_id_augment')
+
+    self._user_tower_emb = None
+    self._item_tower_emb = None
+
+  def build_predict_graph(self):
+    num_user_dnn_layer = len(self.user_tower.dnn.hidden_units)
+    last_user_hidden = self.user_tower.dnn.hidden_units.pop()
+    user_dnn = dnn.DNN(self.user_tower.dnn, self._l2_reg, 'user_dnn',
+                       self._is_training)
+
+    user_tower_feature = tf.concat(
+        [self.user_deep_feature, self.user_augmented_vec], axis=-1)
+    user_tower_emb = user_dnn(user_tower_feature)
+    user_tower_emb = tf.layers.dense(
+        inputs=user_tower_emb,
+        units=last_user_hidden,
+        kernel_regularizer=self._l2_reg,
+        name='user_dnn/dnn_%d' % (num_user_dnn_layer - 1))
+
+    num_item_dnn_layer = len(self.item_tower.dnn.hidden_units)
+    last_item_hidden = self.item_tower.dnn.hidden_units.pop()
+    item_dnn = dnn.DNN(self.item_tower.dnn, self._l2_reg, 'item_dnn',
+                       self._is_training)
+
+    item_tower_feature = tf.concat(
+        [self.item_deep_feature, self.item_augmented_vec], axis=-1)
+    item_tower_emb = item_dnn(item_tower_feature)
+    item_tower_emb = tf.layers.dense(
+        inputs=item_tower_emb,
+        units=last_item_hidden,
+        kernel_regularizer=self._l2_reg,
+        name='item_dnn/dnn_%d' % (num_item_dnn_layer - 1))
+
+    user_tower_emb = self.norm(user_tower_emb)
+    item_tower_emb = self.norm(item_tower_emb)
+    temperature = self._model_config.temperature
+
+    y_pred = self.sim(user_tower_emb, item_tower_emb) / temperature
+
+    if self._is_point_wise:
+      raise ValueError('Currently DAT model only supports list wise mode.')
+
+    if self._loss_type == LossType.CLASSIFICATION:
+      raise ValueError(
+          'Currently DAT model only supports SOFTMAX_CROSS_ENTROPY loss.')
+    elif self._loss_type == LossType.SOFTMAX_CROSS_ENTROPY:
+      y_pred = self._mask_in_batch(y_pred)
+      self._prediction_dict['logits'] = y_pred
+      self._prediction_dict['probs'] = tf.nn.softmax(y_pred)
+    else:
+      self._prediction_dict['y'] = y_pred
+
+    self._prediction_dict['user_tower_emb'] = user_tower_emb
+    self._prediction_dict['item_tower_emb'] = item_tower_emb
+    self._prediction_dict['user_emb'] = tf.reduce_join(
+        tf.as_string(user_tower_emb), axis=-1, separator=',')
+    self._prediction_dict['item_emb'] = tf.reduce_join(
+        tf.as_string(item_tower_emb), axis=-1, separator=',')
+
+    augmented_p_u = tf.stop_gradient(user_tower_emb)
+    augmented_p_i = tf.stop_gradient(item_tower_emb)
+
+    self._prediction_dict['augmented_p_u'] = augmented_p_u
+    self._prediction_dict['augmented_p_i'] = augmented_p_i
+
+    self._prediction_dict['augmented_a_u'] = self.user_augmented_vec
+    self._prediction_dict['augmented_a_i'] = self.item_augmented_vec
+
+    return self._prediction_dict
+
+  def get_outputs(self):
+    if self._loss_type == LossType.CLASSIFICATION:
+      raise ValueError(
+          'Currently DAT model only supports SOFTMAX_CROSS_ENTROPY loss.')
+    elif self._loss_type == LossType.SOFTMAX_CROSS_ENTROPY:
+      self._prediction_dict['logits'] = tf.squeeze(
+          self._prediction_dict['logits'], axis=-1)
+      self._prediction_dict['probs'] = tf.nn.sigmoid(
+          self._prediction_dict['logits'])
+      return [
+          'logits', 'probs', 'user_emb', 'item_emb', 'user_tower_emb',
+          'item_tower_emb', 'augmented_p_u', 'augmented_p_i', 'augmented_a_u',
+          'augmented_a_i'
+      ]
+    else:
+      raise ValueError('invalid loss type: %s' % str(self._loss_type))
+
+  def build_output_dict(self):
+    output_dict = super(DAT, self).build_output_dict()
+    return output_dict

easy_rec/python/model/dbmtl.py

@@ -0,0 +1,116 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import tensorflow as tf
+
+from easy_rec.python.layers import cmbf
+from easy_rec.python.layers import dnn
+from easy_rec.python.layers import mmoe
+from easy_rec.python.layers import uniter
+from easy_rec.python.model.multi_task_model import MultiTaskModel
+from easy_rec.python.protos.dbmtl_pb2 import DBMTL as DBMTLConfig
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class DBMTL(MultiTaskModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DBMTL, self).__init__(model_config, feature_configs, features, labels,
+                                is_training)
+    assert self._model_config.WhichOneof('model') == 'dbmtl', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+    self._model_config = self._model_config.dbmtl
+    assert isinstance(self._model_config, DBMTLConfig)
+
+    if self._model_config.HasField('bottom_cmbf'):
+      self._cmbf_layer = cmbf.CMBF(model_config, feature_configs, features,
+                                   self._model_config.bottom_cmbf,
+                                   self._input_layer)
+    elif self._model_config.HasField('bottom_uniter'):
+      self._uniter_layer = uniter.Uniter(model_config, feature_configs,
+                                         features,
+                                         self._model_config.bottom_uniter,
+                                         self._input_layer)
+    elif not self.has_backbone:
+      self._features, self._feature_list = self._input_layer(
+          self._feature_dict, 'all')
+    else:
+      assert False, 'invalid code branch'
+    self._init_towers(self._model_config.task_towers)
+
+  def build_predict_graph(self):
+    bottom_fea = self.backbone
+    if bottom_fea is None:
+      if self._model_config.HasField('bottom_cmbf'):
+        bottom_fea = self._cmbf_layer(self._is_training, l2_reg=self._l2_reg)
+      elif self._model_config.HasField('bottom_uniter'):
+        bottom_fea = self._uniter_layer(self._is_training, l2_reg=self._l2_reg)
+      elif self._model_config.HasField('bottom_dnn'):
+        bottom_dnn = dnn.DNN(
+            self._model_config.bottom_dnn,
+            self._l2_reg,
+            name='bottom_dnn',
+            is_training=self._is_training)
+        bottom_fea = bottom_dnn(self._features)
+      else:
+        bottom_fea = self._features
+
+    # MMOE block
+    if self._model_config.HasField('expert_dnn'):
+      mmoe_layer = mmoe.MMOE(
+          self._model_config.expert_dnn,
+          l2_reg=self._l2_reg,
+          num_task=self._task_num,
+          num_expert=self._model_config.num_expert)
+      task_input_list = mmoe_layer(bottom_fea)
+    else:
+      task_input_list = [bottom_fea] * self._task_num
+
+    tower_features = {}
+    # task specify network
+    for i, task_tower_cfg in enumerate(self._model_config.task_towers):
+      tower_name = task_tower_cfg.tower_name
+      if task_tower_cfg.HasField('dnn'):
+        tower_dnn = dnn.DNN(
+            task_tower_cfg.dnn,
+            self._l2_reg,
+            name=tower_name + '/dnn',
+            is_training=self._is_training)
+        tower_fea = tower_dnn(task_input_list[i])
+        tower_features[tower_name] = tower_fea
+      else:
+        tower_features[tower_name] = task_input_list[i]
+
+    tower_outputs = {}
+    relation_features = {}
+    # bayes network
+    for task_tower_cfg in self._model_config.task_towers:
+      tower_name = task_tower_cfg.tower_name
+      relation_dnn = dnn.DNN(
+          task_tower_cfg.relation_dnn,
+          self._l2_reg,
+          name=tower_name + '/relation_dnn',
+          is_training=self._is_training)
+      tower_inputs = [tower_features[tower_name]]
+      for relation_tower_name in task_tower_cfg.relation_tower_names:
+        tower_inputs.append(relation_features[relation_tower_name])
+      relation_input = tf.concat(
+          tower_inputs, axis=-1, name=tower_name + '/relation_input')
+      relation_fea = relation_dnn(relation_input)
+      relation_features[tower_name] = relation_fea
+
+      output_logits = tf.layers.dense(
+          relation_fea,
+          task_tower_cfg.num_class,
+          kernel_regularizer=self._l2_reg,
+          name=tower_name + '/output')
+      tower_outputs[tower_name] = output_logits
+
+    self._add_to_prediction_dict(tower_outputs)
+    return self._prediction_dict

easy_rec/python/model/dcn.py

@@ -0,0 +1,70 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import tensorflow as tf
+
+from easy_rec.python.layers import dnn
+from easy_rec.python.model.rank_model import RankModel
+
+from easy_rec.python.protos.dcn_pb2 import DCN as DCNConfig  # NOQA
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class DCN(RankModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DCN, self).__init__(model_config, feature_configs, features, labels,
+                              is_training)
+    assert self._model_config.WhichOneof('model') == 'dcn', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+    self._model_config = self._model_config.dcn
+    assert isinstance(self._model_config, DCNConfig)
+
+    self._features, _ = self._input_layer(self._feature_dict, 'all')
+
+  def _cross_net(self, tensor, num_cross_layers):
+    x = x0 = tensor
+    input_dim = tensor.shape[-1]
+    for i in range(num_cross_layers):
+      name = 'cross_layer_%s' % i
+      w = tf.get_variable(
+          name=name + '_w',
+          dtype=tf.float32,
+          shape=(input_dim),
+      )
+      b = tf.get_variable(name=name + '_b', dtype=tf.float32, shape=(input_dim))
+      xw = tf.reduce_sum(x * w, axis=1, keepdims=True)  # (B, 1)
+      x = tf.math.add(tf.math.add(x0 * xw, b), x)
+    return x
+
+  def build_predict_graph(self):
+    tower_fea_arr = []
+    # deep tower
+    deep_tower_config = self._model_config.deep_tower
+
+    dnn_layer = dnn.DNN(deep_tower_config.dnn, self._l2_reg, 'dnn',
+                        self._is_training)
+    deep_tensor = dnn_layer(self._features)
+    tower_fea_arr.append(deep_tensor)
+    # cross tower
+    cross_tower_config = self._model_config.cross_tower
+    num_cross_layers = cross_tower_config.cross_num
+    cross_tensor = self._cross_net(self._features, num_cross_layers)
+    tower_fea_arr.append(cross_tensor)
+    # final tower
+    all_fea = tf.concat(tower_fea_arr, axis=1)
+    final_dnn_layer = dnn.DNN(self._model_config.final_dnn, self._l2_reg,
+                              'final_dnn', self._is_training)
+    all_fea = final_dnn_layer(all_fea)
+    output = tf.layers.dense(all_fea, self._num_class, name='output')
+
+    self._add_to_prediction_dict(output)
+
+    return self._prediction_dict

easy_rec/python/model/deepfm.py

@@ -0,0 +1,106 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import tensorflow as tf
+
+from easy_rec.python.layers import dnn
+from easy_rec.python.layers import fm
+from easy_rec.python.model.rank_model import RankModel
+from easy_rec.python.protos.deepfm_pb2 import DeepFM as DeepFMConfig
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class DeepFM(RankModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DeepFM, self).__init__(model_config, feature_configs, features,
+                                 labels, is_training)
+    assert self._model_config.WhichOneof('model') == 'deepfm', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+    self._model_config = self._model_config.deepfm
+    assert isinstance(self._model_config, DeepFMConfig)
+
+    # backward compatibility
+    if self._model_config.HasField('wide_regularization'):
+      tf.logging.warn(
+          'wide_regularization is deprecated, please use l2_regularization')
+
+    self._wide_features, _ = self._input_layer(self._feature_dict, 'wide')
+    self._deep_features, self._fm_features = self._input_layer(
+        self._feature_dict, 'deep')
+    if 'fm' in self._input_layer._feature_groups:
+      _, self._fm_features = self._input_layer(self._feature_dict, 'fm')
+
+  def build_input_layer(self, model_config, feature_configs):
+    # overwrite create input_layer to support wide_output_dim
+    has_final = len(model_config.deepfm.final_dnn.hidden_units) > 0
+    if not has_final:
+      assert model_config.deepfm.wide_output_dim == model_config.num_class
+    self._wide_output_dim = model_config.deepfm.wide_output_dim
+    super(DeepFM, self).build_input_layer(model_config, feature_configs)
+
+  def build_predict_graph(self):
+    # Wide
+    wide_fea = tf.reduce_sum(
+        self._wide_features, axis=1, keepdims=True, name='wide_feature')
+
+    # FM
+    fm_fea = fm.FM(name='fm_feature')(self._fm_features)
+    self._fm_outputs = fm_fea
+
+    # Deep
+    deep_layer = dnn.DNN(self._model_config.dnn, self._l2_reg, 'deep_feature',
+                         self._is_training)
+    deep_fea = deep_layer(self._deep_features)
+
+    # Final
+    if len(self._model_config.final_dnn.hidden_units) > 0:
+      all_fea = tf.concat([wide_fea, fm_fea, deep_fea], axis=1)
+      final_dnn_layer = dnn.DNN(self._model_config.final_dnn, self._l2_reg,
+                                'final_dnn', self._is_training)
+      all_fea = final_dnn_layer(all_fea)
+      output = tf.layers.dense(
+          all_fea,
+          self._num_class,
+          kernel_regularizer=self._l2_reg,
+          name='output')
+    else:
+      if self._num_class > 1:
+        fm_fea = tf.layers.dense(
+            fm_fea,
+            self._num_class,
+            kernel_regularizer=self._l2_reg,
+            name='fm_logits')
+      else:
+        fm_fea = tf.reduce_sum(fm_fea, 1, keepdims=True)
+      deep_fea = tf.layers.dense(
+          deep_fea,
+          self._num_class,
+          kernel_regularizer=self._l2_reg,
+          name='deep_logits')
+      output = wide_fea + fm_fea + deep_fea
+
+    self._add_to_prediction_dict(output)
+
+    return self._prediction_dict
+
+  def build_feature_output_dict(self):
+    outputs = super(DeepFM, self).build_feature_output_dict()
+    outputs.update({
+        'wide_features':
+            tf.reduce_join(
+                tf.as_string(self._wide_features), axis=-1, separator=','),
+        'deep_features':
+            tf.reduce_join(
+                tf.as_string(self._deep_features), axis=-1, separator=','),
+        'fm_outputs':
+            tf.reduce_join(
+                tf.as_string(self._fm_outputs), axis=-1, separator=',')
+    })
+    return outputs

easy_rec/python/model/dlrm.py

@@ -0,0 +1,73 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import logging
+
+import tensorflow as tf
+
+from easy_rec.python.layers import dnn
+from easy_rec.python.model.rank_model import RankModel
+
+from easy_rec.python.protos.dlrm_pb2 import DLRM as DLRMConfig  # NOQA
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class DLRM(RankModel):
+  """Implements Deep Learning Recommendation Model for Personalization and Recommendation Systems(FaceBook)."""
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DLRM, self).__init__(model_config, feature_configs, features, labels,
+                               is_training)
+    assert model_config.WhichOneof('model') == 'dlrm', \
+        'invalid model config: %s' % model_config.WhichOneof('model')
+    self._model_config = model_config.dlrm
+    assert isinstance(self._model_config, DLRMConfig)
+    assert self._input_layer.has_group(
+        'sparse'), 'sparse group is not specified'
+    _, self._sparse_features = self._input_layer(self._feature_dict, 'sparse')
+    assert self._input_layer.has_group('dense'), 'dense group is not specified'
+    self._dense_feature, _ = self._input_layer(self._feature_dict, 'dense')
+
+  def build_predict_graph(self):
+    bot_dnn = dnn.DNN(self._model_config.bot_dnn, self._l2_reg, 'bot_dnn',
+                      self._is_training)
+    dense_fea = bot_dnn(self._dense_feature)
+    logging.info('arch_interaction_op = %s' %
+                 self._model_config.arch_interaction_op)
+    if self._model_config.arch_interaction_op == 'cat':
+      all_fea = tf.concat([dense_fea] + self._sparse_features, axis=1)
+    elif self._model_config.arch_interaction_op == 'dot':
+      assert dense_fea.get_shape()[1] == self._sparse_features[0].get_shape()[1], \
+          'bot_dnn last hidden[%d] != sparse feature embedding_dim[%d]' % (
+          dense_fea.get_shape()[1], self._sparse_features[0].get_shape()[1])
+
+      all_feas = [dense_fea] + self._sparse_features
+      all_feas = [x[:, None, :] for x in all_feas]
+      all_feas = tf.concat(all_feas, axis=1)
+      num_fea = all_feas.get_shape()[1]
+      interaction = tf.einsum('bne,bme->bnm', all_feas, all_feas)
+      offset = 0 if self._model_config.arch_interaction_itself else 1
+      upper_tri = []
+      for i in range(num_fea):
+        upper_tri.append(interaction[:, i, (i + offset):num_fea])
+      upper_tri = tf.concat(upper_tri, axis=1)
+      concat_feas = [upper_tri] + self._sparse_features
+      if self._model_config.arch_with_dense_feature:
+        concat_feas.append(dense_fea)
+      all_fea = tf.concat(concat_feas, axis=1)
+
+    top_dnn = dnn.DNN(self._model_config.top_dnn, self._l2_reg, 'top_dnn',
+                      self._is_training)
+    all_fea = top_dnn(all_fea)
+    logits = tf.layers.dense(
+        all_fea, 1, kernel_regularizer=self._l2_reg, name='output')
+
+    self._add_to_prediction_dict(logits)
+
+    return self._prediction_dict