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

easy_rec/python/model/dropoutnet.py

@@ -0,0 +1,207 @@
+# -*- 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.loss.pairwise_loss import pairwise_loss
+from easy_rec.python.model.easy_rec_model import EasyRecModel
+from easy_rec.python.protos.loss_pb2 import LossType
+from easy_rec.python.utils.proto_util import copy_obj
+
+from easy_rec.python.protos.dropoutnet_pb2 import DropoutNet as DropoutNetConfig  # NOQA
+from easy_rec.python.loss.softmax_loss_with_negative_mining import softmax_loss_with_negative_mining  # NOQA
+from easy_rec.python.protos.dropoutnet_pb2 import DropoutNet as DropoutNetConfig  # NOQA
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+losses = tf.losses
+
+
+def cosine_similarity(user_emb, item_emb):
+  user_item_sim = tf.reduce_sum(
+      tf.multiply(user_emb, item_emb), axis=1, name='cosine')
+  return user_item_sim
+
+
+def bernoulli_dropout(x, rate, training=False):
+  if rate == 0.0 or not training:
+    return x
+  keep_rate = 1.0 - rate
+  dist = tf.distributions.Bernoulli(probs=keep_rate, dtype=x.dtype)
+  mask = dist.sample(sample_shape=tf.stack([tf.shape(x)[0], 1]))
+  return x * mask / keep_rate
+
+
+class DropoutNet(EasyRecModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DropoutNet, self).__init__(model_config, feature_configs, features,
+                                     labels, is_training)
+    self._losses = self._model_config.losses
+    assert self._model_config.WhichOneof(
+        'model'
+    ) == 'dropoutnet', 'invalid model config: %s' % self._model_config.WhichOneof(
+        'model')
+    self._model_config = self._model_config.dropoutnet
+    assert isinstance(self._model_config, DropoutNetConfig)
+
+    # copy_obj so that any modification will not affect original config
+    self.user_content_layers = copy_obj(self._model_config.user_content)
+    self.user_preference_layers = copy_obj(self._model_config.user_preference)
+    self.user_tower_layers = copy_obj(self._model_config.user_tower)
+    self.user_content_feature, self.user_preference_feature = None, None
+    if self._input_layer.has_group('user_content'):
+      self.user_content_feature, _ = self._input_layer(self._feature_dict,
+                                                       'user_content')
+    if self._input_layer.has_group('user_preference'):
+      self.user_preference_feature, _ = self._input_layer(
+          self._feature_dict, 'user_preference')
+    assert self.user_content_feature is not None or self.user_preference_feature is not None, 'no user feature'
+
+    # copy_obj so that any modification will not affect original config
+    self.item_content_layers = copy_obj(self._model_config.item_content)
+    self.item_preference_layers = copy_obj(self._model_config.item_preference)
+    self.item_tower_layers = copy_obj(self._model_config.item_tower)
+    self.item_content_feature, self.item_preference_feature = None, None
+    if self._input_layer.has_group('item_content'):
+      self.item_content_feature, _ = self._input_layer(self._feature_dict,
+                                                       'item_content')
+    if self._input_layer.has_group('item_preference'):
+      self.item_preference_feature, _ = self._input_layer(
+          self._feature_dict, 'item_preference')
+    assert self.item_content_feature is not None or self.item_preference_feature is not None, 'no item feature'
+
+  def build_predict_graph(self):
+    num_user_dnn_layer = len(self.user_tower_layers.hidden_units)
+    last_user_hidden = self.user_tower_layers.hidden_units.pop()
+    num_item_dnn_layer = len(self.item_tower_layers.hidden_units)
+    last_item_hidden = self.item_tower_layers.hidden_units.pop()
+    assert last_item_hidden == last_user_hidden, 'the last hidden layer size of user tower and item tower must be equal'
+
+    # --------------------------build user tower-----------------------------------
+    with tf.name_scope('user_tower'):
+      user_features = []
+      if self.user_content_feature is not None:
+        user_content_dnn = dnn.DNN(self.user_content_layers, self._l2_reg,
+                                   'user_content', self._is_training)
+        content_feature = user_content_dnn(self.user_content_feature)
+        user_features.append(content_feature)
+      if self.user_preference_feature is not None:
+        user_prefer_feature = bernoulli_dropout(
+            self.user_preference_feature, self._model_config.user_dropout_rate,
+            self._is_training)
+        user_prefer_dnn = dnn.DNN(self.user_preference_layers, self._l2_reg,
+                                  'user_preference', self._is_training)
+        prefer_feature = user_prefer_dnn(user_prefer_feature)
+        user_features.append(prefer_feature)
+
+      user_tower_feature = tf.concat(user_features, axis=-1)
+
+      user_dnn = dnn.DNN(self.user_tower_layers, self._l2_reg, 'user_dnn',
+                         self._is_training)
+      user_hidden = user_dnn(user_tower_feature)
+      user_tower_emb = tf.layers.dense(
+          inputs=user_hidden,
+          units=last_user_hidden,
+          kernel_regularizer=self._l2_reg,
+          name='user_dnn/dnn_%d' % (num_user_dnn_layer - 1))
+
+    # --------------------------build item tower-----------------------------------
+    with tf.name_scope('item_tower'):
+      item_features = []
+      if self.item_content_feature is not None:
+        item_content_dnn = dnn.DNN(self.item_content_layers, self._l2_reg,
+                                   'item_content', self._is_training)
+        content_feature = item_content_dnn(self.item_content_feature)
+        item_features.append(content_feature)
+      if self.item_preference_feature is not None:
+        item_prefer_feature = bernoulli_dropout(
+            self.item_preference_feature, self._model_config.item_dropout_rate,
+            self._is_training)
+        item_prefer_dnn = dnn.DNN(self.item_preference_layers, self._l2_reg,
+                                  'item_preference', self._is_training)
+        prefer_feature = item_prefer_dnn(item_prefer_feature)
+        item_features.append(prefer_feature)
+
+      item_tower_feature = tf.concat(item_features, axis=-1)
+
+      item_dnn = dnn.DNN(self.item_tower_layers, self._l2_reg, 'item_dnn',
+                         self._is_training)
+      item_hidden = item_dnn(item_tower_feature)
+      item_tower_emb = tf.layers.dense(
+          inputs=item_hidden,
+          units=last_item_hidden,
+          kernel_regularizer=self._l2_reg,
+          name='item_dnn/dnn_%d' % (num_item_dnn_layer - 1))
+
+    user_emb = tf.nn.l2_normalize(user_tower_emb, axis=-1)
+    item_emb = tf.nn.l2_normalize(item_tower_emb, axis=-1)
+    cosine = cosine_similarity(user_emb, item_emb)
+    self._prediction_dict['similarity'] = cosine
+    self._prediction_dict['float_user_emb'] = user_emb
+    self._prediction_dict['float_item_emb'] = item_emb
+    self._prediction_dict['user_emb'] = tf.reduce_join(
+        tf.as_string(user_emb), axis=-1, separator=',')
+    self._prediction_dict['item_emb'] = tf.reduce_join(
+        tf.as_string(item_emb), axis=-1, separator=',')
+    return self._prediction_dict
+
+  def build_loss_graph(self):
+    labels = list(self._labels.values())[0]
+    logits = self._prediction_dict['similarity']
+    for loss in self._losses:
+      if loss.loss_type == LossType.SOFTMAX_CROSS_ENTROPY_WITH_NEGATIVE_MINING:
+        assert self._model_config.HasField(
+            'softmax_loss'), '`softmax_loss` must be configured'
+        user_emb = self._prediction_dict['float_user_emb']
+        item_emb = self._prediction_dict['float_item_emb']
+        loss_value = softmax_loss_with_negative_mining(
+            user_emb,
+            item_emb,
+            labels,
+            self._model_config.softmax_loss.num_negative_samples,
+            embed_normed=True,
+            weights=self._sample_weight,
+            margin=self._model_config.softmax_loss.margin,
+            gamma=self._model_config.softmax_loss.gamma,
+            t=self._model_config.softmax_loss.coefficient_of_support_vector)
+        self._loss_dict['softmax_loss'] = loss_value * loss.weight
+      elif loss.loss_type == LossType.PAIR_WISE_LOSS:
+        loss_value = pairwise_loss(labels, logits)
+        self._loss_dict['pairwise_loss'] = loss_value * loss.weight
+      elif loss.loss_type == LossType.CLASSIFICATION:
+        loss_value = tf.losses.sigmoid_cross_entropy(labels, logits,
+                                                     self._sample_weight)
+        self._loss_dict['sigmoid_loss'] = loss_value * loss.weight
+    return self._loss_dict
+
+  def build_metric_graph(self, eval_config):
+    from easy_rec.python.core.easyrec_metrics import metrics_tf as metrics
+    metric_dict = {}
+    labels = list(self._labels.values())[0]
+    sim_score = self._prediction_dict['similarity']
+    prob = tf.nn.sigmoid(sim_score)
+    predict = tf.greater(prob, 0.5)
+    for metric in eval_config.metrics_set:
+      if metric.WhichOneof('metric') == 'auc':
+        metric_dict['auc'] = metrics.auc(
+            labels, prob, weights=self._sample_weight)
+      elif metric.WhichOneof('metric') == 'accuracy':
+        metric_dict['accuracy'] = metrics.accuracy(
+            tf.cast(labels, tf.bool), predict, weights=self._sample_weight)
+      elif metric.WhichOneof('metric') == 'precision':
+        metric_dict['precision'] = metrics.precision(
+            labels, predict, weights=self._sample_weight)
+      elif metric.WhichOneof('metric') == 'recall':
+        metric_dict['recall'] = metrics.recall(
+            labels, predict, weights=self._sample_weight)
+      else:
+        ValueError('invalid metric type: %s' % str(metric))
+    return metric_dict
+
+  def get_outputs(self):
+    return ['similarity', 'user_emb', 'item_emb']

