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

easy_rec/python/test/odps_test_util.py

@@ -0,0 +1,237 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import logging
+import os
+import time
+import traceback
+
+import oss2
+
+try:
+  from datahub import DataHub
+  from datahub.exceptions import InvalidOperationException
+  from datahub.exceptions import ResourceExistException
+  # from datahub.exceptions import LimitExceededException
+  # from datahub.exceptions import ResourceNotFoundException
+  # from datahub.models import BlobRecord
+  # from datahub.models import CursorType
+  from datahub.models import FieldType
+  from datahub.models import RecordSchema
+  from datahub.models import RecordType
+  from datahub.models import TupleRecord
+except Exception:
+  logging.error(
+      'DataHub is not installed, please installed it by: pip install pydatahub')
+  DataHub = None
+
+try:
+  from odps import ODPS
+  from odps.df import DataFrame
+except Exception:
+  ODPS = None
+  DataFrame = None
+
+
+class OdpsOSSConfig:
+
+  def __init__(self, script_path='./samples/odps_script'):
+    self.time_stamp = int(time.time())
+    temp_dir = os.environ.get('TMPDIR', '/tmp')
+    self.exp_dir = 'easy_rec_odps_test_%d' % self.time_stamp
+    self.temp_dir = os.path.join(temp_dir, self.exp_dir)
+    self.log_dir = os.path.join(self.temp_dir, 'logs/')
+
+    # public buckets with readyonly access
+    self.ali_bucket_endpoint = 'http://oss-cn-beijing.aliyuncs.com'
+    self.ali_bucket_name = 'easyrec'
+    self.script_path = script_path
+    # read only access
+    self.ali_oss_key = os.environ['ALI_OSS_KEY']
+    self.ali_oss_secret = os.environ['ALI_OSS_SEC']
+
+    self.oss_key = ''
+    self.oss_secret = ''
+    self.endpoint = ''
+    self.arn = 'acs:ram::xxx:role/aliyunodpspaidefaultrole'
+    self.bucket_name = ''
+
+    self.odpscmd_path = os.environ.get('ODPS_CMD_PATH', 'odpscmd')
+    self.odps_config_path = ''
+
+    self.project_name = ''
+
+    self.dh_id = ''
+    self.dh_key = ''
+
+    self.dh_endpoint = 'https://dh-cn-beijing.aliyuncs.com'
+    self.dh_topic = 'easy_rec_test'
+    self.dh_project = 'easy_rec_test'
+
+    self.odps_endpoint = ''
+
+    self.dh = None
+    self.odps = None
+
+    # default to algo_public
+    self.algo_project = None
+    self.algo_res_project = None
+    self.algo_version = None
+    self.algo_name = 'easy_rec_ext'
+
+    # default to outer environment
+    # the difference are ossHost buckets arn settings
+    self.is_outer = True
+
+  def load_oss_config(self, config_path):
+    with open(config_path, 'r') as fin:
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_str = line_str.replace(' ', '')
+        if line_str.startswith('accessKeyID='):
+          self.oss_key = line_str[len('accessKeyID='):].strip()
+        elif line_str.startswith('accessKeySecret='):
+          self.oss_secret = line_str[len('accessKeySecret='):].strip()
+        elif line_str.startswith('endpoint='):
+          self.endpoint = line_str[len('endpoint='):].strip()
+
+  def load_odps_config(self, config_path):
+    self.odps_config_path = config_path
+    with open(config_path, 'r') as fin:
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_str = line_str.replace(' ', '')
+        key_str = 'project_name='
+        if line_str.startswith(key_str):
+          self.project_name = line_str[len(key_str):]
+        key_str = 'end_point='
+        if line_str.startswith(key_str):
+          self.odps_endpoint = line_str[len(key_str):]
+        key_str = 'access_id='
+        if line_str.startswith(key_str):
+          self.dh_id = line_str[len(key_str):]
+        key_str = 'access_key='
+        if line_str.startswith(key_str):
+          self.dh_key = line_str[len(key_str):]
+
+  def clean_topic(self, dh_project):
+    if not dh_project:
+      logging.error('project is empty .')
+      topic_names = self.dh.list_topic(dh_project).topic_names
+      for topic_name in topic_names:
+        self.clean_subscription(topic_name)
+        self.dh.delete_topic(dh_project, topic_name)
+
+  def clean_project(self):
+    project_names = self.dh.list_project().project_names
+    for dh_project in project_names:
+      if dh_project == self.dh_project:
+        self.clean_topic(dh_project)
+        try:
+          self.dh.delete_project(dh_project)
+        except InvalidOperationException:
+          pass
+
+  def clean_subscription(self, topic_name):
+    subscriptions = self.dh.list_subscription(self.dh_project, topic_name, '',
+                                              1, 100).subscriptions
+    for subscription in subscriptions:
+      self.dh.delete_subscription(self.dh_project, topic_name, subscription)
+
+  def get_input_type(self, input_type):
+    DhDict = {
+        'INT64': FieldType.BIGINT,
+        'INT32': FieldType.BIGINT,
+        'STRING': FieldType.STRING,
+        'BOOLEAN': FieldType.BOOLEAN,
+        'FLOAT32': FieldType.DOUBLE,
+        'FLOAT64': FieldType.DOUBLE
+    }
+
+    return DhDict.get(input_type)
+
+  def init_dh_and_odps(self):
+    self.dh = DataHub(self.dh_id, self.dh_key, self.dh_endpoint)
+    self.odps = ODPS(self.dh_id, self.dh_key, self.project_name,
+                     self.odps_endpoint)
+    self.odpsTable = 'deepfm_train_%s' % self.time_stamp
+    self.clean_project()
+    read_odps = DataFrame(self.odps.get_table(self.odpsTable))
+    col_name = read_odps.schema.names
+    col_type = [self.get_input_type(str(i)) for i in read_odps.schema.types]
+    try:
+      self.dh.create_project(self.dh_project, comment='EasyRecTest')
+      logging.info('create project success!')
+    except ResourceExistException:
+      logging.warning('project %s already exist!' % self.dh_project)
+    except Exception:
+      logging.error(traceback.format_exc())
+    record_schema = RecordSchema.from_lists(col_name, col_type)
+    try:
+      # project_name, topic_name, shard_count, life_cycle, record_schema, comment
+      self.dh.create_tuple_topic(
+          self.dh_project,
+          self.dh_topic,
+          7,
+          3,
+          record_schema,
+          comment='EasyRecTest')
+      logging.info('create tuple topic %s success!' % self.dh_topic)
+    except ResourceExistException:
+      logging.info('topic %s already exist!' % self.dh_topic)
+    except Exception as ex:
+      logging.error('exception:%s' % str(ex))
+      logging.error(traceback.format_exc())
+    try:
+      self.dh.wait_shards_ready(self.dh_project, self.dh_topic)
+      logging.info('datahub[%s,%s] shards all ready' %
+                   (self.dh_project, self.dh_topic))
+      topic_result = self.dh.get_topic(self.dh_project, self.dh_topic)
+      if topic_result.record_type != RecordType.TUPLE:
+        logging.error('invalid topic type: %s' % str(topic_result.record_type))
+      record_schema = topic_result.record_schema
+      t = self.odps.get_table(self.odpsTable)
+      with t.open_reader() as reader:
+        record_list = []
+        for data in reader:
+          record = TupleRecord(values=data.values, schema=record_schema)
+          record_list.append(record)
+        for i in range(10):
+          self.dh.put_records(self.dh_project, self.dh_topic, record_list)
+    except Exception as ex:
+      logging.error('exception: %s' % str(ex))
+      logging.error(traceback.format_exc())
+
+
+def get_oss_bucket(oss_key, oss_secret, endpoint, bucket_name):
+  """Build oss2.Bucket instance.
+
+  Args:
+    oss_key: oss access_key
+    oss_secret: oss access_secret
+    endpoint: oss endpoint
+    bucket_name: oss bucket name
+  Return:
+    oss2.Bucket instance
+  """
+  if oss_key is None or oss_secret is None:
+    logging.info('oss_key or oss_secret is None')
+    return None
+  auth = oss2.Auth(oss_key, oss_secret)
+  bucket = oss2.Bucket(auth, endpoint, bucket_name)
+  return bucket
+
+
+def delete_oss_path(bucket, in_prefix, bucket_name):
+  """Delete oss path.
+
+  Args:
+    bucket: oss2.Bucket instance
+    in_prefix: oss path prefix to be removed
+    bucket_name: bucket_name
+  """
+  prefix = in_prefix.replace('oss://' + bucket_name + '/', '')
+  for obj in oss2.ObjectIterator(bucket, prefix=prefix):
+    bucket.delete_object(obj.key)
+  bucket.delete_object(prefix)
+  logging.info('delete oss path: %s, completed.' % in_prefix)

