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

easy_rec/python/test/kafka_test.py

@@ -0,0 +1,373 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import json
+import logging
+import os
+import threading
+import time
+import traceback
+import unittest
+
+import numpy as np
+import six
+import tensorflow as tf
+from tensorflow.python.data.ops import iterator_ops
+from tensorflow.python.platform import gfile
+
+from easy_rec.python.inference.predictor import Predictor
+from easy_rec.python.input.kafka_dataset import KafkaDataset
+from easy_rec.python.utils import numpy_utils
+from easy_rec.python.utils import test_utils
+
+try:
+  import kafka
+  from kafka import KafkaProducer, KafkaAdminClient
+  from kafka.admin import NewTopic
+except ImportError:
+  logging.warning('kafka-python is not installed: %s' % traceback.format_exc())
+
+
+class KafkaTest(tf.test.TestCase):
+
+  def setUp(self):
+    self._success = True
+    self._test_dir = test_utils.get_tmp_dir()
+    if self._testMethodName == 'test_session':
+      self._kafka_server_proc = None
+      self._zookeeper_proc = None
+      return
+
+    logging.info('Testing %s.%s, test_dir=%s' %
+                 (type(self).__name__, self._testMethodName, self._test_dir))
+    self._log_dir = os.path.join(self._test_dir, 'logs')
+    if not gfile.IsDirectory(self._log_dir):
+      gfile.MakeDirs(self._log_dir)
+
+    self._kafka_servers = ['127.0.0.1:9092']
+    self._test_topic = 'kafka_op_test_topic'
+
+    if 'kafka_install_dir' in os.environ:
+      kafka_install_dir = os.environ.get('kafka_install_dir', None)
+
+      zookeeper_config_raw = '%s/config/zookeeper.properties' % kafka_install_dir
+      zookeeper_config = os.path.join(self._test_dir, 'zookeeper.properties')
+      with open(zookeeper_config, 'w') as fout:
+        with open(zookeeper_config_raw, 'r') as fin:
+          for line_str in fin:
+            if line_str.startswith('dataDir='):
+              fout.write('dataDir=%s/zookeeper\n' % self._test_dir)
+            else:
+              fout.write(line_str)
+      cmd = 'bash %s/bin/zookeeper-server-start.sh %s' % (kafka_install_dir,
+                                                          zookeeper_config)
+      log_file = os.path.join(self._log_dir, 'zookeeper.log')
+      self._zookeeper_proc = test_utils.run_cmd(cmd, log_file)
+
+      kafka_config_raw = '%s/config/server.properties' % kafka_install_dir
+      kafka_config = os.path.join(self._test_dir, 'server.properties')
+      with open(kafka_config, 'w') as fout:
+        with open(kafka_config_raw, 'r') as fin:
+          for line_str in fin:
+            if line_str.startswith('log.dirs='):
+              fout.write('log.dirs=%s/kafka\n' % self._test_dir)
+            else:
+              fout.write(line_str)
+      cmd = 'bash %s/bin/kafka-server-start.sh %s' % (kafka_install_dir,
+                                                      kafka_config)
+      log_file = os.path.join(self._log_dir, 'kafka_server.log')
+      self._kafka_server_proc = test_utils.run_cmd(cmd, log_file)
+
+      started = False
+      while not started:
+        if self._kafka_server_proc.poll(
+        ) and self._kafka_server_proc.returncode:
+          logging.warning('start kafka server failed, will retry.')
+          os.system('cat %s' % log_file)
+          self._kafka_server_proc = test_utils.run_cmd(cmd, log_file)
+          time.sleep(5)
+        else:
+          try:
+            admin_clt = KafkaAdminClient(bootstrap_servers=self._kafka_servers)
+            logging.info('old topics: %s' % (','.join(admin_clt.list_topics())))
+            admin_clt.close()
+            started = True
+          except kafka.errors.NoBrokersAvailable:
+            time.sleep(2)
+      self._create_topic()
+    else:
+      self._zookeeper_proc = None
+      self._kafka_server_proc = None
+    self._should_stop = False
+    self._producer = None
+
+  def _create_topic(self, num_partitions=2):
+    admin_clt = KafkaAdminClient(bootstrap_servers=self._kafka_servers)
+
+    logging.info('create topic: %s' % self._test_topic)
+    topic_list = [
+        NewTopic(
+            name=self._test_topic,
+            num_partitions=num_partitions,
+            replication_factor=1)
+    ]
+
+    admin_clt.create_topics(new_topics=topic_list, validate_only=False)
+    logging.info('all topics: %s' % (','.join(admin_clt.list_topics())))
+    admin_clt.close()
+
+  def _create_producer(self, generate_func):
+    # start produce thread
+
+    prod = threading.Thread(target=generate_func)
+    prod.start()
+    return prod
+
+  def _stop_producer(self):
+    if self._producer is not None:
+      self._should_stop = True
+      self._producer.join()
+
+  def tearDown(self):
+    try:
+      self._stop_producer()
+      if self._kafka_server_proc is not None:
+        self._kafka_server_proc.terminate()
+    except Exception as ex:
+      logging.warning('exception terminate kafka proc: %s' % str(ex))
+
+    try:
+      if self._zookeeper_proc is not None:
+        self._zookeeper_proc.terminate()
+    except Exception as ex:
+      logging.warning('exception terminate zookeeper proc: %s' % str(ex))
+
+    test_utils.set_gpu_id(None)
+    if self._success:
+      test_utils.clean_up(self._test_dir)
+
+  @unittest.skipIf('kafka_install_dir' not in os.environ,
+                   'Only execute when kafka is available')
+  def test_kafka_ops(self):
+    try:
+      test_utils.set_gpu_id(None)
+
+      def _generate():
+        producer = KafkaProducer(
+            bootstrap_servers=self._kafka_servers, api_version=(0, 10, 1))
+        i = 0
+        while not self._should_stop:
+          msg = 'user_id_%d' % i
+          producer.send(self._test_topic, msg)
+        producer.close()
+
+      self._producer = self._create_producer(_generate)
+
+      group = 'dataset_consumer'
+      k = KafkaDataset(
+          servers=self._kafka_servers[0],
+          topics=[self._test_topic + ':0', self._test_topic + ':1'],
+          group=group,
+          eof=True,
+          # control the maximal read of each partition
+          config_global=['max.partition.fetch.bytes=1048576'],
+          message_key=True,
+          message_offset=True)
+
+      batch_dataset = k.batch(5)
+
+      iterator = iterator_ops.Iterator.from_structure(
+          batch_dataset.output_types)
+      init_batch_op = iterator.make_initializer(batch_dataset)
+      get_next = iterator.get_next()
+
+      sess = tf.Session()
+      sess.run(init_batch_op)
+
+      p = sess.run(get_next)
+
+      self.assertEquals(len(p), 3)
+      offset = p[2]
+      self.assertEquals(offset[0], '0:0')
+      self.assertEquals(offset[1], '0:1')
+
+      p = sess.run(get_next)
+      offset = p[2]
+      self.assertEquals(offset[0], '0:5')
+      self.assertEquals(offset[1], '0:6')
+
+      max_iter = 300
+      while max_iter > 0:
+        sess.run(get_next)
+        max_iter -= 1
+    except tf.errors.OutOfRangeError:
+      pass
+    except Exception as ex:
+      self._success = False
+      raise ex
+
+  @unittest.skipIf('kafka_install_dir' not in os.environ,
+                   'Only execute when kafka is available')
+  def test_kafka_train(self):
+    try:
+      # start produce thread
+      self._producer = self._create_producer(self._generate)
+
+      test_utils.set_gpu_id(None)
+
+      self._success = test_utils.test_single_train_eval(
+          'samples/model_config/deepfm_combo_avazu_kafka.config',
+          self._test_dir)
+      self.assertTrue(self._success)
+    except Exception as ex:
+      self._success = False
+      raise ex
+
+  def _generate(self):
+    producer = KafkaProducer(
+        bootstrap_servers=self._kafka_servers, api_version=(0, 10, 1))
+    while not self._should_stop:
+      with open('data/test/dwd_avazu_ctr_deepmodel_10w.csv', 'r') as fin:
+        for line_str in fin:
+          line_str = line_str.strip()
+          if self._should_stop:
+            break
+          if six.PY3:
+            line_str = line_str.encode('utf-8')
+          producer.send(self._test_topic, line_str)
+    producer.close()
+    logging.info('data generation thread done.')
+
+  @unittest.skipIf('kafka_install_dir' not in os.environ,
+                   'Only execute when kafka is available')
+  def test_kafka_train_chief_redundant(self):
+    try:
+      # start produce thread
+      self._producer = self._create_producer(self._generate)
+
+      test_utils.set_gpu_id(None)
+
+      self._success = test_utils.test_distributed_train_eval(
+          'samples/model_config/deepfm_combo_avazu_kafka_chief_redundant.config',
+          self._test_dir,
+          num_evaluator=1)
+      self.assertTrue(self._success)
+    except Exception as ex:
+      self._success = False
+      raise ex
+
+  @unittest.skipIf('kafka_install_dir' not in os.environ,
+                   'Only execute when kafka is available')
+  def test_kafka_train_v2(self):
+    try:
+      # start produce thread
+      self._producer = self._create_producer(self._generate)
+
+      test_utils.set_gpu_id(None)
+
+      self._success = test_utils.test_single_train_eval(
+          'samples/model_config/deepfm_combo_avazu_kafka_time_offset.config',
+          self._test_dir)
+
+      self.assertTrue(self._success)
+    except Exception as ex:
+      self._success = False
+      raise ex
+
+  @unittest.skipIf(
+      'kafka_install_dir' not in os.environ or 'oss_path' not in os.environ or
+      'oss_endpoint' not in os.environ and 'oss_ak' not in os.environ or
+      'oss_sk' not in os.environ, 'Only execute when kafka is available')
+  def test_kafka_processor(self):
+    self._test_kafka_processor(
+        'samples/model_config/taobao_fg_incr_save.config')
+
+  @unittest.skipIf(
+      'kafka_install_dir' not in os.environ or 'oss_path' not in os.environ or
+      'oss_endpoint' not in os.environ and 'oss_ak' not in os.environ or
+      'oss_sk' not in os.environ, 'Only execute when kafka is available')
+  def test_kafka_processor_ev(self):
+    self._test_kafka_processor(
+        'samples/model_config/taobao_fg_incr_save_ev.config')
+
+  def _test_kafka_processor(self, config_path):
+    self._success = False
+    success = test_utils.test_distributed_train_eval(
+        config_path, self._test_dir, total_steps=500)
+    self.assertTrue(success)
+    export_cmd = """
+       python -m easy_rec.python.export --pipeline_config_path %s/pipeline.config
+           --export_dir %s/export/sep/ --oss_path=%s --oss_ak=%s --oss_sk=%s --oss_endpoint=%s
+           --asset_files ./samples/rtp_fg/fg.json
+           --checkpoint_path %s/train/model.ckpt-0
+    """ % (self._test_dir, self._test_dir, os.environ['oss_path'],
+           os.environ['oss_ak'], os.environ['oss_sk'],
+           os.environ['oss_endpoint'], self._test_dir)
+    proc = test_utils.run_cmd(export_cmd,
+                              '%s/log_export_sep.txt' % self._test_dir)
+    proc.wait()
+    self.assertTrue(proc.returncode == 0)
+    files = gfile.Glob(os.path.join(self._test_dir, 'export/sep/[1-9][0-9]*'))
+    export_sep_dir = files[0]
+
+    predict_cmd = """
+        python -m easy_rec.python.inference.processor.test --saved_model_dir %s
+           --input_path data/test/rtp/taobao_test_feature.txt
+           --output_path %s/processor.out  --test_dir %s
+     """ % (export_sep_dir, self._test_dir, self._test_dir)
+    envs = dict(os.environ)
+    envs['PROCESSOR_TEST'] = '1'
+    proc = test_utils.run_cmd(
+        predict_cmd, '%s/log_processor.txt' % self._test_dir, env=envs)
+    proc.wait()
+    self.assertTrue(proc.returncode == 0)
+
+    with open('%s/processor.out' % self._test_dir, 'r') as fin:
+      processor_out = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        processor_out.append(json.loads(line_str))
+
+    predictor = Predictor(os.path.join(self._test_dir, 'train/export/final/'))
+    with open('data/test/rtp/taobao_test_feature.txt', 'r') as fin:
+      inputs = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_tok = line_str.split(';')[-1]
+        line_tok = line_tok.split(chr(2))
+        inputs.append(line_tok)
+    output_res = predictor.predict(inputs, batch_size=1024)
+
+    with open('%s/predictor.out' % self._test_dir, 'w') as fout:
+      for i in range(len(output_res)):
+        fout.write(
+            json.dumps(output_res[i], cls=numpy_utils.NumpyEncoder) + '\n')
+
+    for i in range(len(output_res)):
+      val0 = output_res[i]['probs']
+      val1 = processor_out[i]['probs']
+      diff = np.abs(val0 - val1)
+      assert diff < 1e-4, 'too much difference[%.6f] >= 1e-4' % diff
+    self._success = True
+
+  @unittest.skipIf('kafka_install_dir' not in os.environ,
+                   'Only execute when kafka is available')
+  def test_kafka_train_v3(self):
+    try:
+      # start produce thread
+      self._producer = self._create_producer(self._generate)
+
+      test_utils.set_gpu_id(None)
+
+      self._success = test_utils.test_single_train_eval(
+          'samples/model_config/deepfm_combo_avazu_kafka_time_offset2.config',
+          self._test_dir)
+
+      self.assertTrue(self._success)
+    except Exception as ex:
+      self._success = False
+      raise ex
+
+
+if __name__ == '__main__':
+  tf.test.main()