easy_rec/python/model/dssm.py

@@ -0,0 +1,154 @@
+# -*- 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.dssm_pb2 import DSSM as DSSMConfig
+from easy_rec.python.protos.loss_pb2 import LossType
+from easy_rec.python.protos.simi_pb2 import Similarity
+from easy_rec.python.utils.proto_util import copy_obj
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+losses = tf.losses
+
+
+class DSSM(MatchModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DSSM, self).__init__(model_config, feature_configs, features, labels,
+                               is_training)
+    assert self._model_config.WhichOneof('model') == 'dssm', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+    self._model_config = self._model_config.dssm
+    assert isinstance(self._model_config, DSSMConfig)
+
+    # copy_obj so that any modification will not affect original config
+    self.user_tower = copy_obj(self._model_config.user_tower)
+    self.user_tower_feature, _ = self._input_layer(self._feature_dict, 'user')
+    # copy_obj so that any modification will not affect original config
+    self.item_tower = copy_obj(self._model_config.item_tower)
+    self.item_tower_feature, _ = self._input_layer(self._feature_dict, 'item')
+    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_emb = user_dnn(self.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_emb = item_dnn(self.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))
+
+    if self._model_config.simi_func == Similarity.COSINE:
+      user_tower_emb = self.norm(user_tower_emb)
+      item_tower_emb = self.norm(item_tower_emb)
+      temperature = self._model_config.temperature
+    else:
+      temperature = 1.0
+
+    user_item_sim = self.sim(user_tower_emb, item_tower_emb) / temperature
+    if self._model_config.scale_simi:
+      sim_w = tf.get_variable(
+          'sim_w',
+          dtype=tf.float32,
+          shape=(1),
+          initializer=tf.ones_initializer())
+      sim_b = tf.get_variable(
+          'sim_b',
+          dtype=tf.float32,
+          shape=(1),
+          initializer=tf.zeros_initializer())
+      y_pred = user_item_sim * tf.abs(sim_w) + sim_b
+    else:
+      y_pred = user_item_sim
+
+    if self._is_point_wise:
+      y_pred = tf.reshape(y_pred, [-1])
+
+    if self._loss_type == LossType.CLASSIFICATION:
+      self._prediction_dict['logits'] = y_pred
+      self._prediction_dict['probs'] = tf.nn.sigmoid(y_pred)
+    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=',')
+    return self._prediction_dict
+
+  def get_outputs(self):
+    if self._loss_type == LossType.CLASSIFICATION:
+      return [
+          'logits', 'probs', 'user_emb', 'item_emb', 'user_tower_emb',
+          'item_tower_emb'
+      ]
+    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'
+      ]
+    elif self._loss_type == LossType.L2_LOSS:
+      return ['y', 'user_emb', 'item_emb', 'user_tower_emb', 'item_tower_emb']
+    else:
+      raise ValueError('invalid loss type: %s' % str(self._loss_type))
+
+  def build_output_dict(self):
+    output_dict = super(DSSM, self).build_output_dict()
+    output_dict['user_tower_feature'] = tf.reduce_join(
+        tf.as_string(self.user_tower_feature), axis=-1, separator=',')
+    output_dict['item_tower_feature'] = tf.reduce_join(
+        tf.as_string(self.item_tower_feature), axis=-1, separator=',')
+    return output_dict
+
+  def build_rtp_output_dict(self):
+    output_dict = super(DSSM, self).build_rtp_output_dict()
+    if 'user_tower_emb' not in self._prediction_dict:
+      raise ValueError(
+          'User tower embedding does not exist. Please checking predict graph.')
+    output_dict['user_embedding_output'] = tf.identity(
+        self._prediction_dict['user_tower_emb'], name='user_embedding_output')
+    if 'item_tower_emb' not in self._prediction_dict:
+      raise ValueError(
+          'Item tower embedding does not exist. Please checking predict graph.')
+    output_dict['item_embedding_output'] = tf.identity(
+        self._prediction_dict['item_tower_emb'], name='item_embedding_output')
+    if self._loss_type == LossType.CLASSIFICATION:
+      if 'probs' not in self._prediction_dict:
+        raise ValueError(
+            'Probs output does not exist. Please checking predict graph.')
+      output_dict['rank_predict'] = tf.identity(
+          self._prediction_dict['probs'], name='rank_predict')
+    return output_dict