easy_rec/python/test/pre_check_test.py

@@ -0,0 +1,54 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import logging
+
+import tensorflow as tf
+
+from easy_rec.python.utils import test_utils
+
+if tf.__version__ >= '2.0':
+  tf = tf.compat.v1
+gfile = tf.gfile
+
+
+class CheckTest(tf.test.TestCase):
+
+  def setUp(self):
+    self._test_dir = test_utils.get_tmp_dir()
+    self._success = True
+    logging.info('Testing %s.%s' % (type(self).__name__, self._testMethodName))
+    logging.info('test dir: %s' % self._test_dir)
+
+  def tearDown(self):
+    test_utils.set_gpu_id(None)
+    if self._success:
+      test_utils.clean_up(self._test_dir)
+
+  def test_csv_input_train_with_check(self):
+    self._success = test_utils.test_single_train_eval(
+        'samples/model_config/dbmtl_on_taobao.config',
+        self._test_dir,
+        check_mode=True)
+    self.assertTrue(self._success)
+
+  def test_rtp_input_train_with_check(self):
+    self._success = test_utils.test_single_train_eval(
+        'samples/model_config/taobao_fg.config',
+        self._test_dir,
+        check_mode=True)
+    self.assertTrue(self._success)
+
+  def test_csv_input_with_pre_check(self):
+    self._success = test_utils.test_single_pre_check(
+        'samples/model_config/dbmtl_on_taobao.config', self._test_dir)
+    self.assertTrue(self._success)
+
+  def test_rtp_input_with_pre_check(self):
+    self._success = test_utils.test_single_pre_check(
+        'samples/model_config/dbmtl_on_taobao.config', self._test_dir)
+    self.assertTrue(self._success)
+
+
+if __name__ == '__main__':
+  tf.test.main()