easy_rec/python/test/local_incr_test.py

@@ -0,0 +1,122 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import json
+import logging
+import os
+import unittest
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.python.platform import gfile
+
+from easy_rec.python.inference.predictor import Predictor
+from easy_rec.python.utils import numpy_utils
+from easy_rec.python.utils import test_utils
+
+
+class LocalIncrTest(tf.test.TestCase):
+
+  def setUp(self):
+    self._success = True
+    self._test_dir = test_utils.get_tmp_dir()
+
+    logging.info('Testing %s.%s, test_dir=%s' %
+                 (type(self).__name__, self._testMethodName, self._test_dir))
+    self._log_dir = os.path.join(self._test_dir, 'logs')
+    if not gfile.IsDirectory(self._log_dir):
+      gfile.MakeDirs(self._log_dir)
+
+  @unittest.skipIf(
+      'oss_path' not in os.environ or
+      'oss_endpoint' not in os.environ and 'oss_ak' not in os.environ or
+      'oss_sk' not in os.environ, 'Only execute when kafka is available')
+  def test_incr_save(self):
+    self._test_incr_save(
+        'samples/model_config/taobao_fg_incr_save_local.config')
+
+  @unittest.skipIf(
+      'oss_path' not in os.environ or
+      'oss_endpoint' not in os.environ and 'oss_ak' not in os.environ or
+      'oss_sk' not in os.environ, 'Only execute when kafka is available')
+  def test_incr_save_ev(self):
+    self._test_incr_save(
+        'samples/model_config/taobao_fg_incr_save_ev_local.config')
+
+  @unittest.skipIf(
+      'oss_path' not in os.environ or
+      'oss_endpoint' not in os.environ and 'oss_ak' not in os.environ or
+      'oss_sk' not in os.environ, 'Only execute when kafka is available')
+  def test_incr_save_share_ev(self):
+    self._test_incr_save(
+        'samples/model_config/taobao_fg_incr_save_share_ev_local.config')
+
+  def _test_incr_save(self, config_path):
+    self._success = False
+    success = test_utils.test_distributed_train_eval(
+        config_path,
+        self._test_dir,
+        total_steps=100,
+        edit_config_json={
+            'train_config.incr_save_config.fs.mount_path':
+                os.path.join(self._test_dir, 'train/incr_save/')
+        })
+    self.assertTrue(success)
+    export_cmd = """
+       python -m easy_rec.python.export --pipeline_config_path %s/pipeline.config
+           --export_dir %s/export/sep/ --oss_path=%s --oss_ak=%s --oss_sk=%s --oss_endpoint=%s
+           --asset_files ./samples/rtp_fg/fg.json
+           --checkpoint_path %s/train/model.ckpt-0
+    """ % (self._test_dir, self._test_dir, os.environ['oss_path'],
+           os.environ['oss_ak'], os.environ['oss_sk'],
+           os.environ['oss_endpoint'], self._test_dir)
+    proc = test_utils.run_cmd(export_cmd,
+                              '%s/log_export_sep.txt' % self._test_dir)
+    proc.wait()
+    self.assertTrue(proc.returncode == 0)
+    files = gfile.Glob(os.path.join(self._test_dir, 'export/sep/[1-9][0-9]*'))
+    export_sep_dir = files[0]
+
+    predict_cmd = """
+        python -m easy_rec.python.inference.processor.test --saved_model_dir %s
+           --input_path data/test/rtp/taobao_test_feature.txt
+           --output_path %s/processor.out  --test_dir %s
+     """ % (export_sep_dir, self._test_dir, self._test_dir)
+    envs = dict(os.environ)
+    envs['PROCESSOR_TEST'] = '1'
+    proc = test_utils.run_cmd(
+        predict_cmd, '%s/log_processor.txt' % self._test_dir, env=envs)
+    proc.wait()
+    self.assertTrue(proc.returncode == 0)
+
+    with open('%s/processor.out' % self._test_dir, 'r') as fin:
+      processor_out = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        processor_out.append(json.loads(line_str))
+
+    predictor = Predictor(os.path.join(self._test_dir, 'train/export/final/'))
+    with open('data/test/rtp/taobao_test_feature.txt', 'r') as fin:
+      inputs = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_tok = line_str.split(';')[-1]
+        line_tok = line_tok.split(chr(2))
+        inputs.append(line_tok)
+    output_res = predictor.predict(inputs, batch_size=1024)
+
+    with open('%s/predictor.out' % self._test_dir, 'w') as fout:
+      for i in range(len(output_res)):
+        fout.write(
+            json.dumps(output_res[i], cls=numpy_utils.NumpyEncoder) + '\n')
+
+    for i in range(len(output_res)):
+      val0 = output_res[i]['probs']
+      val1 = processor_out[i]['probs']
+      diff = np.abs(val0 - val1)
+      assert diff < 1e-4, 'too much difference[%.6f] >= 1e-4' % diff
+    self._success = True
+
+
+if __name__ == '__main__':
+  tf.test.main()