easy_rec/python/model/dssm_senet.py

@@ -0,0 +1,143 @@
+# -*- 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 senet
+from easy_rec.python.model.dssm import DSSM
+from easy_rec.python.model.match_model import MatchModel
+from easy_rec.python.protos.loss_pb2 import LossType
+from easy_rec.python.protos.simi_pb2 import Similarity
+from easy_rec.python.utils.proto_util import copy_obj
+
+from easy_rec.python.protos.dssm_senet_pb2 import DSSM_SENet as DSSM_SENet_Config  # NOQA
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+losses = tf.losses
+
+
+class DSSM_SENet(DSSM):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+
+    MatchModel.__init__(self, model_config, feature_configs, features, labels,
+                        is_training)
+
+    assert self._model_config.WhichOneof('model') == 'dssm_senet', \
+        'invalid model config: %s' % self._model_config.WhichOneof('model')
+    self._model_config = self._model_config.dssm_senet
+    assert isinstance(self._model_config, DSSM_SENet_Config)
+
+    # copy_obj so that any modification will not affect original config
+    self.user_tower = copy_obj(self._model_config.user_tower)
+
+    self.user_seq_features, self.user_plain_features, self.user_feature_list = self._input_layer(
+        self._feature_dict, 'user', is_combine=False)
+    self.user_num_fields = len(self.user_feature_list)
+
+    # copy_obj so that any modification will not affect original config
+    self.item_tower = copy_obj(self._model_config.item_tower)
+
+    self.item_seq_features, self.item_plain_features, self.item_feature_list = self._input_layer(
+        self._feature_dict, 'item', is_combine=False)
+    self.item_num_fields = len(self.item_feature_list)
+
+    self._user_tower_emb = None
+    self._item_tower_emb = None
+
+  def build_predict_graph(self):
+    user_senet = senet.SENet(
+        num_fields=self.user_num_fields,
+        num_squeeze_group=self.user_tower.senet.num_squeeze_group,
+        reduction_ratio=self.user_tower.senet.reduction_ratio,
+        l2_reg=self._l2_reg,
+        name='user_senet')
+    user_senet_output_list = user_senet(self.user_feature_list)
+    user_senet_output = tf.concat(user_senet_output_list, axis=-1)
+
+    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_emb = user_dnn(user_senet_output)
+    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))
+
+    item_senet = senet.SENet(
+        num_fields=self.item_num_fields,
+        num_squeeze_group=self.item_tower.senet.num_squeeze_group,
+        reduction_ratio=self.item_tower.senet.reduction_ratio,
+        l2_reg=self._l2_reg,
+        name='item_senet')
+
+    item_senet_output_list = item_senet(self.item_feature_list)
+    item_senet_output = tf.concat(item_senet_output_list, axis=-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_emb = item_dnn(item_senet_output)
+    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))
+
+    if self._model_config.simi_func == Similarity.COSINE:
+      user_tower_emb = self.norm(user_tower_emb)
+      item_tower_emb = self.norm(item_tower_emb)
+      temperature = self._model_config.temperature
+    else:
+      temperature = 1.0
+
+    user_item_sim = self.sim(user_tower_emb, item_tower_emb) / temperature
+    if self._model_config.scale_simi:
+      sim_w = tf.get_variable(
+          'sim_w',
+          dtype=tf.float32,
+          shape=(1),
+          initializer=tf.ones_initializer())
+      sim_b = tf.get_variable(
+          'sim_b',
+          dtype=tf.float32,
+          shape=(1),
+          initializer=tf.zeros_initializer())
+      y_pred = user_item_sim * tf.abs(sim_w) + sim_b
+    else:
+      y_pred = user_item_sim
+
+    if self._is_point_wise:
+      y_pred = tf.reshape(y_pred, [-1])
+
+    if self._loss_type == LossType.CLASSIFICATION:
+      self._prediction_dict['logits'] = y_pred
+      self._prediction_dict['probs'] = tf.nn.sigmoid(y_pred)
+    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=',')
+    return self._prediction_dict
+
+  def build_output_dict(self):
+    output_dict = MatchModel.build_output_dict(self)
+
+    return output_dict