easy_rec/python/test/predictor_test.py

@@ -0,0 +1,394 @@
+# -*- encoding:utf-8 -*-
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import csv
+import json
+import logging
+import os
+import shutil
+
+import numpy as np
+import tensorflow as tf
+
+from easy_rec.python.inference.csv_predictor import CSVPredictor
+from easy_rec.python.inference.predictor import Predictor
+from easy_rec.python.utils import config_util
+from easy_rec.python.utils import test_utils
+from easy_rec.python.utils.test_utils import RunAsSubprocess
+
+
+class PredictorTest(tf.test.TestCase):
+
+  def setUp(self):
+    self.gpus = test_utils.get_available_gpus()
+    self.assertTrue(len(self.gpus) > 0, 'no available gpu on this machine')
+    logging.info('available gpus %s' % self.gpus)
+    test_utils.set_gpu_id(self.gpus[0])
+    logging.info('Testing %s.%s' % (type(self).__name__, self._testMethodName))
+    self._test_path = 'data/test/inference/taobao_infer_data.txt'
+
+  def tearDown(self):
+    test_utils.set_gpu_id(None)
+
+  @RunAsSubprocess
+  def test_pred_list(self):
+    predictor = Predictor('data/test/inference/tb_multitower_export/')
+    with open(self._test_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        inputs.append(row[2:])
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 100)
+
+  @RunAsSubprocess
+  def test_lookup_pred(self):
+    predictor = Predictor('data/test/inference/lookup_export')
+    lookup_pred_path = 'data/test/inference/lookup_data_test80.csv'
+    with open(lookup_pred_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        inputs.append(row[1:])
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 80)
+
+  @RunAsSubprocess
+  def test_pred_dict(self):
+    predictor = Predictor('data/test/inference/tb_multitower_export/')
+    field_keys = [
+        'pid', 'adgroup_id', 'cate_id', 'campaign_id', 'customer', 'brand',
+        'user_id', 'cms_segid', 'cms_group_id', 'final_gender_code',
+        'age_level', 'pvalue_level', 'shopping_level', 'occupation',
+        'new_user_class_level', 'tag_category_list', 'tag_brand_list', 'price'
+    ]
+    with open(self._test_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        inputs.append({f: row[fid + 2] for fid, f in enumerate(field_keys)})
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 100)
+
+  @RunAsSubprocess
+  def test_pred_placeholder_named_by_input(self):
+    predictor = Predictor(
+        'data/test/inference/tb_multitower_placeholder_rename_export/')
+    field_keys = [
+        'pid', 'adgroup_id', 'cate_id', 'campaign_id', 'customer', 'brand',
+        'user_id', 'cms_segid', 'cms_group_id', 'final_gender_code',
+        'age_level', 'pvalue_level', 'shopping_level', 'occupation',
+        'new_user_class_level', 'tag_category_list', 'tag_brand_list', 'price'
+    ]
+    with open(self._test_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        line_input = {}
+        for fid, f in enumerate(field_keys):
+          if f in ['tag_category_list', 'tag_brand_list']:
+            line_input[f] = ['12', '23']
+          else:
+            line_input[f] = row[fid + 2]
+        inputs.append(line_input)
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 100)
+
+  @RunAsSubprocess
+  def test_fm_pred_list(self):
+    predictor = Predictor('data/test/inference/fm_export/')
+    with open(self._test_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        inputs.append(row[2:])
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 100)
+
+  @RunAsSubprocess
+  def test_fm_pred_dict(self):
+    predictor = Predictor('data/test/inference/fm_export/')
+    field_keys = [
+        'pid', 'adgroup_id', 'cate_id', 'campaign_id', 'customer', 'brand',
+        'user_id', 'cms_segid', 'cms_group_id', 'final_gender_code',
+        'age_level', 'pvalue_level', 'shopping_level', 'occupation',
+        'new_user_class_level', 'tag_category_list', 'tag_brand_list', 'price'
+    ]
+    with open(self._test_path, 'r') as fin:
+      reader = csv.reader(fin)
+      inputs = []
+      for row in reader:
+        inputs.append({f: row[fid + 2] for fid, f in enumerate(field_keys)})
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 100)
+
+
+class PredictorTestOnDS(tf.test.TestCase):
+
+  def setUp(self):
+
+    self._test_dir = test_utils.get_tmp_dir()
+    self._test_output_path = None
+    logging.info('Testing %s.%s' % (type(self).__name__, self._testMethodName))
+
+  def tearDown(self):
+    if self._test_output_path and (os.path.exists(self._test_output_path)):
+      shutil.rmtree(self._test_output_path)
+    test_utils.set_gpu_id(None)
+
+  @RunAsSubprocess
+  def test_local_pred(self):
+    test_input_path = 'data/test/inference/taobao_infer_data.txt'
+    self._test_output_path = os.path.join(self._test_dir, 'taobao_infer_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_export/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        output_sep=';',
+        selected_cols='')
+
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='ALL_COLUMNS',
+        output_cols='ALL_COLUMNS',
+        slice_id=0,
+        slice_num=1)
+    header_truth = 'logits;probs;clk;buy;pid;adgroup_id;cate_id;campaign_id;customer;'\
+                   'brand;user_id;cms_segid;cms_group_id;final_gender_code;age_level;pvalue_level;' \
+                   'shopping_level;occupation;new_user_class_level;tag_category_list;tag_brand_list;price'
+
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+      self.assertEqual(output_res[0].strip(), header_truth)
+
+  @RunAsSubprocess
+  def test_local_pred_with_header(self):
+    test_input_path = 'data/test/inference/taobao_infer_data_with_header.txt'
+    self._test_output_path = os.path.join(self._test_dir, 'taobao_infer_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_export/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+    pipeline_config.data_config.with_header = True
+
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        with_header=True,
+        output_sep=';',
+        selected_cols='')
+
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='ALL_COLUMNS',
+        output_cols='ALL_COLUMNS',
+        slice_id=0,
+        slice_num=1)
+    header_truth = 'logits;probs;clk;buy;pid;adgroup_id;cate_id;campaign_id;customer;'\
+                   'brand;user_id;cms_segid;cms_group_id;final_gender_code;age_level;pvalue_level;' \
+                   'shopping_level;occupation;new_user_class_level;tag_category_list;tag_brand_list;price'
+
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+      self.assertEqual(output_res[0].strip(), header_truth)
+
+  @RunAsSubprocess
+  def test_local_pred_without_config(self):
+    test_input_path = 'data/test/inference/taobao_infer_data.txt'
+    self._test_output_path = os.path.join(self._test_dir, 'taobao_infer_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_export/'
+    self._success = test_utils.test_single_predict(self._test_dir,
+                                                   test_input_path,
+                                                   self._test_output_path,
+                                                   saved_model_dir)
+    self.assertTrue(self._success)
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+
+  @RunAsSubprocess
+  def test_local_pred_with_part_col(self):
+    test_input_path = 'data/test/inference/taobao_infer_data.txt'
+    self._test_output_path = os.path.join(self._test_dir, 'taobao_infer_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_export/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        output_sep=';',
+        selected_cols='')
+
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='clk,buy,user_id,adgroup_id',
+        output_cols='probs',
+        slice_id=0,
+        slice_num=1)
+    header_truth = 'probs;clk;buy;user_id;adgroup_id'
+
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+      self.assertEqual(output_res[0].strip(), header_truth)
+
+  @RunAsSubprocess
+  def test_local_pred_rtp(self):
+    test_input_path = 'data/test/inference/taobao_infer_rtp_data.txt'
+    self._test_output_path = os.path.join(self._test_dir,
+                                          'taobao_test_feature_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_rtp_export/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        output_sep=';',
+        selected_cols='0,3')
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='ALL_COLUMNS',
+        output_cols='ALL_COLUMNS',
+        slice_id=0,
+        slice_num=1)
+    header_truth = 'logits;probs;clk;no_used_1;no_used_2;features'
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+      self.assertEqual(output_res[0].strip(), header_truth)
+
+  @RunAsSubprocess
+  def test_local_pred_rtp_with_part_col(self):
+    test_input_path = 'data/test/inference/taobao_infer_rtp_data.txt'
+    self._test_output_path = os.path.join(self._test_dir,
+                                          'taobao_test_feature_result')
+    saved_model_dir = 'data/test/inference/tb_multitower_rtp_export/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        output_sep=';',
+        selected_cols='0,3')
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='clk,features,no_used_1',
+        output_cols='ALL_COLUMNS',
+        slice_id=0,
+        slice_num=1)
+    header_truth = 'logits;probs;clk;features;no_used_1'
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(len(output_res) == 101)
+      self.assertEqual(output_res[0].strip(), header_truth)
+
+  @RunAsSubprocess
+  def test_local_pred_embedding(self):
+    test_input_path = 'data/test/inference/taobao_item_feature_data.csv'
+    self._test_output_path = os.path.join(self._test_dir, 'taobao_item_feature')
+    saved_model_dir = 'data/test/inference/dssm_item_model/'
+    pipeline_config_path = os.path.join(saved_model_dir,
+                                        'assets/pipeline.config')
+    pipeline_config = config_util.get_configs_from_pipeline_file(
+        pipeline_config_path, False)
+    predictor = CSVPredictor(
+        saved_model_dir,
+        pipeline_config.data_config,
+        ds_vector_recall=True,
+        output_sep=';',
+        selected_cols='pid,adgroup_id,cate_id,campaign_id,customer,brand,price')
+
+    predictor.predict_impl(
+        test_input_path,
+        self._test_output_path,
+        reserved_cols='adgroup_id',
+        output_cols='item_emb',
+        slice_id=0,
+        slice_num=1)
+
+    with open(self._test_output_path + '/part-0.csv', 'r') as f:
+      output_res = f.readlines()
+      self.assertTrue(
+          output_res[1] ==
+          '-0.187066,-0.027638,-0.117294,0.115318,-0.273561,0.035698,-0.055832,'
+          '0.226849,-0.105808,-0.152751,0.081528,-0.183329,0.134619,0.185392,'
+          '0.096774,0.104428,0.161868,0.269710,-0.268538,0.138760,-0.170105,'
+          '0.232625,-0.121130,0.198466,-0.078941,0.017774,0.268834,-0.238553,0.084058,'
+          '-0.269466,-0.289651,0.179517;620392\n')
+
+
+class PredictorTestV2(tf.test.TestCase):
+
+  def setUp(self):
+    self.gpus = test_utils.get_available_gpus()
+    self.assertTrue(len(self.gpus) > 0, 'no available gpu on this machine')
+    logging.info('available gpus %s' % self.gpus)
+    test_utils.set_gpu_id(self.gpus[0])
+    logging.info('Testing %s.%s' % (type(self).__name__, self._testMethodName))
+
+  def tearDown(self):
+    test_utils.set_gpu_id(None)
+
+  @RunAsSubprocess
+  def test_pred_multi(self):
+    predictor = Predictor('data/test/inference/fg_export_multi')
+    test_path = 'data/test/rtp/taobao_test_feature.txt'
+    with open(test_path, 'r') as fin:
+      inputs = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_toks = line_str.split(';')
+        feature = line_toks[-1]
+        feature = feature.split('\002')
+        inputs.append(feature)
+      output_res = predictor.predict(inputs, batch_size=32)
+      self.assertTrue(len(output_res) == 10000)
+    with open('data/test/rtp/taobao_fg_pred.out', 'r') as fin:
+      for line_id, line_str in enumerate(fin):
+        line_str = line_str.strip()
+        line_pred = json.loads(line_str)
+        self.assertTrue(
+            np.abs(line_pred['probs'] - output_res[line_id]['probs']) < 5e-6)
+
+  @RunAsSubprocess
+  def test_pred_single(self):
+    predictor = Predictor('data/test/inference/fg_export_single')
+    test_path = 'data/test/rtp/taobao_test_feature.txt'
+    with open(test_path, 'r') as fin:
+      inputs = []
+      for line_str in fin:
+        line_str = line_str.strip()
+        line_toks = line_str.split(';')
+        feature = line_toks[-1]
+        inputs.append(feature)
+      output_res = predictor.predict(inputs, batch_size=32)
+    with open('data/test/rtp/taobao_fg_pred.out', 'r') as fin:
+      for line_id, line_str in enumerate(fin):
+        line_str = line_str.strip()
+        line_pred = json.loads(line_str)
+        self.assertTrue(
+            np.abs(line_pred['probs'] - output_res[line_id]['probs']) < 5e-5)
+
+
+if __name__ == '__main__':
+  tf.test.main()