easy_rec/python/test/loss_test.py

@@ -0,0 +1,110 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import tensorflow as tf
+
+from easy_rec.python.loss.circle_loss import circle_loss
+from easy_rec.python.loss.circle_loss import get_anchor_positive_triplet_mask
+
+from easy_rec.python.loss.f1_reweight_loss import f1_reweight_sigmoid_cross_entropy  # NOQA
+
+from easy_rec.python.loss.softmax_loss_with_negative_mining import softmax_loss_with_negative_mining  # NOQA
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+
+
+class LossTest(tf.test.TestCase):
+
+  def test_f1_reweighted_loss(self):
+    print('test_f1_reweighted_loss')
+    logits = tf.constant([0.1, 0.5, 0.3, 0.8, -0.1, 0.3])
+    labels = tf.constant([1, 1, 0, 0, 1, 1])
+    loss = f1_reweight_sigmoid_cross_entropy(
+        labels=labels, logits=logits, beta_square=4)
+    with self.test_session() as sess:
+      loss_val = sess.run(loss)
+      self.assertAlmostEqual(loss_val, 0.47844395, delta=1e-5)
+
+  def test_softmax_loss_with_negative_mining(self):
+    print('test_softmax_loss_with_negative_mining')
+    user_emb = tf.constant([[0.1, 0.5, 0.3], [0.8, -0.1, 0.3], [0.28, 0.3, 0.9],
+                            [0.37, 0.45, 0.93], [-0.7, 0.15, 0.03],
+                            [0.18, 0.9, -0.3]])
+    item_emb = tf.constant([[0.1, -0.5, 0.3], [0.8, -0.31, 0.3],
+                            [0.7, -0.45, 0.15], [0.08, -0.31, -0.9],
+                            [-0.7, 0.85, 0.03], [0.18, 0.89, -0.3]])
+
+    label = tf.constant([1, 1, 0, 0, 1, 1])
+    loss = softmax_loss_with_negative_mining(
+        user_emb, item_emb, label, num_negative_samples=2, seed=1)
+    with self.test_session() as sess:
+      loss_val = sess.run(loss)
+      self.assertAlmostEqual(loss_val, 0.48577175, delta=1e-5)
+
+  def test_circle_loss(self):
+    print('test_circle_loss')
+    emb = tf.constant([[0.1, 0.2, 0.15, 0.1], [0.3, 0.6, 0.45, 0.3],
+                       [0.13, 0.6, 0.45, 0.3], [0.3, 0.26, 0.45, 0.3],
+                       [0.3, 0.6, 0.5, 0.13], [0.08, 0.43, 0.21, 0.6]],
+                      dtype=tf.float32)
+    label = tf.constant([1, 1, 2, 2, 3, 3])
+    loss = circle_loss(emb, label, label, margin=0.25, gamma=64)
+    with self.test_session() as sess:
+      loss_val = sess.run(loss)
+      self.assertAlmostEqual(loss_val, 52.75707, delta=1e-5)
+
+  def test_triplet_mask(self):
+    print('test_triplet_mask')
+    label = tf.constant([1, 1, 2, 2, 3, 3, 4, 5])
+    positive_mask = tf.constant(
+        [[0., 1., 0., 0., 0., 0., 0., 0.], [1., 0., 0., 0., 0., 0., 0., 0.],
+         [0., 0., 0., 1., 0., 0., 0., 0.], [0., 0., 1., 0., 0., 0., 0., 0.],
+         [0., 0., 0., 0., 0., 1., 0., 0.], [0., 0., 0., 0., 1., 0., 0., 0.],
+         [0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0.]],
+        dtype=tf.float32)
+    negative_mask = tf.constant(
+        [[0., 0., 1., 1., 1., 1., 1., 1.], [0., 0., 1., 1., 1., 1., 1., 1.],
+         [1., 1., 0., 0., 1., 1., 1., 1.], [1., 1., 0., 0., 1., 1., 1., 1.],
+         [1., 1., 1., 1., 0., 0., 1., 1.], [1., 1., 1., 1., 0., 0., 1., 1.],
+         [1., 1., 1., 1., 1., 1., 0., 1.], [1., 1., 1., 1., 1., 1., 1., 0.]],
+        dtype=tf.float32)
+    with self.test_session():
+      pos_mask = get_anchor_positive_triplet_mask(label, label)
+      self.assertAllEqual(positive_mask, pos_mask)
+
+      neg_mask = _get_anchor_negative_triplet_mask(label, label)
+      self.assertAllEqual(negative_mask, neg_mask)
+
+      batch_size = label.shape.as_list()[0]
+      neg_mask2 = 1 - pos_mask - tf.eye(batch_size)
+      self.assertAllEqual(neg_mask, neg_mask2)
+
+
+def _get_anchor_negative_triplet_mask(labels, sessions):
+  """Return a 2D mask where mask[a, n] is 1.0 iff a and n have distinct session or label.
+
+  Args:
+    sessions: a `Tensor` with shape [batch_size]
+    labels: a `Tensor` with shape [batch_size]
+
+  Returns:
+    mask: tf.bool `Tensor` with shape [batch_size, batch_size]
+  """
+  # Check if sessions[i] != sessions[k]
+  # Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)
+  session_not_equal = tf.not_equal(
+      tf.expand_dims(sessions, 0), tf.expand_dims(sessions, 1))
+
+  if labels is sessions:
+    return tf.cast(session_not_equal, tf.float32)
+
+  # Check if labels[i] != labels[k]
+  # Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)
+  label_not_equal = tf.not_equal(
+      tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))
+
+  mask = tf.logical_or(session_not_equal, label_not_equal)
+  return tf.cast(mask, tf.float32)
+
+
+if __name__ == '__main__':
+  tf.test.main()