easy_rec/python/model/dummy_model.py

@@ -0,0 +1,48 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import tensorflow as tf
+
+from easy_rec.python.model.easy_rec_model import EasyRecModel
+
+
+class DummyModel(EasyRecModel):
+
+  def __init__(self,
+               model_config,
+               feature_configs,
+               features,
+               labels=None,
+               is_training=False):
+    super(DummyModel, self).__init__(model_config, feature_configs, features,
+                                     labels, is_training)
+
+    if self._labels is not None:
+      self._labels = list(self._labels.values())
+      if self._labels[0].dtype != tf.float32:
+        self._labels[0] = tf.ones_like(self._labels[0], tf.float32)
+
+  def build_predict_graph(self):
+    input_data = tf.random_uniform(tf.shape(self._labels[0]), dtype=tf.float32)
+    input_data = tf.reshape(input_data, [-1, 1])
+    output = tf.layers.dense(inputs=input_data, units=1, name='layer_0')
+    self._prediction_dict['output'] = output
+    for key in self._feature_dict:
+      val = self._feature_dict[key]
+      if isinstance(val, tf.sparse.SparseTensor):
+        val = val.values
+      self._prediction_dict[key] = val
+    return self._prediction_dict
+
+  def build_loss_graph(self):
+    return {
+        'cross_ent':
+            tf.reduce_sum(
+                tf.square(self._prediction_dict['output'] - self._labels[0]))
+    }
+
+  def get_outputs(self):
+    return ['output']
+
+  def build_metric_graph(self):
+    return {}