easy_rec/python/test/odps_command.py

@@ -0,0 +1,61 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import logging
+import os
+import subprocess
+
+from easy_rec.python.test.odps_test_util import get_oss_bucket
+
+
+class OdpsCommand:
+
+  def __init__(self, odps_oss_config):
+    """Wrapper for running odps command.
+
+    Args:
+      odps_oss_config: instance of easy_rec.python.utils.odps_test_util.OdpsOSSConfig
+    """
+    self.bucket = get_oss_bucket(odps_oss_config.oss_key,
+                                 odps_oss_config.oss_secret,
+                                 odps_oss_config.endpoint,
+                                 odps_oss_config.bucket_name)
+    self.bucket_name = odps_oss_config.bucket_name
+    self.temp_dir = odps_oss_config.temp_dir
+    self.log_path = odps_oss_config.log_dir
+    self.odpscmd = odps_oss_config.odpscmd_path
+    self.odps_config_path = odps_oss_config.odps_config_path
+    self.algo_project = odps_oss_config.algo_project
+    self.algo_res_project = odps_oss_config.algo_res_project
+    self.algo_version = odps_oss_config.algo_version
+
+  def run_odps_cmd(self, script_file):
+    """Run sql use odpscmd.
+
+    Args:
+      script_file: xxx.sql file, to be runned by odpscmd
+    Raise:
+      ValueError if failed
+    """
+    exec_file_path = os.path.join(self.temp_dir, script_file)
+    file_name = os.path.split(script_file)[1]
+    log_file = os.path.join(self.log_path, file_name)
+
+    if self.odps_config_path is None:
+      cmd = 'nohup %s  -f  %s > %s.log 2>&1' % (self.odpscmd, exec_file_path,
+                                                log_file)
+    else:
+      cmd = 'nohup %s --config=%s -f  %s > %s.log 2>&1' % (
+          self.odpscmd, self.odps_config_path, exec_file_path, log_file)
+    logging.info('will run cmd: %s' % (cmd))
+    proc = subprocess.Popen(cmd, shell=True)
+    proc.wait()
+    if (proc.returncode == 0):
+      logging.info('%s run succeed' % script_file)
+    else:
+      raise ValueError('%s run FAILED: please check log file:%s.log' %
+                       (exec_file_path, log_file))
+
+  def run_list(self, files):
+    for f in files:
+      self.run_odps_cmd(f)