One-to-All-Animation/benchmark/DisCo/utils/process_tsv.py

# from .cloud_storage import create_cloud_fuse
import argparse
import base64
import copy
import cv2
import glob
import imghdr
import inspect
import json
import logging
import math
import numpy as np
import os
import os.path as op
import pymongo
import random
import re
import shutil
from collections import OrderedDict
import sys
import time
import unicodedata
import yaml
from .tsv_io import TSVSplitProperty
from .tsv_io import CompositeTSVFile
from .common import pilimg_from_base64
from .common import dict_get_all_path
from .tsv_io import get_tsv_associates
from .common import dict_get_path_value
from .common import qd_tqdm
from .common import qd_tqdm as tqdm
from .common import parallel_map
from .common import split_to_chunk_to_range
from .common import ensure_remove_file
from .common import get_tmp_folder

from collections import defaultdict
from deprecated import deprecated
from pathos.multiprocessing import ProcessingPool as Pool
from datetime import datetime
from pprint import pformat
try:
    from StringIO import StringIO
except ImportError:
    from io import StringIO
from future.utils import viewitems
from .cloud_storage import CloudStorage
from .process_image import draw_bb, show_image, save_image
from .process_image import show_images
from .process_image import draw_rects
from .common import calculate_image_ap
from .common import calculate_iou
from .common import dict_to_list
from .common import ensure_directory
from .common import normalize_to_str
from .common import generate_lineidx
from .common import get_mpi_rank, get_mpi_size
from .common import hash_sha1
from .common import ensure_copy_file
from .common import img_from_base64
from .common import init_logging
from .common import json_dump
from .common import list_to_dict, list_to_dict_unique
from .common import parse_test_data
from .common import read_to_buffer
from .tsv_io import load_list_file
from .common import worth_create
from .tsv_io import write_to_file
from .common import write_to_yaml_file, load_from_yaml_file
from .common import float_tolorance_equal
from .common import is_positive_uhrs_verified, is_negative_uhrs_verified
from .tsv_io import concat_files
from .common import try_delete
from .common import encoded_from_img
from .common import get_frame_info
from .common import calc_mean
from .taxonomy import child_parent_print_tree2
from .taxonomy import create_markdown_url
from .taxonomy import disambibuity_noffsets
from .taxonomy import gen_noffset
from .taxonomy import gen_term_list
from .taxonomy import get_nick_name
from .taxonomy import is_noffset
from .taxonomy import LabelToSynset, synset_to_noffset
from .taxonomy import load_all_tax, merge_all_tax
from .taxonomy import noffset_to_synset
from .taxonomy import populate_cum_images
from .taxonomy import populate_url_for_offset
from .taxonomy import Taxonomy
from .tsv_io import create_inverted_list
from .tsv_io import create_inverted_list2
from .tsv_io import extract_label
from .tsv_io import get_meta_file
from .tsv_io import load_labels
from .tsv_io import TSVDataset, TSVFile
from .tsv_io import tsv_reader, tsv_writer
from .tsv_io import is_verified_rect
from .tsv_io import tsv_copy
from .tsv_io import tsv_writers
from .tsv_io import get_default_splits
from .db import create_mongodb_client
from .db import create_bbverification_db
from .tsv_io import get_tsv_lineidx_8b
from .tsv_io import File
import torch


def delete_tsv_files(tsvs):
    for t in tsvs:
        if op.isfile(t):
            try_delete(t)
        line = op.splitext(t)[0] + '.lineidx'
        if op.isfile(line):
            try_delete(line)
        line = get_tsv_lineidx_8b(t)
        if op.isfile(line):
            try_delete(line)

def concat_tsv_files_mem_efficient(tsvs, out_tsv):
    # prefer concat_tsv_files
    if len(tsvs) == 1 and tsvs[0] == out_tsv:
        return
    concat_files(tsvs, out_tsv)
    sizes = [os.stat(t).st_size for t in tsvs]
    sizes = np.cumsum(sizes)
    debug_check = {'n': 0, 'n8b': 0}
    def gen_lineidx():
        for i, t in enumerate(tsvs):
            with File.open(op.splitext(t)[0] + '.lineidx') as fp:
                for idx in fp:
                    debug_check['n'] += 1
                    if i == 0:
                        yield int(idx)
                    else:
                        yield int(idx) + sizes[i - 1]
    with File.open(op.splitext(out_tsv)[0] + '.lineidx', 'w') as fp:
        for x in tqdm(gen_lineidx()):
            fp.write(str(x) + '\n')

    def gen_lineidx_8b():
        for i, t in enumerate(tsvs):
            with File.open(op.splitext(t)[0] + '.lineidx.8b', 'rb') as fp:
                while True:
                    x = fp.read(8)
                    if x != b'':
                        idx = int.from_bytes(x, 'little')
                        debug_check['n8b'] += 1
                        if i == 0:
                            yield idx
                        else:
                            yield int(idx) + sizes[i - 1]
                    else:
                        break
    with File.open(op.splitext(out_tsv)[0] + '.lineidx.8b', 'wb') as fp:
        for x in tqdm(gen_lineidx_8b()):
            fp.write(int(x).to_bytes(8, 'little'))
    assert debug_check['n'] == debug_check['n8b']

def concat_tsv_files(tsvs, out_tsv, gen_lineidx=True):
    if len(tsvs) == 1 and tsvs[0] == out_tsv:
        return
    File.prepare(tsvs)
    concat_files(tsvs, out_tsv)
    sizes = [File.get_file_size(t) for t in tsvs]
    sizes = np.cumsum(sizes)
    sizes = [0] + sizes[:-1].tolist()

    if gen_lineidx:
        # the generation process is much slower than that for lineidx.8b. As
        # this format is going to be deprecated, we have a flag to disable this
        # ggeneration proces
        concate_lineidx(sizes, tsvs, out_tsv)
    concate_lineidx_8b(sizes, tsvs, out_tsv)

def concate_lineidx(sizes, tsvs, out_tsv):
    File.prepare(tsvs)
    def row_processor(row):
        offset, in_tsv, out_tsv = row
        fbar = qd_tqdm(unit_scale=True)
        with File.open(in_tsv) as fp:
            with File.open(out_tsv, 'w') as fpout:
                for idx in fp:
                    fbar.update(1)
                    fpout.write(str(int(idx) + offset) + '\n')
    all_info = [(sizes[i], op.splitext(t)[0] + '.lineidx') for i, t in enumerate(tsvs)]
    folder = get_tmp_folder()
    all_info = [(offset, in_tsv, op.join(folder, in_tsv)) for offset, in_tsv in all_info]
    #for _, __, f in all_info:
        #ensure_directory(op.dirname(f))
    parallel_map(row_processor, all_info, 64)
    concat_files([i[2] for i in all_info], op.splitext(out_tsv)[0] + '.lineidx')
    for d in all_info:
        ensure_remove_file(d[2])

def concate_lineidx_8b(sizes, tsvs, out_tsv):
    File.prepare(tsvs)
    folder = get_tmp_folder()
    def row_processor_8b(row):
        offset, in_tsv, out_tsv = row
        fbar = qd_tqdm(unit_scale=True)
        bulk_size = 1024
        with File.open(in_tsv, 'rb') as fp:
            with File.open(out_tsv, 'wb') as fpout:
                while True:
                    x = fp.read(8 * bulk_size)
                    fbar.update(len(x) // 8)
                    if x != b'':
                        import struct
                        fmt = '<{}q'.format(len(x) // 8)
                        x = [i + offset for i in struct.unpack(fmt, x)]
                        fpout.write(b''.join([i.to_bytes(8, 'little') for i in
                                              x]))
                    else:
                        break
    all_info_8b = [(sizes[i], op.splitext(t)[0] + '.lineidx.8b') for i, t in enumerate(tsvs)]
    File.prepare([in_tsv for _, in_tsv in all_info_8b])
    # op.join(folder, in_tsv) may also be equal to in_tsv, although it is fine
    all_info_8b = [(offset, in_tsv, '{}/{}'.format(folder, in_tsv + '.lineidx.8b')) for offset, in_tsv
                   in all_info_8b]
    parallel_map(row_processor_8b, all_info_8b, 64)
    concat_files([i[2] for i in all_info_8b], op.splitext(out_tsv)[0] + '.lineidx.8b')
    for d in all_info_8b:
        ensure_remove_file(d[2])

def concat_tsv_files_old(tsvs, out_tsv):
    # prefer concat_tsv_files
    if len(tsvs) == 1 and tsvs[0] == out_tsv:
        return
    concat_files(tsvs, out_tsv)
    sizes = [os.stat(t).st_size for t in tsvs]
    sizes = np.cumsum(sizes)
    all_idx = []
    for i, t in enumerate(tsvs):
        for idx in load_list_file(op.splitext(t)[0] + '.lineidx'):
            if i == 0:
                all_idx.append(idx)
            else:
                all_idx.append(str(int(idx) + sizes[i - 1]))
    write_to_file('\n'.join(all_idx), op.splitext(out_tsv)[0] + '.lineidx')
    with File.open(get_tsv_lineidx_8b(out_tsv), 'wb') as fp:
        for i in all_idx:
            fp.write(int(i).to_bytes(8, 'little'))

def merge_data_feature_tsv(from_data, to_data, feature_version):
    assert from_data.startswith(to_data)
    from_dataset = TSVDataset(from_data)
    to_dataset = TSVDataset(to_data)
    src_tsvs = load_list_file(from_dataset.get_data(
        'trainX', 'feature', feature_version))
    dest_tsvs = load_list_file(to_dataset.get_data(
        'trainX',
        'feature',
        feature_version))
    assert len(dest_tsvs) == 1
    dest_tsv = dest_tsvs[0]
    logging.info(pformat(src_tsvs))
    logging.info(pformat(dest_tsv))
    if op.isfile(dest_tsv):
        logging.info('skip to merge as exists')
    else:
        concat_tsv_files(src_tsvs, dest_tsv)

def train_test_split(data_from, data_to, split_from='train', num_test=5000):
    populate_dataset_details(data_from)
    dataset_from = TSVDataset(data_from)
    dataset_to = TSVDataset(data_to)

    num_total_image = dataset_from.num_rows(split_from)
    total_idx = list(range(num_total_image))
    random.seed(666)
    random.shuffle(total_idx)
    split_names = ['test', 'train']
    all_split_idx = [total_idx[: num_test], total_idx[num_test:]]
    for split_idx, split_name in zip(all_split_idx, split_names):
        dataset_to.write_data(dataset_from.iter_data(split_from,
            filter_idx=split_idx), split_name)
        # all label file
        v = 0
        while dataset_from.has(split_from, 'label', version=v):
            dataset_to.write_data(dataset_from.iter_data(split_from,
                t='label', version=v, filter_idx=split_idx),
                split_name, t='label', version=v)
            v = v + 1

def find_best_matched_rect_idx(target, rects, check_class=True):
    target_class_lower = target['class'].lower()
    if check_class:
        same_class_rects = [r for r in rects if r['class'].lower() == target_class_lower]
    else:
        same_class_rects = rects
    idx_ious = [(i, calculate_iou(r['rect'], target['rect']))
        for i, r in enumerate(same_class_rects)]
    if len(idx_ious) == 0:
        return None, -1
    return max(idx_ious, key=lambda r: r[-1])

def find_best_matched_rect(target, rects, check_class=True, check_iou=True):
    target_class_lower = target['class'].lower()
    if check_class:
        same_class_rects = [r for r in rects if r['class'].lower() == target_class_lower]
    else:
        same_class_rects = rects
    if check_iou:
        rect_ious = [(r, calculate_iou(r['rect'], target['rect']))
            for r in same_class_rects]
    else:
        rect_ious = [(r, 1) for r in same_class_rects]
    if len(rect_ious) == 0:
        return None, -1
    return max(rect_ious, key=lambda r: r[-1])

def create_tsvdataset_from_image_folder(root_folder, data):
    from .process_image import load_image
    dataset = TSVDataset(data)
    all_full_file_name = [op.join(root, f) for root, dirnames, filenames in os.walk(root_folder)
        for f in filenames]
    def row_processor(full_file_name):
        im = load_image(full_file_name)
        if im is not None:
            key = full_file_name.replace(root_folder, '')
            return key, base64.b64encode(read_to_buffer(full_file_name))
    parallel_tsv_process(
        row_processor,
        all_full_file_name,
        dataset.get_data('train'),
        64
    )

def create_new_image_tsv_if_exif_rotated(data, split):
    dataset = TSVDataset(data)
    key_no_rotate_in_image = 'no_rotate_in_image'
    if dataset.has(split, key_no_rotate_in_image):
        return
    info = {'changed': 0, 'total': 0}
    def gen_rows():
        logging.info('{}-{}'.format(data, split))
        for key, str_rects, str_im in tqdm(dataset.iter_data(split)):
            info['total'] = info['total'] + 1
            im = img_from_base64(str_im)
            from .common import img_from_base64_ignore_rotation
            im2 = img_from_base64_ignore_rotation(str_im)
            if im.shape[0] != im2.shape[0] or im.shape[1] != im2.shape[1]:
                assert im.shape[0] == im2.shape[1]
                assert im.shape[1] == im2.shape[0]
                info['changed'] = info['changed'] + 1
                yield key, str_rects, encoded_from_img(im)
            else:
                yield key, str_rects, str_im
    tmp_tsv = dataset.get_data(split, 'tmp')
    tsv_writer(gen_rows(), tmp_tsv)
    logging.info(pformat(info))
    if info['changed'] != 0:
        from .tsv_io import tsv_mv
        tsv_mv(tmp_tsv, dataset.get_data(split))
    else:
        from .tsv_io import tsv_rm
        tsv_rm(tmp_tsv)
    dataset.write_data([], split, key_no_rotate_in_image)

def get_data_distribution(data, split, version):
    # return a dictionary to represent the distribution of the data
    # only composite dataset requires the following two information
    result = {}

    populate_dataset_details(data)
    dataset = TSVDataset(data)
    tsvsource_to_imageratio = {src[5:]:
            (float(numdestimages) / float(numsrcimages))
            for src, numdestimages, numsrcimages in
            dataset.iter_data(split + 'X', 'tsvsource.numdestimages.numsrcimages')}
    result['tsvsource_to_imageratio'] = tsvsource_to_imageratio

    tsvsource_to_boxratio = {src[5:]:
            (float(numdest) / float(numsrc))
            for src, numdest, numsrc in
            dataset.iter_data(split + 'X', 'tsvsource.numdestbbs.numsrcbbs')}
    result['tsvsource_to_boxratio'] = tsvsource_to_boxratio

    tsvsource_to_num_image = {source[5:]: int(num_image) for source, num_image in dataset.iter_data(split + 'X', 'numImagesPerSource')}
    result['tsvsource_to_num_image'] = tsvsource_to_num_image

    tsvsource_to_num_category = {source[5:]: int(num_image) for source, num_image
            in dataset.iter_data(split + 'X', 'numCategoriesPerSource')}
    result['tsvsource_to_num_category'] = tsvsource_to_num_category

    label_to_count = {l: int(c) for l, c in dataset.iter_data(split, 'inverted.label.count', version=version)}
    unique_labels = set([l if not l.startswith('-') else l[1:] for l in label_to_count])
    import math
    all_label_pos_negs = [[l, [label_to_count.get(l, 0), -label_to_count.get('-' + l, 0)]] for l in unique_labels]
    all_label_pos_negs = [[l, [math.log10(label_to_count.get(l, 0) + 1),
        -math.log10(label_to_count.get('-' + l, 0) + 1)]] for l in unique_labels]
    all_label_pos_negs = sorted(all_label_pos_negs, key=lambda x: x[1][0])
    result['all_label_pos_negs'] = all_label_pos_negs

    result['num_labels_with_neg'] = len([l for l, (pos, neg) in all_label_pos_negs if neg != 0])
    result['num_labels_with_pos'] = len([l for l, (pos, neg) in all_label_pos_negs if pos != 0])

    label_to_count = {l: int(c) for l, c in dataset.iter_data(split, 'inverted.label.count',
            version=version)}
    _, c = next(dataset.iter_data(split, 'inverted.background.count',
        version=version))
    label_to_count['__background'] = int(c)
    result['label_to_count'] = label_to_count

    return result

def convert_pred_to_dataset_label(full_expid, predict_file,
        th_file, min_value):
    pred_file = op.join('output',
            full_expid,
            'snapshot',
            predict_file)

    from .common import parse_test_data
    data, split = parse_test_data(predict_file)

    from process_tsv import load_key_rects

    dataset = TSVDataset(data)
    populate_dataset_details(data)
    latest_version = dataset.get_latest_version(split, 'label')
    gt_key_rects = load_key_rects(dataset.iter_data(split, 'label',
        latest_version))
    pred_key_rects = load_key_rects(tsv_reader(pred_file))
    pred_key_to_rects = {key: rects for key, rects in pred_key_rects}
    if th_file:
        th_file = op.join('output', full_expid, 'snapshot', th_file)
        per_cat_th = {l: max(float(th), min_value) for l, th, _ in tsv_reader(th_file)}
    else:
        per_cat_th = {}
    def gen_rows():
        for key, rects in gt_key_rects:
            pred_rects = pred_key_to_rects.get(key, [])
            pred_rects = [r for r in pred_rects
                    if r['conf'] >= per_cat_th.get(r['class'], 0)]
            yield key, json.dumps(pred_rects)
    info = [('full_expid', full_expid),
            ('predict_file', pred_file),
            ('th_file', th_file),
            ('min_value', min_value)]
    dataset.update_data(gen_rows(), split, 'label',
            generate_info=info)

    populate_dataset_details(data)

def ensure_inject_expid(full_expid):
    all_predict = []
    all_predict.extend(glob.glob(op.join('output', full_expid, 'snapshot',
        '*.predict')))
    all_predict.extend(glob.glob(op.join('output', full_expid, 'snapshot',
        '*.predict.tsv')))
    for p in all_predict:
        ensure_inject_expid_pred(full_expid, op.basename(p))

def ensure_inject_dataset(data, **kwargs):
    for split in get_default_splits():
        ensure_upload_image_to_blob(data, split)
        ensure_inject_image(data, split)
        ensure_inject_gt(data, split, **kwargs)

def ensure_inject_decorate(func):
    def func_wrapper(*args, **kwargs):
        client = create_mongodb_client()
        db = client['qd']
        task = db['task']
        # .func_name is ok for python2, but not for python3. .__name__ is ok
        # for both
        func_name = func.__name__
        if func_name.startswith('ensure_'):
            func_name = func_name[len('ensure_'): ]
        argnames, ins_varargs, ins_kwargs, ins_defaults = inspect.getargspec(func)
        # we have not supported if other paramseters is not None
        assert ins_varargs is None and ins_kwargs is None
        query = {'task_type': func_name}
        for n, v in zip(argnames[: len(args)], args):
            assert n not in query
            query[n] = v
        for k in kwargs:
            assert k not in query
            query[k] = kwargs[k]

        # create the unique index to make the update_one atomic
        logging.info('make sure the index is created: {}'.format(
            ', '.join(query.keys())))
        task.create_index([(k, pymongo.ASCENDING) for k in query])

        while True:
            result = task.update_one(filter=query,
                                    update={'$setOnInsert': query},
                                    upsert=True)
            if result.matched_count == 0:
                task.update_one(filter=query,
                        update={'$set': {'status': 'started',
                                         'create_time': datetime.now()}})
                func(*args, **kwargs)
                task.update_many(filter=query,
                        update={'$set': {'status': 'done'}})
                return True
            else:
                assert result.matched_count == 1
                existing_entries = list(task.find(query))
                if any(e for e in existing_entries if e['status'] == 'done'):
                    logging.info('ignore to inject since it is done: \n{}'.format(query))
                    break
                else:
                    logging.info('waiting to finish \n{}'.format(
                        pformat(existing_entries)))
                    time.sleep(10)
                # return False if not done
    return func_wrapper

def ensure_composite_key_url(data, split):
    dataset = TSVDataset(data)
    if not dataset.has(split):
        logging.info('data tsv does not exist')
        return
    if dataset.has(split, 'key.url'):
        logging.info('it exists')
        return
    data_to_dataset = {}
    uploaded_key_url = set()
    def gen_rows():
        for key, _ in dataset.iter_data(split, 'label'):
            c_data, c_split, c_key = parse_combine(key)
            if c_data in data_to_dataset:
                c_dataset = data_to_dataset[c_data]
            else:
                c_dataset = TSVDataset(c_data)
                data_to_dataset[c_data] = c_dataset
            if (c_data, c_split) not in uploaded_key_url:
                ensure_upload_image_to_blob(c_data, c_split)
                uploaded_key_url.add((c_data, c_split))
            _, url = c_dataset.seek_by_key(c_key, c_split, 'key.url')
            yield key, url
    dataset.write_data(gen_rows(), split, 'key.url')

def upload_image_to_blob(data, split, config=None):
    dataset = TSVDataset(data)
    if not dataset.has(split):
        logging.info('{} - {} does not exist'.format(data, split))
        return
    logging.info('{} - {}'.format(data, split))
    if op.isfile(dataset.get_data(split + 'X')):
        ensure_composite_key_url(data, split)
        logging.info('ignore to upload images for composite dataset')
        return
    parallel = True
    if not parallel:
        s = CloudStorage(config=config)
        def gen_rows():
            for key, _, str_im in tqdm(dataset.iter_data(split)):
                url_key = map_image_key_to_url_key(data, split, key)
                if sys.version_info.major == 3:
                    url = s.upload_stream(base64.b64decode(str_im),
                            'images/' + url_key + '.jpg')
                else:
                    url = s.upload_stream(StringIO(base64.b64decode(str_im)),
                            'images/' + url_key)
                yield key, url
        dataset.write_data(gen_rows(), split, 'key.url')
    else:
        from .common import split_to_chunk
        from .tsv_io import rm_tsv
        num_rows = dataset.num_rows(split)
        num_chunk = num_rows // 1000
        num_chunk = max(1, num_chunk)
        tasks = split_to_chunk(range(num_rows), num_chunk)
        tasks = [(data, split, t, i, len(tasks), config) for i, t in enumerate(tasks)]
        parallel_map(upload_image_to_blob_by_idx, tasks)
        # merge the result
        def gen_rows():
            for idx_task in range(len(tasks)):
                for key, url in dataset.iter_data(split,
                        'key.url.{}.{}'.format(idx_task, len(tasks))):
                    yield key, url
        dataset.write_data(gen_rows(), split, 'key.url')
        # remove intermediate files
        for idx_task in range(len(tasks)):
            rm_tsv(dataset.get_data(split, 'key.url.{}.{}'.format(idx_task, len(tasks))))

def upload_image_to_blob_by_idx(args):
    data, split, idxes, idx_task, num_task, config = args
    t = 'key.url.{}.{}'.format(idx_task, num_task)
    dataset = TSVDataset(data)
    if dataset.has(split, t):
        logging.info('return since exist')
        return
    s = CloudStorage(config=config)
    def gen_rows():
        for key, _, str_im in tqdm(dataset.iter_data(split, filter_idx=idxes)):
            url_key = map_image_key_to_url_key(data, split, key)
            if sys.version_info.major == 3:
                url = s.upload_stream(base64.b64decode(str_im),
                        'images/' + url_key + '.jpg')
            else:
                url = s.upload_stream(StringIO(base64.b64decode(str_im)),
                        'images/' + url_key)
            if s.sas_token:
                url += s.sas_token
            yield key, url
    dataset.write_data(gen_rows(), split, t)

@ensure_inject_decorate
def ensure_upload_image_to_blob(data, split, config=None):
    upload_image_to_blob(data, split, config=config)

@ensure_inject_decorate
def ensure_inject_image(data, split):
    dataset = TSVDataset(data)
    if not dataset.has(split):
        return

    client = create_mongodb_client()
    db = client['qd']
    images = db['image']
    images.delete_many(filter={'data': data, 'split': split})
    images.create_index([
        ('data', pymongo.ASCENDING),
        ('split', pymongo.ASCENDING),
        ('key', pymongo.ASCENDING),
        ],
        unique=True)
    all_data = []

    logging.info('injecting {} - {}'.format(data, split))
    injected = set()
    key_to_hw = None
    if dataset.has(split, 'hw'):
        key_to_hw = {key: [int(x) for x in hw.split(' ')] for key, hw in
                dataset.iter_data(split, 'hw')}
    assert dataset.has(split, 'key.url')
    key_to_url = {key: url for key, url in dataset.iter_data(split, 'key.url')}
    logging.info('injecting image for {} - {}'.format(data, split))
    for i, (key, _) in tqdm(enumerate(dataset.iter_data(split,
        'label'))):
        if key in injected:
            continue
        else:
            injected.add(key)
        url = key_to_url[key]
        doc = {'data': data,
                'split': split,
                'key': key,
                'idx_in_split': i,
                'url': url,
                'create_time': datetime.now(),
                }
        if key_to_hw:
            doc['height'], doc['width'] = key_to_hw[key]
        all_data.append(doc)
        if len(all_data) > 1000:
            images.insert_many(all_data)
            all_data = []
    if len(all_data) > 0:
        images.insert_many(all_data)
        all_data = []

@ensure_inject_decorate
def ensure_update_pred_with_correctness(data, split,
        full_expid, predict_file):
    ensure_inject_gt(data, split)
    ensure_inject_pred(full_expid, predict_file, data, split)

    update_pred_with_correctness(data, split,
        full_expid,
        predict_file)


def update_pred_with_correctness(test_data, test_split,
        full_expid,
        predict_file):
    client = create_mongodb_client()
    db = client['qd']
    _pred = db['predict_result']

    # get the latest version of the gt
    pipeline = [{'$match': {'data': test_data,
                            'split': test_split,
                            'version': {'$lte': 0}}},
                {'$group': {'_id': {'data': '$data',
                                    'split': '$split',
                                    'key': '$key',
                                    'action_target_id': '$action_target_id'},
                            'contribution': {'$sum': '$contribution'},
                            'class': {'$first': '$class'},
                            'rect': {'$first': '$rect'}}},
                {'$match': {'contribution': {'$gte': 1}}}, # if it is 0, it means we removed the box
                {'$addFields': {'data': '$_id.data',
                                'split': '$_id.split',
                                'key': '$_id.key'}},
                ]
    def get_query_pipeline(data, split, key, class_name):
        return [{'$match': {'$expr': {'$and': [{'$eq': ['$data', '$${}'.format(data)]},
                                               {'$eq': ['$split', '$${}'.format(split)]},
                                               {'$eq': ['$key', '$${}'.format(key)]},
                                               {'$eq': ['$class', '$${}'.format(class_name)]}]}}},
                 {'$group': {'_id': '$action_target_id',
                             'contribution': {'$sum': '$contribution'},
                             'create_time': {'$max': '$create_time'},
                             'rect': {'$first': '$rect'}}},
                 {'$match': {'contribution': {'$gte': 1}}},
                ]

    # get the target prediction bounding boxes
    pipeline = [{'$match': {'full_expid': full_expid,
                            'pred_file': predict_file}},
                {'$group': {'_id': {'data': '$data',
                                   'split': '$split',
                                   'key': '$key',
                                   'class': '$class'},
                           'pred_box': {'$push': {'rect': '$rect',
                                                  'conf': '$conf',
                                                  'pred_box_id': '$_id'}}}},
                {'$lookup': {'from': 'ground_truth',
                             'let': {'target_data': '$_id.data',
                                     'target_split': '$_id.split',
                                     'target_key': '$_id.key',
                                     'target_class': '$_id.class'},
                             'pipeline': get_query_pipeline('target_data',
                                                            'target_split',
                                                            'target_key',
                                                            'target_class'),
                             'as': 'gt_box'}},
            ]
    all_correct_box, all_wrong_box = [], []
    for row in tqdm(_pred.aggregate(pipeline, allowDiskUse=True)):
        curr_pred = row['pred_box']
        curr_gt = row['gt_box']
        curr_pred = sorted(curr_pred, key=lambda x: -x['conf'])
        for p in curr_pred:
            matched = [g for g in curr_gt if
                    not g.get('used', False) and
                    ('rect' not in p or
                        not p['rect'] or
                        'rect' not in g or
                        not g['rect'] or
                        calculate_iou(g['rect'], p['rect']) > 0.3)]
            if len(matched) == 0:
                all_wrong_box.append(p['pred_box_id'])
            else:
                all_correct_box.append(p['pred_box_id'])
                matched[0]['used'] = True
        if len(all_correct_box) > 1000:
            _pred.update_many({'_id': {'$in': all_correct_box}},
                    {'$set': {'correct': 1}})
            all_correct_box = []
        if len(all_wrong_box) > 1000:
            _pred.update_many({'_id': {'$in': all_wrong_box}},
                    {'$set': {'correct': 0}})
            all_wrong_box = []
    if len(all_correct_box) > 0:
        _pred.update_many({'_id': {'$in': all_correct_box}},
                {'$set': {'correct': 1}})
        all_correct_box = []
    if len(all_wrong_box) > 0:
        _pred.update_many({'_id': {'$in': all_wrong_box}},
                {'$set': {'correct': 0}})
        all_wrong_box = []

def ensure_inject_expid_pred(full_expid, predict_file):
    try:
        data, split = parse_test_data(predict_file)
    except:
        logging.info('ignore to inject {} - {}'.format(full_expid, predict_file))
        return
    ensure_upload_image_to_blob(data, split)
    ensure_inject_image(data, split)
    ensure_inject_gt(data, split)
    ensure_inject_pred(full_expid,
            predict_file,
            data,
            split)
    ensure_update_pred_with_correctness(data, split,
        full_expid, predict_file)

@ensure_inject_decorate
def ensure_inject_pred(full_expid, pred_file, test_data, test_split):
    client = create_mongodb_client()
    db = client['qd']
    pred_collection = db['predict_result']
    logging.info('cleaning {} - {}'.format(full_expid, pred_file))
    pred_collection.delete_many({'full_expid': full_expid, 'pred_file': pred_file})
    pred_file = op.join('output', full_expid, 'snapshot', pred_file)
    all_rect = []
    for key, label_str in tqdm(tsv_reader(pred_file)):
        rects = json.loads(label_str)
        rects = [r for r in rects if r['conf'] > 0.05]
        for i, r in enumerate(rects):
            r['full_expid'] = full_expid
            r['pred_file'] = op.basename(pred_file)
            r['data'] = test_data
            r['split'] = test_split
            r['key'] = key
        all_rect.extend(rects)
        if len(all_rect) > 10000:
            pred_collection.insert_many(all_rect)
            all_rect = []
    if len(all_rect) > 0:
        pred_collection.insert_many(all_rect)

def ensure_inject_gt(data, split, **kwargs):
    client = create_mongodb_client()
    db = client['qd']
    task = db['task']
    assert split is not None
    dataset = TSVDataset(data)
    version = 0
    set_previous_key_rects = False
    while dataset.has(split, 'label', version=version):
        query = {'task_type': 'inject_gt',
                                'data': data,
                                'split': split,
                                'version': version}
        result = task.update_one(filter=query,
                                update={'$setOnInsert': query},
                                upsert=True)
        if result.matched_count == 0:
            logging.info('start to inserting {}-{}-{}'.format(data,
                split, version))
            # no process is working on inserting current version
            task.update_one(filter=query,
                    update={'$set': {'status': 'started',
                                     'create_time': datetime.now()}})
            if not set_previous_key_rects:
                if version == 0:
                    previous_key_to_rects = {}
                else:
                    key_rects = load_key_rects(dataset.iter_data(split, 'label',
                        version=version-1))
                    previous_key_to_rects = {key: rects for key, rects in key_rects}
                set_previous_key_rects = True
            inject_gt_version(data, split, version, previous_key_to_rects,
                    **kwargs)
            task.update_many(filter={'task_type': 'inject_gt',
                'data': data,
                'split': split,
                'version': version}, update={'$set': {'status': 'done'}})
        else:
            # it is done or it is started by anohter process. let's skip
            # this version
            assert result.matched_count == 1
            while True:
                existing_entries = list(task.find(query))
                if any(e for e in existing_entries if e['status'] == 'done'):
                    logging.info('ignore to inject since it is done: \n{}'.format(query))
                    break
                elif len(existing_entries) == 0:
                    logging.info('we will do it')
                    version = version - 1
                    break
                else:
                    logging.info('waiting to finish \n{}'.format(
                        pformat(existing_entries)))
                    time.sleep(10)
            set_previous_key_rects = False
        version = version + 1

def inject_gt_version(data, split, version, previous_key_to_rects,
        delete_existing=True):
    client = create_mongodb_client()
    db = client['qd']
    gt = db['ground_truth']
    dataset = TSVDataset(data)
    if delete_existing:
        logging.info('deleting data={}, split={}, version={}'.format(
            data, split, version))
        gt.delete_many({'data': data, 'split': split, 'version': version})
    dataset = TSVDataset(data)

    if not dataset.has(split, 'label', version):
        return False
    all_rect = []
    logging.info('{}-{}-{}'.format(data, split, version))
    total_inserted = 0
    for idx_in_split, (key, label_str) in tqdm(enumerate(dataset.iter_data(
        split, 'label', version=version))):
        rects = json.loads(label_str)
        def add_to_all_rect(r, extra_info):
            r2 = copy.deepcopy(r)
            r2.update(extra_info)
            r2['idx_in_split'] = idx_in_split
            r2['data'] = data
            r2['split'] = split
            r2['key'] = key
            r2['action_target_id'] = hash_sha1([data, split, key, r['class'],
                r.get('rect', [])])
            r2['version'] = version
            r2['create_time'] = datetime.now()
            all_rect.append(r2)
        if version == 0:
            assert key not in previous_key_to_rects
            for r in rects:
                add_to_all_rect(r, {'contribution': 1})
        else:
            previous_rects = previous_key_to_rects[key]
            # use strict_rect_in_rects rather than rect_in_rects: if the higher
            # version contains more properies, we want to have the properies in
            # teh database also.
            previous_not_in_current = copy.deepcopy([r for r in previous_rects if
                    not strict_rect_in_rects(r, rects)])
            current_not_in_previous = copy.deepcopy([r for r in rects if
                    not strict_rect_in_rects(r, previous_rects)])
            for r in previous_not_in_current:
                add_to_all_rect(r, {'contribution': -1})
            for r in current_not_in_previous:
                add_to_all_rect(r, {'contribution': 1})
        previous_key_to_rects[key] = rects
        if len(all_rect) > 1000:
            db_insert_many(gt, all_rect)
            total_inserted = total_inserted + len(all_rect)
            logging.info('inserting data={}, split={}, version={}, curr_insert={}, total={}'.format(
                data, split, version, len(all_rect), total_inserted))
            all_rect = []

    if len(all_rect) > 0:
        total_inserted = total_inserted + len(all_rect)
        logging.info('inserting data={}, split={}, version={}, curr_insert={}, total={}'.format(
            data, split, version, len(all_rect), total_inserted))
        db_insert_many(gt, all_rect)
        all_rect = []
    return True

def db_insert_many(collection, all_info):
    for a in all_info:
        if '_id' in a:
            del a['_id']
    collection.insert_many(all_info)

class VisualizationDatabaseByMongoDB():
    def __init__(self):
        self._client = create_mongodb_client()
        self._db = self._client['qd']
        self._pred = self._db['predict_result']
        self._gt = self._db['ground_truth']

    def _get_positive_start(self, start_id, max_item):
        if start_id < 0:
            rank = pymongo.DESCENDING
            start_id = min(0, start_id + max_item)
            start_id = abs(start_id)
        else:
            rank = pymongo.ASCENDING
        return rank, start_id

    def query_pipeline(self, pipeline, collection, db_name):
        image_info = list(self._client[db_name][collection].aggregate(
            pipeline, allowDiskUse=True))
        logging.info(len(image_info))
        if len(image_info) > 0:
            logging.info(pformat(image_info[0]))
        image_info = [{'key': x['key'],
            'url': x.get('url', ''),
            'gt': x.get('gt', []),
            'pred': x.get('pred', [])} for x in image_info]
        return image_info

    def insert(self, dic, collection, db_name):
        return self._client[db_name][collection].insert(dic)

    def query_by_id(self, _id, collection, db_name):
        from bson.objectid import ObjectId
        return list(self._client[db_name][collection].find({'_id':
            ObjectId(_id)}))[0]

    def query_predict_recall(self, full_expid, pred_file, class_name, threshold, start_id, max_item):
        rank, start_id = self._get_positive_start(start_id, max_item)
        # from the predict file
        row = self._pred.find_one({'full_expid': full_expid, 'pred_file':
            pred_file})
        if row is None:
            logging.info('no prediction data in db')
            return []
        data = row['data']
        split = row['split']
        logging.info(data)
        logging.info(split)
        pipeline = [{'$match': {'data': data, 'split': split, 'class': class_name}},
                    {'$group': {'_id': {'key': '$key', 'target_action_id': '$target_action_id'},
                                'contribution': {'$sum': '$contribution'},
                                'num_target_label': {'$sum': 1}}},
                    {'$match': {'contribution': {'$gte': 1}}},
                    {'$group': {'_id': {'key': '$_id.key'},
                                'num_contribution': {'$sum': 1}}},
                    ## add the number of correct predicted
                    {'$lookup': {
                        'from': 'predict_result',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'full_expid': full_expid,
                                                 'pred_file': pred_file,
                                                 'class': class_name,
                                                 'conf': {'$gte': threshold}}},
                                     {'$group': {'_id': {'key': '$key'},
                                                 'correct': {'$sum': '$correct'}}},
                                      {'$match': {'$expr': {'$and': [{'$eq': ['$_id.key', '$$key']}]}}},
                                      ],
                        'as': 'recall',
                        }},
                    {'$unwind': {'path': '$recall', 'preserveNullAndEmptyArrays': True}},
                    {'$addFields': {'recall': {'$divide': ['$recall.correct', '$num_target_label']}}},
                    {'$sort': {'recall': rank}},
                    {'$skip': start_id},
                    {'$limit': max_item},
                    # add the field of url
                    {'$lookup': {
                        'from': 'image',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$data', data]},
                                                                    {'$eq': ['$split', split]},
                                                                    {'$eq': ['$key', '$$key']},],}}},
                                     {'$project': {'url': True, '_id': 0}}],
                        'as': 'url',
                        }},
                    {'$addFields': {'url': {'$arrayElemAt': ['$url', 0]}}},
                    {'$addFields': {'url': '$url.url'}},
                    ## add the field of pred
                    {'$lookup': {
                        'from': 'predict_result',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$full_expid', full_expid]},
                                                                    {'$eq': ['$pred_file', pred_file]},
                                                                    {'$eq': ['$key', '$$key']},
                                                                    {'$gte': ['$conf', threshold]}]}}},
                                     {'$project': {'conf': True, 'rect': True, 'class': True, '_id': 0}}],
                        'as': 'pred',
                        }
                    },
                    ## add the gt field
                    {'$lookup': {
                        'from': 'ground_truth',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$data', data]},
                                                                    {'$eq': ['$split', split]},
                                                                    {'$eq': ['$key', '$$key']},],}}},
                                    {'$group': {'_id': {'action_target_id': '$action_target_id'},
                                                'contribution': {'$sum': '$contribution'},
                                                'rect': {'$first': '$rect'},
                                                'class': {'$first': '$class'},
                                                'conf': {'$first': '$conf'}}, },
                                    {'$match': {'contribution': {'$gte': 1}}},
                                    ],
                        'as': 'gt',
                        }}
                    ]
        image_info = list(self._gt.aggregate(pipeline))
        logging.info(len(image_info))
        image_info = [{'key': x['_id']['key'],
            'url': x['url'],
            'gt': x['gt'],
            'pred': x['pred']} for x in image_info]
        return image_info

    def query_predict_precision(self, full_expid, pred_file, class_name, threshold, start_id, max_item):
        rank, start_id = self._get_positive_start(start_id, max_item)
        filter_pred = {'full_expid': full_expid,
                            'pred_file': pred_file,
                            'conf': {'$gte': threshold}}
        if class_name != 'None' and class_name:
            filter_pred['class'] = class_name
        pipeline = [
                {'$match': filter_pred},
                {'$group': {'_id': {'data': '$data',
                                    'split': '$split',
                                    'key': '$key'},
                            'correct': {'$sum': '$correct'},
                            'total': {'$sum': 1}}},
                {'$addFields': {'precision': {'$divide': ['$correct', '$total']}}},
                {'$sort': {'precision': rank}},
                {'$skip': start_id},
                {'$limit': max_item},
                # add the field of url
                {'$lookup': {
                    'from': 'image',
                    'let': {'data': '$_id.data',
                            'split': '$_id.split',
                            'key': '$_id.key'},
                    'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$data', '$$data']},
                                                                {'$eq': ['$split', '$$split']},
                                                                {'$eq': ['$key', '$$key']},],}}},
                                 {'$project': {'url': True, '_id': 0}}],
                    'as': 'url',
                    }},
                {'$unwind': '$url'},
                {'$addFields': {'url': '$url.url'}},
                ## add the field of pred
                {'$lookup': {
                    'from': 'predict_result',
                    'let': {'data': '$_id.data',
                            'split': '$_id.split',
                            'key': '$_id.key'},
                    'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$full_expid', full_expid]},
                                                                {'$eq': ['$pred_file', pred_file]},
                                                                {'$eq': ['$key', '$$key']},
                                                                {'$gte': ['$conf', threshold]}]}}},
                                 {'$project': {'conf': True, 'rect': True, 'class': True, '_id': 0}}],
                    'as': 'pred',
                    }
                },
                ## add the gt field
                {'$lookup': {
                    'from': 'ground_truth',
                    'let': {'data': '$_id.data',
                            'split': '$_id.split',
                            'key': '$_id.key'},
                    'pipeline': [{'$match': {'$expr': {'$and': [{'$eq': ['$data', '$$data']},
                                                                {'$eq': ['$split', '$$split']},
                                                                {'$eq': ['$key', '$$key']},],}}},
                                {'$group': {'_id': {'action_target_id': '$action_target_id'},
                                            'contribution': {'$sum': '$contribution'},
                                            'rect': {'$first': '$rect'},
                                            'class': {'$first': '$class'},
                                            'conf': {'$first': '$conf'}}, },
                                {'$match': {'contribution': {'$gte': 1}}},
                                ],
                    'as': 'gt',
                    }}
                ]

        logging.info(pformat(pipeline))
        image_info = list(self._pred.aggregate(pipeline))
        image_info = [{'key': x['_id']['key'],
            'url': x['url'],
            'gt': x['gt'],
            'pred': x['pred']} for x in image_info]
        return image_info

    def query_ground_truth(self, data, split, version, label, start_id, max_item):
        pipeline = self.get_ground_truth_pipeline(data, split, version, label, start_id, max_item)
        image_info = list(self._gt.aggregate(pipeline['pipeline']))
        logging.info(len(image_info))
        image_info = [{'key': x['key'],
            'url': x['url'],
            'gt': x['gt']} for x in image_info]
        return pipeline, image_info

    def get_ground_truth_pipeline(self, data, split, version, label, start_id, max_item):
        rank, start_id = self._get_positive_start(start_id, max_item)

        match_pairs = {'data': data}
        gt_match = []
        gt_match.append({'$eq': ['$data', data]})
        url_match = []
        url_match.append({'$eq': ['$data', data]})
        if split is not None:
            match_pairs['split'] = split
            gt_match.append({'$eq': ['$split', split]})
            url_match.append({'$eq': ['$split', split]})
        if label is not None:
            match_pairs['class'] = label
        if version is not None:
            match_pairs['version'] = {'$lte': version}
            gt_match.append({'$lte': ['$version', version]})
        gt_match.append({'$eq': ['$key', '$$key']})
        url_match.append({'$eq': ['$key', '$$key']})
        pipeline = [{'$match': match_pairs},
                    {'$group': {'_id': {'key': '$key'},
                                'contribution': {'$sum': '$contribution'}}},
                    {'$match': {'contribution': {'$gte': 1}}},
                    {'$sort': {'_id.key': rank}},
                    {'$skip': start_id},
                    {'$limit': max_item},
                    # add gt boxes
                    {'$lookup': {
                        'from': 'ground_truth',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'$expr': {'$and': gt_match}}},
                                     {'$group': {'_id': {'action_target_id': '$action_target_id'},
                                                 'contribution': {'$sum': '$contribution'},
                                                 'rect': {'$first': '$rect'},
                                                 'class': {'$first': '$class'},
                                                 'conf': {'$first': '$conf'}}, },
                                     {'$match': {'contribution': {'$gte': 1}}},
                                    ],
                        'as': 'gt',
                        }},
                    # add url
                    {'$lookup': {
                        'from': 'image',
                        'let': {'key': '$_id.key'},
                        'pipeline': [{'$match': {'$expr': {'$and': url_match}}},
                                     {'$project': {'url': True, '_id': 0}}],
                        'as': 'url',
                        }},
                    {'$unwind': '$url'},
                    {'$addFields': {'url': '$url.url',
                                    'key': '$_id.key'}},
                    ]

        return {'pipeline': pipeline,
                'database': 'qd',
                'collection': 'ground_truth'}

def get_class_count(data, splits):
    dataset = TSVDataset(data)
    result = {}
    for split in splits:
        result[split] = {row[0]: int(row[1])
                for row in dataset.iter_data(
                    split, 'inverted.label.count', -1)}
    return result

def get_colored_name(node, colors):
    name = node.name
    if hasattr(node, 'sub_group'):
        sub_group = node.sub_group
    else:
        sub_group = -1
    idx = sub_group + 1
    while idx >= len(colors):
        colors.append('rgb({},{},{})'.format(
            int(random.random() * 255),
            int(random.random() * 255),
            int(random.random() * 255)))
    return "<span style='color:{}'>{}</span>".format(colors[idx],
            name)

def get_vis_url(data, l, split=None):
    if split is None:
        return '/detection/view_image?data={}&label={}&start_id=0'.format(
                data, l)
    else:
        return '/detection/view_image?data={}&split={}&label={}&start_id=0'.format(
                data, split, l)


def get_readable_label(l):
    if is_noffset(l):
        return '{}({})'.format(l, get_nick_name(noffset_to_synset(l)))
    else:
        return l

def get_node_key(node, k, default_value=-1):
    r = default_value
    if hasattr(node, k):
        r = node.__getattribute__(k)
    return r

def get_node_info(data, node, colors, all_data):
    ss = []
    if hasattr(node, 'ap'):
        ss.append('ap({0:.2f})'.format(node.ap))
    if hasattr(node, 'images_with_bb') and \
            hasattr(node, 'images_no_bb'):
        keys = ['with_bb', 'no_bb']
        for k in keys:
            ss.append("{}({},<span><a href='{}' target='_blank'>{}</a></span>,<span><a href='{}' target='_blank'>{}</a></span>)".format(
                k,
                get_node_key(node, 'images_' + k, -1),
                get_vis_url(data + '_' + k, node.name, split='train'),
                get_node_key(node, k + '_train', -1),
                get_vis_url(data + '_' + k, node.name, split='test'),
                get_node_key(node, k + '_test', -1)))
    ignore_keys = ['support', 'dist', 'name', 'url',
            'with_bb_train',
            'with_bb_test',
            'no_bb_train',
            'no_bb_test',
            'ap',
            'images_with_bb',
            'images_no_bb',
            'noffset',
            'sub_group',
            'cum_images_with_bb',
            'cum_images_no_bb']
    for key in node.features:
        if any(x == key for x in ignore_keys):
            continue
        if key.endswith('_readable') or \
                key.endswith('_toTrain') or \
                key.endswith('_toTest') or \
                key.endswith('_total'):
            continue
        value = node.__getattribute__(key)
        if key in all_data and value != None:
            total = get_node_key(node, '{}_total'.format(key))
            toTrain = get_node_key(node, '{}_toTrain'.format(key))
            toTest = get_node_key(node, '{}_toTest'.format(key))
            extra_info = '({},{},{})'.format(total, toTrain, toTest)
            labels = value.split(',')
            value = ','.join(["<a href='{}' target='_blank'>{}</a>".format(get_vis_url(key, l),
                get_readable_label(l)) for l in labels])
            value = '{}{}'.format(value, extra_info)
        ss.append('{}[{}]'.format(key, value))
    if len(ss) > 0:
        return "{}: {}".format(
                get_colored_name(node, colors),
                '; '.join(ss))
    else:
        return get_colored_name(node, colors)

def gen_html_tree_view(data, full_expid=None,
        predict_file=None):
    colors=['rgb(0,0,0)',
                'rgb(255,0,0)',
                'rgb(0,0,255)']
    dataset = TSVDataset(data)
    all_data = os.listdir('./data')
    file_name = op.join(dataset._data_root, 'root_enriched.yaml')
    logging.info('loading {}'.format(file_name))
    with open(file_name, 'r') as fp:
        config_tax = yaml.load(fp)
    tax = Taxonomy(config_tax)
    if full_expid is not None and \
            predict_file is not None:
        map_file = op.join('output',full_expid, 'snapshot',
                op.splitext(predict_file)[0] + '.report.class_ap.json')
        if op.isfile(map_file):
            class_ap = json.loads(read_to_buffer(map_file))
            class_ap = class_ap['overall']['0.3']['class_ap']
            for node in tax.root.iter_search_nodes():
                node.add_feature('ap',
                        class_ap.get(node.name, -1))

    def gen_html_tree_view_rec(root):
        '''
        include itself
        '''
        if len(root.children) == 0:
            s = u"<li data-jstree='{{\"icon\":\"glyphicon glyphicon-leaf\"}}'><span>{}</span></li>".format(
                    get_node_info(data, root, colors, all_data))
            return s
        else:
            result = []
            # we cannot remove span tag here
            result.append("<li data-jstree='{{\"opened\":true}}' ><span>{}</span>".format(
                get_node_info(data, root, colors, all_data)))
            result.append('<ul>')
            all_child = sorted(root.children, key=lambda c: c.sub_group)
            for c in all_child:
                r = gen_html_tree_view_rec(c)
                result.append(r)
            result.append('</ul>')
            result.append('</li>')
            return '\n'.join(result)
    s = gen_html_tree_view_rec(tax.root)
    return s


def gt_predict_images(predicts, gts, test_data, target_images, label, start_id, threshold,
        label_to_idx, image_aps, test_data_split='test'):
    test_dataset = TSVDataset(test_data)
    test_tsv = TSVFile(test_dataset.get_data(test_data_split))
    for i in xrange(start_id, len(target_images)):
        key = target_images[i]
        logging.info('key = {}, ap = {}'.format(key, image_aps[i][1]))
        idx = label_to_idx[key]
        row = test_tsv.seek(idx)
        origin = img_from_base64(row[2])
        im_gt = np.copy(origin)
        draw_bb(im_gt, [g['rect'] for g in gts[key]],
                [g['class'] for g in gts[key]])
        im_gt_target = np.copy(origin)
        gts_target = [g for g in gts[key] if g['class'] == label]
        draw_bb(im_gt_target, [g['rect'] for g in gts_target],
                [g['class'] for g in gts_target])
        im_pred = np.copy(origin)
        rects = [p for p in predicts[key] if p['conf'] > threshold]
        draw_bb(im_pred, [r['rect'] for r in rects],
                [r['class'] for r in rects],
                [r['conf'] for r in rects])
        im_pred_target = np.copy(origin)
        rects = [p for p in rects if p['class'] == label]
        draw_bb(im_pred_target, [r['rect'] for r in rects],
                [r['class'] for r in rects],
                [r['conf'] for r in rects])
        yield key, origin, im_gt_target, im_pred_target, im_gt, im_pred, image_aps[i][1]

def get_confusion_matrix_by_predict_file_label(full_expid,
        predict_file, label, threshold):
    '''
    get confusion matrix for specific label
    '''
    test_data, test_data_split = parse_test_data(predict_file)

    # load the gt
    logging.info('loading {} - {}'.format(test_data, test_data_split))
    test_dataset = TSVDataset(test_data)
    rows = test_dataset.iter_data(test_data_split, 'label', -1)
    gts = {}
    label_to_idx = {}
    keys_with_label = []
    for i, row in enumerate(rows):
        rects = json.loads(row[1])
        gts[row[0]] = rects
        label_to_idx[row[0]] = i
        if any(r['class'] == label for r in rects):
            keys_with_label.append(row[0])

    predict_full_path = op.join('output', full_expid, 'snapshot', predict_file)
    if not full_expid.startswith('Tax'):
        logging.info('loading {}'.format(predict_file))
        predicts, _ = load_labels(predict_full_path)
    else:
        # create the inverted index
        pred_label_file = '{}.labelmap.tsv'.format(predict_full_path)
        pred_inverted_file = '{}.inverted.tsv'.format(predict_full_path)
        pred_key_file = '{}.key.tsv'.format(predict_full_path)
        if not op.isfile(pred_label_file) or \
                not op.isfile(pred_inverted_file) or \
                not op.isfile(pred_key_file):
            pred_inverted = {}
            pred_keys = []
            rows = tsv_reader(predict_full_path)
            logging.info('loading data and creating index')
            inverted, pred_keys = create_inverted_list2(
                    tsv_reader(predict_full_path))
            logging.info('done loading data and creating index')
            pred_labels = inverted.keys()
            tsv_writer(([l] for l in pred_labels), pred_label_file)
            tsv_writer(((l, ' '.join(map(str, inverted[l]))) for l in
                    pred_labels), pred_inverted_file)
            tsv_writer([[k] for k in pred_keys], pred_key_file)
        # find out data whose prediction has the target label
        all_labels = load_list_file(pred_label_file)
        if label in all_labels:
            row = TSVFile(pred_inverted_file).seek(all_labels.index(label))
            assert row[0] == label
            idx = map(int, row[1].split(' '))
        else:
            idx = []
        # find out the index from the ground truth
        key_to_predidx = {k: i for i, k in enumerate(load_list_file(pred_key_file))}
        idx.extend([key_to_predidx[k] for k in keys_with_label])
        idx = set(idx)
        tsv = TSVFile(predict_full_path)
        predicts = {}
        logging.info('loading')
        for i in idx:
            row = tsv.seek(i)
            assert len(row) == 2
            predicts[row[0]] = json.loads(row[1])
        logging.info('done')
        # load data from the inverted index
    logging.info('done loading {}'.format(predict_file))

    return {'predicts': predicts,
            'gts': gts,
            'label_to_idx': label_to_idx}

def get_confusion_matrix_by_predict_file(full_expid,
        predict_file, threshold):
    '''
    get confusion matrix for all classes
    '''

    test_data, test_data_split = parse_test_data(predict_file)

    # load the gt
    logging.info('loading {} - {}'.format(test_data, test_data_split))
    test_dataset = TSVDataset(test_data)
    rows = test_dataset.iter_data(test_data_split, 'label', -1)
    gts = {}
    label_to_idx = {}
    for i, row in enumerate(rows):
        gts[row[0]] = json.loads(row[1])
        label_to_idx[row[0]] = i

    logging.info('loading {}'.format(predict_file))
    predicts, _ = load_labels(op.join('output', full_expid, 'snapshot', predict_file))
    logging.info('done loading {}'.format(predict_file))

    # calculate the confusion matrix
    confusion_pred_gt = {}
    confusion_gt_pred = {}
    update_confusion_matrix(predicts, gts, threshold,
            confusion_pred_gt,
            confusion_gt_pred)

    return {'predicts': predicts,
            'gts': gts,
            'confusion_pred_gt': confusion_pred_gt,
            'confusion_gt_pred': confusion_gt_pred,
            'label_to_idx': label_to_idx}

def inc_one_dic_dic(dic, c1, c2):
    if c1 not in dic:
        dic[c1] = {}
    if c2 not in dic[c1]:
        dic[c1][c2] = 0
    dic[c1][c2] = dic[c1][c2] + 1

def update_confusion_matrix(predicts, gts, threshold,
            confusion_pred_gt,
            confusion_gt_pred):
    for key in predicts:
        curr_pred = [p for p in predicts[key] if p['conf'] > threshold]
        if key not in gts:
            continue
        curr_gt = gts[key]
        if len(curr_pred) == 0 and len(curr_gt) > 0:
            for g in curr_gt:
                inc_one_dic_dic(confusion_gt_pred, g['class'], 'None')
            continue
        elif len(curr_pred) > 0 and len(curr_gt) == 0:
            for p in curr_pred:
                inc_one_dic_dic(confusion_pred_gt, p['class'], 'None')
            continue
        elif len(curr_pred) == 0 and len(curr_gt) == 0:
            continue
        ious = np.zeros((len(curr_pred), len(curr_gt)))
        for i, p in enumerate(curr_pred):
            for j, g in enumerate(curr_gt):
                iou = calculate_iou(p['rect'], g['rect'])
                ious[i, j] = iou
        gt_idx = np.argmax(ious, axis=1)
        for i, p in enumerate(curr_pred):
            j = gt_idx[i]
            predict_class = p['class']
            gt_class = curr_gt[j]['class']
            if ious[i, j] > 0.3:
                inc_one_dic_dic(confusion_pred_gt,
                        predict_class, gt_class)
            else:
                inc_one_dic_dic(confusion_pred_gt,
                        predict_class, 'None')
        pred_idx = np.argmax(ious, axis=0)
        for j, g in enumerate(curr_gt):
            i = pred_idx[j]
            predict_class = curr_pred[i]['class']
            gt_class = g['class']
            if ious[i, j] > 0.3:
                inc_one_dic_dic(confusion_gt_pred,
                        gt_class, predict_class)
            else:
                inc_one_dic_dic(confusion_gt_pred,
                        gt_class, 'None')

def normalize_str_in_rects(data, out_data):
    '''
    normalize all the unicode to string
    '''
    dataset = TSVDataset(data)
    dest_dataset = TSVDataset(out_data)
    splits = get_default_splits()
    for split in splits:
        if not op.isfile(dataset.get_data(split)):
            continue
        def gen_rows():
            for key, label_str, im_str in tsv_reader(dataset.get_data(split)):
                rects = json.loads(label_str)
                for rect in rects:
                    s = rect['class']
                    rect['class'] = normalize_to_str(s)
                    if s != rect['class']:
                        logging.info(u'{}->{}'.format(s, rect['class']))
                label_str = json.dumps(rects)
                yield key, label_str, im_str
        tsv_writer(gen_rows(), dest_dataset.get_data(split))

def tsv_details(row_hw, row_label, num_rows):
    label_count = {}
    sizes = []
    logging.info('tsv details...')
    for r_hw, r_label in tqdm(zip(row_hw, row_label), total=num_rows):
        if r_label[1] == 'd':
            # this is the deleted label
            rects = []
        else:
            rects = json.loads(r_label[1])
        assert r_hw[0] == r_label[0]
        height, width = map(int, r_hw[1].split(' '))
        if type(rects) is list:
            # this is the detection dataset
            # convert it to str. if it is unicode, in yaml, there will be some
            # special tags, which is annoying
            curr_labels = set(normalize_to_str(rect['class']) for rect in rects)
            for rect in rects:
                if 'rect' not in rect or all(x == 0 for x in rect['rect']):
                    # it is image-level annotation
                    continue
                r = rect['rect']
                # this should be a valid bounding box
                cx, cy = (r[0] + r[2]) / 2., (r[1] + r[3]) / 2.
                rw, rh = r[2] - r[0], r[3] - r[1]
                #assert cx >= 0 and cx < width \
                        #and cy >= 0 and cy < height
                if rw < 1 or rh < 1:
                    logging.warn('rw or rh too small: {} - {}'.format(r_label[0],
                        ','.join(map(str, r))))
        else:
            # this is classification dataset
            assert type(rects) is int
            curr_labels = [rects]
        for c in curr_labels:
            if c in label_count:
                label_count[c] = label_count[c] + 1
            else:
                label_count[c] = 1
        sizes.append((height, width))
    size_counts = [s[0] * s[1] for s in sizes]
    min_size = sizes[np.argmin(size_counts)]
    max_size = sizes[np.argmax(size_counts)]
    min_size = map(float, min_size)
    max_size = map(float, max_size)
    mean_size = (np.mean([s[0] for s in sizes]),
            np.mean([s[1] for s in sizes]))
    mean_size = map(float, mean_size)

    return {'label_count': label_count,
            'min_image_size': min_size,
            'max_image_size': max_size,
            'mean_image_size': mean_size}


def detect_duplicate_key(tsv, duplicate_tsv):
    rows = tsv_reader(tsv)
    key_to_idx = {}
    for i, row in enumerate(rows):
        key = row[0]
        if key in key_to_idx:
            key_to_idx[key].append(i)
        else:
            key_to_idx[key] = [i]
    def gen_rows():
        for key in key_to_idx:
            idxs = key_to_idx[key]
            if len(idxs) > 1:
                logging.info('duplicate key: {}: {}'.format(key, ', '.join(map(str,
                    idxs))))
                yield key, ','.join(map(str, idxs))
    tsv_writer(gen_rows(), duplicate_tsv)
    return TSVFile(duplicate_tsv).num_rows()

def populate_all_dataset_details():
    all_data = os.listdir('data/')
    for data in all_data:
        try:
            populate_dataset_details(data)
        except:
            continue

def update_labelmap(rows, num_rows, labelmap):
    '''
    labelmap is a hashset and can be added
    '''
    logging.info('updating labelmap')
    for row in tqdm(rows, total=num_rows):
        assert len(row) == 2
        try:
            labelmap.update(set([rect['class'] for rect in
                json.loads(row[1])]))
        except:
            labelmap.add(row[1])
    logging.info('done')

def derive_composite_meta_data(data, split, t):
    data_to_dataset = {}
    dataset = TSVDataset(data)
    all_source_data_split = dataset.load_composite_source_data_split(split)
    def gen_rows():
        assert dataset.has(split, 'label')
        iter_label = dataset.iter_data(split, 'label')
        iter_shuffle = tsv_reader(dataset.get_shuffle_file(split))
        for (idx_source, idx_row), (label_row) in zip(iter_shuffle,
                iter_label):
            idx_source = int(idx_source)
            idx_row = int(idx_row)
            c_data, c_split = all_source_data_split[idx_source]
            if c_data in data_to_dataset:
                c_dataset = data_to_dataset[c_data]
            else:
                c_dataset = TSVDataset(c_data)
                data_to_dataset[c_data] = c_dataset
            assert c_dataset.has(c_split, t)
            key, t_data = c_dataset.seek_by_idx(idx_row, c_split, t)
            yield label_row[0], t_data
    assert not dataset.has(split, t)
    dataset.write_data(gen_rows(), split, t)

def ensure_create_inverted_tsvs(dataset, splits):
    # for each data tsv, generate the inverted file, and the labelmap
    is_parallel = True
    for split in splits:
        if not dataset.has(split):
            continue
        latest = dataset.get_latest_version(split, 'label')
        if not is_parallel:
            for v in range(latest + 1):
                assert dataset.has(split, 'label', v)
                ensure_create_inverted_tsv_for_each((dataset, split, v))
        else:
            params = [(dataset, split, v) for v in range(latest + 1)]
            params = [param for param in params if
                    not has_inverted(param)]
            if len(params) > 0:
                p = Pool()
                p.map(ensure_create_inverted_tsv_for_each, params)

    # generate the inverted tsv for background images without any labels
    for split in splits:
        if not dataset.has(split):
            continue
        latest = dataset.get_latest_version(split, 'label')
        if not is_parallel:
            for v in range(latest + 1):
                assert dataset.has(split, 'label', v)
                ensure_create_inverted_tsv_background_for_each((dataset, split, v))
        else:
            params = [(dataset, split, v) for v in range(latest + 1)]
            params = [param for param in params if
                    not has_inverted_background(param)]
            if len(params) > 0:
                p = Pool()
                p.map(ensure_create_inverted_tsv_background_for_each, params)

def has_inverted(param):
    dataset, split, v = param
    inverted_keys = ['inverted.label',
            'inverted.label.with_bb',
            'inverted.label.no_bb',
            'inverted.label.with_bb.verified',
            'inverted.label.with_bb.noverified',]
    return all(dataset.has(split, k, v) for k in inverted_keys)

def has_inverted_background(args):
    dataset, split, v = args
    if dataset.has(split, 'inverted.background', version=v) and \
            dataset.has(split, 'inverted.background.count'):
        return True
    else:
        return False

def ensure_create_inverted_tsv_background_for_each(args):
    dataset, split, v = args
    if dataset.has(split, 'inverted.background', version=v) and \
            dataset.has(split, 'inverted.background.count'):
        return
    label_to_indices = dataset.load_inverted_label(split, version=v)
    all_idx = [i for l in label_to_indices for i in label_to_indices[l]]
    all_idx = set(all_idx)
    num = dataset.num_rows(split)
    background_idx = set(range(num)).difference(all_idx)

    def gen_rows():
        yield 'background', ' '.join(map(str, background_idx))
    dataset.write_data(gen_rows(), split, 'inverted.background', version=v)

    def gen_row_count():
        yield 'background', len(background_idx)
    dataset.write_data(gen_row_count(), split, 'inverted.background.count',
            version=v)

def ensure_create_inverted_tsv_for_each(args):
    dataset, split, v = args
    if not dataset.has(split, 'labelmap', v) or \
        dataset.last_update_time(split, 'labelmap', v) < dataset.last_update_time(split, 'label', v):
        curr_labelmap = set()
        update_labelmap(dataset.iter_data(split, 'label', v),
                dataset.num_rows(split),
                curr_labelmap)
        curr_labelmap = sorted(list(curr_labelmap))
        dataset.write_data([[l] for l in curr_labelmap], split, 'labelmap', v)
    else:
        curr_labelmap = None
    inverted_keys = ['inverted.label',
            'inverted.label.with_bb',
            'inverted.label.no_bb',
            'inverted.label.with_bb.verified',
            'inverted.label.with_bb.noverified',]
    if any(not dataset.has(split, k, v) for k in inverted_keys):
        logging.info('version = {}'.format(v))
        if curr_labelmap is None:
            curr_labelmap = []
            for row in dataset.iter_data(split, 'labelmap', v):
                assert len(row) == 1
                curr_labelmap.append(row[0])
        def gen_inverted_rows(inv):
            logging.info('re-orderring')
            set_labelmap = set(curr_labelmap)
            for label in tqdm(inv):
                assert label in set_labelmap
            for label in tqdm(curr_labelmap):
                i = inv[label] if label in inv else []
                yield label, ' '.join(map(str, i))
        inverted_result = create_inverted_list(
                dataset.iter_data(split, 'label', v))
        for k in inverted_keys:
            dataset.write_data(gen_inverted_rows(inverted_result[k]),
                    split, k, v)

def ensure_extract_from_data_source(data, split, t):
    assert t != 'label'
    dataset = TSVDataset(data)
    if dataset.has(split, t):
        logging.info('ignore to generate {}, {}, {}'.format(data, split, t))
        return
    all_data_split = dataset.load_composite_source_data_split(split)
    source_data_to_dataset = {}
    label_iter = dataset.iter_data(split, 'label')
    shuffle_iter = tsv_reader(dataset.get_shuffle_file(split))
    def gen_rows():
        for (idx_source, idx_row), label_row in zip(shuffle_iter, label_iter):
            idx_source, idx_row = int(idx_source), int(idx_row)
            source_data, source_split = all_data_split[idx_source]
            if source_data not in source_data_to_dataset:
                source_data_to_dataset[source_data] = TSVDataset(source_data)
            source_dataset = source_data_to_dataset[source_data]
            source_key, str_t = source_dataset.seek_by_idx(idx_row, source_split, t)
            assert label_row[0] == '_'.join([source_data, source_split, source_key])
            yield label_row[0], str_t
    dataset.write_data(gen_rows(), split, t)

def populate_dataset_hw(data,
                        splits=('train', 'trainval', 'test', 'val'),
                        img_t=None,
                        multi_thread=True,
                        ):
    dataset = TSVDataset(data)
    for split in splits:
        if dataset.has(split, img_t) and not dataset.has(split, 'hw'):
            success = False
            if op.isfile(dataset.get_data(split + 'X', img_t)):
                try:
                    derive_composite_meta_data(data, split, 'hw')
                    success = True
                except:
                    pass
            if not success:
                if not multi_thread:
                    logging.info('generating hw')
                    rows = dataset.iter_data(split, img_t, progress=True)
                    dataset.write_data(((row[0], ' '.join(map(str,
                        img_from_base64(row[-1]).shape[:2]))) for
                        row in rows), split, 'hw')
                else:
                    num_images = dataset.num_rows(split, img_t)
                    num_tasks = min(num_images, 128 * 3)
                    num_worker = (num_tasks + 2) // 3
                    num_image_per_worker = (num_images + num_tasks - 1) // num_tasks
                    assert num_image_per_worker > 0
                    all_idx = []
                    for i in range(num_tasks):
                        curr_idx_start = i * num_image_per_worker
                        if curr_idx_start >= num_images:
                            break
                        curr_idx_end = curr_idx_start + num_image_per_worker
                        curr_idx_end = min(curr_idx_end, num_images)
                        if curr_idx_end > curr_idx_start:
                            all_idx.append(range(curr_idx_start, curr_idx_end))
                    logging.info('creating pool')
                    m = Pool(num_worker)
                    def get_hw(filter_idx):
                        dataset = TSVDataset(data)
                        rows = dataset.iter_data(split, img_t, progress=True,
                                filter_idx=filter_idx)
                        return [(row[0], ' '.join(map(str,
                            img_from_base64(row[-1]).shape[:2])))
                            for row in rows]
                    all_result = m.map(get_hw, all_idx)
                    x = []
                    for r in all_result:
                        x.extend(r)
                    dataset.write_data(x, split, 'hw')

def ensure_label_extract(data, splits):
    dataset = TSVDataset(data)
    for split in splits:
        if (not dataset.has(split, 'label')) and \
                dataset.has(split):
            def gen_rows():
                if op.isfile(dataset.get_data(split)):
                    iter_row = dataset.iter_data(split)
                else:
                    iter_row = dataset.iter_composite(split, t=None, version=0)
                for row in tqdm(iter_row):
                    if len(row) == 3:
                        str_rects = row[1]
                    else:
                        assert len(row) == 2
                        str_rects = json_dump([])
                    yield row[0], str_rects
            dataset.write_data(gen_rows(), split, 'label')

def ensure_labelmap_extract(data):
    splits = get_default_splits()
    dataset = TSVDataset(data)
    # generate the label map if there is no
    if not op.isfile(dataset.get_labelmap_file()) and \
            not op.islink(dataset.get_labelmap_file()):
        logging.info('no labelmap, generating...')
        labelmap = []
        for split in splits:
            label_tsv = dataset.get_data(split, 'label', version=0)
            if not op.isfile(label_tsv):
                continue
            for row in tqdm(tsv_reader(label_tsv)):
                try:
                    labelmap.extend(set([rect['class'] for rect in
                        json.loads(row[1])]))
                except:
                    labelmap.append(row[1])
        if len(labelmap) == 0:
            logging.warning('there are no labels!')
        labelmap = sorted(list(set(labelmap)))
        logging.info('find {} labels'.format(len(labelmap)))
        need_update = False
        if op.isfile(dataset.get_labelmap_file()):
            origin_labelmap = dataset.load_labelmap()
            if len(origin_labelmap) == len(labelmap):
                for o in origin_labelmap:
                    if o not in labelmap:
                        need_update = True
                        break
            else:
                need_update = True
        else:
            need_update = True
        if need_update:
            logging.info('updating {}'.format(dataset.get_labelmap_file()))
            write_to_file('\n'.join(labelmap), dataset.get_labelmap_file())

def populate_dataset_details(data, check_image_details=False,
        splits=None, check_box=False, data_root=None):
    logging.info(data)
    dataset = TSVDataset(data)

    if not splits:
        splits = get_default_splits()

    # populate the height and with
    if check_image_details:
        populate_dataset_hw(data, splits)

    ensure_label_extract(data, splits)

    for split in splits:
        tsv_file = dataset.get_data(split)
        out_file = get_meta_file(tsv_file)
        if not op.isfile(out_file) and \
                dataset.has(split, 'hw') and \
                dataset.has(split):
            row_hw = dataset.iter_data(split, 'hw')
            row_label = dataset.iter_data(split, 'label')
            num_rows = dataset.num_rows(split)
            if check_image_details:
                details = tsv_details(row_hw, row_label, num_rows)
                write_to_yaml_file(details, out_file)

    ensure_labelmap_extract(data)

    labelmap = []
    if not op.isfile(dataset.get_pos_labelmap_file()):
        ls = dataset.load_labelmap()
        write_to_file('\n'.join([l for l in ls if not l.startswith('-')]),
                dataset.get_pos_labelmap_file())

    # generate the rows with duplicate keys
    for split in splits:
        label_tsv = dataset.get_data(split, 'label')
        duplicate_tsv = dataset.get_data(split, 'key_duplicate')
        if op.isfile(label_tsv) and not op.isfile(duplicate_tsv):
            detect_duplicate_key(label_tsv, duplicate_tsv)

    # generate lineidx if it is not generated
    for split in splits:
        lineidx = dataset.get_lineidx(split)
        full_tsv = dataset.get_data(split)
        if not op.isfile(lineidx) and op.isfile(full_tsv):
            logging.info('no lineidx for {}. generating...'.format(split))
            generate_lineidx(full_tsv, lineidx)

    ensure_create_inverted_tsvs(dataset, splits)
    # check if the number of rows from the label tsv are equal to the number of rows in image tsv
    for split in splits:
        v = 0
        num_rows = None
        while True:
            if not dataset.has(split, 'label', v):
                break
            if dataset.has(split, 'check_count', v):
                v = v + 1
                continue
            if num_rows is None:
                num_rows = dataset.num_rows(split)
            num_rows_in_label = dataset.num_rows(split, 'label', v)
            # we can remove the assert
            assert num_rows == num_rows_in_label
            if num_rows != num_rows_in_label:
                dataset.write_data([['num_rows', num_rows], ['num_rows_in_label', num_rows_in_label]],
                        split, 'check_count', v)
            else:
                dataset.write_data([], split, 'check_count', v)
            v = v + 1

    if not op.isfile(dataset.get_noffsets_file()):
        logging.info('no noffset file. generating...')
        labelmap = dataset.load_labelmap()
        mapper = LabelToSynset(True)
        ambigous = []
        ss = [mapper.convert(l) for l in labelmap]
        for l, (success, s) in zip(labelmap, ss):
            if not success and len(s) > 1:
                d = create_info_for_ambigous_noffset(l, [synset_to_noffset(s1)
                    for s1 in s])
                ambigous.append(d)
        if len(ambigous) > 0:
            logging.info('ambigous term which has no exact noffset: {}'.format(
                dataset.name))
            write_to_yaml_file(ambigous, dataset.get_noffsets_file() +
                    '.ambigous.yaml')
        noffsets = []
        for success, s in ss:
            if not success:
                noffsets.append('')
            else:
                noffsets.append(','.join([synset_to_noffset(o) for o in s]))
        write_to_file('\n'.join(noffsets), dataset.get_noffsets_file())

    if not op.isfile(dataset.get_labelmap_of_noffset_file()):
        noffsets = dataset.load_noffsets()
        all_line = []
        for noffset in noffsets:
            if len(noffset) == 0:
                all_line.append('unkown')
            else:
                ss = [noffset_to_synset(n) for n in noffset.split(',')]
                all_line.append(','.join([get_nick_name(s) for s in ss]))
        write_to_file('\n'.join(all_line),
                dataset.get_labelmap_of_noffset_file())

    # generate the label -> count tsv
    for split in splits:
        v = 0
        while True:
            label_idx_file = dataset.get_data(split, 'inverted.label', v)
            label_count_file = dataset.get_data(split, 'inverted.label.count', v)
            if op.isfile(label_idx_file):
                if not op.isfile(label_count_file):
                    label_idx = dataset.load_inverted_label_as_list(split, v)
                    tsv_writer(((l, str(len(i))) for l, i in label_idx), label_count_file)
            else:
                break
            v = v + 1

    if op.isfile(dataset.get_data('trainX')):
        # composite dataset.
        create_index_composite_dataset(dataset)

    populate_num_images_composite(dataset)

    add_node_to_ancestors(dataset)

    populate_all_label_counts(dataset)

    if check_box:
        populate_bbcount(dataset)

def create_label_bbcount(dataset, split, v):
    class_to_bbcount = defaultdict(int)
    logging.info('reading {}, {}, {}'.format(split, 'label', v))
    for key, str_rects in dataset.iter_data(split, 'label',
        v, progress=True):
        rects = json.loads(str_rects)
        for r in rects:
            if 'rect' in r and not all(x == 0 for x in r['rect']):
                c = r['class']
                class_to_bbcount[c] = class_to_bbcount[c] + 1
    labelmap = [l for l, in dataset.iter_data(split, 'labelmap',
            v)]
    dataset.write_data(((l, class_to_bbcount.get(l, 0)) for l in labelmap),
            split, 'label.bbcount', v)

def create_label_verifiedbbcount(dataset, split, v):
    class_to_bbcount = defaultdict(int)
    logging.info('reading {}, {}, {}'.format(split, 'label', v))
    for key, str_rects in dataset.iter_data(split, 'label',
        v, progress=True):
        rects = json.loads(str_rects)
        for r in rects:
            if 'rect' in r and \
                    not all(x == 0 for x in r['rect']) and \
                    is_verified_rect(r):
                c = r['class']
                class_to_bbcount[c] = class_to_bbcount[c] + 1
    labelmap = [l for l, in dataset.iter_data(split, 'labelmap',
            v)]
    dataset.write_data(((l, class_to_bbcount.get(l, 0)) for l in labelmap),
            split, 'label.verifiedbbcount', v)

def populate_bbcount(dataset):
    for split in get_default_splits():
        v = 0
        while True:
            if dataset.has(split, 'label', v):
                if not dataset.has(split, 'label.verifiedbbcount', v):
                    create_label_verifiedbbcount(dataset, split, v)
                if not dataset.has(split, 'label.bbcount', v):
                    create_label_bbcount(dataset, split, v)
                v = v + 1
            else:
                break

def populate_all_label_counts(dataset):
    for split in get_default_splits():
        v = 0
        while True:
            if dataset.has(split, 'inverted.label.count', v):
                if not dataset.has(split, 'inverted.label.count.total', v):
                    count = sum([int(count) for _, count in dataset.iter_data(split,
                        'inverted.label.count', v)])
                    dataset.write_data([(str(count),)],
                            split,
                            'inverted.label.count.total', v)
                v = v + 1
            else:
                break

def add_node_to_ancestors(dataset):
    tree_file = op.join(dataset._data_root, 'root.yaml')
    out_file = op.join(dataset._data_root, 'treenode_to_ancestors.tsv')
    if op.isfile(tree_file) and worth_create(tree_file, out_file):
        tax = Taxonomy(load_from_yaml_file(tree_file))
        tax.update()
        tsv_writer([[name, ','.join(tax.name_to_ancestors_list[name])] for name in
            tax.name_to_ancestors_list], out_file)

def populate_num_images_composite(dataset):
    data_with_bb = dataset.name + '_with_bb'
    data_no_bb = dataset.name + '_no_bb'
    datas = [data_with_bb, data_no_bb]
    datasets = [TSVDataset(d) for d in datas]
    suffixes = ['with_bb', 'no_bb']
    splits = ['train', 'test']
    dest_tree_file = op.join(dataset._data_root, 'root_enriched.yaml')
    src_tree_file = op.join(dataset._data_root, 'root.yaml')
    if op.isfile(dest_tree_file) or not op.isfile(src_tree_file):
        return
    tax = Taxonomy(load_from_yaml_file(src_tree_file))
    for split in splits:
        for suffix, d in zip(suffixes, datasets):
            if not d.has(split, 'inverted.label.count'):
                continue
            label_to_count_with_bb = {label: int(count) for label, count in d.iter_data(split,
                    'inverted.label.count')}
            for label in label_to_count_with_bb:
                count = label_to_count_with_bb[label]
                if not label.startswith('-'):
                    nodes = tax.root.search_nodes(name=label)
                else:
                    nodes = tax.root.search_nodes(name=label[1:])
                assert len(nodes) == 1, label
                node = nodes[0]
                if not label.startswith('-'):
                    node.add_feature('{}_{}'.format(suffix, split), count)
                else:
                    node.add_feature('{}_{}_neg'.format(suffix, split), count)
    write_to_yaml_file(tax.dump(), dest_tree_file)

def create_index_composite_dataset(dataset):
    split = 'train'
    splitx = split + 'X'
    fname_numImagesPerSource = dataset.get_data(splitx,
            'numImagesPerSource')
    if op.isfile(fname_numImagesPerSource):
        return
    # how many images are contributed from each data source
    trainX_file = dataset.get_data(splitx)
    source_tsvs = load_list_file(trainX_file)

    shuffle_file = dataset.get_shuffle_file(split)
    if not op.isfile(shuffle_file):
        return
    rows = tsv_reader(shuffle_file)
    all_idxSource_idxRow = []
    for idx_source, idx_row in rows:
        all_idxSource_idxRow.append((int(idx_source), int(idx_row)))
    # note, the data may be duplicated.
    all_idxSource_idxRow = list(set(all_idxSource_idxRow))

    idxSource_to_idxRows = list_to_dict(all_idxSource_idxRow, 0)
    num_images_per_datasource = [None] * len(source_tsvs)
    num_srcimages_per_datasource = [TSVFile(s).num_rows() for s in source_tsvs]
    for idxSource in idxSource_to_idxRows:
        assert num_images_per_datasource[idxSource] is None
        num_images_per_datasource[idxSource] = len(idxSource_to_idxRows[idxSource])
    tsv_writer([(name, str(num)) for name, num in zip(source_tsvs,
        num_images_per_datasource)], fname_numImagesPerSource)
    dataset.write_data([(source_tsvs[i], num_images_per_datasource[i], num_srcimages_per_datasource[i])
        for i in range(len(source_tsvs))], splitx,
        'tsvsource.numdestimages.numsrcimages')

    # for each data source, how many labels are contributed and how many are
    # not
    if op.isfile(dataset.get_data(splitx, 'origin.label')):
        source_tsv_label_files = load_list_file(dataset.get_data(splitx,
            'origin.label'))
        source_tsv_labels = [TSVFile(t) for t in source_tsv_label_files]
        trainX_label_file = dataset.get_data(splitx, 'label')
        all_dest_label_file = load_list_file(trainX_label_file)
        dest_labels = [TSVFile(f) for f in all_dest_label_file]
        all_idxSource_sourceLabel_destLabel = []
        logging.info('each datasource and each idx row')
        idxSource_to_numRect = {}
        all_idxSource_numSourceRects_numDestRects = []
        for idx_source, idx_row in tqdm(all_idxSource_idxRow):
            source_rects = json.loads(source_tsv_labels[idx_source].seek(idx_row)[-1])
            dest_rects = json.loads(dest_labels[idx_source].seek(idx_row)[-1])
            if idx_source not in idxSource_to_numRect:
                idxSource_to_numRect[idx_source] = 0
            idxSource_to_numRect[idx_source] = idxSource_to_numRect[idx_source] + \
                len(dest_rects)
            all_idxSource_numSourceRects_numDestRects.append((
                idx_source, len(source_rects), len(dest_rects)))
            for r in dest_rects:
                all_idxSource_sourceLabel_destLabel.append((idx_source,
                    r.get('class_from', r['class']), r['class']))
        idxSource_to_numSourceRects_numDestRects = list_to_dict(
                all_idxSource_numSourceRects_numDestRects, 0)
        idxSource_to_numSourceRects_numDestRect = {idxSource: [sum(x1 for x1, x2 in idxSource_to_numSourceRects_numDestRects[idxSource]),
                 sum(x2 for x1, x2 in idxSource_to_numSourceRects_numDestRects[idxSource])]
            for idxSource in idxSource_to_numSourceRects_numDestRects}

        dataset.write_data([(source_tsvs[idxSource],
            idxSource_to_numSourceRects_numDestRect[idxSource][1],
            idxSource_to_numSourceRects_numDestRect[idxSource][0])
            for idxSource in range(len(source_tsvs))],
            splitx, 'tsvsource.numdestbbs.numsrcbbs')

        sourcetsv_to_num_rect = {source_tsvs[idx_source]: idxSource_to_numRect[idx_source]
                for idx_source in idxSource_to_numRect}
        dataset.write_data([(s, sourcetsv_to_num_rect[s]) for s in source_tsvs],
            splitx, 'numRectsPerSource')

        idxSource_to_sourceLabel_destLabels = list_to_dict(
                all_idxSource_sourceLabel_destLabel, 0)
        source_numSourceLabels = [(s, 0) for s in source_tsvs]
        source_includedSourceLabels = [(s, []) for s in source_tsvs]
        for idxSource in idxSource_to_sourceLabel_destLabels:
            sourceLabel_destLabels = idxSource_to_sourceLabel_destLabels[idxSource]
            sourceLabel_to_destLabels = list_to_dict(sourceLabel_destLabels, 0)
            source_numSourceLabels[idxSource] = (source_tsvs[idxSource],
                    len(sourceLabel_to_destLabels))
            source_includedSourceLabels[idxSource][1].extend(
                    sourceLabel_to_destLabels.keys())

        dataset.write_data([(n, str(i)) for (n, i) in source_numSourceLabels],
                splitx, 'numCategoriesPerSource')

        # save teh list of included labels
        sourceDataset_to_includedSourceLabels = {}
        for source, sourceLabels in source_includedSourceLabels:
            source_dataset_name = op.basename(op.dirname(source))
            if source_dataset_name not in sourceDataset_to_includedSourceLabels:
                sourceDataset_to_includedSourceLabels[source_dataset_name] = []
            sourceDataset_to_includedSourceLabels[source_dataset_name].extend(sourceLabels)
        for source_dataset_name in sourceDataset_to_includedSourceLabels:
            sourceDataset_to_includedSourceLabels[source_dataset_name] = \
                    set(sourceDataset_to_includedSourceLabels[source_dataset_name])

        tsv_writer([(n, ','.join(sourceDataset_to_includedSourceLabels[n])) for n in
            sourceDataset_to_includedSourceLabels], op.join(dataset._data_root,
                'trainX.includeCategoriesPerSourceDataset.tsv'))

        tsv_writer([(n, get_nick_name(noffset_to_synset(s)) if is_noffset(s) else
            s) for n in sourceDataset_to_includedSourceLabels
              for s in sourceDataset_to_includedSourceLabels[n]],
              op.join(dataset._data_root, 'trainX.includeCategoriesPerSourceDatasetReadable.tsv'))

class TSVTransformer(object):
    def __init__(self):
        self._total_rows = 0
        self._row_processor = None

    def ReadProcess(self, source_tsv, row_processor):
        self._row_processor = row_processor
        self._total_rows = 0

        rows = tsv_reader(source_tsv)
        x = [self._over_row_processor(row) for row in rows]

        logging.info('total rows = {}; total_processed = {}'.format(self._total_rows,
                len(x)))

    def Process(self, source_tsv, dst_tsv, row_processor):
        '''
        row_processor: a function whose input should be a list of tsv cols and
                      whose return is also a list of tsv colums (will be saved into dst_tsv)
        '''
        self._row_processor = row_processor
        self._total_rows = 0

        rows = tsv_reader(source_tsv)
        result = (self._over_row_processor(row) for row in rows)
        tsv_writer(result, dst_tsv)

        logging.info('total rows = {}'.format(self._total_rows))

    def _over_row_processor(self, row):
        out = self._row_processor(row)
        self._total_rows = self._total_rows + 1
        if self._total_rows % 500 == 0:
            logging.info('processed = {}'.format(self._total_rows))
        return out

def randomize_tsv_file(tsv_file):
    prefix = os.path.splitext(tsv_file)[0]
    shuffle_file = prefix + '.shuffle'
    if os.path.exists(shuffle_file):
        return shuffle_file
    idx_file = prefix + '.lineidx'
    with open(idx_file, 'r') as fp:
        num = len([line for line in fp.readlines() if len(line.strip()) > 0])
    np.random.seed(777)
    nums = np.random.permutation(num)
    result = '\n'.join(map(str, nums))
    with open(shuffle_file, 'w') as fp:
        fp.write(result)
    return shuffle_file

def gen_tsv_from_labeling(input_folder, output_folder):
    fs = glob.glob(op.join(input_folder, '*'))
    labels = set()
    def gen_rows():
        for f in fs:
            im = cv2.imread(f, cv2.IMREAD_COLOR)
            if im is None:
                continue
            yaml_file = op.splitext(f)[0] + '.yaml'
            if not op.isfile(yaml_file):
                logging.info('{} not exist'.format(yaml_file))
            with open(yaml_file, 'r') as fp:
                bb_labels = yaml.loads(fp.read())
            for bb_label in bb_labels:
                labels.add(bb_label['class'])
            with open(f, 'r') as fp:
                encoded_im = base64.b64encode(fp.read())
            yield op.basename(f), json.dumps(bb_labels), encoded_im

    tsv_writer(gen_rows(), op.join(output_folder, 'train.tsv'))
    write_to_file('\n'.join(labels), op.join(output_folder, 'labelmap.txt'))

def try_json_parse(s):
    try:
        return json.loads(s)
    except ValueError:
        return s

def get_label_type(full_expid, predict_file):
    label_type = 'label'
    for row in tsv_reader(
        op.join('output', full_expid, 'snapshot', predict_file)):
        rects = json.loads(row[-1])
        if len(rects) > 0:
            if 'caption' in rects[0]:
                label_type = 'caption'
                break
    return label_type

def iter_full_expid_pred(
    full_expid, predict_file, start_id, threshold,
        label_type, label_version=None):
    test_data, test_data_split = parse_test_data(predict_file)
    pred_tsv = TSVFile(op.join('output', full_expid, 'snapshot', predict_file))
    num_total = len(pred_tsv)
    while start_id < 0:
        start_id += num_total
    test_dataset = TSVDataset(test_data)
    iter_image = test_dataset.iter_data(
        test_data_split,
        filter_idx=range(start_id, num_total))
    has_gt = test_dataset.has(test_data_split, t=label_type, version=label_version)
    if has_gt:
        iter_gt = test_dataset.iter_data(test_data_split, t=label_type,
                                     version=label_version,
                                     filter_idx=range(start_id, num_total))
    for i, row_image in enumerate(iter_image):
        key = row_image[0]
        if has_gt:
            row_gt = next(iter_gt)
            str_gt = row_gt[-1]
            key = row_gt[0]
            rects_gt = json.loads(str_gt)
            if not isinstance(rects_gt, list):
                rects_gt = [{'class': str(rects_gt)}]
        else:
            rects_gt = []
        str_im = row_image[-1]
        pred_key, str_pred = pred_tsv[i + start_id]
        assert pred_key == key, (i,pred_key,key)
        im = img_from_base64(str_im)
        rects_pred = [r for r in json.loads(str_pred) if r['conf'] > threshold]
        yield {
            'key': key,
            'im': im,
            'rects_gt': rects_gt,
            'rects_pred': rects_pred,
        }

def visualize_predict_no_draw(full_expid, predict_file, label, start_id,
        threshold):
    test_data, test_data_split = parse_test_data(predict_file)
    logging.info('{}->{}/{}'.format(predict_file, test_data, test_data_split))
    pred_full_path = op.join('output', full_expid, 'snapshot', predict_file)
    pred_key_path = '{}.key.tsv'.format(pred_full_path)
    pred_label_path = '{}.labelmap.th{}.tsv'.format(pred_full_path,
            threshold)
    pred_inverted_path = '{}.inverted.th{}.tsv'.format(pred_full_path,
            threshold)
    pred_sorted_cache_path = '{}.key_idxGT_idxPred_ap.th{}.{}.tsv'.format(
            pred_full_path, threshold, label)

    test_dataset = TSVDataset(test_data)
    if not op.isfile(pred_sorted_cache_path):
        if not op.isfile(pred_key_path) or \
                not op.isfile(pred_label_path) or \
                not op.isfile(pred_inverted_path):
            logging.info('loading {}'.format(pred_full_path))
            inverted, pred_keys = create_inverted_list2(
                    tsv_reader(pred_full_path), threshold)
            pred_labels = inverted.keys()
            logging.info('writing {}'.format(pred_key_path))
            tsv_writer([[k] for k in pred_keys], pred_key_path)
            tsv_writer(([l] for l in pred_labels), pred_label_path)
            tsv_writer(((l, ' '.join(map(str, inverted[l]))) for l in
                    pred_labels), pred_inverted_path)
        keys_from_pred = []
        labelmap = load_list_file(pred_label_path)
        pred_keys = load_list_file(pred_key_path)
        if label in labelmap:
            inverted_row = TSVFile(pred_inverted_path).seek(labelmap.index(label))
            assert inverted_row[0] == label
            assert len(inverted_row) == 2
            idx_from_pred = map(int, inverted_row[1].split(' '))
            keys_from_pred = [pred_keys[i] for i in idx_from_pred]
        else:
            keys_from_pred = []
        inverted_test_split = test_dataset.load_inverted_label(test_data_split, version=-1,
                label=label)
        if label in inverted_test_split:
            idx_from_gt = inverted_test_split[label]
        else:
            idx_from_gt = []
        rows = test_dataset.iter_data(test_data_split, t='label', version=-1,
                filter_idx=idx_from_gt, unique=True)
        keys_from_gt = [row[0] for row in rows]
        target_keys = list(set(keys_from_pred + keys_from_gt))
        target_keys = [k for k in target_keys if k in pred_keys]
        target_idx_in_pred = [pred_keys.index(k) for k in target_keys]
        gt_keys = test_dataset.load_keys(test_data_split)
        target_idx_in_gt = [gt_keys.index(k) for k in target_keys]
        rows_in_gt = test_dataset.iter_data(test_data_split, t='label', version=-1,
                filter_idx=target_idx_in_gt)
        pred_tsv = TSVFile(pred_full_path)
        rows_in_pred = (pred_tsv.seek(i) for i in target_idx_in_pred)
        target_aps = []
        for row_in_gt, row_in_pred in zip(rows_in_gt, rows_in_pred):
            assert row_in_gt[0] == row_in_pred[0]
            assert len(row_in_gt) == 2
            assert len(row_in_pred) == 2
            rects_gt = json.loads(row_in_gt[1])
            rects_pred = json.loads(row_in_pred[1])
            rects_gt = [r for r in rects_gt if r['class'] == label]
            rects_pred = [r for r in rects_pred if r['class'] == label]
            ap = calculate_image_ap([r['rect'] for r in rects_gt if 'rect' in r],
                    [r['rect'] for r in rects_pred])
            target_aps.append(ap)
        key_idxGT_idxPred_aps = zip(target_keys, target_idx_in_gt,
                target_idx_in_pred, target_aps)
        key_idxGT_idxPred_aps = sorted(key_idxGT_idxPred_aps, key=lambda x:
                x[-1])
        tsv_writer(key_idxGT_idxPred_aps, pred_sorted_cache_path)

    tsv = TSVFile(pred_sorted_cache_path)
    total_num = tsv.num_rows()
    if total_num == 0:
        return
    while start_id < 0:
        start_id = start_id + total_num
    while start_id >= total_num:
        start_id = start_id - total_num
    i = start_id
    tsv_pred = TSVFile(pred_full_path)
    for i in range(start_id, total_num):
        key, idx_gt, idx_pred, ap = tsv.seek(i)
        idx_gt, idx_pred, ap = int(idx_gt), int(idx_pred), float(ap)
        row_gt = next(test_dataset.iter_data(test_data_split,
            filter_idx=[idx_gt]))
        row_pred = tsv_pred.seek(idx_pred)
        assert row_gt[0] == row_pred[0], (row_gt[0], row_pred[0])

        rects_gt = json.loads(next(test_dataset.iter_data(test_data_split, 'label',
            filter_idx=[idx_gt], version=-1))[1])

        rects_pred = json.loads(row_pred[1])
        rects_pred = [r for r in rects_pred if r['conf'] > threshold]
        im_origin = img_from_base64(row_gt[-1])
        yield key, im_origin, rects_gt, rects_pred, ap

def visualize_predict(full_expid, predict_file, label, start_id, threshold):
    test_data, test_data_split = parse_test_data(predict_file)
    pred_full_path = op.join('output', full_expid, 'snapshot', predict_file)
    pred_key_path = '{}.key.tsv'.format(pred_full_path)
    pred_label_path = '{}.labelmap.th{}.tsv'.format(pred_full_path,
            threshold)
    pred_inverted_path = '{}.inverted.th{}.tsv'.format(pred_full_path,
            threshold)
    pred_sorted_cache_path = '{}.key_idxGT_idxPred_ap.th{}.{}.tsv'.format(
            pred_full_path, threshold, label)

    test_dataset = TSVDataset(test_data)
    if not op.isfile(pred_sorted_cache_path):
        if not op.isfile(pred_key_path) or \
                not op.isfile(pred_label_path) or \
                not op.isfile(pred_inverted_path):
            logging.info('loading {}'.format(pred_full_path))
            inverted, pred_keys = create_inverted_list2(
                    tsv_reader(pred_full_path), threshold)
            pred_labels = inverted.keys()
            logging.info('writing {}'.format(pred_key_path))
            tsv_writer([[k] for k in pred_keys], pred_key_path)
            tsv_writer(([l] for l in pred_labels), pred_label_path)
            tsv_writer(((l, ' '.join(map(str, inverted[l]))) for l in
                    pred_labels), pred_inverted_path)
        keys_from_pred = []
        labelmap = load_list_file(pred_label_path)
        pred_keys = load_list_file(pred_key_path)
        if label in labelmap:
            inverted_row = TSVFile(pred_inverted_path).seek(labelmap.index(label))
            assert inverted_row[0] == label
            assert len(inverted_row) == 2
            idx_from_pred = map(int, inverted_row[1].split(' '))
            keys_from_pred = [pred_keys[i] for i in idx_from_pred]
        else:
            keys_from_pred = []
        inverted_test_split = test_dataset.load_inverted_label(test_data_split, version=-1,
                label=label)
        if label in inverted_test_split:
            idx_from_gt = inverted_test_split[label]
        else:
            idx_from_gt = []
        rows = test_dataset.iter_data(test_data_split, t='label', version=-1,
                filter_idx=idx_from_gt, unique=True)
        keys_from_gt = [row[0] for row in rows]
        target_keys = list(set(keys_from_pred + keys_from_gt))
        target_keys = [k for k in target_keys if k in pred_keys]
        target_idx_in_pred = [pred_keys.index(k) for k in target_keys]
        gt_keys = test_dataset.load_keys(test_data_split)
        target_idx_in_gt = [gt_keys.index(k) for k in target_keys]
        rows_in_gt = test_dataset.iter_data(test_data_split, t='label', version=-1,
                filter_idx=target_idx_in_gt)
        pred_tsv = TSVFile(pred_full_path)
        rows_in_pred = (pred_tsv.seek(i) for i in target_idx_in_pred)
        target_aps = []
        for row_in_gt, row_in_pred in zip(rows_in_gt, rows_in_pred):
            assert row_in_gt[0] == row_in_pred[0]
            assert len(row_in_gt) == 2
            assert len(row_in_pred) == 2
            rects_gt = json.loads(row_in_gt[1])
            rects_pred = json.loads(row_in_pred[1])
            rects_gt = [r for r in rects_gt if r['class'] == label]
            rects_pred = [r for r in rects_pred if r['class'] == label]
            ap = calculate_image_ap([r['rect'] for r in rects_gt],
                    [r['rect'] for r in rects_pred])
            target_aps.append(ap)
        key_idxGT_idxPred_aps = zip(target_keys, target_idx_in_gt,
                target_idx_in_pred, target_aps)
        key_idxGT_idxPred_aps = sorted(key_idxGT_idxPred_aps, key=lambda x:
                x[-1])
        tsv_writer(key_idxGT_idxPred_aps, pred_sorted_cache_path)

    tsv = TSVFile(pred_sorted_cache_path)
    total_num = tsv.num_rows()
    if total_num == 0:
        return
    while start_id < 0:
        start_id = start_id + total_num
    while start_id >= total_num:
        start_id = start_id - total_num
    i = start_id
    tsv_pred = TSVFile(pred_full_path)
    for i in range(start_id, total_num):
        key, idx_gt, idx_pred, ap = tsv.seek(i)
        idx_gt, idx_pred, ap = int(idx_gt), int(idx_pred), float(ap)
        row_gt = next(test_dataset.iter_data(test_data_split,
            filter_idx=[idx_gt]))
        row_pred = tsv_pred.seek(idx_pred)
        assert row_gt[0] == row_pred[0], (row_gt[0], row_pred[0])

        rects_gt = json.loads(row_gt[1])
        rects_pred = json.loads(row_pred[1])
        rects_pred = [r for r in rects_pred if r['conf'] > threshold]
        rects_gt_target = [r for r in rects_gt if r['class'] == label]
        rects_pred_target = [r for r in rects_pred if r['class'] == label]
        if len(rects_gt_target) == 0 and len(rects_pred_target) == 0:
            logging.info('skipping to next')
            continue
        im_origin = img_from_base64(row_gt[-1])
        im_gt_target = np.copy(im_origin)
        draw_bb(im_gt_target, [r['rect'] for r in rects_gt_target],
                [r['class'] for r in rects_gt_target])
        im_pred_target = np.copy(im_origin)
        draw_bb(im_pred_target, [r['rect'] for r in rects_pred_target],
                [r['class'] for r in rects_pred_target])
        im_gt = np.copy(im_origin)
        draw_bb(im_gt, [r['rect'] for r in rects_gt],
                [r['class'] for r in rects_gt])
        im_pred = np.copy(im_origin)
        draw_bb(im_pred, [r['rect'] for r in rects_pred],
                [r['class'] for r in rects_pred])
        yield key, im_origin, im_gt_target, im_pred_target, im_gt, im_pred, ap

def visualize_box_no_draw(data, split, version, label, start_id, color_map={},
                          split_type='label',
        min_conf=-1, max_conf=2):
    dataset = TSVDataset(data)
    if split is None:
        # guess which split should be used. only support non-composite tsv
        candidate_split = get_default_splits()
        for c in candidate_split:
            if not op.isfile(dataset.get_data(c)):
                continue
            inverted = dataset.load_inverted_label(c, version, label)
            if label not in inverted:
                continue
            n = len(inverted[label])
            if n <= start_id:
                start_id = start_id - n
            else:
                logging.info('split = {}'.format(split))
                split = c
                break
        if not split:
            logging.info('cannot find the valid')
            return
    if label is not None:
        logging.info('loading inverted label')
        idx = dataset.load_inverted_label(split, version, label)[label]
        curr_num_image = len(idx)
    else:
        curr_num_image = dataset.num_rows(split, t=split_type, version=version)
    if curr_num_image == 0:
        logging.info('there is no image')
        return
    while start_id > curr_num_image:
        start_id = start_id - curr_num_image
    while start_id < 0:
        start_id = start_id + curr_num_image
    if label is not None:
        filter_idx = idx[start_id:]
    else:
        filter_idx = range(start_id, curr_num_image)
    logging.info('start to read')
    rows_image = dataset.iter_data(split, filter_idx=filter_idx)
    rows_label = dataset.iter_data(split, split_type, version=version,
            filter_idx=filter_idx)
    for idx_row, (row_image, row_label) in enumerate(zip(rows_image, rows_label)):
        key = row_image[0]
        assert key == row_label[0], (key, row_label[0], idx_row)
        assert len(row_label) == 2
        label_str = row_label[-1]
        img_str = row_image[-1]
        im = img_from_base64(img_str)
        assert im is not None
        origin = np.copy(im)
        rects = try_json_parse(label_str)
        if type(rects) is list:
            if label is not None:
                rects = [r for r in rects if \
                        r['class'] == label and \
                        r.get('conf', 1) >= min_conf and \
                        r.get('conf', 1) <= max_conf or r['class'] != label]
                if all(r['class'] != label for r in rects):
                    continue
            yield (key, origin, rects)
        else:
            yield key, origin, [{'class': label_str, 'rect': [0, 0, 0, 0]}]

def visualize_box(data, split, version, label, start_id, color_map={}):
    dataset = TSVDataset(data)
    logging.info('loading inverted label')
    if split is None:
        # guess which split should be used. only support non-composite tsv
        candidate_split = get_default_splits()
        for c in candidate_split:
            if not op.isfile(dataset.get_data(c)):
                continue
            inverted = dataset.load_inverted_label(c, version, label)
            if label not in inverted:
                continue
            n = len(inverted[label])
            if n <= start_id:
                start_id = start_id - n
            else:
                logging.info('split = {}'.format(split))
                split = c
                break
        if not split:
            logging.info('cannot find the valid')
            return
    else:
        inverted = dataset.load_inverted_label(split, version, label)
    logging.info('inverted label loaded')
    logging.info('keys: {}'.format(inverted.keys()))
    if label not in inverted:
        return
    idx = inverted[label]
    if len(idx) == 0:
        return
    while start_id > len(idx):
        start_id = start_id - len(idx)
    while start_id < 0:
        start_id = start_id + len(idx)
    logging.info('start to read')
    rows_image = dataset.iter_data(split, filter_idx=idx[start_id:])
    rows_label = dataset.iter_data(split, 'label', version=version,
            filter_idx=idx[start_id:])
    for row_image, row_label in zip(rows_image, rows_label):
        key = row_image[0]
        assert key == row_label[0]
        assert len(row_image) == 3
        assert len(row_label) == 2
        label_str = row_label[-1]
        img_str = row_image[-1]
        im = img_from_base64(img_str)
        origin = np.copy(im)
        rects = try_json_parse(label_str)
        new_name = key.replace('/', '_').replace(':', '')
        if type(rects) is list:
            #rects = [l for l in rects if 'conf' not in l or l['conf'] > 0.3]
            def get_rect_class(rects):
                all_class = []
                all_rect = []
                for rect in rects:
                    label_class = rect['class']
                    rect = rect['rect']
                    all_class.append(label_class)
                    if not (rect[0] == 0 and rect[1] == 0
                            and rect[2] == 0 and rect[3] == 0):
                        all_rect.append(rect)
                    else:
                        all_rect.append((0, 0, im.shape[1] - 1, im.shape[0] - 1))
                return all_rect, all_class
            all_rect, all_class = get_rect_class(rects)
            draw_bb(im, all_rect, all_class)
            target_rects = [l for l in rects if l['class']
                    == label]
            all_rect, all_class = get_rect_class(target_rects)
            im_label = np.copy(origin)
            draw_bb(im_label, all_rect, all_class)
            yield new_name, origin, im_label, im, pformat(target_rects)
        else:
            yield new_name, origin, im, im, ''


def visualize_tsv2(data, split, label):
    '''
    by default, pass split as 'train'
    TODO: try to refactor it with visualize_box
    '''
    dataset = TSVDataset(data)
    logging.info('loading inverted label')
    inverted = dataset.load_inverted_label(split)
    logging.info('inverted label loaded')
    logging.info('keys: {}'.format(inverted.keys()))
    assert label in inverted
    idx = inverted[label]
    is_composite = False
    if split == 'train' and not op.isfile(dataset.get_data(split)):
        is_composite = True
        tsvs = [TSVFile(f) for f in dataset.get_train_tsvs()]
        shuffle_tsv_rows = tsv_reader(dataset.get_shuffle_file(split))
        shuffle = []
        for row in shuffle_tsv_rows:
            shuffle.append([int(row[0]), int(row[1])])
    else:
        tsv = TSVFile(dataset.get_data(split))
    num_image = 0
    num_rows = 2
    num_cols = 2
    num_image_one_fig = num_rows * num_cols
    idx.extend([0] * (num_image_one_fig - len(idx) % num_image_one_fig))
    idx = np.asarray(idx)
    idx = idx.reshape((-1, num_image_one_fig))
    logging.info('start to read')
    color_map = {}
    for i in idx:
        all_image = []
        for j in i:
            logging.info(j)
            if is_composite:
                row_image = tsvs[shuffle[j][0]].seek(shuffle[j][1])
            else:
                row_image = tsv.seek(j)
            im = img_from_base64(row_image[-1])
            labels = try_json_parse(row_image[1])
            num_image = num_image + 1
            if type(labels) is list:
                labels = [l for l in labels if 'conf' not in l or l['conf'] > 0.3]
                all_class = []
                all_rect = []
                for label in labels:
                    label_class = label['class']
                    rect = label['rect']
                    all_class.append(label_class)
                    if not (rect[0] == 0 and rect[1] == 0
                            and rect[2] == 0 and rect[3] == 0):
                        all_rect.append(rect)
                    else:
                        all_rect.append((0, 0, im.shape[1] - 1, im.shape[0] - 1))
                new_name = row_image[0].replace('/', '_').replace(':', '')
                draw_bb(im, all_rect, all_class, color=color_map)
            all_image.append(im)
        logging.info('start to show')
        show_images(all_image, num_rows, num_cols)

    logging.info('#image: {}'.format(num_image))

def visualize_tsv(tsv_image, tsv_label, out_folder=None, label_idx=1):
    '''
    deprecated, use visualize_tsv2
    '''
    rows_image = tsv_reader(tsv_image)
    rows_label = tsv_reader(tsv_label)
    assert out_folder == None or not op.exists(out_folder)
    source_folder = op.dirname(tsv_image)
    num_image = 0
    for row_image, row_label in zip(rows_image, rows_label):
        assert row_image[0] == row_label[0]
        im = img_from_base64(row_image[-1])
        labels = try_json_parse(row_label[label_idx])
        num_image = num_image + 1
        if type(labels) is list:
            labels = [l for l in labels if 'conf' not in l or l['conf'] > 0.3]
            all_class = []
            all_rect = []
            for label in labels:
                label_class = label['class']
                rect = label['rect']
                all_class.append(label_class)
                if not (rect[0] == 0 and rect[1] == 0
                        and rect[2] == 0 and rect[3] == 0):
                    all_rect.append(rect)
                else:
                    all_rect.append((0, 0, im.shape[1] - 1, im.shape[0] - 1))
            new_name = row_image[0].replace('/', '_').replace(':', '')
            draw_bb(im, all_rect, all_class)
            if out_folder:
                fname = os.path.join(out_folder,
                        '_'.join(set(c.replace(' ', '_') for c in all_class)),
                        new_name +'.png')
        else:
            fname = op.join(out_folder, row_image[0],
                    '{}_{}_{}.png'.format(num_image, labels, row_image[0]))
        if out_folder:
            save_image(im, fname)
        else:
            show_image(im)

    logging.info('#image: {}'.format(num_image))

def iou(wh1, wh2):
    w1, h1 = wh1
    w2, h2 = wh2
    return min(w1, w2) * min(h1, h2) / max(w1, w2) / max(h1, h2)

class ImageTypeParser(object):
    def __init__(self):
        self.m = None
        pass

    def parse_type(self, im_binary):
        return imghdr.what('', im_binary)
        self._ensure_init()
        mime_type = self.m.buffer(im_binary)
        t = op.basename(mime_type)
        return t

    def _ensure_init(self):
        if self.m is None:
            import magic
            #m = magic.open(magic.MAGIC_MIME_TYPE)
            m = magic.from_file(magic.MAGIC_MIME_TYPE)
            m.load()
            self.m = m

def collect_label(row, stat, **kwargs):
    labels = json.loads(row[1])
    labels = [label['class'] for label in labels]
    remove_labels = kwargs['remove_image'].split(',')
    is_remove = False
    for label in labels:
        if label in remove_labels or remove_labels == 'all':
            if random.random() <= kwargs['remove_image_prob']:
                is_remove = True
                break

    stat.append((is_remove, labels))

class TSVDatasetSource(TSVDataset):
    def __init__(self, name, root=None,
            split_infos=None,
            cleaness=10,
            use_all=False,
            use_negative_label=False,
            select_by_verified=False):
        super(TSVDatasetSource, self).__init__(name)
        self._noffset_count = {}
        self._type = None
        self._root = root
        # the list of <datasetlabel, rootlabel>
        self._sourcelabel_to_targetlabels = None
        self._targetlabel_to_sourcelabels = None
        self._initialized = False
        self._type_to_datasetlabel_to_split_idx = None
        self._type_to_datasetlabel_to_count = None
        self._type_to_split_label_idx = None
        if split_infos is not None:
            self._split_infos = split_infos
        else:
            self._split_infos = [{'split': s, 'version': -1}
                    for s in get_default_splits()]
        assert len(set([split_info['split'] for split_info in
            self._split_infos])) == len(self._split_infos)
        self._use_all = use_all
        self._select_by_verified = select_by_verified
        self.cleaness = cleaness
        self.use_negative_label = use_negative_label

    def get_version_by_split(self, split_name):
        for split_info in self._split_infos:
            if split_info['split'] == split_name:
                return split_info['version']
        return -1

    def get_label_tsv(self, split_name):
        version_by_config = self.get_version_by_split(split_name)
        return super(TSVDatasetSource, self).get_data(split_name, 'label',
                version_by_config)

    def populate_info(self, root):
        self._ensure_initialized()
        for node in root.iter_search_nodes():
            if root == node:
                continue
            if node.name in self._targetlabel_to_sourcelabels:
                sourcelabels = self._targetlabel_to_sourcelabels[node.name]
                node.add_feature(self.name, ','.join(sourcelabels))
                if any(is_noffset(l) for l in sourcelabels):
                    node.add_feature(self.name + '_readable',
                            ','.join(get_nick_name(noffset_to_synset(l)) if
                                is_noffset(l) else l for l in sourcelabels))
                total = 0
                for sourcelabel in sourcelabels:
                    for t in self._type_to_datasetlabel_to_count:
                        datasetlabel_to_count = self._type_to_datasetlabel_to_count[t]
                        c = datasetlabel_to_count.get(sourcelabel, 0)
                        total = total + c
                        key = 'images_{}'.format(t)
                        node.add_feature(key,
                                node.__getattribute__(key) + c)
                node.add_feature('{}_total'.format(self.name), total)

    def _ensure_initialized(self):
        if self._initialized:
            return
        populate_dataset_details(self.name)

        self.update_label_mapper()

        self._load_inverted()

        self._initialized = True

    def _load_inverted(self):
        # make sure self.update_label_mapper() is called
        types = ['with_bb', 'no_bb']
        self._type_split_label_idx = []
        for split_info in self._split_infos:
            split = split_info['split']
            version = split_info['version']
            logging.info('loading the inverted file: {}-{}'.format(self.name,
                split))
            if not self.has(split, 'label', version=version):
                continue
            # load inverted list
            type_to_inverted = {}
            for i, t in enumerate(types):
                if self._select_by_verified:
                    inverted_label_type = 'inverted.label.{}.verified'.format(t)
                else:
                    inverted_label_type = 'inverted.label.{}'.format(t)
                rows = self.iter_data(split, inverted_label_type,
                        version=version)
                type_to_inverted[t] = {r[0]: map(int, r[1].split(' '))
                        for r in tqdm(rows) if
                    r[0] in self._sourcelabel_to_targetlabels and
                    len(r[1]) > 0}

            # register the positive labels
            for i, t in enumerate(types):
                inverted = type_to_inverted[t]
                inverted = {l: inverted[l] for l in inverted if not l.startswith('-')}
                label_idx = dict_to_list(inverted, 0)
                for label, idx in label_idx:
                    self._type_split_label_idx.append((t, split, label, idx))
                    # for no_bb, we need to add the with_bb into the list
                    if t == 'with_bb':
                        self._type_split_label_idx.append(('no_bb', split, label, idx))

            if self.use_negative_label:
                # currently, we only have a scenario where we have negative
                # annotations in the no_bb data source and the need to apply it
                # to no_bb target set.
                inverted = type_to_inverted['no_bb']
                inverted = {l: inverted[l] for l in inverted if l.startswith('-')}
                label_idx = dict_to_list(inverted, 0)
                for label, idx in label_idx:
                    #self._type_split_label_idx.append(('with_bb', split, label, idx))
                    self._type_split_label_idx.append(('no_bb', split, label, idx))

        self._type_split_label_idx = list(set(self._type_split_label_idx))
        self._type_to_split_label_idx = list_to_dict(
                self._type_split_label_idx, 0)
        self._type_to_datasetlabel_to_split_idx = {}
        for t in self._type_to_split_label_idx:
            split_label_idx = self._type_to_split_label_idx[t]
            label_to_split_idx = list_to_dict(split_label_idx, 1)
            self._type_to_datasetlabel_to_split_idx[t] = label_to_split_idx
        self._type_to_datasetlabel_to_count = {}
        for t in self._type_to_datasetlabel_to_split_idx:
            datasetlabel_to_split_idx = self._type_to_datasetlabel_to_split_idx[t]
            datasetlabel_to_count = {l: len(datasetlabel_to_split_idx[l]) for l in
                    datasetlabel_to_split_idx}
            self._type_to_datasetlabel_to_count[t] = datasetlabel_to_count

        self._split_to_num_image = {split_info['split']: self.num_rows(split_info['split']) for split_info in
                self._split_infos if self.has(split_info['split'])}

    def update_label_mapper(self):
        root = self._root
        # load the labelmap for all splits, self.load_labelmap is not correct,
        # since we will update the label and will not update the labelmap
        labelmap = []
        for split_info in self._split_infos:
            split, version = split_info['split'], split_info['version']
            if self.has(split, 'labelmap', version):
                for row in self.iter_data(split, 'labelmap', version):
                    labelmap.append(row[0])
        # if it has a prefix of -, it means it has no that tag.
        labelmap = [l for l in labelmap if not l.startswith('-')]
        hash_labelmap = set(labelmap)
        labelmap = list(hash_labelmap)

        tree_noffsets = {}
        for node in root.iter_search_nodes():
            if node == root or not node.noffset:
                continue
            for s in node.noffset.split(','):
                tree_noffsets[s] = node.name
        name_to_targetlabels = {}
        targetlabel_has_whitelist = set()
        invalid_list = []
        any_source_key = 'label_names_in_all_dataset_source'
        for node in root.iter_search_nodes():
            if node == root:
                continue
            if hasattr(node, self.name) or hasattr(node, any_source_key):
                if hasattr(node, self.name):
                    # this is like a white-list
                    values = node.__getattribute__(self.name)
                else:
                    values = node.__getattribute__(any_source_key)
                if values is not None:
                    source_terms = values.split(',')
                    for t in source_terms:
                        t = t.strip()
                        if t not in name_to_targetlabels:
                            name_to_targetlabels[t] = set()
                        if t not in hash_labelmap:
                            invalid_list.append((t, self.name, node.name))
                            continue
                        name_to_targetlabels[t].add(node.name)
                # even if it is None, we will also add it to white-list so that
                # we will not automatically match the term.
                targetlabel_has_whitelist.add(node.name)
            else:
                # we will keep the lower case always for case-insensitive
                # comparison
                all_candidate_src_names = [node.name.lower()]
                if hasattr(node, 'alias_names'):
                    all_candidate_src_names.extend([s.strip() for s in
                        node.alias_names.split(',')])
                for t in set(all_candidate_src_names):
                    if t not in name_to_targetlabels:
                        name_to_targetlabels[t] = set()
                    name_to_targetlabels[t].add(node.name)

        sourcelabel_targetlabel = []
        if len(invalid_list) != 0:
            logging.warn('invalid white list information: {}'.format(pformat(invalid_list)))

        #result = {}
        label_to_synset = LabelToSynset()
        for l in labelmap:
            matched = False
            if l.lower() in name_to_targetlabels:
                matched = True
                for t in name_to_targetlabels[l.lower()]:
                    sourcelabel_targetlabel.append((l, t))
            if l in name_to_targetlabels:
                for t in name_to_targetlabels[l]:
                    sourcelabel_targetlabel.append((l, t))
                matched = True
            if not matched:
                succeed, ns = label_to_synset.convert(l)
                if not succeed:
                    continue
                for n in ns:
                    n = synset_to_noffset(n)
                    if n in tree_noffsets:
                        t = tree_noffsets[n]
                        if t in targetlabel_has_whitelist:
                            # if it has white list, we will not respect the
                            # noffset to do the autmatic matching
                            continue
                        sourcelabel_targetlabel.append((l, t))
                        #result[l] = t
        if self.use_negative_label:
            # we just add the mapping here. no need to check if -s is in the
            # source label list
            sourcelabel_targetlabel.extend([('-' + s, '-' + t) for s, t in
                sourcelabel_targetlabel])

        self._sourcelabel_to_targetlabels = list_to_dict_unique(sourcelabel_targetlabel,
                0)
        self._targetlabel_to_sourcelabels = list_to_dict_unique(sourcelabel_targetlabel,
                1)

        return self._sourcelabel_to_targetlabels

    def select_tsv_rows(self, label_type):
        self._ensure_initialized()
        result = []
        if label_type in self._type_to_split_label_idx:
            split_label_idx = self._type_to_split_label_idx[label_type]
            datasetlabel_to_splitidx = list_to_dict(split_label_idx, 1)
            for datasetlabel in datasetlabel_to_splitidx:
                if datasetlabel in self._sourcelabel_to_targetlabels:
                    split_idxes = datasetlabel_to_splitidx[datasetlabel]
                    targetlabels = self._sourcelabel_to_targetlabels[datasetlabel]
                    for targetlabel in targetlabels:
                        result.extend([(targetlabel, split, idx) for split, idx in
                            split_idxes])
        # must_have_indices
        for split_info in self._split_infos:
            split = split_info['split']
            must_have_indices = split_info.get('must_have_indices', [])
            # we set the target label here as None so that the post-processing
            # will not ignore it. The real labels will also be converted
            # corrected since we do not depend on this target label only.
            result.extend((None, split, i) for i in must_have_indices)
        if self._use_all:
            split_to_targetlabel_idx = list_to_dict(result, 1)
            for s in split_to_targetlabel_idx:
                rootlabel_idxes = split_to_targetlabel_idx[s]
                idx_to_rootlabel = list_to_dict(rootlabel_idxes, 1)
                num_image = self._split_to_num_image[s]
                idxes = set(range(num_image)).difference(set(idx_to_rootlabel.keys()))
                for i in idxes:
                    # for these images, the root label is hard-coded as None
                    result.append((None, s, i))
            for split_info in self._split_infos:
                s = split_info['split']
                if s in split_to_targetlabel_idx:
                    continue
                if s not in self._split_to_num_image:
                    continue
                result.extend([(None, s, i) for i in
                    range(self._split_to_num_image[s])])
        return result

def initialize_images_count(root):
    for node in root.iter_search_nodes():
        node.add_feature('images_with_bb', 0)
        node.add_feature('images_no_bb', 0)

def trainval_split(dataset, num_test_each_label):
    if op.isfile(dataset.get_train_tsv()):
        logging.info('skip to run trainval split for {} because it has been done'.format(
            dataset.name))
        return
    random.seed(777)
    label_to_idx = {}
    for i, row in enumerate(tsv_reader(dataset.get_trainval_tsv('label'))):
        rects = json.loads(row[1])
        if len(rects) == 0:
            logging.info('{} has empty label for {}'.format(dataset.name, i))
            continue
        random.shuffle(rects)
        label = rects[0]['class']
        if label in label_to_idx:
            label_to_idx[label].append(i)
        else:
            label_to_idx[label] = [i]

    test_idx = []
    train_idx = []
    for label in label_to_idx:
        if len(label_to_idx[label]) < num_test_each_label:
            logging.fatal('dataset {} has less than {} images for label {}'.
                    format(dataset.name, num_test_each_label, label))
        random.shuffle(label_to_idx[label])
        test_idx.extend(label_to_idx[label][: num_test_each_label])
        train_idx.extend(label_to_idx[label][num_test_each_label: ])

    trainval = TSVFile(dataset.get_trainval_tsv())

    def gen_train():
        for i in train_idx:
            row = trainval.seek(i)
            yield row
    tsv_writer(gen_train(), dataset.get_train_tsv())

    def gen_test():
        for i in test_idx:
            yield trainval.seek(i)
    tsv_writer(gen_test(), dataset.get_test_tsv_file())

def convert_one_label(rects, label_mapper):
    to_remove = []
    rects2 = []
    for rect in rects:
        if rect['class'] in label_mapper:
            for t in label_mapper[rect['class']]:
                r2 = copy.deepcopy(rect)
                assert type(t) is str or type(t) is unicode
                r2['class'] = t
                rects2.append(r2)
    rects[:] = []
    rects.extend(rects2)

def convert_label_by_dataset(dataset, split, version, idx, label_mapper, with_bb):
    result = None
    for i, row in zip(idx, dataset.iter_data(split, 'label', version=version,
        filter_idx=idx)):
        assert len(row) == 2
        rects = json.loads(row[1])
        def eval_with_bb(r):
            if not r['class'].startswith('-'):
                return 'rect' in r and any(x != 0 for x in r['rect'])
            else:
                return 'rect' not in r or all(x == 0 for x in r['rect'])
        if with_bb:
            # in the case with -, we will not add rect
                                # with all zeros, thus, no need to check if it is all zeros
                                # when it is negative samples
            rects = [r for r in rects if eval_with_bb(r)]
        # all annotations if eval_with_bb(r) is valid for no_bb. Thus, disable
        # the following
        #else:
            #rects = [r for r in rects if not eval_with_bb(r)]
        if result is None:
            # don't use this, because all list will be shared
            #result = [len(row) * ['d']] * tsv.num_rows()
            result = [None] * dataset.num_rows(split)
            for _ in range(len(result)):
                result[_] = ['d'] * len(row)
        rects2 = []
        # the following code should use convert_one_label
        for rect in rects:
            if rect['class'] in label_mapper:
                for t in label_mapper[rect['class']]:
                    r2 = copy.deepcopy(rect)
                    r2['class'] = t
                    if rect['class'] != t:
                        # keep this for logging
                        r2['class_from'] = rect['class']
                    rects2.append(r2)
        row[1] = rects2
        result[i] = row
    return result

def convert_label(label_tsv, idx, label_mapper, with_bb):
    tsv = TSVFile(label_tsv)
    result = None
    for i in tqdm(idx):
        row = tsv.seek(i)
        assert len(row) == 2
        rects = json.loads(row[1])
        def eval_with_bb(r):
            if not r['class'].startswith('-'):
                return 'rect' in r and any(x != 0 for x in r['rect'])
            else:
                return 'rect' not in r or all(x == 0 for x in r['rect'])
        if with_bb:
            # in the case with -, we will not add rect
                                # with all zeros, thus, no need to check if it is all zeros
                                # when it is negative samples
            rects = [r for r in rects if eval_with_bb(r)]
        # all annotations if eval_with_bb(r) is valid for no_bb. Thus, disable
        # the following
        #else:
            #rects = [r for r in rects if not eval_with_bb(r)]
        if result is None:
            # don't use this, because all list will be shared
            #result = [len(row) * ['d']] * tsv.num_rows()
            result = [None] * tsv.num_rows()
            for _ in range(len(result)):
                result[_] = ['d'] * len(row)
        rects2 = []
        # the following code should use convert_one_label
        for rect in rects:
            if rect['class'] in label_mapper:
                for t in label_mapper[rect['class']]:
                    r2 = copy.deepcopy(rect)
                    r2['class'] = t
                    if rect['class'] != t:
                        # keep this for logging
                        r2['class_from'] = rect['class']
                    rects2.append(r2)
        row[1] = rects2
        result[i] = row
    return result

def create_info_for_ambigous_noffset(name, noffsets):
    definitions = [str(noffset_to_synset(n).definition()) for n in noffsets]
    de = [{'noffset': n,
          'definition': d.replace("`", '').replace("'", ''),
          'nick_name': str(get_nick_name(noffset_to_synset(n)))}
            for n, d in zip(noffsets, definitions)]
    d = {'name': name,
            'definitions': de,
            'noffset': None,
            'markdown_url': create_markdown_url(noffsets)}
    return d

def node_should_have_images(root, th, fname):
    enough = True
    few_training_with_bb = []
    for node in root.iter_search_nodes():
        if node == root:
            continue
        if node.cum_images_with_bb < th:
            few_training_with_bb.append({'name': node.name,
                'cum_images_with_bb': node.cum_images_with_bb,
                'parent list': [p.name for p in node.get_ancestors()[:-1]]})
            enough = False
            logging.warn('less images: {} ({})'.format(
                node.name.encode('utf-8'),
                node.cum_images_with_bb))
    if enough:
        logging.info('con. every node has at least {} images'.format(th))
    else:
        write_to_yaml_file(few_training_with_bb, fname)

def clean_dataset2(source_dataset_name, dest_dataset_name):
    source_dataset = TSVDataset(source_dataset_name)
    dest_dataset = TSVDataset(dest_dataset_name)
    splits = get_default_splits()
    for split in splits:
        src_tsv = source_dataset.get_data(split)
        if op.isfile(src_tsv):
            valid_idxs = []
            dest_tsv = dest_dataset.get_data(split)
            def gen_rows():
                rows = tsv_reader(src_tsv)
                num_removed_images = 0
                num_removed_rects = 0
                for i, row in enumerate(tqdm(rows)):
                    if (i % 1000) == 0:
                        logging.info('{} - #removedImages={};#removedRects={}'.format(
                            i, num_removed_images, num_removed_rects))
                    im = img_from_base64(row[-1])
                    if im is None:
                        num_removed_images = num_removed_images + 1
                        continue
                    height, width = im.shape[:2]
                    rects = json.loads(row[1])
                    invalid = False
                    to_remove = []
                    for rect in rects:
                        r = rect['rect']
                        if all(s == 0 for s in r):
                            continue
                        changed = False
                        origin = copy.deepcopy(rect)
                        for j in range(4):
                            if r[j] < 0:
                                r[j] = 0
                                changed = True
                        for j in range(2):
                            if r[2 * j] >= width -1:
                                changed = True
                                r[2 * j] = width - 1
                            if [2 * j + 1] >= height - 1:
                                changed = True
                                r[2 * j + 1] = height - 1
                        if changed:
                            rect['changed_from_rect'] = origin
                        cx, cy = (r[0] + r[2]) / 2., (r[1] + r[3]) / 2.
                        w, h = r[2] - r[0], r[3] - r[1]
                        if cx < 0 or cy < 0 or cx >= width or \
                                cy >= height or w <= 1 or h <= 1 or \
                                w >= width or h >= height:
                            to_remove.append(rect)
                    if len(to_remove) > 0:
                        num_removed_rects = num_removed_rects + len(to_remove)
                    for rect in to_remove:
                        rects.remove(rect)
                    valid_idxs.append(i)
                    if len(to_remove) > 0:
                        yield row[0], json.dumps(rects), row[2]
                    else:
                        yield row
            tsv_writer(gen_rows(), dest_tsv)
            dest_dataset.write_data(source_dataset.iter_data(split, 'label',
                filter_idx=valid_idxs), split, 'label')

def clean_dataset(source_dataset_name, dest_dataset_name):
    '''
    use version 2
    '''
    source_dataset = TSVDataset(source_dataset_name)
    dest_dataset = TSVDataset(dest_dataset_name)
    splits = get_default_splits()
    for split in splits:
        src_tsv = source_dataset.get_data(split)
        if op.isfile(src_tsv):
            dest_tsv = dest_dataset.get_data(split)
            def gen_rows():
                rows = tsv_reader(src_tsv)
                num_removed_images = 0
                num_removed_rects = 0
                for i, row in enumerate(rows):
                    if (i % 1000) == 0:
                        logging.info('{} - #removedImages={};#removedRects={}'.format(
                            i, num_removed_images, num_removed_rects))
                    im = img_from_base64(row[-1])
                    height, width = im.shape[:2]
                    rects = json.loads(row[1])
                    invalid = False
                    to_remove = []
                    for rect in rects:
                        r = rect['rect']
                        if all(s == 0 for s in r):
                            continue
                        cx, cy = (r[0] + r[2]) / 2., (r[1] + r[3]) / 2.
                        w, h = r[2] - r[0], r[3] - r[1]
                        if cx < 0 or cy < 0 or cx >= width or \
                                cy >= height or w <= 1 or h <= 1 or \
                                w >= width or h >= height:
                            to_remove.append(rect)
                    if len(to_remove) > 0:
                        logging.info('before removing {}'.format(len(rects)))
                        num_removed_rects = num_removed_rects + len(to_remove)
                    for rect in to_remove:
                        rects.remove(rect)
                        r = rect['rect']
                        logging.info('removing {}'.format(','.join(map(str,
                                r))))
                    if len(to_remove) > 0:
                        logging.info('after removing {}'.format(len(rects)))
                        if len(rects) > 0:
                            yield row[0], json.dumps(rects), row[2]
                        else:
                            num_removed_images = num_removed_images + 1
                            logging.info('removing image {}'.format(row[0]))
                    else:
                        yield row
            tsv_writer(gen_rows(), dest_tsv)

def parallel_convert_label(func, all_task, num_worker=128):
    num_split = num_worker
    num_task_each_split = (len(all_task) + num_split - 1) / num_split
    all_sub_tasks = []
    for i in range(num_split):
        start_idx = i * num_task_each_split
        if start_idx >= len(all_task):
            break
        end_idx = start_idx + num_task_each_split
        if end_idx > len(all_task):
            end_idx = len(all_task)
        all_sub_tasks.append(all_task[start_idx:end_idx])
    m = Pool(num_worker)
    all_sub_results = m.map(func, all_sub_tasks)
    result = all_sub_results[0]
    for s in all_sub_results[1:]:
        assert len(result) == len(s)
        for i in range(len(result)):
            assert len(result[i]) == 2
            assert len(s[i]) == 2
            if result[i][1] == 'd' and s[i][1] != 'd':
                result[i][0] = s[i][0]
                result[i][1] = s[i][1]
            else:
                assert not (result[i][1] != 'd' and s[i][1] != 'd')
    return result

def parallel_map_to_array(func, all_task, num_worker=128):
    num_split = num_worker * 2
    num_task_each_split = (len(all_task) + num_split - 1) / num_split
    all_sub_tasks = []
    for i in range(num_split):
        start_idx = i * num_task_each_split
        if start_idx > len(all_task):
            break
        end_idx = start_idx + num_task_each_split
        if end_idx > len(all_task):
            end_idx = len(all_task)
        all_sub_tasks.append(all_task[start_idx:end_idx])
    m = Pool(num_worker)
    all_sub_results = m.map(func, all_sub_tasks)
    result = []
    for s in all_sub_results:
        result.extend(s)
    return result

def convert_label_db(dataset, split, idx, with_bb):
    result = None
    label_mapper = dataset._sourcelabel_to_targetlabels
    queried = []
    for row_with_idx in tqdm(dataset.iter_gt(split, idx=idx)):
        i = row_with_idx[0]
        queried.append(i)
        row = list(row_with_idx[1:])
        rects = row[1]
        def eval_with_bb(r):
            if not r['class'].startswith('-'):
                return 'rect' in r and any(x != 0 for x in r['rect'])
            else:
                return 'rect' not in r or all(x == 0 for x in r['rect'])
        if with_bb:
            # in the case with -, we will not add rect
                                # with all zeros, thus, no need to check if it is all zeros
                                # when it is negative samples
            rects = [r for r in rects if eval_with_bb(r)]
        # all annotations if eval_with_bb(r) is valid for no_bb. Thus, disable
        # the following
        #else:
            #rects = [r for r in rects if not eval_with_bb(r)]
        if result is None:
            result = [None] * dataset.num_rows(split)
            for _ in range(len(result)):
                result[_] = ['d'] * len(row)
        rects2 = []
        # the following code should use convert_one_label
        for rect in rects:
            if rect['class'] in label_mapper:
                for t in label_mapper[rect['class']]:
                    r2 = copy.deepcopy(rect)
                    r2['class'] = t
                    if rect['class'] != t:
                        # keep this for logging
                        r2['class_from'] = rect['class']
                    rects2.append(r2)
        row[1] = rects2
        result[i] = row
    not_coverred = set(idx).difference(queried)
    assert len(not_coverred) == 0
    return result

def create_trainX_db(train_ldtsi, extra_dtsi, tax, out_dataset,
        lift_train=False):
    t_to_ldsi = list_to_dict(train_ldtsi, 2)
    extra_t_to_dsi = list_to_dict(extra_dtsi, 1)
    train_ldtsik = []
    extra_dtsik = []
    for label_type in t_to_ldsi:
        ldsi = t_to_ldsi[label_type]
        extra_dsi = extra_t_to_dsi.get(label_type, [])
        d_to_lsi = list_to_dict(ldsi, 1)
        extra_d_to_si = list_to_dict(extra_dsi, 0)
        k = 0
        sources = []
        sources_label = []
        with_bb = label_type == 'with_bb'
        for dataset in d_to_lsi:
            lsi = d_to_lsi[dataset]
            extra_si = extra_d_to_si.get(dataset, [])
            s_li = list_to_dict(lsi, 1)
            extra_s_to_i = list_to_dict(extra_si, 0)
            for split in s_li:
                li = s_li[split]
                idx_to_l = list_to_dict(li, 1)
                idx = idx_to_l.keys()
                extra_i = extra_s_to_i.get(split, [])
                # link the data tsv
                source = dataset.get_data(split)
                out_split = 'train{}'.format(k)
                train_ldtsik.extend([(l, dataset, label_type, split, i,
                    k) for l, i in li])
                extra_dtsik.extend([(dataset, label_type, split, i, k)
                    for i in extra_i])
                k = k + 1
                sources.append(source)
                logging.info('converting labels: {}-{}'.format(
                    dataset.name, split))

                converted_label = convert_label_db(dataset,
                        split, idx, with_bb=with_bb)
                # convert the file name
                logging.info('delifting the labels')
                for i in tqdm(idx):
                    l = converted_label[i]
                    if lift_train:
                        l[1] = json.dumps(lift_one_image(l[1], tax))
                    else:
                        l[1] = json.dumps(delift_one_image(l[1], tax))
                    l[0] = '{}_{}_{}'.format(dataset.name, split, l[0])
                label_file = out_dataset[label_type].get_data(out_split, 'label')
                logging.info('writing the label file {}'.format(label_file))
                tsv_writer(converted_label, label_file)
                sources_label.append(label_file)
        write_to_file('\n'.join(sources),
                out_dataset[label_type].get_data('trainX'))
        write_to_file('\n'.join(sources_label),
                out_dataset[label_type].get_data('trainX', 'label'))

    logging.info('saving the shuffle file')
    type_to_ldsik = list_to_dict(train_ldtsik, 2)
    extra_type_to_dsik = list_to_dict(extra_dtsik, 1)
    for label_type in type_to_ldsik:
        ldsik = type_to_ldsik[label_type]
        shuffle_info = [(str(k), str(i)) for l, d, s, i, k in ldsik]
        shuffle_info = list(set(shuffle_info))
        if label_type in extra_type_to_dsik:
            dsik = extra_type_to_dsik[label_type]
            # we should not de-duplicate it because it comes from the duplicate
            # policy
            extra_shuffle_info = [(str(k), str(i) ) for d, s, i, k in dsik]
            shuffle_info.extend(extra_shuffle_info)
        random.shuffle(shuffle_info)
        tsv_writer(shuffle_info,
                out_dataset[label_type].get_shuffle_file('train'))

    populate_output_num_images(train_ldtsik, 'toTrain', tax.root)

def create_trainX(train_ldtsi, extra_dtsi, tax, out_dataset,
        lift_train=False, use_original_label=False):
    t_to_ldsi = list_to_dict(train_ldtsi, 2)
    extra_t_to_dsi = list_to_dict(extra_dtsi, 1)
    train_ldtsik = []
    extra_dtsik = []
    for label_type in t_to_ldsi:
        ldsi = t_to_ldsi[label_type]
        extra_dsi = extra_t_to_dsi.get(label_type, [])
        d_to_lsi = list_to_dict(ldsi, 1)
        extra_d_to_si = list_to_dict(extra_dsi, 0)
        k = 0
        sources = []
        sources_origin_label = []
        sources_label = []
        with_bb = label_type == 'with_bb'
        for dataset in d_to_lsi:
            lsi = d_to_lsi[dataset]
            extra_si = extra_d_to_si.get(dataset, [])
            s_li = list_to_dict(lsi, 1)
            extra_s_to_i = list_to_dict(extra_si, 0)
            for split in s_li:
                li = s_li[split]
                idx_to_l = list_to_dict(li, 1)
                idx = idx_to_l.keys()
                extra_i = extra_s_to_i.get(split, [])
                # link the data tsv
                source = dataset.get_data(split)
                out_split = 'train{}'.format(k)
                train_ldtsik.extend([(l, dataset, label_type, split, i,
                    k) for l, i in li])
                extra_dtsik.extend([(dataset, label_type, split, i, k)
                    for i in extra_i])
                k = k + 1
                sources.append(source)
                logging.info('converting labels: {}-{}'.format(
                    dataset.name, split))
                source_origin_label = dataset.get_label_tsv(split)
                if not use_original_label:
                    #converted_label = convert_label(source_origin_label,
                            #idx, dataset._sourcelabel_to_targetlabels,
                            #with_bb=with_bb)
                    converted_label = convert_label_by_dataset(
                            dataset, split,
                            dataset.get_version_by_split(split),
                            idx, dataset._sourcelabel_to_targetlabels,
                            with_bb=with_bb)
                    sources_origin_label.append(source_origin_label)
                    # convert the file name
                    logging.info('delifting the labels')
                    for i in tqdm(idx):
                        l = converted_label[i]
                        if lift_train:
                            l[1] = json.dumps(lift_one_image(l[1], tax))
                        else:
                            l[1] = json.dumps(delift_one_image(l[1], tax))
                        l[0] = '{}_{}_{}'.format(dataset.name, split, l[0])
                    label_file = out_dataset[label_type].get_data(out_split, 'label')
                    logging.info('writing the label file {}'.format(label_file))
                    tsv_writer(converted_label, label_file)
                else:
                    label_file = source_origin_label
                sources_label.append(label_file)
        write_to_file('\n'.join(sources),
                out_dataset[label_type].get_data('trainX'))
        write_to_file('\n'.join(sources_label),
                out_dataset[label_type].get_data('trainX', 'label'))
        write_to_file('\n'.join(sources_origin_label),
                out_dataset[label_type].get_data('trainX', 'origin.label'))
    logging.info('saving the shuffle file')
    type_to_ldsik = list_to_dict(train_ldtsik, 2)
    extra_type_to_dsik = list_to_dict(extra_dtsik, 1)
    for label_type in type_to_ldsik:
        ldsik = type_to_ldsik[label_type]
        shuffle_info = [(str(k), str(i)) for l, d, s, i, k in ldsik]
        shuffle_info = list(set(shuffle_info))
        if label_type in extra_type_to_dsik:
            dsik = extra_type_to_dsik[label_type]
            # we should not de-duplicate it because it comes from the duplicate
            # policy
            extra_shuffle_info = [(str(k), str(i) ) for d, s, i, k in dsik]
            shuffle_info.extend(extra_shuffle_info)
        random.shuffle(shuffle_info)
        tsv_writer(shuffle_info,
                out_dataset[label_type].get_shuffle_file('train'))

        # expand nested trainX if needed
        expand_nested_splitX(out_dataset[label_type].name, 'train')

    populate_output_num_images(train_ldtsik, 'toTrain', tax.root)

def expand_nested_splitX(data, split):
    dataset = TSVDataset(data)
    if not dataset.has(split):
        logging.info('{}-{} does not exist'.format(data, split))
        return
    if op.isfile(dataset.get_data(split)):
        logging.info('{}/{}.tsv already exists'.format(data, split))
        return
    assert op.isfile(dataset.get_data(split + 'X'))

    need_to_expand = False
    src_data_splits = dataset.load_composite_source_data_split(split)
    for src_data, src_split in src_data_splits:
        src_dataset = TSVDataset(src_data)
        if not op.isfile(src_dataset.get_data(src_split)):
            assert op.isfile(src_dataset.get_data(src_split + 'X'))
            need_to_expand = True
            break
    if not need_to_expand:
        logging.info('no need to expand')
        return

    if not op.isfile(dataset.get_data(split, 'label')):
        convertcomposite_to_standard(data, split, ignore_image=True)

    cache_shuffle = {}
    def get_shuffle(d, s):
        if (d, s) in cache_shuffle:
            return cache_shuffle[(d, s)]
        else:
            shuffle = [(int(i), int(j)) for i, j in
                tsv_reader(TSVDataset(d).get_shuffle_file(s))]
            cache_shuffle[(d, s)] = shuffle
            return shuffle

    cache_src_data_splits = {}
    def get_src_data_splits(d, s):
        if (d, s) in cache_src_data_splits:
            return cache_src_data_splits[(d, s)]
        else:
            ssrc_data_splits = TSVDataset(d).load_composite_source_data_split(s)
            cache_src_data_splits[(d, s)] = ssrc_data_splits
            return ssrc_data_splits

    cache_single_tsv = {}
    def get_single(d, s):
        if (d, s) in cache_single_tsv:
            return cache_single_tsv[(d, s)]
        else:
            single = TSVDataset(d).get_data(s)
            cache_single_tsv[(d, s)] = single
            return single

    cache_is_single = {}
    def get_is_single(d, s):
        if (d, s) in cache_is_single:
            return cache_is_single[(d, s)]
        else:
            is_single = op.isfile(TSVDataset(d).get_data(s))
            cache_is_single[(d, s)] = is_single
            return is_single

    def get_tsv_line(d, s, i):
        single_tsv = get_is_single(d, s)
        if single_tsv:
            return get_single(d, s), i
        else:
            ssrc_data_splits = get_src_data_splits(d, s)
            shuffle = get_shuffle(d, s)
            idx_src, idx_row = shuffle[i]
            src_d, src_s = ssrc_data_splits[idx_src]
            return get_tsv_line(src_d, src_s, idx_row)

    shuffle = get_shuffle(data, split)
    all_tsv_idx = []
    for idx_src, idx_row in shuffle:
        ss_data, ss_split = src_data_splits[idx_src]
        tsv, i = get_tsv_line(ss_data, ss_split, idx_row)
        all_tsv_idx.append((tsv, i))
    unique_tsvs = list(list_to_dict(all_tsv_idx, 0).keys())
    tsv_to_idx = {t: i for i, t in enumerate(unique_tsvs)}
    shuffle_result = [(tsv_to_idx[t], i) for t, i in all_tsv_idx]
    tsv_writer(shuffle_result, dataset.get_shuffle_file(split))
    write_to_file('\n'.join(unique_tsvs), dataset.get_data(split + 'X'))

def create_testX_db(test_ldtsi, tax, out_dataset):
    t_to_ldsi = list_to_dict(test_ldtsi, 2)
    for label_type in t_to_ldsi:
        sources = []
        sources_label = []
        ldsi = t_to_ldsi[label_type]
        d_to_lsi = list_to_dict(ldsi, 1)
        k = 0
        all_ki = []
        with_bb = label_type == 'with_bb'
        for dataset in d_to_lsi:
            lsi = d_to_lsi[dataset]
            s_to_li = list_to_dict(lsi, 1)
            for split in s_to_li:
                li = s_to_li[split]
                idx = list_to_dict(li, 1).keys()
                out_split = 'test{}'.format(k)
                s_file = dataset.get_data(split)
                sources.append(s_file)
                converted_label = convert_label_db(dataset,
                        split, idx, with_bb=with_bb)
                for i in tqdm(idx):
                    l = converted_label[i]
                    l[1] = json.dumps(lift_one_image(l[1], tax))
                    l[0] = '{}_{}_{}'.format(dataset.name, split, l[0])
                all_ki.extend([(str(k), str(i)) for i in idx])
                label_file = out_dataset[label_type].get_data(out_split, 'label')
                tsv_writer(converted_label, label_file)
                sources_label.append(label_file)
                k = k + 1
        write_to_file('\n'.join(sources),
                out_dataset[label_type].get_data('testX'))
        write_to_file('\n'.join(sources_label),
                out_dataset[label_type].get_data('testX', 'label'))
        tsv_writer(all_ki, out_dataset[label_type].get_shuffle_file('test'))

def create_testX(test_ldtsi, tax, out_dataset):
    t_to_ldsi = list_to_dict(test_ldtsi, 2)
    for label_type in t_to_ldsi:
        sources = []
        sources_origin_label = []
        sources_label = []
        ldsi = t_to_ldsi[label_type]
        d_to_lsi = list_to_dict(ldsi, 1)
        k = 0
        all_ki = []
        with_bb = label_type == 'with_bb'
        for dataset in d_to_lsi:
            lsi = d_to_lsi[dataset]
            s_to_li = list_to_dict(lsi, 1)
            for split in s_to_li:
                li = s_to_li[split]
                idx = list_to_dict(li, 1).keys()
                out_split = 'test{}'.format(k)
                s_file = dataset.get_data(split)
                sources.append(s_file)
                source_origin_label = dataset.get_label_tsv(split)
                sources_origin_label.append(source_origin_label)
                #converted_label = convert_label(source_origin_label,
                        #idx, dataset._sourcelabel_to_targetlabels,
                        #with_bb=with_bb)
                converted_label = convert_label_by_dataset(
                        dataset, split, dataset.get_version_by_split(split),
                        idx, dataset._sourcelabel_to_targetlabels,
                        with_bb=with_bb)
                for i in tqdm(idx):
                    l = converted_label[i]
                    l[1] = json.dumps(lift_one_image(l[1], tax))
                    l[0] = '{}_{}_{}'.format(dataset.name, split, l[0])
                all_ki.extend([(str(k), str(i)) for i in idx])
                label_file = out_dataset[label_type].get_data(out_split, 'label')
                tsv_writer(converted_label, label_file)
                sources_label.append(label_file)
                k = k + 1
        write_to_file('\n'.join(sources),
                out_dataset[label_type].get_data('testX'))
        write_to_file('\n'.join(sources_label),
                out_dataset[label_type].get_data('testX', 'label'))
        write_to_file('\n'.join(sources_origin_label),
                out_dataset[label_type].get_data('testX', 'origin.label'))
        tsv_writer(all_ki, out_dataset[label_type].get_shuffle_file('test'))
        expand_nested_splitX(out_dataset[label_type].name, 'test')

def remove_or_duplicate_each_type(train_ldtsi, label_to_min_image, label_to_max_image):
    label_to_dtsi = list_to_dict(train_ldtsi, 0)
    extra_dtsi = []
    for label in label_to_dtsi:
        if label is None:
            continue
        dtsi = label_to_dtsi[label]
        max_image = label_to_max_image[label]
        t_to_dsi = list_to_dict(dtsi, 1)
        if isinstance(label_to_min_image, dict):
            min_image = label_to_min_image[label]
        else:
            # label_to_min_image is an integer
            min_image = label_to_min_image
        for t in t_to_dsi:
            dsi = t_to_dsi[t]
            if len(dsi) > max_image:
                # first remove the images with no bounding box
                num_remove = len(dsi) - max_image
                random.seed(9999)
                random.shuffle(dsi)
                dsi = sorted(dsi, key=lambda x: -x[0].cleaness)
                assert len(dsi) > num_remove
                dsi = dsi[: len(dsi) - num_remove]
                t_to_dsi[t] = dsi
            elif len(dsi) < min_image:
                num_duplicate = int(np.ceil(float(min_image) / len(dsi)))
                logging.info('duplicate images for {}/{}: {}->{}, {}'.format(
                    t, label, len(dsi), min_image, num_duplicate))
                # we already has 1 copy of dsi, thus we should subtract 1
                extra_dsi = (num_duplicate - 1) * dsi
                extra_dtsi.extend([[d, t, s, i] for d, s, i in extra_dsi])
        dtsi = dict_to_list(t_to_dsi, 1)
        label_to_dtsi[label] = dtsi
    logging.info('# train instances before duplication: {}'.format(len(train_ldtsi)))
    train_ldtsi = dict_to_list(label_to_dtsi, 0)
    logging.info('# train instances after duplication: {}'.format(len(train_ldtsi)))
    return train_ldtsi, extra_dtsi

def remove_or_duplicate(train_ldtsi, min_image, label_to_max_image):
    # min_image is for the sum of with_bb and no_bb
    # prefer to use _each_type version, which interpret min_image as the value
    # for each type
    label_to_dtsi = list_to_dict(train_ldtsi, 0)
    extra_dtsi = []
    for label in label_to_dtsi:
        dtsi = label_to_dtsi[label]
        max_image = label_to_max_image[label]
        if len(dtsi) > max_image:
            # first remove the images with no bounding box
            num_remove = len(dtsi) - max_image
            type_to_dsi = list_to_dict(dtsi, 1)
            if 'no_bb' in type_to_dsi:
                dsi = type_to_dsi['no_bb']
                if num_remove >= len(dsi):
                    # remove all this images
                    del type_to_dsi['no_bb']
                    num_remove = num_remove - len(dsi)
                else:
                    random.seed(9999)
                    random.shuffle(dsi)
                    type_to_dsi['no_bb'] = dsi[: len(dsi) - num_remove]
                    num_remove = 0
            if num_remove > 0:
                assert 'with_bb' in type_to_dsi
                dsi = type_to_dsi['with_bb']
                random.seed(9999)
                random.shuffle(dsi)
                dsi = sorted(dsi, key=lambda x: -x[0].cleaness)
                assert len(dsi) > num_remove
                type_to_dsi['with_bb'] = dsi[: len(dsi) - num_remove]
                num_remove = 0
            dtsi = dict_to_list(type_to_dsi, 1)
        elif len(dtsi) < min_image:
            num_duplicate = int(np.ceil(float(min_image) / len(dtsi)))
            logging.info('duplicate images for label of {}: {}->{}, {}'.format(
                label, len(dtsi), min_image, num_duplicate))
            extra_dtsi.extend((num_duplicate - 1) * dtsi)
        label_to_dtsi[label] = dtsi
    logging.info('# train instances before duplication: {}'.format(len(train_ldtsi)))
    train_ldtsi = dict_to_list(label_to_dtsi, 0)
    logging.info('# train instances after duplication: {}'.format(len(train_ldtsi)))
    return train_ldtsi, extra_dtsi

def remove_test_in_train(train_ldtsi, test_ldtsi):
    logging.info('before len(train_ldtsi) = {}'.format(len(train_ldtsi)))
    set_train_dtsi = set((d, t, s, i) for l, d, t, s, i in train_ldtsi)
    if len(train_ldtsi) > 0 and type(train_ldtsi[0]) is list:
        # we need to convert it to immutable tuple since list is not hashable
        train_ldtsi = [(l, d, t, s, i) for l, d, t, s, i in train_ldtsi]
    set_train_ldtsi = set(train_ldtsi)
    #assert len(set_train_ldtsi) == len(train_ldtsi)
    set_test_dtsi = set((d, t, s, i) for l, d, t, s, i in test_ldtsi)
    result = [(l, d, t, s, i) for l, d, t, s, i in train_ldtsi
            if (d, t, s, i) not in set_test_dtsi]
    logging.info('after len(train_ldtsi) = {}'.format(len(result)))
    return result

def split_train_test(ldtsi, num_test):
    # group by label_type
    t_to_ldsi = list_to_dict(ldtsi, 2)
    train_ldtsi = []
    test_ldtsi = []
    for label_type in sorted(t_to_ldsi.keys()):
        ldsi= t_to_ldsi[label_type]
        l_to_dsi = list_to_dict(ldsi, 0)
        for rootlabel in sorted(l_to_dsi.keys()):
            dsi = l_to_dsi[rootlabel]
            if len(dsi) < num_test:
                logging.info('rootlabel={}; label_type={}->less than {} images'.format(
                    rootlabel, label_type, len(dsi)))
            curr_num_test = min(num_test, int(len(dsi) / 2))
            random.shuffle(dsi)
            test_ldtsi.extend([(rootlabel, d, label_type, s, i) for d, s, i
                in dsi[:curr_num_test]])
            train_ldtsi.extend([(rootlabel, d, label_type, s, i) for d, s, i
                in dsi[curr_num_test:]])
    return train_ldtsi, test_ldtsi

def regularize_data_sources(data_infos):
    result = []
    default_splits = get_default_splits()
    for data_info in data_infos:
        if type(data_info) is str:
            r = {'name': data_info,
                    'cleaness': 10,
                    'valid_splits': default_splits,
                    'use_all': False}
            result.append(r)
        elif type(data_info) is tuple or type(data_info) is list:
            assert len(data_info) > 0
            r = {'name': data_info[0],
                    'cleaness': data_info[1] if len(data_info) > 1 else 10,
                    'valid_splits': data_info[2] if len(data_info) > 2 else
                                default_splits,
                    'use_all': data_info[3] if len(data_info) > 3 else False,
                    }
            assert len(data_info) < 5
            result.append(r)
        elif type(data_info) is dict:
            r = data_info
            result.append(r)
        else:
            raise Exception('unkwown data_info = {}'.format(data_info))
    for r in result:
        if 'data' in r:
            assert 'name' not in r
            r['name'] = r['data']
            del r['data']
    return result

def parse_data_clean_splits(data_infos):
    '''
    use regularize_data_sources
    '''
    datas, cleaness, all_valid_splits = [], [], []
    default_splits = get_default_splits()
    for data_info in data_infos:
        if type(data_info) is str:
            datas.append(data_info)
            cleaness.append(10)
            all_valid_splits.append(default_splits)
        elif type(data_info) is tuple or type(data_info) is list:
            assert len(data_info) > 0
            datas.append(data_info[0])
            cleaness.append(data_info[1] if len(data_info) > 1 else 10)
            all_valid_splits.append(data_info[2] if len(data_info) > 2 else default_splits)
        elif type(data_info) is dict:
            datas.append(data_info['data'])
            cleaness.append(data_info.get('cleaness', 10))
            all_valid_splits.append(data_info.get('valid_splits', default_splits))
        else:
            raise Exception('unkwown data_info = {}'.format(data_info))
    return datas, cleaness, all_valid_splits

def attach_properties(src_nodes, dst_tree):
    name_to_dst_node = {n.name: n for n in dst_tree.iter_search_nodes() if
            n != dst_tree}
    confusings = []
    for src_node in src_nodes:
        if src_node.name not in name_to_dst_node:
            continue
        dst_node = name_to_dst_node[src_node.name]
        for f in src_node.features:
            if f in ['support', 'name', 'dist', 'sub_group']:
                continue
            if f in dst_node.features:
                if dst_node.__getattribute__(f) == src_node.__getattribute__(f):
                    continue
                else:
                    confusings.append({'name': src_node.name,
                        'feature': f,
                        'value in tree': dst_node.__getattribute__(f),
                        'value in property list': src_node.__getattribute__(f)})
            else:
                dst_node.add_feature(f, src_node.__getattribute__(f))
    assert len(confusings) == 0, pformat(confusings)

def update_taxonomy_by_latest(ref_data, target_data):
    lift_train = False
    from .common import ensure_copy_folder
    # copy everything from ref_data to target_data and _no_bb
    ensure_copy_folder(op.join('data', ref_data),
            op.join('data', target_data))
    ensure_copy_folder(op.join('data', ref_data + '_no_bb'),
            op.join('data', target_data + '_no_bb'))

    # _with_bb
    ref_data = ref_data + '_with_bb'
    target_data = target_data + '_with_bb'
    update_bb_taxonomy_by_latest(ref_data, target_data)

def update_bb_taxonomy_by_latest(ref_data, target_data):
    ref_dataset = TSVDataset(ref_data)
    out_dataset = TSVDataset(target_data)

    split = 'train'
    splitX = '{}X'.format(split)
    all_idxsource_idxrow = [(int(s_idx_source), int(s_idx_row)) for s_idx_source, s_idx_row in
            tsv_reader(ref_dataset.get_shuffle_file(split))]
    pattern = 'data/(.*)/(train|trainval|test)\.label.*\.tsv'
    # e.g. source_origin_label = 'data/SeeingAISplit/train.label.tsv'
    source_data_splits = [re.match(pattern, source_origin_label).groups()
            for source_origin_label, in ref_dataset.iter_data(splitX, 'origin.label')]
    source_data_split_versions = [(d, s, -1) for d, s in source_data_splits]

    lift_train = False
    dump_to_taxonomy_dataset(ref_dataset, all_idxsource_idxrow,
            source_data_split_versions, lift_train, split, out_dataset)

def dump_to_taxonomy_dataset(ref_dataset, all_idxsource_idxrow,
        source_data_split_versions, lift_train, split, out_dataset):
    splitX = split + 'X'
    tax = Taxonomy(load_from_yaml_file(op.join(ref_dataset._data_root, 'root.yaml')))
    sources_label = []
    sources_origin_label = []
    for idxsource, (source_data, source_split, source_version) in enumerate(source_data_split_versions):
        idx = [idx_r for idx_s, idx_r in all_idxsource_idxrow if idxsource == idx_s]
        for n in tax.root.iter_search_nodes():
            if source_data in n.features:
                n.add_feature(source_data,
                        n.__getattribute__(source_data) + ',{}'.format(n.name))
        source_dataset = TSVDatasetSource(source_data, root=tax.root,
                split_infos=[{'split': source_split, 'version': -1}])
        source_dataset._ensure_initialized()
        source_origin_label = source_dataset.get_data(source_split, 'label',
                source_version)
        sources_origin_label.append(source_origin_label)
        converted_label = convert_label(source_origin_label,
                idx, source_dataset._sourcelabel_to_targetlabels,
                with_bb=True)
        for i in tqdm(idx):
            l = converted_label[i]
            if lift_train:
                l[1] = json.dumps(lift_one_image(l[1], tax))
            else:
                l[1] = json.dumps(delift_one_image(l[1], tax))
            l[0] = '{}_{}_{}'.format(source_dataset.name, source_split, l[0])
        out_split = '{}{}'.format(split, idxsource)
        label_file = out_dataset.get_data(out_split, 'label')
        tsv_writer(converted_label, label_file)
        sources_label.append(label_file)

    # the label version might be updated. Thus, the sources_label could be
    # different from the reference dataset
    write_to_file('\n'.join(sources_label),
            out_dataset.get_data(splitX, 'label'))

    write_to_file('\n'.join(sources_origin_label),
            out_dataset.get_data(splitX, 'origin.label'))

    # copy the image source file
    ensure_copy_file(ref_dataset.get_data(splitX),
            out_dataset.get_data(splitX))

    # copy the labelmap
    ensure_copy_file(ref_dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file())

    # copy the shuffle file
    # the idx could be different since we might add more images here
    tsv_writer(all_idxsource_idxrow,
            out_dataset.get_shuffle_file(split))

def test():
    data = 'LogosInTheWild-v2Clean'
    idx = 1237
    dataset = TSVDataset(data)
    tsv = TSVFile(dataset.get_data('train', 'label', 3))
    key, str_rects = tsv.seek(idx)
    key, _, str_im = dataset.seek_by_key(key, 'train')

    #im = img_from_base64(str_im)
    jpgbytestring = base64.b64decode(str_im)
    nparr = np.frombuffer(jpgbytestring, np.uint8)
    im = cv2.imdecode(nparr, cv2.IMREAD_IGNORE_ORIENTATION);

    rects = json.loads(str_rects)
    draw_rects(im, rects)
    save_image(im, '/mnt/jianfw_desk/a.png')

def trim_rects_from_db(rects):
    keys = ['_id', 'create_time', 'idx_in_split',
            'key', 'split', 'data']
    for rect in rects:
        for k in keys:
            if k in rect:
                del rect[k]

class TSVDatasetDB(object):
    def __init__(self, name):
        self.name = name
        self._db = create_mongodb_client()
        self._gt = self._db['qd']['ground_truth']
        self._image = self._db['qd']['image']

    def iter_gt(self, split, version=None, version_by_time=None,
            idx=None, bb_type='with_bb'):
        # query the image db first and then attach the gt information
        match = {'data': self.name,
                 'split': split}
        if idx:
            match['idx_in_split'] = {'$in': list(idx)}
        lookup_pipeline = self._get_gt_rect_pipeline(
                split, version, version_by_time, bb_type,
                extra_filter={'$eq': ['$key', '$$key']},
                in_lookup=True)
        pipeline = [{'$match': match},
                    {'$lookup': {'from': 'ground_truth',
                                 'let': {'key': '$key'},
                                 'pipeline': lookup_pipeline,
                                 'as': 'rects'
                                 }}]
        for row in self._image.aggregate(pipeline, allowDiskUse=True):
            trim_rects_from_db(row['rects'])
            yield row['idx_in_split'], row['key'], row['rects']

    @deprecated('use iter_gt since this function will not return the image with no bb')
    def iter_gt_image(self, split, version=None, version_by_time=None,
            idx=None, bb_type='with_bb'):
        # deprecated. use iter_gt since this function will not return anything
        # if the image in idx has no box
        # if idx is not none, here we do not guarrentee the order is kept.
        # Thus, we also return the index of the image
        if idx:
            extra_filter = {'idx_in_split': {'$in': list(idx)}}
        else:
            extra_filter = None
        pipeline = self._get_gt_rect_pipeline(split,
                version, version_by_time, bb_type,
                extra_filter)
        pipeline.append({'$group': {'_id': '$idx_in_split',
                                    'key': {'$first': '$key'},
                                    'rects': {'$push': '$$ROOT'}}})
        logging.info(pformat(pipeline))
        for result in self._gt.aggregate(pipeline, allowDiskUse=True):
            for rect in result['rects']:
                if '_id' in rect:
                    del rect['_id']
                if 'create_time' in rect:
                    del rect['create_time']
            yield result['_id'], result['key'], result['rects']

    def _get_gt_rect_pipeline(self, split, version, version_by_time,
            bb_type, extra_filter, in_lookup=False):
        if not in_lookup:
            match = {'data': self.name,
                     'split': split}
        else:
            match_condition = []
            match_condition.append({'$eq': ['$data', self.name]})
            match_condition.append({'$eq': ['$split', split]})
        if extra_filter:
            if not in_lookup:
                match.update(extra_filter)
            else:
                match_condition.append(extra_filter)
        if version_by_time:
            if not in_lookup:
                match['create_time'] = {'$lte': version_by_time}
            else:
                match_condition.append({'$lte': ['$create_time', version_by_time]})
            sort_by = 'create_time'
        else:
            if version is None:
                version = 0
            if version != -1:
                if not in_lookup:
                    match['version'] = {'$lte': version}
                else:
                    match_condition.append({'$lte': ['$version', version]})
            sort_by = 'version'
        if in_lookup:
            match = {'$expr': {'$and': match_condition}}
        sort_value = OrderedDict() # use ordered since dict is non-ordered
        sort_value[sort_by] = -1
        sort_value['contribution'] = -1
        pipeline = [{'$match': match},
                    # we may change some properties at the same version or
                    # time. In this case, we prefer contribution=1
                    {'$sort': sort_value},
                    {'$group': {'_id':      '$action_target_id',
                                'rect_info': {'$first': '$$ROOT'}}},
                    {'$replaceRoot': {'newRoot': '$rect_info'}},
                    {'$match': {'contribution': 1}},
                    ]
        if bb_type == 'with_bb':
            cond1 = {'rect': {'$ne': None}}
            cond2_or = []
            for i in range(4):
                cond2_or.append({'rect.{}'.format(i): {'$ne': 0}})
            cond2 = {'$or': cond2_or}
            match_with_bb = {'$and': [cond1, cond2]}
            pipeline.append({'$match': match_with_bb})
        else:
            assert bb_type == 'no_bb'
        return pipeline

    def iter_gt_rect(self, split, version=None, version_by_time=None,
            bb_type='with_bb',
            extra_filter=None):
            # we do not add any filter here. Thus it is no_bb + with_bb
        pipeline = self._get_gt_rect_pipeline(split, version, version_by_time,
                bb_type, extra_filter)
        return self._gt.aggregate(pipeline, allowDiskUse=True)

    def num_rows(self, split):
        pipeline = [{'$match': {'data': self.name, 'split': split}},
                {'$group': {'_id': 1, 'm': {'$max': '$idx_in_split'}}}]
        result = next(self._image.aggregate(pipeline))
        return result['m'] + 1

    def get_data(self, split):
        return op.join('data', self.name, '{}.tsv'.format(split))

    def _get_unique_labels(self):
        # we ignore the version to make it simplier. it should cover all labels
        splits = [split_info['split'] for split_info in self._split_infos]
        pipeline = [{'$match': {'data': self.name,
                                'split': {'$in': splits}}},
                    {'$group': {'_id': '$class'}}]
        labelmap = sorted([r['_id'] for r in self._gt.aggregate(pipeline)])
        return labelmap

class TSVDatasetSourceDB(TSVDatasetDB):
    def __init__(self, name, root=None,
            split_infos=None,
            cleaness=10,
            use_all=False,
            use_negative_label=False,
            select_by_verified=False):
        super(TSVDatasetSourceDB, self).__init__(name)
        self._noffset_count = {}
        self._type = None
        self._root = root
        # the list of <datasetlabel, rootlabel>
        self._sourcelabel_to_targetlabels = None
        self._targetlabel_to_sourcelabels = None
        self._initialized = False
        self._type_to_datasetlabel_to_split_idx = None
        self._type_to_datasetlabel_to_count = None
        self._type_to_split_label_idx = None
        if split_infos is not None:
            self._split_infos = split_infos
        else:
            self._split_infos = [{'split': s, 'version': -1}
                    for s in get_default_splits()]
        self._split_to_info = {s['split']: s for s in self._split_infos}
        assert len(set([split_info['split'] for split_info in
            self._split_infos])) == len(self._split_infos)
        self._use_all = use_all
        self._select_by_verified = select_by_verified
        self.cleaness = cleaness
        self.use_negative_label = use_negative_label

    def populate_info(self, root):
        self._ensure_initialized()
        for node in root.iter_search_nodes():
            if root == node:
                continue
            if node.name in self._targetlabel_to_sourcelabels:
                sourcelabels = self._targetlabel_to_sourcelabels[node.name]
                node.add_feature(self.name, ','.join(sourcelabels))
                if any(is_noffset(l) for l in sourcelabels):
                    node.add_feature(self.name + '_readable',
                            ','.join(get_nick_name(noffset_to_synset(l)) if
                                is_noffset(l) else l for l in sourcelabels))
                total = 0
                for sourcelabel in sourcelabels:
                    for t in self._type_to_datasetlabel_to_count:
                        datasetlabel_to_count = self._type_to_datasetlabel_to_count[t]
                        c = datasetlabel_to_count.get(sourcelabel, 0)
                        total = total + c
                        key = 'images_{}'.format(t)
                        node.add_feature(key,
                                node.__getattribute__(key) + c)
                node.add_feature('{}_total'.format(self.name), total)

    def _ensure_initialized(self):
        if self._initialized:
            return

        self.update_label_mapper()

        self._load_inverted()

        self._initialized = True

    def _load_inverted(self):
        # make sure self.update_label_mapper() is called
        types = ['with_bb', 'no_bb']
        self._type_split_label_idx = []

        usefull_dataset_labels = self._sourcelabel_to_targetlabels.keys()
        usefull_dataset_labels = [l for l in usefull_dataset_labels if not l.startswith('-')]
        for split_info in self._split_infos:
            for bb_type in types:
                iter_merged = self.iter_gt_rect(split=split_info['split'],
                        version=split_info.get('version'),
                        version_by_time=split_info.get('version_by_time'),
                        bb_type=bb_type,
                        extra_filter={'class': {'$in': usefull_dataset_labels}})
                type_split_label_idx = ((bb_type, rect_info['split'],
                    rect_info['class'], rect_info['idx_in_split'])
                    for rect_info in iter_merged)
                self._type_split_label_idx.extend(type_split_label_idx)

        assert not self.use_negative_label, 'not supported'

        self._type_split_label_idx = list(set(self._type_split_label_idx))
        self._type_to_split_label_idx = list_to_dict(
                self._type_split_label_idx, 0)
        self._type_to_datasetlabel_to_split_idx = {}
        for t in self._type_to_split_label_idx:
            split_label_idx = self._type_to_split_label_idx[t]
            label_to_split_idx = list_to_dict(split_label_idx, 1)
            self._type_to_datasetlabel_to_split_idx[t] = label_to_split_idx
        self._type_to_datasetlabel_to_count = {}
        for t in self._type_to_datasetlabel_to_split_idx:
            datasetlabel_to_split_idx = self._type_to_datasetlabel_to_split_idx[t]
            datasetlabel_to_count = {l: len(datasetlabel_to_split_idx[l]) for l in
                    datasetlabel_to_split_idx}
            self._type_to_datasetlabel_to_count[t] = datasetlabel_to_count

        self._split_to_num_image = {split_info['split']: self.num_rows(split_info['split']) for split_info in
                self._split_infos}

    def update_label_mapper(self):
        root = self._root

        labelmap = self._get_unique_labels()
        hash_labelmap = set(labelmap)

        tree_noffsets = {}
        for node in root.iter_search_nodes():
            if node == root or not node.noffset:
                continue
            for s in node.noffset.split(','):
                tree_noffsets[s] = node.name
        name_to_targetlabels = {}
        targetlabel_has_whitelist = set()
        invalid_list = []
        any_source_key = 'label_names_in_all_dataset_source'
        for node in root.iter_search_nodes():
            if node == root:
                continue
            if hasattr(node, self.name) or hasattr(node, any_source_key):
                if hasattr(node, self.name):
                    # this is like a white-list
                    values = node.__getattribute__(self.name)
                else:
                    values = node.__getattribute__(any_source_key)
                if values is not None:
                    source_terms = values.split(',')
                    for t in source_terms:
                        t = t.strip()
                        if t not in name_to_targetlabels:
                            name_to_targetlabels[t] = set()
                        if t not in hash_labelmap:
                            invalid_list.append((t, self.name, node.name))
                            continue
                        name_to_targetlabels[t].add(node.name)
                # even if it is None, we will also add it to white-list so that
                # we will not automatically match the term.
                targetlabel_has_whitelist.add(node.name)
            else:
                # we will keep the lower case always for case-insensitive
                # comparison
                all_candidate_src_names = [node.name.lower()]
                if hasattr(node, 'alias_names'):
                    all_candidate_src_names.extend([s.strip() for s in
                        node.alias_names.split(',')])
                for t in set(all_candidate_src_names):
                    if t not in name_to_targetlabels:
                        name_to_targetlabels[t] = set()
                    name_to_targetlabels[t].add(node.name)

        sourcelabel_targetlabel = []
        if len(invalid_list) != 0:
            logging.warn('invalid white list information: {}'.format(pformat(invalid_list)))

        #result = {}
        label_to_synset = LabelToSynset()
        for l in labelmap:
            matched = False
            if l.lower() in name_to_targetlabels:
                matched = True
                for t in name_to_targetlabels[l.lower()]:
                    sourcelabel_targetlabel.append((l, t))
            if l in name_to_targetlabels:
                for t in name_to_targetlabels[l]:
                    sourcelabel_targetlabel.append((l, t))
                matched = True
            if not matched:
                succeed, ns = label_to_synset.convert(l)
                if not succeed:
                    continue
                for n in ns:
                    n = synset_to_noffset(n)
                    if n in tree_noffsets:
                        t = tree_noffsets[n]
                        if t in targetlabel_has_whitelist:
                            # if it has white list, we will not respect the
                            # noffset to do the autmatic matching
                            continue
                        sourcelabel_targetlabel.append((l, t))
                        #result[l] = t
        if self.use_negative_label:
            # we just add the mapping here. no need to check if -s is in the
            # source label list
            sourcelabel_targetlabel.extend([('-' + s, '-' + t) for s, t in
                sourcelabel_targetlabel])

        self._sourcelabel_to_targetlabels = list_to_dict_unique(sourcelabel_targetlabel,
                0)
        self._targetlabel_to_sourcelabels = list_to_dict_unique(sourcelabel_targetlabel,
                1)

        return self._sourcelabel_to_targetlabels

    def iter_gt_image(self, split, idx=None, bb_type='with_bb'):
        split_info = self._split_to_info[split]

        return super(TSVDatasetSourceDB, self).iter_gt_image(split,
                version=split_info.get('version'),
                version_by_time=split_info.get('version_by_time'),
                idx=idx, bb_type=bb_type)

    def select_tsv_rows(self, label_type):
        self._ensure_initialized()
        result = []
        if label_type in self._type_to_split_label_idx:
            split_label_idx = self._type_to_split_label_idx[label_type]
            datasetlabel_to_splitidx = list_to_dict(split_label_idx, 1)
            for datasetlabel in datasetlabel_to_splitidx:
                if datasetlabel in self._sourcelabel_to_targetlabels:
                    split_idxes = datasetlabel_to_splitidx[datasetlabel]
                    targetlabels = self._sourcelabel_to_targetlabels[datasetlabel]
                    for targetlabel in targetlabels:
                        result.extend([(targetlabel, split, idx) for split, idx in
                            split_idxes])
        # must_have_indices
        for split_info in self._split_infos:
            split = split_info['split']
            must_have_indices = split_info.get('must_have_indices', [])
            # we set the target label here as None so that the post-processing
            # will not ignore it. The real labels will also be converted
            # corrected since we do not depend on this target label only.
            result.extend((None, split, i) for i in must_have_indices)
        if self._use_all:
            split_to_targetlabel_idx = list_to_dict(result, 1)
            for s in split_to_targetlabel_idx:
                rootlabel_idxes = split_to_targetlabel_idx[s]
                idx_to_rootlabel = list_to_dict(rootlabel_idxes, 1)
                num_image = self._split_to_num_image[s]
                idxes = set(range(num_image)).difference(set(idx_to_rootlabel.keys()))
                for i in idxes:
                    # for these images, the root label is hard-coded as None
                    result.append((None, s, i))
            for split_info in self._split_infos:
                s = split_info['split']
                if s in split_to_targetlabel_idx:
                    continue
                if s not in self._split_to_num_image:
                    continue
                result.extend([(None, s, i) for i in
                    range(self._split_to_num_image[s])])
        return result

def build_tax_dataset_from_db(taxonomy_folder, **kwargs):
    random.seed(777)
    dataset_name = kwargs.get('data',
            op.basename(taxonomy_folder))
    overall_dataset = TSVDataset(dataset_name)
    if op.isfile(overall_dataset.get_labelmap_file()):
        logging.info('ignore to build taxonomy since {} exists'.format(
            overall_dataset.get_labelmap_file()))
        return
    init_logging()
    logging.info('building {}'.format(dataset_name))
    all_tax = load_all_tax(taxonomy_folder)
    tax = merge_all_tax(all_tax)
    tax.update()
    initialize_images_count(tax.root)
    mapper = LabelToSynset()
    mapper.populate_noffset(tax.root)
    imagenet22k = TSVDatasetSource('imagenet22k_448', tax.root)
    if op.isfile(imagenet22k.get_labelmap_file()):
        disambibuity_noffsets(tax.root, imagenet22k.load_noffsets())
    else:
        logging.info('there is no imagenet22k_448 dataset to help identify the noffset')
    populate_url_for_offset(tax.root)

    ambigous_noffset_file = op.join(overall_dataset._data_root,
            'ambigous_noffsets.yaml')
    output_ambigous_noffsets(tax.root, ambigous_noffset_file)

    data_infos = regularize_data_sources(kwargs['datas'])

    data_sources = [TSVDatasetSourceDB(root=tax.root, **d)
            for d in data_infos]

    for s in data_sources:
        s.populate_info(tax.root)

    populate_cum_images(tax.root)

    labels, child_parent_sgs = child_parent_print_tree2(tax.root, 'name')

    label_map_file = overall_dataset.get_labelmap_file()
    write_to_file('\n'.join(labels), label_map_file)
    # save the parameter
    write_to_yaml_file((taxonomy_folder, kwargs), op.join(overall_dataset._data_root,
            'generate_parameters.yaml'))
    dest_taxonomy_folder = op.join(overall_dataset._data_root,
            'taxonomy_folder')
    if op.isdir(dest_taxonomy_folder):
        shutil.rmtree(dest_taxonomy_folder)
    shutil.copytree(taxonomy_folder, dest_taxonomy_folder)

    out_dataset = {'with_bb': TSVDataset(dataset_name + '_with_bb'),
            'no_bb': TSVDataset(dataset_name + '_no_bb')}

    for label_type in out_dataset:
        target_file = out_dataset[label_type].get_labelmap_file()
        ensure_directory(op.dirname(target_file))
        shutil.copy(label_map_file, target_file)

    logging.info('cum_images_with_bb: {}'.format(tax.root.cum_images_with_bb))
    logging.info('cum_images_no_bb: {}'.format(tax.root.cum_images_no_bb))

    # write the simplified version of the tree
    dest = op.join(overall_dataset._data_root, 'root.simple.yaml')
    write_to_yaml_file(tax.dump(['images_with_bb']), dest)

    tree_file = overall_dataset.get_tree_file()
    write_to_file('\n'.join(['{} {}{}'.format(c, p, '' if sg < 0 else ' {}'.format(sg))
                             for c, p, sg in child_parent_sgs]),
            tree_file)
    for label_type in out_dataset:
        target_file = out_dataset[label_type].get_tree_file()
        ensure_directory(op.dirname(target_file))
        shutil.copy(tree_file, target_file)

    node_should_have_images(tax.root, 200,
            op.join(overall_dataset._data_root, 'labels_with_few_images.yaml'))

    # get the information of all train val
    ldtsi = []
    logging.info('collecting all candidate images')
    for label_type in out_dataset:
        for dataset in data_sources:
            targetlabel_split_idxes = dataset.select_tsv_rows(label_type)
            for rootlabel, split, idx in targetlabel_split_idxes:
                ldtsi.append((rootlabel, dataset, label_type, split, idx))
    # we need to remove the duplicates. the duplicates could come from such
    # cases: for example, we have Laptop and laptop in the image. Both of the
    # labels are mapped to laptop, which is in the target domain. In this case,
    # the image could be in the list twice
    ldtsi = list(set(ldtsi))

    num_test = kwargs.get('num_test', 50)

    # for each label, let's duplicate the image or remove the image
    default_max_image = kwargs.get('max_image_per_label', 1000)
    label_to_max_image = {n.name: n.__getattribute__('max_image_extract_for_train')
            if 'max_image_extract_for_train' in n.features and n.__getattribute__('max_image_extract_for_train') > default_max_image
            else default_max_image for n in tax.root.iter_search_nodes() if n != tax.root}
    label_to_max_image = {l: max(label_to_max_image[l], num_test) for l in label_to_max_image}
    # negative images constraint
    labels = list(label_to_max_image.keys())
    for l in labels:
        label_to_max_image['-' + l] = label_to_max_image[l]
    label_to_max_image[None] = 10000000000
    min_image = kwargs.get('min_image_per_label', 200)

    logging.info('keep a small image pool to split')
    label_to_max_augmented_images = {l: label_to_max_image[l] * 3 for l in label_to_max_image}
    # reduce the computing cost
    ldtsi, extra_dtsi = remove_or_duplicate_each_type(ldtsi, 0,
            label_to_max_augmented_images)
    assert len(extra_dtsi) == 0

    logging.info('select the best test image')
    if num_test == 0:
        test_ldtsi = []
    else:
        # generate the test set from the best data source
        label_to_max_images_for_test = {l: num_test for l in
            label_to_max_image}
        test_ldtsi, extra_dtsi = remove_or_duplicate_each_type(ldtsi, 0,
                label_to_max_images_for_test)
        assert len(extra_dtsi) == 0

    logging.info('removing test images from image pool')
    train_ldtsi = remove_test_in_train(ldtsi, test_ldtsi)

    logging.info('select the final training images')
    train_ldtsi, extra_dtsi = remove_or_duplicate_each_type(train_ldtsi, min_image,
            label_to_max_image)

    logging.info('creating the train data')
    create_trainX_db(train_ldtsi, extra_dtsi, tax, out_dataset,
            lift_train=kwargs.get('lift_train', False))

    populate_output_num_images(test_ldtsi, 'toTest', tax.root)

    # dump the tree to yaml format
    dest = op.join(overall_dataset._data_root, 'root.yaml')
    d = tax.dump()
    write_to_yaml_file(d, dest)
    for label_type in out_dataset:
        target_file = op.join(out_dataset[label_type]._data_root, 'root.yaml')
        ensure_directory(op.dirname(target_file))
        shutil.copy(dest, target_file)

    create_testX_db(test_ldtsi, tax, out_dataset)

    logging.info('done')

def build_taxonomy_from_single_composite_source(source_data,
        source_split, source_version,
        min_image_per_label,
        out_data):
    info = get_frame_info()
    out_dataset = TSVDataset(out_data)
    if op.isdir(out_dataset._data_root):
        logging.info('ignore to build since exists')
        return
    populate_dataset_details(source_data)
    dataset = TSVDataset(source_data)
    label_to_idx = dataset.load_inverted_label(source_split,
            version=source_version)
    if min_image_per_label < 1:
        # this is the ratio beteen the real value and the average
        mean_count = calc_mean([len(idx) for _, idx in label_to_idx.items()])
        min_image_per_label = int(mean_count * min_image_per_label)
    all_idx = list(range(dataset.num_rows(source_split)))
    idx_to_labels = list_to_dict(dict_to_list(label_to_idx, 0), 1)

    while len(label_to_idx) > 0:
        # remove the labels if the len(idx) >= min_image_per_label
        to_remove = [l for l in label_to_idx if len(label_to_idx[l]) >= min_image_per_label]
        for l in to_remove:
            del label_to_idx[l]
        if len(label_to_idx) == 0:
            break
        min_label = min(label_to_idx, key=lambda x: len(label_to_idx[x]))
        min_idx = copy.deepcopy(label_to_idx[min_label])
        min_count = len(min_idx)
        copies = (min_image_per_label + min_count - 1)  // min_count - 1
        info['duplicate_info${}'.format(min_label)] = copies
        assert copies > 0
        # add these extra images
        all_idx.extend(copies * min_idx)
        for i in min_idx:
            for l in idx_to_labels[i]:
                if l in label_to_idx:
                    # otherwise, it means that label is enough
                    for _ in range(copies):
                        label_to_idx[l].append(i)
    random.seed(6)
    random.shuffle(all_idx)
    ensure_copy_file(dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file())

    shuffle = TSVFile(dataset.get_shuffle_file(source_split))
    tsv_writer((shuffle[i] for i in all_idx), out_dataset.get_shuffle_file('train'))
    tsv_copy(dataset.get_data(source_split + 'X'),
            out_dataset.get_data('trainX'))

    out_dataset.write_data(
            dataset.iter_data('train', 'hw', filter_idx=all_idx),
            'train', 'hw')
    out_dataset.write_data(
            dataset.iter_data('train', 'label', version=source_version,
                filter_idx=all_idx),
            'train', 'label')
    out_dataset.write_data(list(info.items()), 'train', 'generate_info')

def build_taxonomy_from_single_source(source_data,
        source_split, source_version,
        min_image_per_label,
        out_data):
    populate_dataset_details(source_data)
    populate_dataset_hw(source_data, ['train'])
    dataset = TSVDataset(source_data)
    label_to_idx = dataset.load_inverted_label(source_split,
            version=source_version)
    all_idx = list(range(dataset.num_rows(source_split)))
    idx_to_labels = list_to_dict(dict_to_list(label_to_idx, 0), 1)

    while len(label_to_idx) > 0:
        # remove the labels if the len(idx) >= min_image_per_label
        to_remove = [l for l in label_to_idx if len(label_to_idx[l]) >= min_image_per_label]
        for l in to_remove:
            del label_to_idx[l]
        if len(label_to_idx) == 0:
            break
        min_label = min(label_to_idx, key=lambda x: len(label_to_idx[x]))
        min_idx = copy.deepcopy(label_to_idx[min_label])
        min_count = len(min_idx)
        copies = (min_image_per_label + min_count - 1)  // min_count - 1
        assert copies > 0
        # add these extra images
        all_idx.extend(copies * min_idx)
        for i in min_idx:
            for l in idx_to_labels[i]:
                if l in label_to_idx:
                    # otherwise, it means that label is enough
                    for _ in range(copies):
                        label_to_idx[l].append(i)
    random.seed(6)
    random.shuffle(all_idx)
    out_dataset = TSVDataset(out_data)
    shuffle = [(0, r) for r in all_idx]
    tsv_writer(shuffle, out_dataset.get_train_shuffle_file())
    ensure_copy_file(dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file())

    write_to_file(dataset.get_data('train'),
            out_dataset.get_data('trainX'))
    write_to_file(dataset.get_data('train', 'hw'),
            out_dataset.get_data('trainX', 'hw'))
    write_to_file(dataset.get_data('train', 'label', version=source_version),
            out_dataset.get_data('trainX', 'label'))

def build_taxonomy_impl(taxonomy_folder,
        data, datas,
        taxonomy=None,
        num_test=50, max_image_per_label=1000,
        min_image_per_label=200,
        lift_train=False,
        use_original_label=False,
        **kwargs):
    random.seed(777)
    dataset_name = data
    overall_dataset = TSVDataset(dataset_name)
    if op.isfile(overall_dataset.get_labelmap_file()):
        logging.info('ignore to build taxonomy since {} exists'.format(
            overall_dataset.get_labelmap_file()))
        return
    init_logging()
    logging.info('building {}'.format(dataset_name))
    if taxonomy_folder is not None:
        all_tax = load_all_tax(taxonomy_folder)
        tax = merge_all_tax(all_tax)
    else:
        tax = Taxonomy(taxonomy)
    tax.update()
    initialize_images_count(tax.root)
    mapper = LabelToSynset()
    mapper.populate_noffset(tax.root)
    imagenet22k = TSVDatasetSource('imagenet22k_448', tax.root)
    if op.isfile(imagenet22k.get_labelmap_file()):
        disambibuity_noffsets(tax.root, imagenet22k.load_noffsets())
    else:
        logging.info('there is no imagenet22k_448 dataset to help identify the noffset')
    populate_url_for_offset(tax.root)

    ambigous_noffset_file = op.join(overall_dataset._data_root,
            'ambigous_noffsets.yaml')
    output_ambigous_noffsets(tax.root, ambigous_noffset_file)

    if isinstance(datas, str):
        datas = load_from_yaml_file(datas)
    data_infos = regularize_data_sources(datas)

    data_sources = [TSVDatasetSource(root=tax.root, **d)
            for d in data_infos]

    for s in data_sources:
        s.populate_info(tax.root)

    populate_cum_images(tax.root)

    labels, child_parent_sgs = child_parent_print_tree2(tax.root, 'name')

    label_map_file = overall_dataset.get_labelmap_file()
    write_to_file('\n'.join(labels), label_map_file)
    # save the parameter
    write_to_yaml_file(get_frame_info(),
            op.join(overall_dataset._data_root,
            'generate_parameters.yaml'))
    dest_taxonomy_folder = op.join(overall_dataset._data_root,
            'taxonomy_folder')
    if op.isdir(dest_taxonomy_folder):
        shutil.rmtree(dest_taxonomy_folder)
    if taxonomy_folder is not None:
        shutil.copytree(taxonomy_folder, dest_taxonomy_folder)
    else:
        write_to_yaml_file(taxonomy, op.join(dest_taxonomy_folder, 'root.yaml'))

    out_dataset = {'with_bb': TSVDataset(dataset_name + '_with_bb'),
            'no_bb': TSVDataset(dataset_name + '_no_bb')}

    for label_type in out_dataset:
        target_file = out_dataset[label_type].get_labelmap_file()
        ensure_directory(op.dirname(target_file))
        shutil.copy(label_map_file, target_file)

    logging.info('cum_images_with_bb: {}'.format(tax.root.cum_images_with_bb))
    logging.info('cum_images_no_bb: {}'.format(tax.root.cum_images_no_bb))

    # write the simplified version of the tree
    dest = op.join(overall_dataset._data_root, 'root.simple.yaml')
    write_to_yaml_file(tax.dump(['images_with_bb']), dest)

    tree_file = overall_dataset.get_tree_file()
    write_to_file('\n'.join(['{} {}{}'.format(c, p, '' if sg < 0 else ' {}'.format(sg))
                             for c, p, sg in child_parent_sgs]),
            tree_file)
    for label_type in out_dataset:
        target_file = out_dataset[label_type].get_tree_file()
        ensure_directory(op.dirname(target_file))
        shutil.copy(tree_file, target_file)

    node_should_have_images(tax.root, 200,
            op.join(overall_dataset._data_root, 'labels_with_few_images.yaml'))

    # get the information of all train val
    ldtsi = []
    logging.info('collecting all candidate images')
    for label_type in out_dataset:
        for dataset in data_sources:
            targetlabel_split_idxes = dataset.select_tsv_rows(label_type)
            for rootlabel, split, idx in targetlabel_split_idxes:
                ldtsi.append((rootlabel, dataset, label_type, split, idx))
    # we need to remove the duplicates. the duplicates could come from such
    # cases: for example, we have Laptop and laptop in the image. Both of the
    # labels are mapped to laptop, which is in the target domain. In this case,
    # the image could be in the list twice
    ldtsi = list(set(ldtsi))

    # for each label, let's duplicate the image or remove the image
    default_max_image = max_image_per_label
    label_to_max_image = {n.name: n.__getattribute__('max_image_extract_for_train')
            if 'max_image_extract_for_train' in n.features and n.__getattribute__('max_image_extract_for_train') > default_max_image
            else default_max_image for n in tax.root.iter_search_nodes() if n != tax.root}
    label_to_max_image = {l: max(label_to_max_image[l], num_test) for l in label_to_max_image}
    # negative images constraint
    labels = list(label_to_max_image.keys())
    for l in labels:
        label_to_max_image['-' + l] = label_to_max_image[l]
    label_to_max_image[None] = 10000000000

    label_to_min_image = {n.name: n.__getattribute__('min_image_extract_for_train')
            if 'min_image_extract_for_train' in n.features
            else min_image_per_label for n in tax.root.iter_search_nodes() if n != tax.root}

    logging.info('keep a small image pool to split')
    label_to_max_augmented_images = {l: label_to_max_image[l] * 3 for l in label_to_max_image}
    # reduce the computing cost
    ldtsi, extra_dtsi = remove_or_duplicate_each_type(ldtsi, 0,
            label_to_max_augmented_images)
    assert len(extra_dtsi) == 0

    logging.info('select the best test image')
    if num_test == 0:
        test_ldtsi = []
    else:
        # generate the test set from the best data source
        label_to_max_images_for_test = {l: num_test for l in
            label_to_max_image}
        test_ldtsi, extra_dtsi = remove_or_duplicate_each_type(ldtsi, 0,
                label_to_max_images_for_test)
        assert len(extra_dtsi) == 0

    logging.info('removing test images from image pool')
    train_ldtsi = remove_test_in_train(ldtsi, test_ldtsi)

    logging.info('select the final training images')
    train_ldtsi, extra_dtsi = remove_or_duplicate_each_type(
        train_ldtsi,
        label_to_min_image,
        label_to_max_image)

    logging.info('creating the train data')
    create_trainX(train_ldtsi, extra_dtsi, tax, out_dataset,
            lift_train=lift_train,
            use_original_label=use_original_label)

    populate_output_num_images(test_ldtsi, 'toTest', tax.root)

    # dump the tree to yaml format
    dest = op.join(overall_dataset._data_root, 'root.yaml')
    d = tax.dump()
    write_to_yaml_file(d, dest)
    for label_type in out_dataset:
        target_file = op.join(out_dataset[label_type]._data_root, 'root.yaml')
        ensure_directory(op.dirname(target_file))
        shutil.copy(dest, target_file)

    create_testX(test_ldtsi, tax, out_dataset)

    logging.info('done')

def delift_one_image(rects, tax):
    # currently, for the training, we need to delift the label. That is, if it
    # is man, we should remove the person label
    rects2 = []
    for curr_r in rects:
        if curr_r['class'].startswith('-'):
            # if it is a background, we do nothing here. In the future, we
            # might change this logic
            rects2.append(curr_r)
            continue
        curr_label = curr_r['class']
        if 'rect' not in curr_r:
            same_place_rects = rects2
        else:
            ious = [calculate_iou(r['rect'], curr_r['rect']) for r in rects2]
            same_place_rects = [r for i, r in zip(ious, rects2) if i > 0.9]
        # if current label is one of parent of the same_place rects, ignore it
        ignore = False
        for same_place_r in same_place_rects:
            ancestors = tax.name_to_ancestors[same_place_r['class']]
            if curr_label in ancestors or same_place_r['class'] == curr_label:
                ignore = True
                break
        if ignore:
            continue
        ancestors = tax.name_to_ancestors[curr_label]
        to_removed = []
        for same_place_r in same_place_rects:
            if same_place_r['class'] in ancestors:
                to_removed.append(same_place_r)
        for t in to_removed:
            rects2.remove(t)
        rects2.append(curr_r)
    return rects2

def lift_one_image(rects, tax):
    rects2 = []
    for curr_r in rects:
        if curr_r['class'].startswith('-'):
            rects2.append(curr_r)
            continue
        label = curr_r['class']
        all_label = tax.name_to_ancestors[label]
        all_label.add(label)
        for l in all_label:
            same_label_rects = [r for r in rects2 if r['class'] == l]
            if 'rect' in curr_r:
                ious = [calculate_iou(r['rect'], curr_r['rect']) for r in
                    same_label_rects if 'rect' in r]
                if len(ious) > 0 and max(ious) > 0.9:
                    continue
                else:
                    r = copy.deepcopy(curr_r)
                    r['class'] = l
                    rects2.append(r)
            else:
                if len(same_label_rects) == 0:
                    r = copy.deepcopy(curr_r)
                    r['class'] = l
                    rects2.append(r)
    return rects2

def populate_output_num_images(ldtX, suffix, root):
    label_to_node = {n.name: n for n in root.iter_search_nodes() if n != root}
    targetlabel_to_dX = list_to_dict(ldtX, 0)
    for targetlabel in targetlabel_to_dX:
        if not targetlabel or targetlabel.startswith('-'):
            # currently, we ignore this background case. In the future, we
            # might change this logic
            continue
        if not targetlabel:
            # it means background images
            continue
        dtX = targetlabel_to_dX[targetlabel]
        dataset_to_X = list_to_dict(dtX, 0)
        for dataset in dataset_to_X:
            X = dataset_to_X[dataset]
            if len(X) == 0:
                continue
            key = '{}_{}'.format(dataset.name, suffix)
            value = len(X)
            label_to_node[targetlabel].add_feature(key, value)
        labeltype_to_dX = list_to_dict(dtX, 1)
        for labeltype in labeltype_to_dX:
            dX = labeltype_to_dX[labeltype]
            key = '{}_{}'.format(labeltype, suffix)
            value = len(dX)
            label_to_node[targetlabel].add_feature(key, value)

def output_ambigous_noffsets(root, ambigous_noffset_file):
    ambigous = []
    for node in root.iter_search_nodes():
        if hasattr(node, 'noffsets') and node.noffset is None:
            noffsets = node.noffsets.split(',')
            d = create_info_for_ambigous_noffset(node.name, noffsets)
            d['parent_name'] = ','.join([n.name for n in
                        node.get_ancestors()[:-1]])
            ambigous.append(d)
    if len(ambigous) > 0:
        logging.info('output ambigous terms to {}'.format(ambigous_noffset_file))
        write_to_yaml_file(ambigous, ambigous_noffset_file)
    else:
        logging.info('Congratulations on no ambigous terms.')

def output_ambigous_noffsets_main(tax_input_folder, ambigous_file_out):
    all_tax = load_all_tax(tax_input_folder)
    tax = merge_all_tax(all_tax)
    mapper = LabelToSynset()
    mapper.populate_noffset(tax.root)
    imagenet22k = TSVDatasetSource('imagenet22k')
    if op.isfile(imagenet22k.get_labelmap_file()):
        logging.info('remove the noffset if it is not in imagenet22k')
        disambibuity_noffsets(tax.root, imagenet22k.load_noffsets())
    else:
        logging.info('no imagenet22k data used to help remove noffset ambiguities')

    populate_url_for_offset(tax.root)

    output_ambigous_noffsets(tax.root, ambigous_file_out)

def convert_inverted_file(name):
    d = TSVDataset(name)
    splits = get_default_splits()
    for split in splits:
        logging.info('loading {}-{}'.format(name, split))
        x = d.load_inverted_label(split)
        def gen_rows():
            for label in x:
                idx = x[label]
                yield label, ' '.join(map(str, idx))

        inverted_file = d.get_data(split, 'inverted.label')
        target_file = op.splitext(inverted_file)[0] + '.tsv'
        if not op.isfile(inverted_file):
            if op.isfile(target_file):
                os.remove(target_file)
            continue
        if op.isfile(target_file):
            continue
        tsv_writer(gen_rows(), target_file)

def standarize_crawled(tsv_input, tsv_output):
    rows = tsv_reader(tsv_input)
    def gen_rows():
        for i, row in enumerate(rows):
            if (i % 1000) == 0:
                logging.info(i)
            image_str = row[-1]
            image_label = row[0]
            rects = [{'rect': [0, 0, 0, 0], 'class': image_label}]
            image_name = '{}_{}'.format(op.basename(tsv_input), i)
            yield image_name, json.dumps(rects), image_str
    tsv_writer(gen_rows(), tsv_output)

def get_data_sources(version):
    return load_from_yaml_file('./aux_data/data_sources/{}.yaml'.format(version))

def get_img_url2(img_key):
    # don't use get_image_url
    clean_name = _map_img_key_to_name2(img_key)
    url = _get_url_from_name(clean_name)
    return url

def get_img_url(img_key):
    # use version 2
    clean_name = _map_img_key_to_name(img_key)
    url = _get_url_from_name(clean_name)
    return url

def map_image_key_to_url_key(data, split, key):
    return hash_sha1(str((data, split, key)))

@deprecated(reason='need to incoroprate the data split info')
def _map_img_key_to_name2(key):
    assert len(key) > 0
    ext = '.jpg'
    pattern = '^([0-9]|-|[a-z]|[A-Z]|\.|_)*$'
    if not re.match(pattern, key):
        key = hash_sha1(key)
    key = key.lower()
    if key.endswith(ext):
        return key
    else:
        return key + ext

def _map_img_key_to_name(key):
    # use version 2
    _EXT = ".jpg"
    if key.startswith("brand"):
        return "brand" + str(hash(key)) + _EXT
    else:
        key = key.lower()
        if key.endswith(_EXT):
            return key
        else:
            return key + _EXT

def _get_url_from_name(name):
    _SITE = 'https://cogsimagestorage.blob.core.windows.net/'
    _CONTAINER_NAME = "detectortrain"
    return _SITE + _CONTAINER_NAME + "/" + name

def parse_combine(key):
    pattern = '(.*?)_(train|trainval|test)_(.*)'
    result = re.match(pattern, key)
    if result is None:
        return None, None, key
    else:
        return result.groups()

def convert_to_uhrs_with_url(data):
    dataset = TSVDataset(data)
    for split in get_default_splits():
        if not dataset.has(split, 'label'):
            continue
        v = dataset.get_latest_version(split, 'label')
        def gen_rows():
            for row in dataset.iter_data(split, 'label', version=v):
                key = row[0]
                _, _, key = parse_combine(key)
                row.append(get_img_url(key))
                yield row
        dataset.write_data(gen_rows(), split,
                'url', version=v)

def find_same_location_rects(target, rects, iou=0.95):
    return [r for r in rects if
        calculate_iou(target['rect'], r['rect']) > iou]

def find_same_rects(target, rects, iou=0.95):
    same_class_rects = [r for r in rects if r['class'] == target['class']]
    return [r for r in same_class_rects if
        calculate_iou(target['rect'], r['rect']) > iou]

def rects_diff(lefts, rights, iou=0.95):
    result = []
    for l in lefts:
        if len(find_same_rects(l, rights, iou)) == 0:
            result.append(l)
    return result

def rects_inter(lefts, rights, iou=0.95):
    result = []
    for l in lefts:
        if len(find_same_rects(l, rights, iou)) > 0:
            result.append(l)
    return result


def rect_in_rects(target, rects, iou=0.95):
    same_class_rects = [r for r in rects if r['class'] == target['class']]
    if 'rect' not in target:
        return len(same_class_rects) > 0
    else:
        return any(r for r in same_class_rects if 'rect' in r and
            calculate_iou(target['rect'], r['rect']) > iou)

def strict_rect_in_rects(target, rects):
    return any(float_tolorance_equal(target, r) for r in rects)

def load_key_rects(iter_data):
    assert type(iter_data) is not str
    result = []
    logging.info('loading key rects')
    for row in tqdm(iter_data):
        assert len(row) == 2
        rects = json.loads(row[1])
        if isinstance(rects, int):
            # in this case, it is imagenet2012 dataset, which is the class
            # index.
            rects = [{'class': str(rects)}]
        result.append([row[0], rects])
    return result

def convert_uhrs_result_back_to_sources(in_tsv, debug=True, tree_file=None):
    rows = tsv_reader(in_tsv)
    key_rects3 = []
    num_yes, num_no, num_un = 0, 0, 0
    for row in rows:
        # key, yes, no, uncertain
        assert len(row) == 4
        rects_yes = json.loads(row[1])
        rects_no = json.loads(row[2])
        rects_un = json.loads(row[3])
        num_yes = num_yes + len(rects_yes)
        num_no = num_no + len(rects_no)
        num_un = num_un + len(rects_un)
        key_rects3.append([row[0], [rects_yes, rects_no, rects_un]])

    logging.info('#yes={}; #no={}; #un={}; #yes/(#yes+#no+#un)={}'.format(
        num_yes, num_no, num_un, 1.*num_yes/(num_yes+num_no+num_un)))

    if tree_file:
        tax = Taxonomy(load_from_yaml_file(tree_file))
        mapper = LabelToSynset()
        mapper.populate_noffset(tax.root)

    datas = get_data_sources()
    datas = [data for data, _ in datas]
    datasplitkey_rects3 = [[parse_combine(key), rects3]
            for key, rects3 in key_rects3]
    data_split_key_rects3 = [(data, split, key, rects3)
            for (data, split, key), rects3 in datasplitkey_rects3]

    data_to_split_key_rects3 = list_to_dict(data_split_key_rects3, 0)

    for data in data_to_split_key_rects3:
        logging.info(data)
        if tree_file:
            source_dataset = TSVDatasetSource(data, tax.root)
            source_dataset._ensure_initialized()
        else:
            source_dataset = TSVDataset(data)
        split_key_rects3 = data_to_split_key_rects3[data]
        split_to_key_rects3 = list_to_dict(split_key_rects3, 0)
        for split in split_to_key_rects3:
            logging.info(split)
            key_rects3 = split_to_key_rects3[split]
            key_to_rects3 = list_to_dict(key_rects3, 0)
            v = source_dataset.get_latest_version(split, 'label')
            logging.info('{} - {}'.format(data, split))
            source_key_rects = load_key_rects(source_dataset.iter_data(split, 'label', version=v))
            is_equal = True
            num_added, num_removed = 0, 0
            meta = {'in_tsv': in_tsv}
            for i, (key, origin_rects) in tqdm(enumerate(source_key_rects)):
                if debug:
                    old_origin_rects = copy.deepcopy(origin_rects)
                yes_rects, no_rects, un_rects = key_to_rects3.get(key, [[[], [], []]])[0]
                # if no_rects are in original, remove it. remove first
                for r in no_rects:
                    delete_rects = find_same_rects(r, origin_rects)
                    if tree_file:
                        if r['class'] in source_dataset._targetlabel_to_sourcelabels:
                            for reverse_class in source_dataset._targetlabel_to_sourcelabels[r['class']]:
                                r2 = copy.deepcopy(r)
                                r2['class'] = reverse_class
                                delete_rects2 = find_same_rects(r2, origin_rects)
                                delete_rects.extend(delete_rects2)
                    if 'class_from' in r:
                        r2 = copy.deepcopy(r)
                        r2['class'] = r2['class_from']
                        delete_rects2 = find_same_rects(r2, origin_rects)
                        delete_rects.extend(delete_rects2)
                    for d in delete_rects:
                        # delete rects may include duplicate terms
                        if d in origin_rects:
                            origin_rects.remove(d)
                            num_removed = num_removed + 1
                            is_equal = False
                # if yes_rects are not in original, add it
                for r in yes_rects:
                    same_rects = find_same_rects(r, origin_rects)
                    if len(same_rects) > 0:
                        for s in same_rects:
                            if s.get('uhrs_confirm', 0) == 0:
                                is_equal = False
                            s['uhrs_confirm'] = s.get('uhrs_confirm', 0) + 1
                    else:
                        r['uhrs_confirm'] = r.get('uhrs_confirm', 0) + 1
                        origin_rects.append(copy.deepcopy(r))
                        is_equal = False
                        num_added = num_added + 1
                for r in un_rects:
                    same_rects = find_same_rects(r, origin_rects)
                    for s in same_rects:
                        if s.get('uhrs_uncertain', 0) == 0:
                            is_equal = True
                        s['uhrs_uncertain'] = s.get('uhrs_uncertain', 0) + 1
                if debug:
                    if len(origin_rects) != len(old_origin_rects):
                        for _, _, im_str in source_dataset.iter_data(split, filter_idx=[i]):
                            im = img_from_base64(im_str)
                            old_im = im.copy()
                            draw_bb(old_im, [r['rect'] for r in old_origin_rects],
                                    [r['class'] for r in old_origin_rects])
                            new_im = im.copy()
                            draw_bb(new_im, [r['rect'] for r in origin_rects],
                                    [r['class'] for r in origin_rects])
                            yes_im = im.copy()
                            draw_bb(yes_im, [r['rect'] for r in yes_rects],
                                    [r['class'] for r in yes_rects])
                            no_im = im.copy()
                            draw_bb(no_im, [r['rect'] for r in no_rects],
                                    [r['class'] for r in no_rects])

                            logging.info(pformat(old_origin_rects))
                            logging.info(pformat(origin_rects))
                            logging.info(pformat(yes_rects))
                            logging.info(pformat(no_rects))
                            show_images([old_im, new_im, yes_im, no_im], 2, 2)

            assert not source_dataset.has(split, 'label', v + 1)
            if not is_equal:
                source_dataset.write_data(((key, json.dumps(rects)) for key, rects in source_key_rects),
                        split, 'label', version=v+1)
                meta_file = source_dataset.get_data(split, 'label.metadata', version=v+1) + '.yaml'
                meta['num_added_rects'] = num_added
                meta['num_removed_rects'] = num_removed
                meta['total_number_images'] = len(source_key_rects)

                meta['avg_added_rects'] = 1. * num_added / meta['total_number_images']
                meta['avg_removed_rects'] = 1. * num_removed / meta['total_number_images']
                write_to_yaml_file(meta, meta_file)
                logging.info(pformat(meta))
            else:
                logging.info('equal - {} - {}'.format(data, split))
        populate_dataset_details(data)

def merge_multi_by_key(tsv_file1, all_tsv_file2, out_tsv,
        from_flag1, all_from_flag2):
    files = [tsv_file1]
    files.extend(all_tsv_file2)
    all_key_rects = [load_key_rects(tsv_reader(f)) for f in files]
    all_key_to_rects = [{key: rects for key, rects in key_rects}
        for key_rects in all_key_rects]
    keys = [key for key, _ in all_key_rects[0]]
    flags = [from_flag1]
    flags.extend(all_from_flag2)
    def gen_rows():
        for key in keys:
            all_rects = [key_to_rects[key] for key_to_rects in all_key_to_rects if key in key_to_rects]
            for rects, f in zip(all_rects, flags):
                for r in rects:
                    r['from'] = f
            rects = all_rects[0]
            for r in all_rects[1:]:
                rects.extend(r)
            yield key, json_dump(rects)
    tsv_writer(gen_rows(), out_tsv)

def merge_by_key(tsv_file1, tsv_file2, out_tsv,
        from_flag1='', from_flag2=''):
    files = [tsv_file1, tsv_file2]
    all_key_rects = [load_key_rects(tsv_reader(f)) for f in files]
    all_key_to_rects = [{key: rects for key, rects in key_rects}
        for key_rects in all_key_rects]
    keys = [key for key, _ in all_key_rects[0]]
    flags = [from_flag1, from_flag2]
    def gen_rows():
        for key in keys:
            all_rects = [key_to_rects[key] for key_to_rects in all_key_to_rects if key in key_to_rects]
            for rects, f in zip(all_rects, flags):
                for r in rects:
                    r['from'] = f
            rects = all_rects[0]
            for r in all_rects[1:]:
                rects.extend(r)
            yield key, json_dump(rects)
    tsv_writer(gen_rows(), out_tsv)

def threshold_merged_prediction(pred_tsv_file, from_to_class_to_threshold,
        output_file):
    def gen_rows():
        for key, str_rects in tsv_reader(pred_tsv_file):
            rects = json.loads(str_rects)
            all_rect = []
            for r in rects:
                if type(from_to_class_to_threshold[r['from']]) is dict:
                    th = from_to_class_to_threshold[r['from']][r['class']]
                else:
                    th = from_to_class_to_threshold[r['from']]
                assert type(th) is float or type(th) is int
                if r['conf'] > th:
                    all_rect.append(r)
            yield key, json_dump(all_rect)
    tsv_writer(gen_rows(), output_file)

def remove_has_confirmed_colocation_labels(all_data, iou_threshold=0.75):
    all_split = get_default_splits()
    debug = False
    for data in all_data:
        dataset = TSVDataset(data)
        for split in all_split:
            if not dataset.has(split):
                continue
            logging.info('{} -> {}'.format(data, split))
            info = {'total': 0, 'removed': 0}
            def gen_rows():
                for i, (key, en_rects) in tqdm(enumerate(dataset.iter_data(split,
                    'label', version=-1))):
                    rects = json.loads(en_rects)
                    info['total'] = info['total'] + len(rects)
                    if debug:
                        _, _, im = next(dataset.iter_data(split, filter_idx=[i]))
                        im = img_from_base64(im)
                        im_origin = np.copy(im)
                        draw_bb(im_origin, [r['rect'] for r in rects], [r['class'] for r in rects])
                    all_removed = []
                    # some labels has no rect
                    good_rects = [r for r in rects if 'rect' in r and
                            ('conf' not in r or ('conf' in r and 'uhrs_confirm' in r))]
                    pro_no_verify = [r for r in rects if 'conf' in r and
                            'uhrs_confirm' not in r and 'rect' in r]
                    no_rects = [r for r in rects if 'rect' not in r]
                    assert len(good_rects) + len(pro_no_verify) + len(no_rects)==len(rects)
                    to_remove = []
                    for r in pro_no_verify:
                        if any((s for s in good_rects if
                                calculate_iou(r['rect'], s['rect']) >
                                iou_threshold)):
                            to_remove.append(r)
                    for t in to_remove:
                        rects.remove(t)
                    info['removed'] = info['removed'] + len(to_remove)
                    all_removed.extend(to_remove)
                    if debug and len(all_removed) > 0:
                        logging.info(len(all_removed))
                        im_removed = np.copy(im)
                        logging.info(pformat(all_removed))
                        draw_bb(im_removed, [r['rect'] for r in all_removed],
                                [r['class'] for r in all_removed])
                        show_images([im_origin, im_removed], 1, 2)
                    yield key, json_dump(rects)
            def gen_info():
                yield 'remove auto-pro and has good labels in same locatoin', iou_threshold
                yield 'total', info['total']
                yield 'removed', info['removed']
                ratio = 1. * info['removed'] / info['total']
                yield 'ratio', ratio
                logging.info(pformat(info))
                logging.info(ratio)

            dataset.update_data(gen_rows(), split, 'label', generate_info=gen_info())

def get_taxonomy_path(data):
    pattern = 'Tax(.*)V([0-9]*)_(.*)'
    result = re.match(pattern, data)
    assert result is not None
    major, minor, revision = result.groups()
    return './aux_data/taxonomy10k/Tax{0}/Tax{0}V{1}'.format(major, minor)

def uhrs_verify_db_merge_to_tsv(collection_name='uhrs_logo_verification',
        extra_match=None):
    set_interpretation_result_for_uhrs_result(collection_name)
    c = create_bbverification_db(collection_name=collection_name)
    data_split_to_key_rects, all_id = c.get_completed_uhrs_result(
            extra_match=extra_match)
    merge_uhrs_result_to_dataset(data_split_to_key_rects)
    size = 1000
    i = 0
    while True:
        start = i * size
        end = i * size + size
        if start >= len(all_id):
            break
        if end >= len(all_id):
            end = len(all_id)
        c.set_status_as_merged(all_id[start:end])
        i += 1
    y = [c.set_status_as_merged([i]) for i in tqdm(all_id)]
    y = list(map(lambda i: c.set_status_as_merged([i]), all_id))

def uhrs_merge_one(uhrs_rect, target_rects, tag_only=False):
    info = {'num_added': 0,
            'num_removed': 0,
            'verified_confirmed': 0,
            'verified_removed': 0,
            'non_verified_confirmed': 0,
            'non_verified_removed': 0}
    same_rect, iou = find_best_matched_rect(uhrs_rect, target_rects, check_iou=(not tag_only))
    if iou < 0.8:
        if is_positive_uhrs_verified(uhrs_rect):
            target_rects.append(uhrs_rect)
            info['num_added'] = 1
        return info

    if is_verified_rect(same_rect):
        if is_positive_uhrs_verified(uhrs_rect):
            info['verified_confirmed'] = 1
        elif is_negative_uhrs_verified(uhrs_rect):
            info['verified_removed'] = 1
            target_rects.remove(same_rect)
    else:
        if is_positive_uhrs_verified(uhrs_rect):
            info['non_verified_confirmed'] = 1
        elif is_negative_uhrs_verified(uhrs_rect):
            info['non_verified_removed'] = 1
            target_rects.remove(same_rect)

    same_rect['uhrs'] = {}
    for t, v in viewitems(uhrs_rect['uhrs']):
        same_rect['uhrs'][t] = v

    return info

def merge_uhrs_result_to_dataset(data_split_to_key_rects, tag_only=False):
    from .common import list_to_dict
    from .common import json_dump
    for (data, split), uhrs_key_rects in viewitems(data_split_to_key_rects):
        logging.info((data, split))
        dataset = TSVDataset(data)
        uhrs_key_to_rects = list_to_dict(uhrs_key_rects, 0)
        logging.info('number of image will be affected: {}'.format(len(uhrs_key_rects)))
        info = {}
        def gen_rows():
            for key, str_rects in dataset.iter_data(split, 'label', -1,
                    progress=True):
                rects = json.loads(str_rects)
                if key in uhrs_key_to_rects:
                    uhrs_rects = uhrs_key_to_rects[key]
                    del uhrs_key_to_rects[key]
                else:
                    uhrs_rects = []
                for uhrs_rect in uhrs_rects:
                    sub_info = uhrs_merge_one(uhrs_rect, rects, tag_only=tag_only)
                    for k, v in viewitems(sub_info):
                        info[k] = v + info.get(k, 0)
                yield key, json_dump(rects)
            assert len(uhrs_key_to_rects) == 0
        def generate_info():
            for k, v in viewitems(info):
                yield k, v
            for key, rects in viewitems(uhrs_key_to_rects):
                yield key, json_dump(rects)
        dataset.update_data(gen_rows(), split, 'label',
                generate_info=generate_info())

def set_interpretation_result_for_uhrs_result(collection_name='uhrs_logo_verification'):
    c = create_bbverification_db(collection_name=collection_name)
    query = {'status': {'$in': [c.status_merged, c.status_completed]},
            'interpretation_result': None}
    positive_ids, negative_ids, uncertain_ids = [], [], []
    pos, neg, un = 0, 0, 0
    for rect_info in tqdm(c.collection.find(query)):
        rect = rect_info['rect']
        rect.update({'uhrs': rect_info['uhrs_completed_result']})
        if is_positive_uhrs_verified(rect):
            positive_ids.append(rect_info['_id'])
            if len(positive_ids) > 1000:
                logging.info('positive = {}'.format(pos))
                q = {'_id': {'$in': positive_ids}}
                c.collection.update_many(filter=q,
                        update={'$set': {'interpretation_result': 1}})
                pos += len(positive_ids)
                positive_ids.clear()
        elif is_negative_uhrs_verified(rect):
            negative_ids.append(rect_info['_id'])
            if len(negative_ids) > 1000:
                logging.info('neg = {}'.format(neg))
                q = {'_id': {'$in': negative_ids}}
                c.collection.update_many(filter=q,
                        update={'$set': {'interpretation_result': -1}})
                neg += len(negative_ids)
                negative_ids.clear()
        else:
            uncertain_ids.append(rect_info['_id'])
            if len(uncertain_ids) > 1000:
                logging.info('un = {}'.format(un))
                query = {'_id': {'$in': uncertain_ids}}
                c.collection.update_many(filter=query,
                        update={'$set': {'interpretation_result': 0}})
                un += len(uncertain_ids)
                uncertain_ids.clear()


    if len(positive_ids) > 0:
        query = {'_id': {'$in': positive_ids}}
        c.collection.update_many(filter=query,
                update={'$set': {'interpretation_result': 1}})
    if len(negative_ids) > 0:
        query = {'_id': {'$in': negative_ids}}
        c.collection.update_many(filter=query,
                update={'$set': {'interpretation_result': -1}})
    if len(uncertain_ids) > 0:
        query = {'_id': {'$in': uncertain_ids}}
        c.collection.update_many(filter=query,
                update={'$set': {'interpretation_result': 0}})

def uhrs_verify_db_closest_rect(collection, test_data, test_split, gt_key, p):
    rect_infos = list(collection.find({'data': test_data,
        'split': test_split,
        'key': gt_key}))
    rects = [rect_info['rect'] for rect_info in rect_infos]
    best_idx, best_iou = find_best_matched_rect_idx(p, rects, check_class=True)

    if best_idx is not None:
        rect_info = rect_infos[best_idx]
    else:
        rect_info = None

    return rect_info, best_iou

def verify_prediction_by_db(pred_file, test_data, test_split, conf_th=0.3,
        priority_tier=1, collection_name='uhrs_bounding_box_verification'):
    from qd.process_tsv import ensure_upload_image_to_blob
    from qd.process_tsv import parse_combine
    ensure_upload_image_to_blob(test_data, test_split)

    dataset = TSVDataset(test_data)
    gt_iter = dataset.iter_data(test_split, 'label', version=-1)
    pred_iter = tsv_reader(pred_file)
    key_url_iter = dataset.iter_data(test_split, 'key.url')

    db_task = []
    num_task, num_exists, num_matched_gt, num_change_pri = 0, 0, 0, 0
    c = create_bbverification_db(collection_name=collection_name)
    for gt_row, pred_row, url_row in tqdm(zip(gt_iter, pred_iter,
        key_url_iter)):
        gt_key, gt_str_rects = gt_row
        pred_key, pred_str_rects = pred_row
        assert gt_key == pred_key == url_row[0]
        source_data, source_split, source_key = parse_combine(gt_key)
        if source_data is None and source_split is None:
            source_data = test_data
            source_split = test_split
        gt_rects = json.loads(gt_str_rects)
        pred_rects = json.loads(pred_str_rects)
        for p in pred_rects:
            if p['conf'] < conf_th:
                continue
            # check with the gt
            _, best_iou = find_best_matched_rect(p, gt_rects)
            if best_iou > 0.7:
                num_matched_gt = 0
                continue
            best_rect_info, best_iou = uhrs_verify_db_closest_rect(c.collection, source_data,
                    source_split, source_key, p)
            if best_iou > 0.95:
                num_exists = num_exists + 1
                if best_rect_info['priority_tier'] != c.urgent_priority_tier and \
                        best_rect_info['status'] == c.status_requested:
                    c.collection.update_one(
                            {'_id': best_rect_info['_id']},
                            update={'$set': {'priority_tier': c.urgent_priority_tier}})
                    num_change_pri = num_change_pri + 1
                continue
            p['from'] = pred_file
            url = url_row[1]
            task = {'url': url,
                'data': source_data,
                'split': source_split,
                'key': source_key,
                'rect': p,
                'priority_tier': priority_tier,
                'priority': 0.5}
            num_task = num_task + 1
            db_task.append(task)
            if len(db_task) > 1000:
                c.request_by_insert(db_task)
                db_task = []
    if len(db_task) > 0:
        c.request_by_insert(db_task)
        db_task = []
    logging.info('#task = {}; #exists in db = {}; #matched gt = {}; #num pri change = {}'.format(
        num_task, num_exists, num_matched_gt, num_change_pri))

def convertcomposite_to_standard(data,
        split='train', ignore_image=False, **kwargs):
    dataset = TSVDataset(data)
    if op.isfile(dataset.get_data(split, t='label')) and \
            op.isfile(dataset.get_data(split)):
        logging.info('file exists')
        return
    rows_image = dataset.iter_composite(split, t=None, version=None)
    num_image = dataset.num_rows(split)
    out_tsv = dataset.get_data(split)
    if not ignore_image:
        logging.info('writing image tsv: {}'.format(out_tsv))
        rows_label = dataset.iter_data(split, t='label', version=None)
        tsv_writer(((row_label[0], row_label[1], row_image[2]) for row_image, row_label
                in tqdm(zip(rows_image, rows_label), total=num_image)),
                out_tsv)
    if not op.isfile(dataset.get_data(split, t='label')):
        logging.info('writing image label tsv')
        rows = dataset.iter_composite(split, t='label', version=None)
        tsv_writer(tqdm(rows), dataset.get_data(split, t='label'))

def gen_merged_candidate(prediction_file,
        gts, srclabel_to_destlabel=None, **kwargs):
    # we will only consider the bounding box if the prob is larger than 0.7
    prob_th = kwargs['merge_min_prob']
    prob_th_max = kwargs['merge_max_prob']
    # we will add the bounding box only if the iou is lower than 0.7 to avoid
    # duplicate addition
    iou_th = kwargs['merge_max_iou']
    aug_labels = kwargs['aug_labels']
    prediction = tsv_reader(prediction_file)
    is_aligned = kwargs.get('is_aligned', False)
    logging.info('loading prediction: {}'.format(prediction_file))
    if not is_aligned:
        key_to_pred = {}
        for p in tqdm(prediction):
            assert len(p) == 2
            key = p[0]
            rects = json.loads(p[1])
            key_to_pred[key] = rects
    num_image = 0
    num_added = 0
    for gt in tqdm(gts):
        assert len(gt) == 2
        num_image = num_image + 1
        key = gt[0]
        g_rects = json.loads(gt[1])
        origin_g_rects = copy.deepcopy(g_rects)
        add_rects = []
        if not is_aligned:
            if key not in key_to_pred:
                yield key, origin_g_rects, add_rects, g_rects
                continue
            p_rects = key_to_pred[key]
        else:
            p_key, p_rects = next(prediction)
            p_rects = json.loads(p_rects)
            assert key == p_key
        p_rects = [r for r in p_rects if r['conf'] > prob_th and
                r['conf'] <= prob_th_max]
        if aug_labels is not None:
            p_rects = [r for r in p_rects if r['class'] in aug_labels]
        if srclabel_to_destlabel:
            p_rects = [r for r in p_rects if r['class'] in srclabel_to_destlabel]
            for r in p_rects:
                r['class'] = srclabel_to_destlabel[r['class']]
        p_rects = sorted(p_rects, key=lambda x: -x['conf'])
        for p_rect in p_rects:
            is_add = True
            ious = [calculate_iou(p_rect['rect'], g_rect['rect'])
                    for g_rect in g_rects]
            if len(ious) > 0 and max(ious) > iou_th:
                is_add = False
            if is_add:
                num_added = num_added + 1
                p_rect['from'] = prediction_file
                # add p_rect
                add_rects.append(p_rect)
                g_rects.append(p_rect)
        yield key, origin_g_rects, add_rects, g_rects
    logging.info('num_image = {}'.format(num_image))
    logging.info('num_added = {}'.format(num_added))


def merge_prediction_to_gt(prediction_file, gts, im_rows, dataset, split,
        **param):
    dataset.iter_data(split, 'label')
    gts2 = gen_merged_candidate(prediction_file, gts, **param)
    if im_rows is not None:
        if False:
            # show image
            for gt2, im_row in zip(gts2, im_rows):
                assert gt2[0] == im_row[0]
                im = img_from_base64(im_row[-1])
                origin_rects = gt2[1]
                add_rects = gt2[2]
                merged_rects = gt2[3]
                if len(add_rects) == 0:
                    continue
                im_origin_gt = np.copy(im)
                draw_bb(im_origin_gt, [r['rect'] for r in origin_rects],
                        [r['class'] for r in origin_rects])
                im_add = np.copy(im)
                draw_bb(im_add, [r['rect'] for r in add_rects],
                        [r['class'] for r in add_rects],
                        [r['conf'] for r in add_rects])
                im_merged = np.copy(im)
                draw_bb(im_merged, [r['rect'] for r in merged_rects],
                        [r['class'] for r in merged_rects])
                logging.info(pformat(add_rects))
                show_images([im_origin_gt, im_add, im_merged], 1, 3)
        else:
            # save image
            for i, (gt2, im_row) in enumerate(zip(gts2, im_rows)):
                assert gt2[0] == im_row[0]
                im = img_from_base64(im_row[-1])
                origin_rects = gt2[1]
                add_rects = gt2[2]
                merged_rects = gt2[3]
                if len(add_rects) == 0:
                    continue
                add_class = list(set([r['class'] for r in add_rects]))
                for c in add_class:
                    c_rects = [r for r in add_rects if r['class'] == c]
                    im_add = np.copy(im)
                    draw_rects(c_rects, im_add, add_label=False)
                    im_origin = np.copy(im)
                    draw_rects([x for x in origin_rects if x['class'] == c], im_origin)
                    im_merged = np.copy(im)
                    draw_rects([x for x in merged_rects if x['class'] == c], im_merged)
                    top = np.concatenate((im, im_add), 1)
                    bottom = np.concatenate((im_origin, im_merged), 1)
                    x = np.concatenate((top, bottom), 0)
                    save_image(x, './output/add_image/{}_{}.jpg'.format(
                        c, im_row[0]))
    else:
        meta = {'num_image': 0,
                'num_added_total': 0,
                'from': prediction_file}
        all_added = []
        def gen_rows():
            for key, origin_rects, add_rects, merged_rects in gts2:
                all_added.append((key, add_rects))
                meta['num_added_total'] = meta['num_added_total']+len(add_rects)
                meta['num_image'] = meta['num_image'] + 1
                yield key, json_dump(merged_rects)
        # we will not change the files if they are the same
        def gen_info():
            meta['num_added_each'] = 1. * meta['num_added_total'] / meta['num_image']
            for k, v in viewitems(meta):
                yield k, v
            for k, rects in all_added:
                yield k, json_dump(rects)
        dataset.update_data(gen_rows(), split, 'label',
                generate_info=gen_info())

def generate_labels_to_verify(predict_file, data, split, th,
        pred_to_gt, output_file):
    dataset = TSVDataset(data)
    if op.isfile(op.join(dataset._data_root, 'root.yaml')):
        tax = Taxonomy(load_from_yaml_file(op.join(dataset._data_root, 'root.yaml')))
    else:
        tax = None
    gt_key_rects = [(row[0], json.loads(row[1])) for row in tqdm(dataset.iter_data(split,
        'label', version=-1))]
    logging.info('loading pred')
    pred_key_to_rects = {}
    for row in tqdm(tsv_reader(predict_file)):
        key = row[0]
        rects = json.loads(row[1])
        pred_key_to_rects[key] = [r for r in rects if r['conf'] > th]

    def gen_rows(pred_to_gt=True):
        logging.info('start to writting')
        for key, gt_rects in tqdm(gt_key_rects):
            if tax is not None:
                rects2 = lift_one_image(gt_rects, tax)
                del gt_rects[:]
                gt_rects.extend(rects2)
            pred_rects = pred_key_to_rects.get(key)
            if pred_rects is None:
                continue
            need_confirm = []
            if pred_to_gt:
                for pr in pred_rects:
                    if not onebb_in_list_of_bb(pr, gt_rects):
                        need_confirm.append(pr)
            else:
                for g in gt_rects:
                    if len(g) == 2:
                        assert 'class' in g and 'rect' in g
                        continue
                    if not onebb_in_list_of_bb(g, pred_rects):
                        need_confirm.append(g)
            yield key, json.dumps(need_confirm)

    tsv_writer(gen_rows(pred_to_gt=pred_to_gt), output_file)

def onebb_in_list_of_bb(bb, bbs):
    bbs = [b for b in bbs if b['class'] == bb['class']]
    return any(calculate_iou(b['rect'], bb['rect']) > 0.5 for b in bbs)

def inject_accuracy():
    all_full_expid = os.listdir('./output')
    for full_expid in tqdm(all_full_expid):
        inject_accuracy_one(full_expid)

def inject_accuracy_one(full_expid):
    from qd.db import create_annotation_db
    c = create_annotation_db()
    all_predict = glob.glob(op.join('output', full_expid, 'snapshot',
        '*.predict'))
    all_predict.extend(glob.glob(op.join('output', full_expid, 'snapshot',
        '*.predict.tsv')))

    all_report = glob.glob(op.join('output', full_expid, 'snapshot', '*.report'))
    for report_file in all_report:
        from .common import parse_test_data_with_version
        try:
            test_data, test_split, test_version = parse_test_data_with_version(op.basename(report_file))
        except:
            continue
        info = {'full_expid': full_expid,
                'report_file': op.basename(report_file),
                'test_data': test_data,
                'test_split': test_split,
                'test_version': test_version,
                }
        if 'coco_box' in report_file or '.randomness.' in report_file:
            acc = load_from_yaml_file(report_file)
        elif '.neg_aware_gmap.' in report_file:
            acc = load_from_yaml_file(report_file)
            if 'neg_aware_gmap.noNMSGt.noNMSDet.noExpandDet.report' in report_file:
                key = 'nngmAP'
            elif '.neg_aware_gmap.noNMSGt.report' in report_file:
                key = 'ngmAP'
            else:
                key = 'gmAP'
            acc = {key: acc['map']}
        elif '.top1.' in report_file:
            acc = load_from_yaml_file(report_file)
        elif report_file.endswith('predict.tsv.speed.yaml'):
            all_meter = load_from_yaml_file(report_file)['meters']
            all_meter = [m for m in all_meter if m['name'] == '']
            assert len(all_meter) == 1
            acc = all_meter[0]
            del acc['name']
        elif report_file.endswith('caption.report'):
            acc = json.loads(read_to_buffer(report_file))
        elif any(report_file.endswith(k) for k in [
            'ir_acc.report',
            'cap_acc.report',
            'cap_acc.nospace.report',
            'vqa_acc.report',
            'vqa2.report',
            'stvqa_acc.report',
            'stvqa_nopro_acc',
            'stvqa_anls.report',
            'nlvr2.report',
            'acc.report',
            'vizwiz_vqa.report',
            'textvqa_acc.report',
        ]):
            acc = load_from_yaml_file(report_file)
            from .common import get_all_path, dict_get_path_value
            all_path = get_all_path(acc)
            acc = {p: dict_get_path_value(acc, p) for p in all_path}
        elif report_file.endswith('attr.report'):
            x = json.loads(read_to_buffer(report_file))
            acc = {'attr': x['overall']['0.5']['map']}
        else:
            map_json_file = report_file + '.map.json'
            if op.isfile(map_json_file):
                x = json.loads(read_to_buffer(map_json_file))
                acc = {}
                for k1 in x:
                    for k2 in x[k1]:
                        for k3 in x[k1][k2]:
                            k = '{}${}${}'.format(k1, k2, k3)
                            acc[k] = x[k1][k2][k3]
            else:
                continue
        for k in list(acc.keys()):
            curr = copy.deepcopy(info)
            curr['metric_name'] = k
            exist = False
            for found in c.iter_acc(**curr):
                exist = True
                if found['metric_value'] == acc[k]:
                    continue
                else:
                    # the newer one will overwrite the old one. Sometimes, the
                    # code has issues and the experiment results are not
                    # correct
                    c.update_one_acc(query=curr,
                            update={'$set': {'metric_value': acc[k]}})
            if not exist:
                curr['metric_value'] = acc[k]
                c.insert_acc(**curr)

def find_predict_file(report_file, all_predict):
    for k in ['.ir_acc.report',
              '.vqa_acc.report',
              '.stvqa_acc.report',
              '.stvqa_anls.report',
              '.caption.report',
              '.attr.report'
              ]:
        if report_file.endswith(k):
            pred = report_file[:-len(k)] + '.tsv'
            if pred in all_predict:
                return pred
    #model_iter_0200182.pt.TaxImageNet2012CapDef.test.max_token100.vphoto_def.predict.top1.vphoto_def.report
    #model_iter_0200182.pt.TaxImageNet2012CapDef.test.max_token100.vphoto_def.predict.tsv
    r_pattern = '.*\.(v[^\.]*)\..*(v[^\.]*)\..*'
    result = re.match(r_pattern, op.basename(report_file))
    if result is not None:
        v1, v2 = result.groups()
        if v1 == v2:
           pattern = '(.*)\.top1\.{}\.report'.format(v1)
           result = re.match(pattern, op.basename(report_file))
           if result is not None:
               prefix, = result.groups()
               p = prefix + '.tsv'
               p = op.join(op.dirname(report_file), p)
               for p1 in all_predict:
                   if p1 == p:
                       return p


    found = False
    for p in all_predict:
        if p + '.report' == report_file:
            assert not found
            found = True
            result = p
            return result
    for p in all_predict:
        if p.endswith('.predict.tsv'):
            ps = p[: -len('.predict.tsv')]
        elif p.endswith('.predict'):
            ps = p[: -len('.predict')]
        else:
            continue
        if report_file.startswith(ps):
            rs = report_file[len(ps):]
            logging.info(rs)
            eval_keys = ['predict', 'tsv', 'coco_box', 'neg_aware_gmap', 'top1',
                    'noNMSGt', 'noNMSDet', 'noExpandDet', 'speed', 'MaxDet.*']
            p0 = ''.join(['(\.{})?'.format(k) for k in eval_keys])
            pattern = '{}(\.v[0-9]*)?(\.0)?\.(report|yaml)'.format(p0)
            if re.match(pattern, rs):
                assert not found
                found = True
                result = p
    if not found:
        matched = [p for p in all_predict if report_file.startswith(p)]
        if len(matched) > 0:
            result = sorted(matched, key=lambda x: -len(x))[0]
            found = True
    assert found
    return result

def softnms_row_process(row, sigma=0.5, method=2, Nt=0.5):
    from .common import softnms_c
    key, str_rects = row
    rects = json.loads(str_rects)
    all_class_rect = [(r['class'], r) for r in rects]
    class_to_rects = list_to_dict(all_class_rect, 0)
    rects2 = []
    for c, rs in class_to_rects.items():
        rs = softnms_c(rs, sigma=sigma, method=method, Nt=Nt)
        for r in rs:
            r['class'] = c
        rects2.extend(rs)
    return key, json_dump(rects2)

def tsv_subset_process_NtoN(info):
    row_processor = info['row_processor']
    idx_process = info['idx_process']
    tmp_out = info['tmp_out']
    idx_range_start = info['idx_range_start']
    idx_range_end = info['idx_range_end']
    head = info['head']
    sep = info['out_sep']
    if all(op.isfile(t) and all(op.isfile(s) for s in get_tsv_associates(t)) for t in tmp_out):
        logging.info('skip since exist: {}'.format(tmp_out))
        return
    if 'in_tsvs' in info:
        tsvs = info['in_tsvs']
    else:
        tsvs = [TSVFile(t) for t in info['in_tsv_files']]
    def gen_rows():
        if idx_process == 0 and head is not None:
            yield head
        for i in tqdm(range(idx_range_start, idx_range_end)):
            r = row_processor([t[i] for t in tsvs])
            if r is None:
                continue
            yield r
    tsv_writers(gen_rows(), tmp_out, sep=sep)
    logging.info('done to generate {}'.format(tmp_out))

def tsv_subset_process_1toN(info, with_row_idx):
    row_processor = info['row_processor']
    idx_process = info['idx_process']
    tmp_out = info['tmp_out']
    idx_range_start = info['idx_range_start']
    idx_range_end = info['idx_range_end']
    head = info['head']
    sep = info['out_sep']
    if all(op.isfile(t) for t in tmp_out):
        logging.info('skip since exist: {}'.format(tmp_out))
        return
    if 'in_tsv' in info:
        tsv = info['in_tsv']
    else:
        in_tsv_file = info['in_tsv_file']
        tsv = TSVFile(in_tsv_file)
    def gen_rows():
        if idx_process == 0 and head is not None:
            yield head
        for i in tqdm(range(idx_range_start, idx_range_end)):
            try:
                if with_row_idx:
                    r = row_processor(tsv[i], i)
                else:
                    r = row_processor(tsv[i])
                if r is None:
                    continue
                if isinstance(r, (list, tuple)):
                    yield r
                else:
                    while True:
                        try:
                            x = next(r)
                            yield x
                        except StopIteration:
                            break
            except:
                logging.info(f'{tsv}-{i}')
                raise
    tsv_writers(gen_rows(), tmp_out, sep=sep)

def tsv_subset_process(info, with_row_idx=False):
    row_processor = info['row_processor']
    idx_process = info['idx_process']
    tmp_out = info['tmp_out']
    idx_range_start = info['idx_range_start']
    idx_range_end = info['idx_range_end']
    head = info['head']
    sep = info['out_sep']
    if op.isfile(tmp_out):
        logging.info('skip since exist: {}'.format(tmp_out))
        return
    if 'in_tsv' in info:
        tsv = info['in_tsv']
    else:
        in_tsv_file = info['in_tsv_file']
        tsv = TSVFile(in_tsv_file)
    def gen_rows():
        if idx_process == 0 and head is not None:
            yield head
        for i in tqdm(range(idx_range_start, idx_range_end)):
            # this is a breaking change to add i as option, but we have to do
            # this as row_processor has no way to figure it out which row it is
            try:
                if with_row_idx:
                    r = row_processor(tsv[i], i)
                else:
                    r = row_processor(tsv[i])
                if r is None:
                    continue
                if isinstance(r, (list, tuple)):
                    yield r
                else:
                    while True:
                        try:
                            x = next(r)
                            yield x
                        except StopIteration:
                            break
            except:
                logging.info(f'{tsv}/{i}')
                raise
    tsv_writer(gen_rows(), tmp_out, sep=sep)

def tsv_subset_aggregator(info, with_row_idx=False):
    row_processor = info['row_processor']
    tmp_out = info['tmp_out']
    idx_range_start = info['idx_range_start']
    idx_range_end = info['idx_range_end']
    if File.isfile(tmp_out):
        return load_from_yaml_file(tmp_out)
    if 'in_tsv' in info:
        tsv = info['in_tsv']
    else:
        in_tsv_file = info['in_tsv_file']
        tsv = TSVFile(in_tsv_file)
    ret = {}
    for i in tqdm(range(idx_range_start, idx_range_end)):
        # this is a breaking change to add i as option, but we have to do
        # this as row_processor has no way to figure it out which row it is
        try:
            if with_row_idx:
                row_processor(ret, tsv[i], i)
            else:
                row_processor(ret, tsv[i])
        except:
            logging.info(f'{tsv}/{i}')
            raise
    write_to_yaml_file(ret, tmp_out)
    return ret

def multi_tsv_subset_process(info):
    row_processor = info['row_processor']
    idx_process = info['idx_process']
    in_tsv_files = info['in_tsv_files']
    tmp_out = info['tmp_out']
    idx_range = info['idx_range']
    head = info['head']
    out_sep = info['out_sep']
    if op.isfile(tmp_out):
        logging.info('skip to create {}'.format(tmp_out))
        return
    def gen_rows():
        if idx_process == 0 and head is not None:
            yield head
        tsvs = [TSVFile(f) for f in in_tsv_files]
        for i in tqdm(idx_range):
            row_result = row_processor([tsv[i] for tsv in tsvs])
            if row_result is not None:
                # we can return None to remove rows
                yield row_result
    tsv_writer(gen_rows(), tmp_out, sep=out_sep)

def multi_tsv_row_merger(rows):
    all_key = [row[0] for row in rows]
    assert all(all_key[0] == key for key in all_key[1:])
    all_rect = [json.loads(row[1]) for row in rows]
    str_rect = json_dump([r for rs in all_rect for r in rs])
    return all_key[0], str_rect

def parallel_tsv_process_NtoN(row_processor, in_tsv_files,
        out_tsv_files, num_process, num_jobs=None, head=None, out_sep='\t'):
    in_tsvs = [TSVFile(in_tsv_file) if isinstance(in_tsv_file, str) else
               in_tsv_file for in_tsv_file in in_tsv_files]
    total = len(in_tsvs[0])
    assert all(len(t) == total for t in in_tsvs[1:])
    for t in in_tsvs:
        t.close()
    if num_jobs is None:
        num_jobs = max(1, num_process)
    rows_each_rank = (total + num_jobs - 1) // num_jobs
    all_task = []
    folder = get_tmp_folder()
    for i in range(num_jobs):
        start = i * rows_each_rank
        end = start + rows_each_rank
        end = min(end, total)
        tmp_out = ['{}/{}'.format(folder, out_tsv_file) + '.{}.{}.tsv'.format(i, num_jobs)
            for out_tsv_file in out_tsv_files]
        info = {
            'row_processor': row_processor,
            'idx_process': i,
            #'in_tsv_files': in_tsv_files,
            'in_tsvs': in_tsvs,
            'tmp_out': tmp_out,
            'idx_range_start': start,
            'idx_range_end': end,
            'head': head,
            'out_sep': out_sep,
        }
        all_task.append(info)
    from .common import parallel_map
    parallel_map(tsv_subset_process_NtoN, all_task,
                 num_worker=num_process)
    all_out = [task['tmp_out'] for task in all_task]
    for i, out_tsv_file in enumerate(out_tsv_files):
        tmp_out = [out[i] for out in all_out]
        concat_tsv_files(tmp_out, out_tsv_file, gen_lineidx=False)
        delete_tsv_files(tmp_out)

def parallel_multi_tsv_process(row_processor, in_tsv_files,
        out_tsv_file, num_process, num_jobs=None, head=None, out_sep='\t'):
    in_tsvs = [TSVFile(in_tsv_file) for in_tsv_file in in_tsv_files]
    total = len(in_tsvs[0])
    assert all(len(t) == total for t in in_tsvs[1:])
    if num_jobs is None:
        num_jobs = max(1, num_process)
    rows_each_rank = (total + num_jobs - 1) // num_jobs
    all_task = []
    for i in range(num_jobs):
        start = i * rows_each_rank
        end = start + rows_each_rank
        end = min(end, total)
        if num_jobs == 1:
            tmp_out = out_tsv_file
        else:
            tmp_out = out_tsv_file + '.{}.{}.tsv'.format(i, num_jobs)
        info = {'row_processor': row_processor,
                'idx_process': i,
                'in_tsv_files': in_tsv_files,
                'tmp_out': tmp_out,
                'idx_range': list(range(start, end)),
                'head': head,
                'out_sep': out_sep
                }
        all_task.append(info)
    from .common import parallel_map
    parallel_map(multi_tsv_subset_process, all_task,
            num_worker=num_process)
    if num_jobs > 1:
        all_out = [task['tmp_out'] for task in all_task]
        concat_tsv_files(all_out, out_tsv_file, gen_lineidx=False)
        delete_tsv_files(all_out)

def parallel_tsv_process_1toN(row_processor, in_tsv_file,
                              out_tsv_files, num_process, num_jobs=None, head=None, out_sep='\t',
                              with_row_idx=False,
                              ):
    # in_tsv_file can be a string, interpreted as a tsv file
    # or a list
    if isinstance(in_tsv_file, str):
        in_tsv = TSVFile(in_tsv_file)
    else:
        in_tsv = in_tsv_file
    total = len(in_tsv)
    if num_jobs is None:
        if num_process == 0:
            num_jobs = 1
        else:
            num_jobs = num_process
    rows_each_rank = (total + num_jobs - 1) // num_jobs
    all_task = []
    if isinstance(in_tsv, (TSVFile, CompositeTSVFile)):
        # we need to clear all the cache in TSVFile. otherwise, the process
        # might need a lot of time to copy the cache in in_tsv, e.g. lineidx
        # when the number of data are huge.
        in_tsv.close()
    folder = get_tmp_folder()
    for i in range(num_jobs):
        start = i * rows_each_rank
        end = start + rows_each_rank
        end = min(end, total)
        tmp_out = ['{}/{}'.format(folder, out_tsv_file) + '.{}.{}.tsv'.format(i, num_jobs)
            for out_tsv_file in out_tsv_files]
        info = {'row_processor': row_processor,
                'idx_process': i,
                #'in_tsv_file': in_tsv_file,
                'in_tsv': in_tsv,
                'tmp_out': tmp_out,
                'idx_range_start': start,
                'idx_range_end': end,
                'head': head,
                'out_sep': out_sep
                }
        all_task.append(info)
    from .common import parallel_map
    parallel_map(lambda x: tsv_subset_process_1toN(x, with_row_idx), all_task,
            num_worker=num_process)
    all_out = [task['tmp_out'] for task in all_task]
    if isinstance(in_tsv, TSVFile):
        # explicitly close the file
        in_tsv.close()
    for i, out_tsv_file in enumerate(out_tsv_files):
        tmp_out = [out[i] for out in all_out]
        concat_tsv_files(tmp_out, out_tsv_file, gen_lineidx=False)
        delete_tsv_files(tmp_out)

def parallel_tsv_process(row_processor, in_tsv_file,
                         out_tsv_file,
                         num_process=64,
                         num_jobs=None,
                         head=None,
                         out_sep='\t',
                         with_row_idx=False,
                         ):
    if isinstance(in_tsv_file, str):
        in_tsv = TSVFile(in_tsv_file)
    else:
        in_tsv = in_tsv_file
    total = len(in_tsv)
    if num_jobs is None:
        if num_process == 0:
            num_jobs = 1
        else:
            num_jobs = num_process
    rows_each_rank = (total + num_jobs - 1) // num_jobs
    all_task = []
    if isinstance(in_tsv, TSVFile):
        # we need to clear all the cache in TSVFile. otherwise, the process
        # might need a lot of time to copy the cache in in_tsv, e.g. lineidx
        # when the number of data are huge.
        in_tsv.close()
    folder = get_tmp_folder()
    for i in range(num_jobs):
        start = i * rows_each_rank
        end = start + rows_each_rank
        end = min(end, total)
        #tmp_out = out_tsv_file + '.{}.{}.tsv'.format(i, num_jobs)
        tmp_out = '{}/{}'.format(folder, out_tsv_file) + '.{}.{}.tsv'.format(i, num_jobs)
        info = {'row_processor': row_processor,
                'idx_process': i,
                #'in_tsv_file': in_tsv_file,
                'in_tsv': in_tsv,
                'tmp_out': tmp_out,
                'idx_range_start': start,
                'idx_range_end': end,
                'head': head,
                'out_sep': out_sep
                }
        all_task.append(info)
    from .common import parallel_map
    parallel_map(lambda x: tsv_subset_process(x, with_row_idx), all_task,
            num_worker=num_process)
    all_out = [task['tmp_out'] for task in all_task]
    concat_tsv_files(all_out, out_tsv_file, gen_lineidx=False)
    delete_tsv_files(all_out)

def parallel_tsv_aggregator(
    mapper,
    reducer,
    in_tsv_file,
    num_process=64,
    num_jobs=None,
    head=None,
    out_sep='\t',
    with_row_idx=False,
):
    if isinstance(in_tsv_file, str):
        in_tsv = TSVFile(in_tsv_file)
    else:
        in_tsv = in_tsv_file
    total = len(in_tsv)
    if num_jobs is None:
        if num_process == 0:
            num_jobs = 1
        else:
            num_jobs = num_process
    rows_each_rank = (total + num_jobs - 1) // num_jobs
    all_task = []
    if isinstance(in_tsv, TSVFile):
        # we need to clear all the cache in TSVFile. otherwise, the process
        # might need a lot of time to copy the cache in in_tsv, e.g. lineidx
        # when the number of data are huge.
        in_tsv.close()
    folder = get_tmp_folder()
    basename = datetime.now().strftime('%Y_%m_%d_%H_%M_%S') + '_' + str(hash(in_tsv_file))
    for i in range(num_jobs):
        start = i * rows_each_rank
        end = start + rows_each_rank
        end = min(end, total)
        #tmp_out = out_tsv_file + '.{}.{}.tsv'.format(i, num_jobs)
        tmp_out = '{}/{}'.format(folder, basename) + '.{}.{}.yaml'.format(i, num_jobs)
        info = {'row_processor': mapper,
                'idx_process': i,
                #'in_tsv_file': in_tsv_file,
                'in_tsv': in_tsv,
                'tmp_out': tmp_out,
                'idx_range_start': start,
                'idx_range_end': end,
                'head': head,
                'out_sep': out_sep
                }
        all_task.append(info)
    from .common import parallel_map
    rets = parallel_map(lambda x: tsv_subset_aggregator(x, with_row_idx), all_task,
            num_worker=num_process)
    rets = reducer(rets)
    all_out = [task['tmp_out'] for task in all_task]
    for f in all_out:
        ensure_remove_file(f)
    return rets

def mpi_tsv_process(row_processor, in_tsv_file, out_tsv_file):
    mpi_size = get_mpi_size()
    mpi_rank = get_mpi_rank()
    in_tsv = TSVFile(in_tsv_file)
    total = len(in_tsv)
    rows_each_rank = (total + mpi_size - 1) // mpi_size
    logging.info('size for each rank = {}'.format(rows_each_rank))
    start = mpi_rank * rows_each_rank
    end = min(start + rows_each_rank, total)
    logging.info('rank = {}; start = {}; end = {}'.format(mpi_rank,
        start, end))
    out_tsv_rank = out_tsv_file + '.{}.{}.tsv'.format(mpi_rank, mpi_size)
    def gen_rows():
        for i in tqdm(range(start, end)):
            row = in_tsv[i]
            row = row_processor(row)
            yield row
    tsv_writer(gen_rows(), out_tsv_rank)

    all_out = [out_tsv_file + '.{}.{}.tsv'.format(i, mpi_size) for i in
            range(mpi_size)]

    while True:
        if all(op.isfile(f) for f in all_out):
            break
        logging.info('waiting {}'.format('; '.join(f for f in all_out if not
            op.isfile(f))))
        time.sleep(5)

    if mpi_rank == 0:
        concat_tsv_files(all_out, out_tsv_file)
        delete_tsv_files(all_out)
    else:
        while not op.isfile(out_tsv_file):
            logging.info('waiting {}'.format(out_tsv_file))
            time.sleep(5)

def create_focus_dataset(data, source_version, target_labels, out_data):
    out_dataset = TSVDataset(out_data)
    write_to_file('\n'.join(target_labels),
            out_dataset.get_labelmap_file())

    # train
    dataset = TSVDataset(data)
    write_to_file(dataset.get_data('train'), out_dataset.get_data('trainX'))
    write_to_file(dataset.get_data('train', t='hw'),
            out_dataset.get_data('trainX', t='hw'))

    def gen_rows():
        target_label_set = set(target_labels)
        for key, str_rects in dataset.iter_data('train', t='label',
                version=source_version, progress=True):
            rects = json.loads(str_rects)
            rects = [r for r in rects if r['class'] in target_label_set]
            yield '_'.join([data, 'train', key]), json_dump(rects)
    out_dataset.write_data(gen_rows(), 'train', t='label')
    num_rows = dataset.num_rows('train')
    tsv_writer(((0, i) for i in range(num_rows)),
            op.join(out_dataset._data_root, 'train.shuffle.txt'))

class CogAPI(object):
    def __init__(self):
        self.remote_image_features = ['adult']
        self.run_ocr = False
        self.computervision_client = None

    def ensure_init(self):
        from msrest.authentication import CognitiveServicesCredentials
        from azure.cognitiveservices.vision.computervision import ComputerVisionClient
        if self.computervision_client is None:
            x = load_from_yaml_file('aux_data/configs/cognitive_credential.yaml')
            self.subscription_key = x['subscription_key']
            self.endpoint = x['endpoint']
            self.computervision_client = ComputerVisionClient(self.endpoint,
                    CognitiveServicesCredentials(self.subscription_key))

    def call(self, image_url):
        self.ensure_init()
        result = {}
        if self.remote_image_features:
            remote_image_analysis = self.computervision_client.analyze_image(image_url,
                    self.remote_image_features)
            from azure.cognitiveservices.vision.computervision.models import VisualFeatureTypes
            if 'adult' in self.remote_image_features:
                result.update(self.parse_adult(remote_image_analysis))
            if 'description' in self.remote_image_features:
                result.update(self.parse_description(remote_image_analysis))
            if VisualFeatureTypes.image_type in self.remote_image_features:
                result.update(self.parse_type(remote_image_analysis))
        if self.run_ocr:
            recognize_printed_results = self.computervision_client.batch_read_file(image_url,  raw=True)
            result.update(self.parse_ocr(recognize_printed_results))

        return result

    def parse_ocr(self, recognize_printed_results):
        from azure.cognitiveservices.vision.computervision.models import TextOperationStatusCodes
        # Get the operation location (URL with an ID at the end) from the response
        operation_location_remote = recognize_printed_results.headers["Operation-Location"]
        # Grab the ID from the URL
        operation_id = operation_location_remote.split("/")[-1]

        # Call the "GET" API and wait for it to retrieve the results 
        while True:
            get_printed_text_results = self.computervision_client.get_read_operation_result(operation_id)
            if get_printed_text_results.status not in ['NotStarted', 'Running']:
                break
            time.sleep(1)

        lines = []
        if get_printed_text_results.status == TextOperationStatusCodes.succeeded:
            for text_result in get_printed_text_results.recognition_results:
                for line in text_result.lines:
                    lines.append({'text': line.text, 'bounding_box':
                        line.bounding_box})
        return {'ocr': lines}

    def parse_description(self, result):
        return {'captions': [{'text': cap.text,
                              'conf': cap.confidence}
                              for cap in result.description.captions]}

    def parse_type(self, remote_image_analysis):
        return {'clip_art_type': remote_image_analysis.image_type.clip_art_type,
                'line_drawing_type': remote_image_analysis.image_type.line_drawing_type,
                }

    def parse_adult(self, remote_image_analysis):
        result = {'is_adult': remote_image_analysis.adult.is_adult_content,
                'adult_score': remote_image_analysis.adult.adult_score,
                'is_racy': remote_image_analysis.adult.is_racy_content,
                'racy_score': remote_image_analysis.adult.racy_score}
        return result

def adult_filtering_by_cogapi(data, split):
    dataset = TSVDataset(data)
    api = CogAPI()
    in_tsv = dataset.get_data(split, 'key.url')
    out_tsv = dataset.get_data(split, 'key.adult')
    def row_processor(row):
        key, url = row
        try:
            result = api.call(url)
            return key, json_dump(result)
        except:
            from .common import print_trace
            print_trace()
            return key, json_dump(-1)
    if op.isfile(out_tsv):
        return
    parallel_tsv_process(row_processor, in_tsv,
            out_tsv, num_process=16, num_jobs=1024)

def scale_ocr_result(result, h_scale, w_scale):
    for r in result:
        r['rect'][::2] = [x * w_scale for x in r['rect'][::2]]
        r['rect'][1::2] = [x * h_scale for x in r['rect'][1::2]]
        r['lines'][::2] = [x * w_scale for x in r['lines'][::2]]
        r['lines'][1::2] = [x * h_scale for x in r['lines'][1::2]]

def ocr_engine_result_to_rects(lines):
    rects = []
    for info in lines:
        r = {}
        xs = info['boundingBox'][::2]
        ys = info['boundingBox'][1::2]
        r['rect'] = [min(xs), min(ys), max(xs), max(ys)]
        r['class'] = 'text'
        r['lines'] = info['boundingBox']
        r['text'] = info['text']
        rects.append(r)
    return rects

def run_ocr_on_content(input_file, urls):
    headers = {
        'Content-Type':'image/jpg'
    }
    url = urls[int(random.random() * 9999) % len(urls)]
    import requests
    r = requests.post(url, headers=headers, data=input_file)

    if (r.ok):
        x = json.loads(r.text)
        if 'analyzeResult' not in x or 'readResults' not in x['analyzeResult']:
            return []
        rects = ocr_engine_result_to_rects(x['analyzeResult']['readResults'][0]['lines'])
        return rects

class OCRRowProcessor(object):
    def __init__(self, urls):
        self.urls = urls

    def __call__(self, row):
        if len(row) == 3:
            key, str_rects, str_im = row
        else:
            key, str_im = row
        im = img_from_base64(str_im)
        def proper_image_scale(im):
            h, w = im.shape[:2]
            if h <= w:
                ratio = 800. / h
                w = ratio * w
                h = 800
                if w > 8000:
                    w = 8000
            else:
                ratio = 800. / w
                w = 800
                h = ratio * h
                if h > 8000:
                    h = 8000
            im = cv2.resize(im, (int(w), int(h)))
            return im

        if max(im.shape[:2]) <= 200 or max(im.shape[:2]) > 8000:        
            im_scale = proper_image_scale(im)
            h_scale, w_scale = (1. * im_scale.shape[0] / im.shape[0], 1. *
                    im_scale.shape[1] / im.shape[1])
        else:
            h_scale, w_scale = 1, 1
            im_scale = im

        content = cv2.imencode('.jpg', im_scale)[1]
        try:
            result = run_ocr_on_content(content.tobytes(), self.urls)
        except:
            logging.info(pformat(im_scale.shape))
            raise
        if result is None:
            logging.info('unable to process {}'.format(key))
            return key, -1
        else:
            scale_ocr_result(result, 1./h_scale, 1./w_scale)
            return key, json_dump(result)

def ocr_tsv(in_tsv, out_tsv, urls):
    processor = OCRRowProcessor(urls)
    parallel_tsv_process(processor, in_tsv, out_tsv,
            num_process=5, num_jobs=10240)

def create_dataset_from_pred(pred_tsv, conf_th, src_data, out_data):
    # create label
    def gen_rows():
        for key, str_rects in tqdm(tsv_reader(pred_tsv)):
            rects = json.loads(str_rects)
            high_rects = [r for r in rects if r['conf'] > conf_th]
            if len(high_rects) > 0:
                yield '_'.join([src_data, 'train', key]), json_dump(high_rects)
    tsv_writer(gen_rows(), './data/{}/train.label.tsv'.format(out_data))

    create_image_X_by_key(out_data, 'train', 'label')
    ensure_copy_file(TSVDataset('coco2017Full').get_labelmap_file(),
        TSVDataset(out_data).get_labelmap_file())
    populate_dataset_details(out_data)
    populate_dataset_hw(out_data, ['train'])

def create_image_X_by_key(target_data, target_split, t):
    # given train.label.tsv where key is a composed key, we derive the
    # trainX.tsv and the shuffle file
    dataset = TSVDataset(target_data)
    data_split_keys = [parse_combine(key) for key, _ in
            dataset.iter_data(target_split, t)]
    data_to_split_keys = list_to_dict(data_split_keys, 0)
    data_splits = []
    for data, split_keys in data_to_split_keys.items():
        split_to_keys = list_to_dict(split_keys, 0)
        for split in split_to_keys:
            data_splits.append((data, split))
    data_to_dataset = {}
    def get_dataset(src_data):
        if src_data not in data_to_dataset:
            data_to_dataset[src_data] = TSVDataset(src_data)
        return data_to_dataset[src_data]
    src_tsv = [get_dataset(data).get_data(split) for data, split in data_splits]
    data_split_to_idx = {data_split: i for i, data_split in
            enumerate(data_splits)}
    def gen_shuffle():
        for src_data, src_split, src_key in data_split_keys:
            idx_source = data_split_to_idx[(src_data, src_split)]
            idx_key = get_dataset(src_data).get_idx_by_key(src_key,
                    src_split)
            yield idx_source, idx_key

    tsv_writer(gen_shuffle(),
            get_dataset(target_data).get_shuffle_file(target_split))
    write_to_file('\n'.join(src_tsv),
            get_dataset(target_data).get_data(target_split + 'X'))

def create_tiny_set(data, out_data):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)

    num_image = dataset.num_rows('train')
    all_idx = list(range(num_image))
    random.shuffle(all_idx)

    out_num_train = int(0.1 * len(all_idx))
    out_num_test = int(0.05 * len(all_idx))
    train_idx = all_idx[:out_num_train]
    test_idx = all_idx[out_num_train: (out_num_train + out_num_test)]

    ensure_copy_file(dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file())

    for t in [None, 'label']:
        out_dataset.write_data(dataset.iter_data('train',
                                                 t=t,
                                                 filter_idx=train_idx,
                                                 progress=True),
                               split='train',
                               t=t)
        out_dataset.write_data(dataset.iter_data('train',
                                                 t=t,
                                                 filter_idx=test_idx,
                                                 progress=True),
                               split='test',
                               t=t)

def create_tsv_by_image_folder(folder, tsv_file,
        max_short=1200, key_func=None):
    from .common import is_valid_image
    from .common import insensitive_glob
    from .process_image import load_image
    if key_func is None:
        key_func = lambda f: op.basename(f)
    def gen_rows():
        for ext in ['png', 'jpg', 'jpeg', 'JPG']:
            pattern = '*.{}'.format(ext)
            pattern = op.join(folder, pattern)
            im_files = insensitive_glob(pattern)
            for f in tqdm(im_files):
                im = load_image(f)
                if not is_valid_image(im):
                    continue
                if min(im.shape[:2]) > max_short:
                    ratio = 1. * max_short / min(im.shape[:2])
                    h = int(im.shape[0] * ratio)
                    w = int(im.shape[1] * ratio)
                    im = cv2.resize(im, (w, h))
                    yield key_func(f), encoded_from_img(im)
                else:
                    yield key_func(f), base64.b64encode(read_to_buffer(f))
    tsv_writer(gen_rows(), tsv_file)

def create_versions_from_uncertain_label(data, split):
    dataset = TSVDataset(data)
    info = defaultdict(int)
    assert not dataset.has(split, 'label', version=1)
    assert not dataset.has(split, 'label', version=2)
    def gen_rows():
        iter_label = dataset.iter_data(split, 'label')
        for key, str_rects in tqdm(iter_label):
            rects = json.loads(str_rects)
            for r in rects:
                if r['class'].endswith('_?'):
                    r['class'] = r['class'][:-2]
                    info[r['class']] += 1
            yield key, json_dump(rects)
    def gen_info():
        yield 'remove _? in class name', 'keep the boxes'
        for k, v in info.items():
            yield k, v
    dataset.update_data(gen_rows(), split, 'label',
            generate_info=gen_info())

    info = defaultdict(int)
    def gen_rows2():
        iter_label = dataset.iter_data(split, 'label')
        for key, str_rects in iter_label:
            rects = json.loads(str_rects)
            origin_num = len(rects)
            info['original box'] += origin_num
            if split == 'train':
                rects = [r for r in rects if not r['class'].endswith('_?')]
                info['removed'] += origin_num - len(rects)
            else:
                assert split == 'test'
                for r in rects:
                    if r['class'].endswith('_?'):
                        r['class'] = r['class'][:-2]
                        r['diff'] = 1
                        info['new diff set'] += 1
            yield key, json_dump(rects)
    def gen_info2():
        if split == 'train':
            yield 'remove the box whose label ends with _?',
        else:
            assert split == 'test'
            yield 'remove _? if the class ends with _?.', \
                    'keep the box', \
                    'add diff = 1'
        for k, v in info.items():
            yield k, v
    dataset.update_data(gen_rows2(), split, 'label',
            generate_info=gen_info2())

def remove_size_in_label(data, split, version):
    dataset = TSVDataset(data)
    def gen_rows():
        for key, str_rects in tqdm(dataset.iter_data(split, 'label',
            version=version)):
            rects = json.loads(str_rects)
            assert len(rects) == 1
            c = rects[0]['class']
            assert not all(s in c for s in ['_s_', '_S_'])
            for s in ['_s_', '_S_']:
                parts = c.split('_s_')
                assert len(parts) in [1, 2]
                rects[0]['class'] = parts[0]
                if len(parts) == 2:
                    break
            yield key, json_dump(rects)
    dataset.update_data(gen_rows(), split, 'label',
        generate_info=[('remove size in the label', )])

def crop_detbox(data, split, version, out_data=None, save_type=None):
    dataset = TSVDataset(data)
    iter_image = dataset.iter_data(split)
    iter_label = dataset.iter_data(split, 'label', version=version)
    labels = []
    def gen_rows():
        for (image_key, _, image_str), (label_key, str_rects) in tqdm(
                zip(iter_image, iter_label)):
            assert image_key == label_key
            im = img_from_base64(image_str)
            h, w = im.shape[:2]
            rects = json.loads(str_rects)
            for i, r in enumerate(rects):
                x0, y0, x1, y1 = r['rect']
                x0, y0 = int(x0), int(y0)
                x1, y1 = math.ceil(x1), math.ceil(y1)
                x0, y0 = max(0, x0), max(0, y0)
                x1, y1 = min(x1, w), min(y1, h)
                if x1 <= x0 or y1 <= y0:
                    continue
                sub = im[y0:y1, x0:x1, :]
                del r['rect']
                res_key = image_key + '${}'.format(i)
                str_label = json_dump([r])
                labels.append((res_key, str_label))
                yield res_key, str_label, encoded_from_img(sub,
                        save_type=save_type)
    if out_data is None:
        out_data = '{}_crop_{}{}'.format(data, split, version)
    out_dataset = TSVDataset(out_data)
    if out_dataset.has(split):
        logging.info('{} - {} exists'.format(out_dataset.name,
            split))
        return out_data
    #assert not out_dataset.has(split)
    out_dataset.write_data(gen_rows(), split)
    out_dataset.write_data(labels, split, 'label')
    populate_dataset_details(out_data)
    return out_data

def create_single_class_detection_taxonomy(data, split, version, root_name,
        excludes=None):
    populate_dataset_details(data)
    dataset = TSVDataset(data)
    labels = [l for l, in dataset.iter_data(split, 'labelmap', version=version)]
    if excludes is not None:
        lower_label = [(l.lower(), l) for l in labels]
        lower_to_labels = list_to_dict(lower_label, 0)
        lower_excludes = [e.lower() for e in excludes]
        for e in lower_excludes:
            if e in lower_to_labels:
                del lower_to_labels[e]
        labels = [l for _, ls in lower_to_labels.items() for l in ls]
    info = [{'name': root_name,
            'alias_names': ','.join(labels)}]
    return info

def unflatten_to_detection(data, split, pred, output,
        threshold=0.01):
    dataset = TSVDataset(data)
    iter_label = dataset.iter_data(split, 'label')
    iter_pred = tsv_reader(pred)
    def gen_rows():
        pre_key = None
        pre_rects = []
        for (key, str_rects), (pred_key, pred_rects) in tqdm(zip(
                iter_label, iter_pred)):
            assert key == pred_key
            idx = key.rfind('$')
            real_key = key[:idx]
            if real_key != pre_key:
                if pre_key is not None:
                    yield pre_key, json_dump(pre_rects)
                pre_key = real_key
                pre_rects = []
            gt = json.loads(str_rects)
            assert len(gt) == 1
            gt = gt[0]
            pred = json.loads(pred_rects)
            for p in pred:
                sub_gt = copy.deepcopy(gt)
                sub_gt['class'] = p['class']
                sub_gt['conf'] *= p['conf']
                if sub_gt['conf'] > threshold:
                    pre_rects.append(sub_gt)
        yield pre_key, json_dump(pre_rects)
    tsv_writer(gen_rows(), output)

def flatten_labels_for_classification(image_data, image_split, label_tsv,
        out_data, out_split):
    input_argument = get_frame_info()
    input_argument['func'] = 'flatten_labels_for_classification'

    dataset = TSVDataset(image_data)

    populate_dataset_hw(image_data, [image_split])

    iter_hw = dataset.iter_data(image_split, 'hw')
    if label_tsv is not None:
        iter_label = tsv_reader(label_tsv)
    else:
        iter_label = dataset.iter_data(image_split, 'label')

    all_idx = []
    def gen_rows():
        for idx_image, ((label_key, str_rects), (hw_key, str_hw)) in enumerate(
                zip(iter_label, iter_hw)):
            assert label_key == hw_key
            h, w = map(int, str_hw.split(' '))
            rects = json.loads(str_rects)
            for i, r in enumerate(rects):
                x1, y1, x2, y2 = r['rect']

                # since it is for classification, it has to be a valid box.
                # Here we do the fewest pre-processing/filtering to have a
                # valid box coordinates
                x1 = int(x1)
                y1 = int(y1)
                x2 = math.ceil(x2)
                y2 = math.ceil(y2)

                x1 = min(w, max(0, x1))
                x2 = min(w, max(0, x2))
                y1 = min(h, max(0, y1))
                y2 = min(h, max(0, y2))

                if y2 <= y1 or x2 <= x1:
                    continue
                r['rect'] = [x1, y1, x2, y2]
                all_idx.append(idx_image)
                yield label_key + '${}'.format(i), json_dump([r])
    if out_data == None:
        out_data = '{}_{}'.format(image_data,
                hash_sha1(label_tsv)[-5:])
    out_dataset = TSVDataset(out_data)
    if op.isdir(out_dataset._data_root):
        logging.info('{} exists'.format(out_dataset._data_root))
        return out_data
    out_dataset.write_data(gen_rows(), out_split, 'label')
    tsv_writer(((0, i) for i in all_idx),
            out_dataset.get_shuffle_file(out_split))
    write_to_file(dataset.get_data(image_split), out_dataset.get_data(out_split
        + 'X'))
    readme_file = op.join(out_dataset._data_root, 'readme.yaml')

    write_to_yaml_file(input_argument, readme_file)

    expand_nested_splitX(out_data, out_split)

    return out_data

def download_images_to_tsv(info, tsv_file, key='key'):
    from .common import url_to_bytes
    from .common import bytes_to_image
    def processor(i):
        bs = url_to_bytes(i['url'])
        if bs is None:
            return None
        try:
            im = bytes_to_image(bs)
        except:
            return None
        if im is None:
            return None
        return i[key], json_dump([]), base64.b64encode(bs)
    parallel_tsv_process(processor, info, tsv_file, num_process=16,
            num_jobs=1024)

def smart_resize_dataset(data, input_size, out_data, resize_type='cv2',
        save_type=None):
    if resize_type is None:
        resize_type = 'cv2'
    assert resize_type in ['cv2', 'pil']
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)

    for split in ['train', 'test']:
        if not dataset.has(split):
            continue
        infos = []
        def gen_rows():
            if resize_type == 'cv2':
                for key, str_rects, str_im in dataset.iter_data(split,
                        progress=True):
                    im = img_from_base64(str_im)
                    im2, left, top, scale = smart_resize(im, input_size)
                    im2 = im2.astype(np.uint8)
                    infos.append((left, top, scale))
                    yield key, json_dump([]), encoded_from_img(im2,
                            save_type=save_type)
            else:
                assert resize_type == 'pil'
                for key, str_rects, str_im in dataset.iter_data(split,
                        progress=True):
                    im = pilimg_from_base64(str_im)
                    im2, left, top, scale = smart_resize(im, input_size)
                    infos.append((left, top, scale))
                    yield key, json_dump([]), encoded_from_img(im2,
                            save_type=save_type)
        if not out_dataset.has(split):
            out_dataset.write_data(gen_rows(), split)
        v = 0
        while dataset.has(split, 'label', version=v):
            def gen_label_rows():
                for i, (key, str_rects) in enumerate(dataset.iter_data(split, 'label',
                        version=v, progress=True)):
                    rects = json.loads(str_rects)
                    def transform_box(r, info):
                        left, top, scale = info
                        x1, y1, x2, y2 = r['rect']
                        out_x1 = x1 * scale + left
                        out_y1 = y1 * scale + top
                        out_x2 = x2 * scale + left
                        out_y2 = y2 * scale + top
                        r['rect'] = [out_x1, out_y1, out_x2, out_y2]
                        return r
                    rects = [transform_box(r, infos[i]) for r in rects]
                    yield key, json_dump(rects)
            if not out_dataset.has(split, 'label', version=v):
                out_dataset.write_data(gen_label_rows(), split, 'label', version=v)
            v += 1
    ensure_copy_file(dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file())
    populate_dataset_hw(out_data)

def smart_resize_lefttop(im, target_size, lower=True):
    from .process_image import is_pil_image
    if is_pil_image(im):
        w, h = im.size
    else:
        h, w, c = im.shape
    alpha = target_size / np.sqrt(h * w)
    if lower:
        height2 = int(alpha * h)
        width2 = int(alpha * w)
    else:
        height2 = int(np.round(alpha * h))
        width2 = int(np.round(alpha * w))
    if h > w:
        if lower:
            input_height = height2 // 32 * 32
            input_width = (input_height * w) // h // 32 * 32
            im_scale = input_width / w
        else:
            input_height = (height2 + 31) // 32 * 32
            input_width = ((input_height * w + h - 1) // h +
                                        31) // 32 * 32
    else:
        if lower:
            input_width = (width2) // 32 * 32
            input_height = (input_width * h) // w // 32 * 32
            im_scale = input_height / h
        else:
            input_width = (width2 + 31) // 32 * 32
            input_height = ((input_width * h + w - 1) // w +
                                        31) // 32 * 32

    im_resized = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,
                            interpolation=cv2.INTER_LINEAR)
    if is_pil_image(im_resized):
        new_w, new_h = im_resized.size
    else:
        new_h, new_w = im_resized.shape[0:2]
    left = 0
    right = input_width - new_w - left
    top = 0
    bottom = input_height - new_h - top
    from .process_image import copy_make_border
    im_squared = copy_make_border(im_resized, top=top,
            bottom=bottom, left=left, right=right)
    return im_squared, im_scale

def smart_resize(im, target_size):
    from .process_image import is_pil_image
    if is_pil_image(im):
        w, h = im.size
    else:
        h, w, c = im.shape
    alpha = target_size / np.sqrt(h * w)
    height2 = int(np.round(alpha * h))
    width2 = int(np.round(alpha * w))
    if h > w:
        input_height = (height2 + 31) // 32 * 32
        input_width = ((input_height * w + h - 1) // h +
                                    31) // 32 * 32
    else:
        input_width = (width2 + 31) // 32 * 32
        input_height = ((input_width * h + w - 1) // w +
                                    31) // 32 * 32

    if float(h) / input_height > float(w) / input_width:
        rescale_size = input_height
    else:
        rescale_size = input_width
    from .process_image import im_rescale
    im_resized, im_scale = im_rescale(im, rescale_size)
    if is_pil_image(im_resized):
        new_w, new_h = im_resized.size
    else:
        new_h, new_w = im_resized.shape[0:2]
    left = (input_width - new_w) // 2
    right = input_width - new_w - left
    top = (input_height - new_h) // 2
    bottom = input_height - new_h - top
    from .process_image import copy_make_border
    im_squared = copy_make_border(im_resized, top=top,
            bottom=bottom, left=left, right=right)
    return im_squared, left, top, im_scale

def kmeans(np_feature, k, seed=6):
    from sklearn.preprocessing import normalize
    from libKMCUDA import kmeans_cuda
    np_feature = normalize(np_feature, axis=1)
    init = 'kmeans++'
    while True:
        centroid, assignments = kmeans_cuda(np_feature,
                                            k,
                                            verbosity=1,
                                            seed=seed,
                                            device=1,
                                            init=init,
                                            metric='cos',
                                            )
        unique_assignment, cluster_count = np.unique(assignments, return_counts=True)
        if len(unique_assignment) == k:
            logging.info('reached non-empty')
            break
        num_new = k - len(unique_assignment)
        logging.info('adding {}'.format(num_new))
        new_from_cluster_idx = np.argsort(cluster_count)[-num_new:]
        cluster_idx = unique_assignment[new_from_cluster_idx]
        feat_idx = [np.where(assignments == i)[0] for i in cluster_idx]
        feat_idx = np.concatenate(feat_idx)
        np.random.seed(6)
        feat_idx = np.random.permutation(feat_idx)
        new_cluster = np_feature[feat_idx[:num_new]]
        new_cluster_idx = 0
        for c in range(len(centroid)):
            if np.isnan(centroid[c][0]):
                centroid[c] = new_cluster[new_cluster_idx]
                new_cluster_idx += 1
        assert new_cluster_idx == len(new_cluster)
        init = centroid
    return centroid, assignments

def kmeans_pred_to_dataX(data, split, k, feature_fname, out_data,
                         num_kmeans=1):
    out_dataset = TSVDataset(out_data)
    if op.isfile(out_dataset.get_labelmap_file()) and \
            op.isfile(out_dataset.get_data(split + 'X')):
        return out_data
    dataset = TSVDataset(data)
    iter_label = dataset.iter_data(split, 'label')
    iter_pred = tsv_reader(feature_fname)
    np_feature = None
    num_rows = dataset.num_rows(split)
    for i, (label_row, pred_row) in tqdm(enumerate(zip(iter_label, iter_pred))):
        assert label_row[0] == pred_row[0]
        f = json.loads(pred_row[-1])[0]['feature']
        if np_feature is None:
            np_feature = np.zeros((num_rows, len(f)), dtype=np.float32)
        np_feature[i] = f
    # there are some issues with multi-gpu. Thus setting device=1 which means to use
    # gpu 0
    all_centroid, all_assignment = [], []
    for i in range(num_kmeans):
        centroid, assignments = kmeans(np_feature, k, seed=i + 9)
        all_centroid.append(centroid)
        all_assignment.append(assignments)
    disk_assign = [int(i) for _, i in out_dataset.iter_data(split, 'label')]
    for a, da in zip(assignments, disk_assign):
        assert a == da
    for i, centroid in zip(range(num_kmeans), all_centroid):
        out_dataset.write_data(centroid, split, 'kmeans_center', version=i)
    write_to_file(dataset.get_data(split),
                  out_dataset.get_data(split + 'X'))
    tsv_writer(((0, i) for i in range(num_rows)),
               out_dataset.get_shuffle_file(split))
    if op.isfile(out_dataset.get_labelmap_file()):
        labelmap = out_dataset.load_labelmap()
        assert len(labelmap) == k
        for i, l in enumerate(labelmap):
            assert l == str(i)
    else:
        tsv_writer(((i,) for i in range(k)), out_dataset.get_labelmap_file())
    iter_label = dataset.iter_data(split, 'label')
    def gen_label():
        for row in zip(iter_label, *all_assignment):
            key = row[0][0]
            label = '_'.join(map(str, [int(a) for a in row[1:]]))
            yield key, json_dump([{'class': label}])
    tsv_writer(gen_label(), out_dataset.get_data(split, 'label'))
    tsv_writer([(feature_fname,)], out_dataset.get_data(split, 'feature_ptr'))
    return out_data

def create_compare_dataset(pred1, pred2, suffix1, suffix2, data, split, out_data):
    out_dataset = TSVDataset(out_data)
    dataset = TSVDataset(data)
    tsv_writer([(dataset.get_data(split),)], out_dataset.get_data(split + 'X'))
    tsv_writer(((0, i)  for i in range(dataset.num_rows(split)) for _ in
                range(2)),
               out_dataset.get_shuffle_file(split))
    iter_pred1 = tsv_reader(pred1)
    iter_pred2 = tsv_reader(pred2)
    iter_gt = dataset.iter_data(split, 'label')
    def gen_label_rows():
        for row_gt, row_pred1, row_pred2 in zip(iter_gt, iter_pred1, iter_pred2):
            assert row_gt[0] == row_pred1[0] == row_pred2[0]
            rects_pred1 = json.loads(row_pred1[1])
            rects_pred1 = [r for r in rects_pred1 if r['conf'] > 0.2]
            rects_pred2 = json.loads(row_pred2[1])
            rects_pred2 = [r for r in rects_pred2 if r['conf'] > 0.2]
            yield row_gt[0] + suffix1, json_dump(rects_pred1)
            yield row_gt[0] + suffix2, json_dump(rects_pred2)
    out_dataset.write_data(gen_label_rows(), split, 'label')
    expand_nested_splitX(out_data, split)
    populate_dataset_details(out_data)

def duplicate_balance_fg_classes(
    data, split, version,
    bkg_class, fg_ratio, fg_rel_class_ratio, out_data):
    # some recommendation: fg_ratio = 0.3
    # fg_rel_class_ratio: 0.1
    info = get_frame_info()
    populate_dataset_details(data)
    out_dataset = TSVDataset(out_data)
    if op.isfile(out_dataset.get_labelmap_file()):
        logging.info('{} exists'.format(out_dataset))
        return
    dataset = TSVDataset(data)

    # {label: list_of_idx}
    label_to_idx = dataset.load_inverted_label(split, version)
    # the number of images with unknown categories
    unknown_count = len(label_to_idx[bkg_class])
    # total number of images with product categories
    product_count = sum([len(idx) for l, idx in label_to_idx.items()
         if l != bkg_class])
    # current ratio
    curr_ratio = 1. * product_count / (product_count + unknown_count)
    # we need to duplicate product images by dup_factor times
    dup_factor = int(math.ceil(fg_ratio / curr_ratio))
    # duplicate operations by duplicating the index
    dup_label_to_idx = {l: idx * dup_factor for l, idx in label_to_idx.items()
                        if l != bkg_class}
    info['dup_factor'] = dup_factor
    # calculate the average number of images for each category
    avg_count = calc_mean([len(idx) for l, idx in dup_label_to_idx.items()])
    # based on the parameters, each category should have at_least_count images.
    at_least_count = int(avg_count * fg_rel_class_ratio)
    for l, idx in dup_label_to_idx.items():
        if len(idx) < at_least_count:
            info[l] = (len(idx), at_least_count)
    # duplicate the images by duplicating the index
    dup_label_to_idx = {l: idx
                        if len(idx) >= at_least_count else idx * int(math.ceil(1. * at_least_count / len(idx)))
                        for l, idx in dup_label_to_idx.items()
                        }
    # make the index as a list
    final_idx = [i for _, idxs in dup_label_to_idx.items() for i in idxs]
    final_idx.extend(label_to_idx[bkg_class])
    # random shuffling
    random.shuffle(final_idx)
    # save it
    tsv_writer(((0, i) for i in final_idx), out_dataset.get_shuffle_file(split))
    assert op.isfile(dataset.get_data(split))
    assert op.isfile(dataset.get_data(split, t='label', version=version))
    tsv_writer([(dataset.get_data(split),)], out_dataset.get_data(split + 'X'))
    tsv_writer([(dataset.get_data(split, t='label', version=version),)],
               out_dataset.get_data(split + 'X', t='label'))
    ensure_copy_file(dataset.get_labelmap_file(),
                     out_dataset.get_labelmap_file())
    out_dataset.write_data(info.items(), split, t='generate_info')

    populate_dataset_details(out_data)

def split_dataset_one(
    data, num_split, out_data,
    split_type, split, version
):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)
    num_rows = dataset.num_rows(split, t=split_type, version=version)
    each_size = (num_rows + num_split - 1) //  num_split
    shuffle = []
    t_to_tsvs = defaultdict(list)
    for i in range(num_split):
        start = i * each_size
        end = start + each_size
        end = min(end, num_rows)
        t = split_type
        logging.info('split = {}; i = {}; t = {}'.format(
            split, i, t))
        def gen_rows():
            for j, row in enumerate(dataset.iter_data(
                split, t=t,
                version=version,
                filter_idx=range(start,
                                 end),
                    progress=True)):
                if t is None:
                    shuffle.append((i, j))
                yield row
        ssplit = '{}_{}_{}'.format(split, i, num_split)
        if out_dataset.has(ssplit, t, version=version):
            iter_in_file = out_dataset.iter_data(ssplit, t, version=version)
            for in_file, curr in zip(iter_in_file, gen_rows()):
                assert in_file == curr
        else:
            out_dataset.safe_write_data(
                gen_rows(),
                split=ssplit, t=t,
                version=version)
        t_to_tsvs[str(t)].append(out_dataset.get_data(ssplit, t, version))
    if op.isfile(out_dataset.get_shuffle_file(split)):
        iter_in_file = tsv_reader(out_dataset.get_shuffle_file(split))
        for x, y in zip(iter_in_file, shuffle):
            assert x == y
    else:
        tsv_writer(shuffle, out_dataset.get_shuffle_file(split))
    t = split_type
    split_x = '{}X'.format(split)
    target_file = out_dataset.get_data(split_x, t=t, version=version)
    if op.isfile(target_file):
        assert '\n'.join(t_to_tsvs[str(t)]) == read_to_buffer(target_file).decode()
    else:
        write_to_file('\n'.join(t_to_tsvs[str(t)]), target_file)
    ensure_copy_file(dataset.get_labelmap_file(), out_dataset.get_labelmap_file())

def split_dataset(
    data, num_split, out_data,
    split_types=(None, 'label', 'hw', 'caption'),
    splits=('train', 'trainval', 'test'),
):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)
    for split in splits:
        num_rows = dataset.num_rows(split)
        each_size = (num_rows + num_split - 1) //  num_split
        shuffle = []
        t_to_tsvs = defaultdict(list)
        for i in range(num_split):
            start = i * each_size
            end = start + each_size
            end = min(end, num_rows)
            for t in split_types:
                logging.info('split = {}; i = {}; t = {}'.format(
                    split, i, t))
                def gen_rows():
                    for j, row in enumerate(dataset.iter_data(
                        split, t=t,
                        filter_idx=range(start,
                                         end),
                            progress=True)):
                        if t is None:
                            shuffle.append((i, j))
                        yield row
                ssplit = '{}_{}_{}'.format(split, i, num_split)
                if out_dataset.has(ssplit, t):
                    iter_in_file = out_dataset.iter_data(ssplit, t)
                    for in_file, curr in zip(iter_in_file, gen_rows()):
                        assert in_file == curr
                else:
                    out_dataset.write_data(gen_rows(), split=ssplit, t=t)
                t_to_tsvs[str(t)].append(out_dataset.get_data(ssplit, t))
        if op.isfile(out_dataset.get_shuffle_file(split)):
            iter_in_file = tsv_reader(out_dataset.get_shuffle_file(split))
            for x, y in zip(iter_in_file, shuffle):
                assert x == y
        else:
            tsv_writer(shuffle, out_dataset.get_shuffle_file(split))
        for t in split_types:
            split_x = '{}X'.format(split)
            target_file = out_dataset.get_data(split_x, t=t)
            if op.isfile(target_file):
                assert '\n'.join(t_to_tsvs[str(t)]) == read_to_buffer(target_file).decode()
            else:
                write_to_file('\n'.join(t_to_tsvs[str(t)]), target_file)
    ensure_copy_file(dataset.get_labelmap_file(), out_dataset.get_labelmap_file())

def merge_dataset_parallel(*args, **kwargs):
    merge_dataset(*args, **kwargs)

#@deprecated('use merge_dataset_parallel')
#def merge_dataset(source_infos, target_info, ps):
    #target_dataset = TSVDataset(target_info['data'])
    #for p in ps:
        #tsv_list = []
        #for source in source_infos:
            #dataset = TSVDataset(source['data'])
            #if 'version_info' in source and p['type'] in source['version_info']:
                #version = source['version_info'][p['type']]
            #elif 'version' in p:
                #version = p['version']
            #else:
                #version = None
            #tsv_file = dataset.get_data(source['split'], t=p['type'],
                                #version=version)
            #if op.isfile(tsv_file):
                #tsv_list.append(tsv_file)
            #else:
                #tsv_x = dataset.get_data(source['split'] + 'X', t=p['type'],
                                         #version=version)
                #curr_list = load_list_file(tsv_x)
                #curr_shuffle = dataset.get_shuffle_file(source['split'])
                #logging.info('loading {}'.format(curr_shuffle))
                #tsv_list.extend(curr_list)
        #out_tsvx = target_dataset.get_data(
            #target_info['split'] + 'X', p['type'],
            #version=target_info.get('version'))
        #if not op.isfile(out_tsvx):
            #write_to_file('\n'.join(tsv_list), out_tsvx)
        #else:
            #es = load_list_file(out_tsvx)
            #assert len(tsv_list) == len(es)
            #for e, c in zip(es, tsv_list):
                #assert e == c, (e, c)

    #for p in ps:
        #if p.get('type') is not None:
            #continue
        #tsv_list = []
        #def gen_shuffle():
            #for source in source_infos:
                #dataset = TSVDataset(source['data'])
                #if 'version_info' in source and p['type'] in source['version_info']:
                    #version = source['version_info'][p['type']]
                #elif 'version' in p:
                    #version = p['version']
                #else:
                    #version = None
                #tsv_file = dataset.get_data(source['split'], t=p['type'],
                                    #version=version)
                #tsv_offset = len(tsv_list)
                #if op.isfile(tsv_file):
                    #num = dataset.num_rows(source['split'])
                    #for i in range(num):
                        #yield tsv_offset, i
                    #tsv_list.append(tsv_file)
                #else:
                    #tsv_x = dataset.get_data(source['split'] + 'X', t=p['type'],
                                             #version=version)
                    #curr_list = load_list_file(tsv_x)
                    #curr_shuffle = dataset.get_shuffle_file(source['split'])
                    #logging.info('loading {}'.format(curr_shuffle))
                    #for i, j in tqdm(tsv_reader(curr_shuffle)):
                        #yield int(i) + tsv_offset, j
                    #tsv_list.extend(curr_list)
        #shuffle_f = target_dataset.get_shuffle_file(target_info['split'])
        #if not op.isfile(shuffle_f):
            #tsv_writer(gen_shuffle(), shuffle_f)
        #else:
            #for in_file, curr in zip(tsv_reader(shuffle_f), gen_shuffle()):
                #assert in_file[0] == str(curr[0])
                #assert in_file[1] == str(curr[1])



#@deprecated('try to switch to merge_dataset2, tested once')
#def merge_dataset(source_infos, target_info, ps):
    #target_dataset = TSVDataset(target_info['data'])
    #for p in ps:
        #tsv_list = []
        #shuffle = []
        #for source in source_infos:
            #dataset = TSVDataset(source['data'])
            #if 'version_info' in source and p['type'] in source['version_info']:
                #version = source['version_info'][p['type']]
            #elif 'version' in p:
                #version = p['version']
            #else:
                #version = None
            #tsv_file = dataset.get_data(source['split'], t=p['type'],
                                #version=version)
            #tsv_offset = len(tsv_list)
            #if op.isfile(tsv_file):
                #num = dataset.num_rows(source['split'])
                #shuffle.extend([(tsv_offset, i) for i in range(num)])
                #tsv_list.append(tsv_file)
            #else:
                #tsv_x = dataset.get_data(source['split'] + 'X', t=p['type'],
                                         #version=version)
                #curr_list = load_list_file(tsv_x)
                #curr_shuffle = dataset.get_shuffle_file(source['split'])
                #logging.info('loading {}'.format(curr_shuffle))
                #shuffle.extend([(int(i) + tsv_offset, j) for i, j in
                                #tqdm(tsv_reader(curr_shuffle))])
                #tsv_list.extend(curr_list)
        #out_tsvx = target_dataset.get_data(
            #target_info['split'] + 'X', p['type'],
            #version=target_info.get('version'))
        #if not op.isfile(out_tsvx):
            #write_to_file('\n'.join(tsv_list), out_tsvx)
        #else:
            #es = load_list_file(out_tsvx)
            #assert len(tsv_list) == len(es)
            #for e, c in zip(es, tsv_list):
                #assert e == c, (e, c)
        #if p.get('type') is None:
            #shuffle_f = target_dataset.get_shuffle_file(target_info['split'])
            #if not op.isfile(shuffle_f):
                #tsv_writer(shuffle, shuffle_f)
            #else:
                #for in_file, curr in zip(tsv_reader(shuffle_f), shuffle):
                    #assert in_file[0] == str(curr[0])
                    #assert in_file[1] == str(curr[1])

    ## labelmap
    ##target_labelmap = target_dataset.get_labelmap_file()
    ##lss = [TSVDataset(source['data']).load_labelmap() for source in source_infos]
    ##labelmap = list(set([l for ls in lss for l in ls]))
    ##labelmap = sorted(labelmap)
    ##if not op.isfile(target_labelmap):
        ##write_to_file('\n'.join(labelmap), target_labelmap)
    ##else:
        ##existing = load_list_file(target_labelmap)
        ##assert len(existing) == len(labelmap)
        ##for e, l in zip(existing, labelmap):
            ##assert e == l

def merge_dataset_row_processor(row, offset):
    i, j = row
    return int(i) + offset, j

def merge_dataset(source_infos, target_info, ps):
    target_dataset = TSVDataset(target_info['data'])
    for p in ps:
        tsv_list = []
        for source in source_infos:
            dataset = TSVDataset(source['data'])
            if 'version_info' in source and p['type'] in source['version_info']:
                version = source['version_info'][p['type']]
            elif 'version' in p:
                version = p['version']
            else:
                version = None
            tsv_file = dataset.get_data(source['split'], t=p['type'],
                                version=version)
            if File.isfile(tsv_file):
                tsv_list.append(tsv_file)
            else:
                tsv_x = dataset.get_data(source['split'] + 'X', t=p['type'],
                                         version=version)
                curr_list = load_list_file(tsv_x)
                curr_shuffle = dataset.get_shuffle_file(source['split'])
                logging.info('loading {}'.format(curr_shuffle))
                tsv_list.extend(curr_list)
        out_tsvx = target_dataset.get_data(
            target_info['split'] + 'X', p['type'],
            version=target_info.get('version'))
        if not File.isfile(out_tsvx):
            tsv_writer(((_t, ) for _t in tsv_list), out_tsvx)
            #write_to_file('\n'.join(tsv_list), out_tsvx)
        else:
            es = load_list_file(out_tsvx)
            assert len(tsv_list) == len(es)
            for e, c in zip(es, tsv_list):
                assert e == c, (e, c)

    all_num_tsv = []
    for source in source_infos:
        dataset = TSVDataset(source['data'])
        curr_shuffle = dataset.get_shuffle_file(source['split'])
        if File.isfile(curr_shuffle):
            tsv_x = dataset.get_data(source['split'] + 'X', t=p['type'],
                                     version=version)
            curr_list = load_list_file(tsv_x)
            all_num_tsv.append(len(curr_list))
        else:
            assert File.isfile(dataset.get_data(source['split']))
            all_num_tsv.append(1)

    s = 0
    tsv_offset = [0]
    for n in all_num_tsv[:-1]:
        s += n
        tsv_offset.append(s)

    all_shuffle = []
    target_shuffle = target_dataset.get_shuffle_file(target_info['split'])
    folder = get_tmp_folder()
    for idxsource, source in enumerate(source_infos):
        dataset = TSVDataset(source['data'])
        out_shuffle = op.join(folder,
                              '{}'.format(target_shuffle) +
                              '.{}.{}.tsv'.format(idxsource, len(source_infos)),
                              )
        src_shuffle_tsv = dataset.get_shuffle_file(source['split'])
        parallel_tsv_process(lambda row: merge_dataset_row_processor(row, tsv_offset[idxsource]),
                             src_shuffle_tsv,
                             out_shuffle,
                             64,
                             )
        all_shuffle.append(out_shuffle)
    concat_tsv_files(all_shuffle,
                     target_dataset.get_shuffle_file(target_info['split']),
                     gen_lineidx=False
                     )
    delete_tsv_files(all_shuffle)

def tuple_merge_pred_label_to_gt(x):
    pred, data, split, in_version, out_version = x
    merge_pred_label_to_gt(pred, data, split, in_version, out_version)

def merge_pred_label_to_gt(pred, data, split, in_version, out_version):
    dataset = TSVDataset(data)
    def gen_rows():
        iter_pred = tsv_reader(pred)
        iter_gt = dataset.iter_data(split, 'label', version=in_version)
        for row_pred, row_gt in tqdm(zip(iter_pred, iter_gt)):
            assert row_pred[0] == row_gt[0]
            pred_rects = json.loads(row_pred[1])
            gt = json.loads(row_gt[1])
            for p in pred_rects:
                if 'zlib_feature' in p:
                    del p['zlib_feature']
                if 'attr_labels' in p:
                    del p['attr_labels']
                if 'attr_scores' in p:
                    del p['attr_scores']
            gt.extend(pred_rects)
            yield row_pred[0], json_dump(gt)
    #assert not dataset.has(split, 'label', version=out_version)
    dataset.write_data(gen_rows(), split, 'label', version=out_version)

def generate_caption_linelist(data, split, version=None):
    dataset = TSVDataset(data)
    if not dataset.has(split, 'caption', version=None):
        logging.info('caption does not exist')
        return
    iter_caption = dataset.iter_data(split, 'caption', version=version)
    iter_shuffle = tsv_reader(dataset.get_shuffle_file(split))

    def gen_rows():
        for (idx_source, idx_row), (key, s) in tqdm(zip(iter_shuffle,
                                                        iter_caption)):
            cs = json.loads(s)
            for idx_caption in range(len(cs)):
                yield idx_source, idx_row, idx_caption
    if not dataset.has(split, 'caption_linelist', version=version):
        dataset.safe_write_data(gen_rows(), split, 'caption_linelist',
                           version=version)

def generate_key_idximage_idxcaption_from_num(data, split, version):
    dataset = TSVDataset(data)
    if not dataset.has(split, 'caption', version):
        logging.info('ignore to generate as caption file does not exist')
        return
    iter_caption = dataset.iter_data(split, 'num_caption', version=version)

    def gen_rows():
        for idx_img, (key, n) in tqdm(enumerate(iter_caption)):
            n = int(n)
            for i in range(n):
                yield key, idx_img, i

    t = 'key_idximage_idxcaption'
    if not dataset.has(split, t, version=version):
        dataset.write_data(gen_rows(), split, t, version=version)

def derive_key_idximage_idxcaption_from_merge_dataset(source_infos, target_info):
    for s in source_infos:
        assert s.get('version_info') is None
        generate_key_idximage_idxcaption(s['data'], s['split'])

    split = target_info['split']
    def gen_rows():
        offset = 0
        for s in source_infos:
            dataset = TSVDataset(s['data'])
            for key, idximage, idxcaption in dataset.iter_data(s['split'],
                                                               t='key_idximage_idxcaption'):
                yield key, int(idximage) + offset, idxcaption
            added = False
            for t in [None, 'caption', 'hw']:
                if dataset.has(s['split'], t):
                    offset += dataset.num_rows(s['split'])
                    added = True
                    break
            assert added
    data = target_info['data']
    out = TSVDataset(data)
    if not out.has(split, 'key_idximage_idxcaption'):
        out.write_data(gen_rows(), split, t='key_idximage_idxcaption')

def derive_key_idximage_idxcaption_from_merge_dataset_parallel_multi_source(source_infos, target_info):
    for s in source_infos:
        assert s.get('version_info') is None
        generate_key_idximage_idxcaption(s['data'], s['split'])

    out = TSVDataset(target_info['data'])
    if out.has(target_info['split'], 'key_idximage_idxcaption'):
        return

    all_size = [len(TSVSplitProperty(s['data'], s['split'], 'caption')) for s in
                source_infos]
    cum_size = 0
    all_offset = [cum_size]
    for s in all_size[:-1]:
        cum_size += s
        all_offset.append(cum_size)

    in_tsvs = list(zip(all_offset, source_infos))
    from .cloud_storage import create_cloud_fuse
    c = create_cloud_fuse()
    tsvs = [TSVDataset(s['data']).get_data(s['split'], 'key_idximage_idxcaption') for s
            in source_infos]
    c.ensure_cache(tsvs)
    c.ensure_cache([get_tsv_associates(t)[0] for t in tsvs])

    def row_processor(row):
        offset, s = row
        for key, idximage, idxcaption in TSVSplitProperty(s['data'],
                                                          s['split'],
                                                          'key_idximage_idxcaption'):
            yield key, int(idximage) + offset, idxcaption
    out_tsv = out.get_data(target_info['split'], 'key_idximage_idxcaption')
    parallel_tsv_process(
        row_processor,
        in_tsvs,
        out_tsv,
        64
    )

def derive_key_idximage_idxcaption_from_merge_dataset_parallel_each(source_infos, target_info):
    for s in source_infos:
        assert s.get('version_info') is None
        generate_key_idximage_idxcaption(s['data'], s['split'])

    out = TSVDataset(target_info['data'])
    if out.has(target_info['split'], 'key_idximage_idxcaption'):
        return

    all_size = [len(TSVSplitProperty(s['data'], s['split'], 'caption')) for s in
                source_infos]
    cum_size = 0
    all_offset = [cum_size]
    for s in all_size[:-1]:
        cum_size += s
        all_offset.append(cum_size)

    from .cloud_storage import create_cloud_fuse
    c = create_cloud_fuse()
    tsvs = [TSVDataset(s['data']).get_data(s['split'], 'key_idximage_idxcaption') for s
            in source_infos]
    c.ensure_cache(tsvs)
    c.ensure_cache([get_tsv_associates(t)[0] for t in tsvs])

    tmp_folder = get_tmp_folder()
    out_tsv = out.get_data(target_info['split'], 'key_idximage_idxcaption')
    all_tmp = []
    for offset, s in zip(all_offset, source_infos):
        curr_in_tsv = TSVDataset(s['data']).get_data(s['split'], 'key_idximage_idxcaption')
        curr_out_tsv = op.join(tmp_folder, out_tsv + f'.{offset}.tsv')

        def row_processor(row):
            key, idximage, idxcaption = row
            return key, int(idximage) + offset, idxcaption
        parallel_tsv_process(
            row_processor,
            curr_in_tsv,
            curr_out_tsv,
            64
        )
        all_tmp.append(curr_out_tsv)
    concat_tsv_files(all_tmp, out_tsv, gen_lineidx=False)
    delete_tsv_files(all_tmp)

def derive_key_idximage_idxcaption_idxsource_from_merge_dataset_parallel_multi_source(source_infos, target_info):
    for s in source_infos:
        assert s.get('version_info') is None
        generate_key_idximage_idxcaption_idxsource(s['data'], s['split'])

    out = TSVDataset(target_info['data'])
    if out.has(target_info['split'], 'key_idximage_idxcaption_idxsource'):
        return

    all_size = [len(TSVSplitProperty(s['data'], s['split'], 'caption')) for s in
                source_infos]
    cum_size = 0
    all_img_offset = [cum_size]
    for s in all_size[:-1]:
        cum_size += s
        all_img_offset.append(cum_size)

    all_source_offset = [0]
    cum = 0
    for s in source_infos[:-1]:
        curr_dataset = TSVDataset(s['data'])
        if File.isfile(curr_dataset.get_data(s['split'])):
            num = 1
        else:
            num = len(load_list_file(curr_dataset.get_data(s['split'] + 'X')))
        cum += num
        all_source_offset.append(cum)

    in_tsvs = list(zip(all_img_offset, all_source_offset, source_infos))
    from .cloud_storage import create_cloud_fuse
    c = create_cloud_fuse()
    tsvs = [TSVDataset(s['data']).get_data(s['split'],
                                           'key_idximage_idxcaption_idxsource') for s
            in source_infos]
    c.ensure_cache(tsvs)
    c.ensure_cache([get_tsv_associates(t)[0] for t in tsvs])

    def row_processor(row):
        img_offset, source_offset, s = row
        for idxsource, in TSVSplitProperty(s['data'], s['split'], 'key_idximage_idxcaption_idxsource'):
            yield int(idxsource) + source_offset,
    out_tsv = out.get_data(target_info['split'], 'key_idximage_idxcaption_idxsource')
    parallel_tsv_process(row_processor, in_tsvs, out_tsv, 64)

def derive_key_idximage_idxcaption_idxsource_from_merge_dataset_parallel_each_source(source_infos, target_info):
    for s in source_infos:
        assert s.get('version_info') is None
        generate_key_idximage_idxcaption_idxsource(s['data'], s['split'])

    out = TSVDataset(target_info['data'])
    if out.has(target_info['split'], 'key_idximage_idxcaption_idxsource'):
        return

    all_size = [len(TSVSplitProperty(s['data'], s['split'], 'caption')) for s in
                source_infos]
    cum_size = 0
    all_img_offset = [cum_size]
    for s in all_size[:-1]:
        cum_size += s
        all_img_offset.append(cum_size)

    all_source_offset = [0]
    cum = 0
    for s in source_infos[:-1]:
        curr_dataset = TSVDataset(s['data'])
        if File.isfile(curr_dataset.get_data(s['split'])):
            num = 1
        else:
            num = len(load_list_file(curr_dataset.get_data(s['split'] + 'X')))
        cum += num
        all_source_offset.append(cum)

    c = create_cloud_fuse()
    tsvs = [TSVDataset(s['data']).get_data(s['split'],
                                           'key_idximage_idxcaption_idxsource') for s
            in source_infos]
    c.ensure_cache(tsvs)
    c.ensure_cache([get_tsv_associates(t)[0] for t in tsvs])

    out_tsv = out.get_data(target_info['split'], 'key_idximage_idxcaption_idxsource')

    tmp_folder = get_tmp_folder()
    all_tmp = []
    for img_offset, source_offset, s in zip(all_img_offset, all_source_offset, source_infos):
        def row_processor(row):
            idxsource, = row
            return int(idxsource) + source_offset,
        in_tsv = TSVDataset(s['data']).get_data(s['split'], 'key_idximage_idxcaption_idxsource')
        curr_out = '{}/{}'.format(tmp_folder, out_tsv + '.{}.tsv'.format(img_offset))
        parallel_tsv_process(row_processor, in_tsv, curr_out, 64)
        all_tmp.append(curr_out)
    concat_tsv_files(all_tmp, out_tsv, gen_lineidx=False)
    delete_tsv_files(all_tmp)

def assert_dataset_each_length_same(data):
    dataset = TSVDataset(data)
    img_tsvs = load_list_file(dataset.get_data('trainX'))
    cap_tsvs = load_list_file(dataset.get_data('trainX', 'caption'))
    assert len(img_tsvs) == len(cap_tsvs)
    #c = create_cloud_fuse()
    #c.ensure_cache(fs)
    for i, c in tqdm(zip(img_tsvs, cap_tsvs)):
        assert len(TSVFile(i)) == len(TSVFile(c)), (i, c)


def generate_key_idximage_idxcaption(data, split, version=None):
    dataset = TSVDataset(data)
    if not dataset.has(split, 'caption', version):
        logging.info('ignore to generate as caption file does not exist')
        return
    #from qd.data_layer.loader import iter_data_loader
    #iter_caption = iter_data_loader(
        #data, split, 'caption', version=version,
        #transform=lambda x: (x[0], json.loads(x[1])),
        #num_workers=8,
    #)
    info = defaultdict(int)
    def row_processor(row, idx_img):
        key, s = row
        try:
            cs = json.loads(s)
        except:
            logging.info('{}/{}'.format(s, idx_img))
            raise
        for i in range(len(cs)):
            if ('caption' in cs[i] and isinstance(cs[i]['caption'], str)) or ('caption' not in cs[i]):
                yield (key, idx_img, i)
                info['valid'] += 1
            else:
                info['non_str_caption'] += 1

    t = 'key_idximage_idxcaption'
    if not dataset.has(split, t, version=version):
        tsv = TSVSplitProperty(data=data, split=split, t='caption', version=version)
        fs = dataset.get_data(split + 'X', 'caption', version=version)
        if File.isfile(fs):
            tsvs = load_list_file(fs)
            File.prepare(tsvs)
            File.prepare([get_tsv_associates(t)[0] for t in tsvs])
        parallel_tsv_process(
            row_processor,
            tsv,
            dataset.get_data(split, t, version=version),
            64,
            with_row_idx=True
        )
    logging.info(info)

def generate_idximage_idxcaption(
        data, split, version=None):
    dataset = TSVDataset(data)
    if not dataset.has(split, 'caption', version):
        logging.info('ignore to generate as caption file does not exist')
        return
    info = defaultdict(int)
    def row_processor(row, idx_img):
        key, s = row
        cs = json.loads(s)
        for i in range(len(cs)):
            if ('caption' in cs[i] and isinstance(cs[i]['caption'], str)) or ('caption' not in cs[i]):
                yield idx_img, i
                info['valid'] += 1
            else:
                info['non_str_caption'] += 1

    t = 'idximage_idxcaption'
    if not dataset.has(split, t, version=version):
        tsv = TSVSplitProperty(data=data, split=split, t='caption', version=version)
        c = create_cloud_fuse()
        fs = dataset.get_data(split + 'X', 'caption', version=version)
        if File.isfile(fs):
            tsvs = load_list_file(fs)
            c.ensure_cache(tsvs)
            c.ensure_cache([get_tsv_associates(t)[0] for t in tsvs])
        parallel_tsv_process(
            row_processor,
            tsv,
            dataset.get_data(split, t, version=version),
            64,
            with_row_idx=True
        )
    logging.info(info)

@deprecated('use generate_idximage_idxcaption')
def generate_idximage_idxcaption_parallel(*args, **kwargs):
    generate_idximage_idxcaption(*args, **kwargs)

#def generate_key_idximage_idxcaption(data, split, version=None):
    #dataset = TSVDataset(data)
    #if not dataset.has(split, 'caption', version):
        #logging.info('ignore to generate as caption file does not exist')
        #return
    ##from qd.data_layer.loader import iter_data_loader
    ##iter_caption = iter_data_loader(
        ##data, split, 'caption', version=version,
        ##transform=lambda x: (x[0], json.loads(x[1])),
        ##num_workers=8,
    ##)
    #info = defaultdict(int)
    #def gen_rows():
        ##iter_caption = dataset.iter_data(split, 'caption', version=version)
        ##total = dataset.num_rows(split, 'caption')
        #iter_caption = TSVSplitProperty(data=data, split=split, t='caption', version=version)
        ##for idx_img, (key, s) in tqdm(enumerate(iter_caption), total=total):
        #for idx_img, (key, s) in tqdm(enumerate(iter_caption)):
            #cs = json.loads(s)
            #for i in range(len(cs)):
                #if ('caption' in cs[i] and isinstance(cs[i]['caption'], str)) or ('caption' not in cs[i]):
                    #yield key, idx_img, i
                    #info['valid'] += 1
                #else:
                    #info['non_str_caption'] += 1

    #t = 'key_idximage_idxcaption'
    #if not dataset.has(split, t, version=version):
        #dataset.write_data(gen_rows(), split, t, version=version)
    #logging.info(info)

def generate_idximage_idxcaption_from_with_key(data, split, version=None):
    dataset = TSVDataset(data)
    def gen_rows():
        #iter_caption = dataset.iter_data(split, 'caption', version=version)
        #total = dataset.num_rows(split, 'caption')
        iter_old = TSVSplitProperty(data=data, split=split, t='key_idximage_idxcaption', version=version)
        #for idx_img, (key, s) in tqdm(enumerate(iter_caption), total=total):
        for key, idximage, idxcaption in tqdm(iter_old):
            yield idximage, idxcaption

    t = 'idximage_idxcaption'
    if not dataset.has(split, t, version=version):
        dataset.write_data(gen_rows(), split, t, version=version)


#def generate_idximage_idxcaption(data, split, version=None):
    #dataset = TSVDataset(data)
    #if not dataset.has(split, 'caption', version):
        #logging.info('ignore to generate as caption file does not exist')
        #return
    ##from qd.data_layer.loader import iter_data_loader
    ##iter_caption = iter_data_loader(
        ##data, split, 'caption', version=version,
        ##transform=lambda x: (x[0], json.loads(x[1])),
        ##num_workers=8,
    ##)
    #info = defaultdict(int)
    #def gen_rows():
        ##iter_caption = dataset.iter_data(split, 'caption', version=version)
        ##total = dataset.num_rows(split, 'caption')
        #iter_caption = TSVSplitProperty(data=data, split=split, t='caption', version=version)
        ##for idx_img, (key, s) in tqdm(enumerate(iter_caption), total=total):
        #for idx_img, (key, s) in tqdm(enumerate(iter_caption)):
            #cs = json.loads(s)
            #for i in range(len(cs)):
                #if ('caption' in cs[i] and isinstance(cs[i]['caption'], str)) or ('caption' not in cs[i]):
                    #yield idx_img, i
                    #info['valid'] += 1
                #else:
                    #info['non_str_caption'] += 1

    #t = 'idximage_idxcaption'
    #if not dataset.has(split, t, version=version):
        #dataset.write_data(gen_rows(), split, t, version=version)
    #logging.info(info)

def generate_num_caption(data, split, version=None):
    dataset = TSVDataset(data)
    if not dataset.has(split, 'caption', version):
        logging.info('ignore to generate as caption file does not exist')
        return
    iter_caption = dataset.iter_data(split, 'caption', version=version)

    def gen_rows():
        for (key, s) in tqdm(iter_caption):
            cs = json.loads(s)
            yield key, len(cs)

    if not dataset.has(split, 'num_caption', version=version):
        dataset.write_data(gen_rows(), split, 'num_caption', version=version)

def create_n_class_label(data_sources, out_data, out_split):
    frame_info = get_frame_info()
    out_dataset = TSVDataset(out_data)
    if out_dataset.has(out_split, 'label'):
        logging.info('skip for {}'.format(pformat(frame_info)))
        return
    all_ds = []
    for ds in data_sources:
        expand = ds.get('expand')
        if expand:
            curr_dataset = TSVDataset(ds['data'])
            data_splits = curr_dataset.load_composite_source_data_split(
                ds['split'])
            for d, s in data_splits:
                all_ds.append({'data': d, 'split': s, 'version': ds['version']})
        else:
            # in expand, we only support data/split/version. If we add other property, we should also update this code
            assert len(ds) == 3
            assert all(k in ds for k in ['data', 'split', 'version'])
            all_ds.append(ds)
    data_sources = all_ds
    # with expand, data_sources will be different. We save this information
    frame_info['data_sources'] = data_sources

    def gen_rows():
        for idx_source, data_source in enumerate(data_sources):
            curr_dataset = TSVDataset(data_source['data'])
            iter_label = curr_dataset.iter_data(
                data_source['split'],
                'label',
                version=data_source['version'],
            )
            total = curr_dataset.num_rows(data_source['split'])
            for i, (key, str_rects) in tqdm(enumerate(iter_label), total=total):
                rects = json.loads(str_rects)
                if isinstance(rects, int):
                    rects = [{'class': str(rects)}]
                if len(rects) == 0:
                    continue
                for r in rects:
                    if '$' not in r['class']:
                        if not r['class'].startswith('-'):
                            r['class'] = '$'.join([data_source['data'], r['class']])
                        else:
                            r['class'] = '$'.join([data_source['data'], r['class'][1:]])
                            r['class'] = '-{}'.format(r['class'])
                yield (key, json_dump(rects)), (idx_source, i)
    def gen_info():
        yield 'create_n_classs_label',
        ps = dict_get_all_path(frame_info)
        for p in ps:
            v = dict_get_path_value(frame_info, p)
            yield p, v

    label_file = out_dataset.get_data(out_split, 'label')
    shuffle_file = out_dataset.get_shuffle_file(out_split)
    if not op.isfile(label_file):
        tsv_writers(gen_rows(), (label_file, shuffle_file))
        gen_tsv = out_dataset.get_gen_info_data(out_split, 'label')
        tsv_writer(gen_info(), gen_tsv)
    labelmap = []
    #domain_info = []
    for ds_data in set(d['data'] for d in data_sources):
        curr_labelmap = TSVDataset(ds_data).load_labelmap()
        labelmap.extend(['{}${}'.format(
            ds_data, l) for l in curr_labelmap])
        #domain_info.append({'data': ds_data, 'labelmap': curr_labelmap})
    write_to_file('\n'.join(set(labelmap)), out_dataset.get_labelmap_file())
    #write_to_yaml_file(domain_info, out_dataset.get_file('domainmap.yaml'))
    image_tsvs = [TSVDataset(source['data']).get_data(source['split']) for source in
                  data_sources]
    write_to_file('\n'.join(image_tsvs), out_dataset.get_data(out_split + 'X'))
    expand_nested_splitX(out_data, out_split)

def merge_prediction_to_data(
    data, split, in_version, predict_file, conf_th, out_version,
    merge_colocated_iou=0.8,
):
    frame_info = get_frame_info()
    dataset = TSVDataset(data)
    assert dataset.has(split, 'label', version=in_version), (
        dataset, split, in_version
    )
    if dataset.has(split, 'label', version=out_version):
        logging.info('out version esists {}'.format(out_version))
        return
    iter_gt = dataset.iter_data(split, 'label', version=in_version)
    info = defaultdict(int)
    def gen_rows():
        debug = False
        iter_pred = tsv_reader(predict_file)
        for i, (row_gt, row_pred) in tqdm(enumerate(
            zip(iter_gt, iter_pred))):
            key = row_gt[0]
            assert row_pred[0] == key
            gt = json.loads(row_gt[1])
            pred = json.loads(row_pred[1])
            pred = [p for p in pred if p['conf'] >= conf_th]
            if debug:
                origin_gt = copy.deepcopy(gt)
                extra = []
            info['num_label_pre'] += len(gt)
            for g in gt:
                if 'location_id' not in g:
                    g['location_id'] = hash_sha1(g['rect'])
            for p in pred:
                if 'location_id' not in p:
                    p['location_id'] = hash_sha1(p['rect'])
            for p in pred:
                idx, iou = find_best_matched_rect_idx(p, gt, check_class=False)
                if iou >= merge_colocated_iou:
                    p['rect'] = gt[idx]['rect']
                    p['location_id'] = gt[idx]['location_id']
                    info['merge_colocated'] += 1
                p['predict_file'] = predict_file
                info['added'] += 1
                if debug:
                    extra.append(p)
                gt.append(p)
            if debug and len(extra) > 0:
                logging.info('debugging')
                im = img_from_base64(dataset.seek_by_idx(i, split='train')[-1])
                im_gt = im.copy()
                draw_rects(origin_gt, im_gt)
                im_extra = im.copy()
                draw_rects(extra, im_extra)
                save_image(np.concatenate((im_gt, im_extra)),
                           '/mnt/gpu02_raid/jianfw/work/tmp9/{}.jpg'.format(key))
            info['num_label_after'] += len(gt)
            yield key, json_dump(gt)
    def gen_info():
        for k, v in frame_info.items():
            yield k, v
        for k, v in info.items():
            yield k, v
    dataset.write_data(gen_rows(), split, 'label', version=out_version,
                       generate_info=gen_info())
    logging.info(pformat(info))

def create_1_class_label(data_sources, out_data, out_split,
                         cls_name):
    frame_info = get_frame_info()
    out_dataset = TSVDataset(out_data)
    if out_dataset.has(out_split, 'label'):
        logging.info('skip for {}'.format(pformat(frame_info)))
        return
    def gen_rows():
        for idx_source, data_source in enumerate(data_sources):
            curr_dataset = TSVDataset(data_source['data'])
            iter_label = curr_dataset.iter_data(
                data_source['split'],
                'label',
                version=data_source['version'],
            )
            for i, (key, str_rects) in tqdm(enumerate(iter_label)):
                rects = json.loads(str_rects)
                if len(rects) == 0:
                    continue
                for r in rects:
                    assert 'from_class' not in r
                    r['from_class'] = r['class']
                    r['class'] = 'object'
                yield (key, json_dump(rects)), (idx_source, i)
    def gen_info():
        yield 'create_1_classs_label',
        for k, v in frame_info.items():
            yield k, v

    label_file = out_dataset.get_data(out_split, 'label')
    shuffle_file = out_dataset.get_shuffle_file(out_split)
    assert not op.isfile(label_file)
    tsv_writers(gen_rows(), (label_file, shuffle_file))
    gen_tsv = out_dataset.get_gen_info_data(out_split, 'label')
    tsv_writer(gen_info(), gen_tsv)
    write_to_file(cls_name, out_dataset.get_labelmap_file())

    image_tsvs = [TSVDataset(source['data']).get_data(source['split']) for source in
                  data_sources]
    write_to_file('\n'.join(image_tsvs), out_dataset.get_data(out_split + 'X'))
    expand_nested_splitX(out_data, out_split)

def open_each_tsv(data, split, hold=False):
    dataset = TSVDataset(data)
    files = load_list_file(dataset.get_data(split + 'X'))
    all_tsv = []
    for f in files:
        logging.info('open and read {}'.format(f))
        tsv = TSVFile(f)
        tsv[0]
        if hold:
            all_tsv.append(tsv)
        else:
            tsv.close()
        from .common import print_opened_files
        print_opened_files()

def iter_caption_to_json(iter_caption, json_file):
    # save gt caption to json format so thet we can call the api
    key_captions = [(key, json.loads(p)) for key, p in iter_caption]

    info = {
        'info': 'dummy',
        'licenses': 'dummy',
        'type': 'captions',
    }
    info['images'] = [{'file_name': k, 'id': k} for k, _ in key_captions]
    n = 0
    annotations = []
    for k, cs in key_captions:
        for c in cs:
            annotations.append({
                'image_id': k,
                'caption': c['caption'],
                'id': n
            })
            n += 1
    info['annotations'] = annotations
    from .common import write_to_file
    write_to_file(json.dumps(info), json_file)

def compare_2_way_save(iter_pred1, iter_pred2, iter_image, out_data,
                       diff_iou=0.95, inter_iou=0.95, force=False, hint1='1', hint2='2'):
    labels = []
    def gen_rows():
        for _, ((key1, rects1), (key2, rects2), (im_key, _, str_im)) in tqdm(enumerate(zip(
                iter_pred1, iter_pred2, iter_image))):
            assert key1 == key2 == im_key
            unique_rects1 = rects_diff(rects1, rects2, iou=diff_iou)
            unique_rects2 = rects_diff(rects2, rects1, iou=diff_iou)
            k, l = key1 + '_{}'.format(hint1), json_dump(rects1)
            labels.append((k, l))
            yield k, l, str_im
            k, l = key2 + '_{}'.format(hint2), json_dump(rects2)
            labels.append((k, l))
            yield k, l, str_im
            k, l = key1 + '_{}_unique'.format(hint1), json_dump(unique_rects1)
            labels.append((k, l))
            yield k, l, str_im
            k, l = key2 + '_{}_unique'.format(hint2), json_dump(unique_rects2)
            labels.append((k, l))
            yield k, l, str_im
    if force:
        from .common import ensure_remove_dir
        ensure_remove_dir(op.join('data', out_data))
    out_dataset = TSVDataset(out_data)
    assert not op.isdir(out_dataset._data_root) and \
            not op.islink(out_dataset._data_root)
    out_dataset.write_data(gen_rows(), 'test')
    out_dataset.write_data(labels, 'test', 'label')
    populate_dataset_details(out_data)

def create_caption_map(data, split, version):
    dataset = TSVDataset(data)
    all_cap = []
    for k, ss in tqdm(dataset.iter_data(
        split,
        'caption',
        version=version,
    )):
        rects = json.loads(ss)
        for r in rects:
            all_cap.append(r['caption'])
    all_cap = list(set(all_cap))
    dataset.write_data(((c,)for c in all_cap), split, 'captionmap',
                       version=version)

def create_filter_dataset(src_data, excludes, dst_data):
    filters = []
    data, split = src_data, 'train'
    for e in excludes:
        filter_file = 'data/remove_duplicate/target_{}_{}_exclude_{}_{}_0.995_filter_by_pixel.tsv'.format(
            data, split, e['data'], e['split']
        )
        filters.append(filter_file)

    ensure_directory(op.join('data', dst_data))
    for f in glob.glob(op.join('data', src_data, 'trainX*')):
        dest_f = op.join('data', dst_data, op.basename(f))
        ensure_copy_file(f, dest_f)

    shuffle = [(int(i), int(j)) for i, j in tsv_reader(op.join('data', src_data, 'train.shuffle.txt'))]

    idx = []
    for f in filters:
        idx.extend([int(idx_train) for idx_test, idx_train in tsv_reader(f)])
    all_idx = set(range(len(shuffle)))
    logging.info('before {}'.format(len(all_idx)))
    all_idx = all_idx.difference(idx)
    logging.info('after {}'.format(len(all_idx)))
    if len(idx) > 0:
        assert max(idx) < len(shuffle)
    dest_shuffle = [shuffle[i] for i in all_idx]

    tsv_writer(dest_shuffle, op.join('data', dst_data, 'train.shuffle.txt'))

    #generate_key_idximage_idxcaption(dst_data, 'train', None)

def remove_duplicate_loader(exclude, train_data, train_split):
    #dataset = TSVDataset('TaxFlickr30K')
    #dataset = TSVDataset('TaxVQA')
    num_workers = 64
    batch_size = 32
    use_hist = False
    threshold = 0.995
    out_file = 'data/remove_duplicate/target_{}_{}_exclude_{}_{}_{}_filter_by_hist.tsv'.format(
        train_data,
        train_split,
        exclude['data'],
        exclude['split'],
        threshold)
    out_file2 = 'data/remove_duplicate/target_{}_{}_exclude_{}_{}_{}_filter_by_pixel.tsv'.format(
        train_data,
        train_split,
        exclude['data'],
        exclude['split'],
        threshold)
    if File.isfile(out_file2):
        return
    def get_hist(data):
        image = data['image']
        all_hist = []
        h, w = image.shape[:2]
        if use_hist:
            for i in range(3):
                hist = cv2.calcHist([image], [i], None, [256], [0, 256])
                hist = torch.tensor(hist)
                all_hist.append(hist)

                hist = cv2.calcHist([image[:h//2]], [i], None, [256], [0, 256])
                hist = torch.tensor(hist)
                all_hist.append(hist)

                hist = cv2.calcHist([image[h//2:]], [i], None, [256], [0, 256])
                hist = torch.tensor(hist)
                all_hist.append(hist)

                hist = cv2.calcHist([image[:, :w//2, :]], [i], None, [256], [0, 256])
                hist = torch.tensor(hist)
                all_hist.append(hist)

                hist = cv2.calcHist([image[:, w//2:, :]], [i], None, [256], [0, 256])
                hist = torch.tensor(hist)
                all_hist.append(hist)

            hist = torch.cat(all_hist, dim=0)
            hist = torch.nn.functional.normalize(hist, dim=0)
            #ipdb> pp hist.shape
            #torch.Size([256, 1])
            data['hist'] = hist.squeeze()
        else:
            image = torch.tensor(cv2.resize(image, (64, 64)))
            image = image.view(1, -1)
            image = torch.nn.functional.normalize(image.float(), dim=1)
            image = image.squeeze()
            data['hist'] = image
        del data['image']
        return data

    hists = []
    info = exclude
    loader = create_tsv_dataset_loader(
        info['data'], info['split'],
        batch_size=batch_size,
        num_workers=num_workers,
        extra_transform=get_hist,
    )
    for info in tqdm(loader, total=len(loader)):
        hist = info['hist']
        hists.append(hist)
    hists = torch.cat(hists, dim=0)

    data_loader = create_tsv_dataset_loader(
        train_data, train_split,
        extra_transform=get_hist,
        num_workers=num_workers,
        batch_size=batch_size,
    )

    #device = 'cuda'
    device = 'cpu'
    hists = hists.to(device)
    def gen_rows():
        for i, info in tqdm(enumerate(data_loader), total=len(data_loader)):
            hist = info['hist']
            hist = hist.squeeze(-1)

            hist = hist.to(device)

            sim = torch.matmul(hists, hist.t())
            idx = sim > threshold
            del sim

            idx_test, idx_train = idx.nonzero(as_tuple=True)
            idx_train = idx_train + i * batch_size
            for nz_test, nz_train  in zip(idx_test.to('cpu'), idx_train.to('cpu')):
                yield int(nz_test), int(nz_train)
    tsv_writer(gen_rows(), out_file)

    remove_duplicate_double_check_im(
        exclude['data'], exclude['split'], train_data, out_file, out_file2,
        1-threshold,
    )

def remove_duplicate_double_check_im(
        exclude_data, exclude_split, train_data, tsv_fn, out_tsv, threshold):
    row_processor = CheckDuplicate(exclude_data, exclude_split, train_data,
                                   threshold)
    parallel_tsv_process(row_processor, tsv_fn, out_tsv, 64)

class CheckDuplicate(object):
    def __init__(self, exclude_data, exclude_split, train_data, threshold):
        from .tsv_io import TSVSplitProperty
        self.tsv_exclude = TSVSplitProperty(exclude_data, exclude_split)
        self.tsv_train = TSVSplitProperty(train_data, 'train')
        self.threshold = threshold

    def __call__(self, row):
        idx_exclude, idx_train = map(int, row)
        im_exclude = self.tsv_exclude[idx_exclude][-1]
        im_train = self.tsv_train[idx_train][-1]
        im_exclude = img_from_base64(im_exclude)
        im_train = img_from_base64(im_train)
        im2 = im_exclude
        im1 = im_train
        if im2.shape != im1.shape:
            im2 = cv2.resize(im2, (im1.shape[1], im1.shape[0]))
        if np.absolute(im1 - im2).mean() < self.threshold * im1.mean():
            return row
        return None


def create_tsv_dataset_loader(
        data, split, extra_transform=None, batch_size=1, num_workers=1):
    from qd.data_layer.loader import create_data_loader
    from qd.data_layer.dataset import (
        CaptionIdxTSVDataset,
        ImageIdxTSVDataset,
        DatasetPlusTransform,
    )
    from qd.data_layer.transform import (
        LoadLabel,
        LoadHW,
        LoadFeature,
        LoadImage,
        LoadCaption,
        IdentifyTextAB,
        RandomPairNegative,
        CaptionTensorizer,
        TokenizeTransform,
        NoChange,
        PrepareLabel,
        RemoveUselessKeys,
        RenameKey,
        AppendDummyFeature,
    )
    from torchvision.transforms import transforms
    tsv = ImageIdxTSVDataset(data, split)
    loader = LoadImage(data, split)
    hw = LoadHW(data, split)
    useless = RemoveUselessKeys(['dataset'])
    ts = [
        loader,
        hw,
        useless,
    ]
    if extra_transform is not None:
        ts.append(extra_transform)
    transform = transforms.Compose(ts)
    return create_data_loader(tsv, transform, batch_size, num_workers=num_workers)

def parse_hw_column(s_hw):
    try:
        h, w = map(int, s_hw.split(' '))
        return h, w
    except:
        info = json.loads(s_hw)
        if isinstance(info, list):
            assert len(info) == 1
            info = info[0]
        return info['height'], info['width']

def limit_image_size_with_filter(in_rows, min_size, max_size, resave=True, quality=None):
    assert len(in_rows) == 2
    result = limit_image_size(in_rows[:1], min_size, max_size, resave=True, quality=None)
    if result is None:
        return None
    else:
        assert result[0][0] == in_rows[1][0]
        return result[0], in_rows[1]

def limit_image_size(in_rows, min_size, max_size, resave=True, quality=None):
    #debug = True
    debug = False
    if len(in_rows) == 2:
        in_img_row, in_hw_row = in_rows
        h, w = parse_hw_column(in_hw_row[1])
    else:
        in_img_row = in_rows[0]
        h, w = None, None
    img = img_from_base64(in_img_row[-1])
    if img is None:
        img = pilimg_from_base64(in_img_row[-1])
        if img is None:
            return None
        img = np.array(img)
        if img.size == 0:
            return None
        # Convert RGB to BGR
        img = img[:, :, ::-1].copy()
    if h is None:
        h, w = img.shape[:2]
    if w != img.shape[1] or h != img.shape[0]:
        logging.info('{}: w = {}; h = {}; img.shape = {}'.format(
            in_img_row[0], w, h, img.shape))
        w = img.shape[1]
        h = img.shape[0]
    image_min = min(h, w)
    image_max = max(h, w)
    if image_min < min_size and image_max < max_size:
        if resave or quality:
            im = img_from_base64(in_img_row[-1])
            in_img_row[-1] = encoded_from_img(im, quality=quality)
        return in_img_row,
    scale = min(min_size * 1. / image_min, max_size * 1. / image_max)
    w2 = int(round(scale * w))
    h2 = int(round(scale * h))
    w2 = max(1, w2)
    h2 = max(1, h2)
    #img = pilimg_from_base64(in_img_row[-1])
    #img = ImageOps.exif_transpose(img)
    if debug:
        img.show()
    img = cv2.resize(img, (w2, h2),
                     interpolation=cv2.INTER_AREA,
                     )
    #save_image(img, '/tmp/b.jpg')
    #img = img.resize((w2, h2))
    in_img_row[-1] = encoded_from_img(img, quality=quality)
    if debug:
        img.show()
    return in_img_row,
    # we need to do resizing

def parallel_limit_image_size(im_tsv, hw_tsv, min_size, max_size,
                              quality,
                              out_tsv):
    process_func = lambda x: limit_image_size(x, min_size, max_size,
                                              quality=quality)
    num_process = 64
    if hw_tsv is not None:
        parallel_tsv_process_NtoN(process_func, (im_tsv, hw_tsv), (out_tsv, ),
                                  num_process)
    else:
        parallel_tsv_process_NtoN(process_func, (im_tsv,), (out_tsv, ),
                                  num_process)

def parallel_limit_image_size_with_filter(im_tsv, other_tsv, min_size, max_size,
                              quality,
                              out_tsv, out_other_tsv):
    process_func = lambda x: limit_image_size_with_filter(
        x, min_size, max_size, quality=quality)
    num_process = 64
    parallel_tsv_process_NtoN(process_func, (im_tsv, other_tsv), (out_tsv, out_other_tsv), num_process)

def filter_dataset_by_size(data, out_data):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)
    iter_hw = dataset.iter_data('train', 'hw')

    if op.isfile(dataset.get_shuffle_file('train')):
        iter_shuffle = tsv_reader(dataset.get_shuffle_file('train'))
        info = defaultdict(int)
        def gen_rows():
            for (key, str_hw), s in tqdm(zip(iter_hw, iter_shuffle)):
                try:
                    h, w = map(int, str_hw.split(' '))
                except:
                    x = json.loads(str_hw)
                    if isinstance(x, list):
                        x = x[0]
                    h, w = x['height'], x['width']
                r = 1. * h / w
                if r > 4 or r < 1. / 4:
                    info['ratio_too_large'] += 1
                    continue
                if min(h, w) < 64:
                    info['size_too_small'] += 1
                    continue
                yield s
        tsv_writer(gen_rows(), out_dataset.get_shuffle_file('train'))
        for t in [None, 'hw', 'caption']:
            ensure_copy_file(
                dataset.get_data('trainX', t),
                out_dataset.get_data('trainX', t),
            )
    else:
        info = defaultdict(int)
        def gen_rows():
            for i, (key, str_hw) in tqdm(enumerate(iter_hw)):
                try:
                    h, w = map(int, str_hw.split(' '))
                except:
                    x = json.loads(str_hw)
                    if isinstance(x, list):
                        x = x[0]
                    h, w = x['height'], x['width']
                r = 1. * h / w
                if r > 4 or r < 1. / 4:
                    info['ratio_too_large'] += 1
                    continue
                if min(h, w) < 64:
                    info['size_too_small'] += 1
                    continue
                yield (0, i)
        tsv_writer(gen_rows(), out_dataset.get_shuffle_file('train'))
        for t in [None, 'hw', 'caption']:
            write_to_file(
                dataset.get_data('train', t),
                out_dataset.get_data('trainX', t),
            )

def limit_dataset_image_size_to_single(
        data, split, image_t, min_size, max_size,
        quality, out_data):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)

    process_func = lambda x: limit_image_size(
        x, min_size, max_size, quality=quality)

    i = TSVSplitProperty(data, split)
    h = TSVSplitProperty(data, split, 'hw')
    o = out_dataset.get_data(split, image_t)
    if not op.isfile(o):
        parallel_tsv_process_NtoN(process_func, (i, h), (o, ), 64)

    for t in ['label', 'caption']:
        if dataset.has(split, t):
            tsv_writer(
                TSVSplitProperty(data, split, t),
                out_dataset.get_data(split, t)
            )
    populate_dataset_hw(out_data, splits=[split], img_t=image_t)
    if File.isfile(dataset.get_labelmap_file()):
        ensure_copy_file(
            dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file()
        )

def limit_dataset_image_size(
        data, split, image_t, min_size, max_size,
        quality, out_data):
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)

    if op.isfile(dataset.get_data(split, image_t)):
        in_img_tsv = [dataset.get_data(split, image_t)]
        caption_tsvs = [dataset.get_data(split, 'caption')]
        in_hw_tsv = [dataset.get_data(split, 'hw')]
        out_tsv = [out_dataset.get_data(split, image_t)]
        single_tsv = True
    else:
        in_img_tsv = load_list_file(dataset.get_data(split + 'X', image_t))
        hw_file = dataset.get_data(split + 'X', 'hw')
        if op.isfile(hw_file):
            in_hw_tsv = load_list_file(dataset.get_data(split + 'X', 'hw'))
        else:
            hw_file = dataset.get_data(split, 'hw')
            assert op.isfile(hw_file)
            in_hw_tsv = [hw_file]
            iter_shuffle = tsv_reader(dataset.get_shuffle_file(split))
            for i, (idx_source, idx_row) in enumerate(iter_shuffle):
                assert i == int(idx_row)
                assert int(idx_source) == 0
            assert len(in_img_tsv) == 1
            assert len(TSVFile(hw_file)) == len(TSVFile(in_img_tsv[0]))
        num_split = len(in_img_tsv)
        out_tsv = [out_dataset.get_data(split + '_{}_{}'.format(i, num_split))
                   for i in range(num_split)]
        caption_tsvs = load_list_file(
            dataset.get_data(split + 'X', 'caption')
        )
        label_tsvs = load_list_file(
            dataset.get_data(split + 'X', 'label')
        )
        single_tsv = False

    process_func = lambda x: limit_image_size(
        x, min_size, max_size, quality=quality)

    for i, h, o in zip(in_img_tsv, in_hw_tsv, out_tsv):
        from qd.process_tsv import parallel_tsv_process_NtoN
        if not op.isfile(o):
            parallel_tsv_process_NtoN(process_func, (i, h), (o, ), 64)

    if not single_tsv:
        write_to_file(
            '\n'.join(out_tsv),
            out_dataset.get_data(split + 'X', image_t),
        )
        write_to_file(
            '\n'.join(caption_tsvs),
            out_dataset.get_data(split + 'X', 'caption')
        )
        write_to_file(
            '\n'.join(label_tsvs),
            out_dataset.get_data(split + 'X', 'label')
        )
        tsv_copy(
            dataset.get_shuffle_file(split),
            out_dataset.get_shuffle_file(split),
        )
        splits = ['train_{}_{}'.format(i, num_split) for i in range(num_split)]
        populate_dataset_hw(out_data, splits=splits)
        write_to_file(
            '\n'.join((out_dataset.get_data(
                split + '_{}_{}'.format(i, num_split), 'hw',
            ) for i in range(num_split))),
            out_dataset.get_data(split + 'X', 'hw'),
        )
    else:
        for t in ['label', 'caption']:
            from_f = dataset.get_data(split, t)
            if File.isfile(from_f):
                tsv_copy(
                    dataset.get_data(split, t),
                    out_dataset.get_data(split, t)
                )
        populate_dataset_hw(out_data, splits=[split], img_t=image_t)
    if File.isfile(dataset.get_labelmap_file()):
        ensure_copy_file(
            dataset.get_labelmap_file(),
            out_dataset.get_labelmap_file()
        )

def video_convert_tsv_one(old_tsv, new_tsv):
    def gen_rows():
        for row in tsv_reader(old_tsv):
            #assert len(row) == 34
            idx = (len(row) - 2) // 2 + 2
            yield row[0], row[idx]
    if not op.isfile(new_tsv):
        tsv_writer(gen_rows(), new_tsv)

def get_max_iter_for_vl_plus_l_data(
    data, vl_data_rate, num_epoch_vl, effective_batch_size,
    effective_batch_size_text_only,
):

    iter_cache = TSVDataset(data).iter_data(
        'train',
        'key_idximage_idxcaption_num_valid_image',
    )
    info = {k: int(v) for k, v in iter_cache}
    num_vl_pair = info['num_valid_vl_pair']
    num_l_pair = info['num_l_only_pair']
    max_iter = int(num_vl_pair * num_epoch_vl / effective_batch_size / vl_data_rate + 0.5)
    num_epoch_l = max_iter * (1 - vl_data_rate) * effective_batch_size_text_only / num_l_pair
    logging.info(f'num_epoch_l = {num_epoch_l}; max_iter={max_iter}')
    return max_iter

def generate_num_vl_data(data, split, out_type='key_idximage_idxcaption_num_valid_image'):
    # this is mainly used by VisionLanguagePlusLanguageBatchSampler
    dataset = TSVDataset(data)
    source_list = load_list_file(dataset.get_data(split + 'X'))
    is_valid = tuple([s != 'd' for s in source_list])
    source = TSVSplitProperty(data, split,
                               'key_idximage_idxcaption_idxsource')
    ranges = split_to_chunk_to_range(len(source), num_chunk=64)
    def process(x):
        start, end = x
        info = defaultdict(int)
        with_image = True
        for i in tqdm(range(start, end)):
            s = int(source[i][0])
            if is_valid[s]:
                assert with_image
                info['with_valid_image'] += 1
            elif with_image:
                with_image = False
            info['total'] += 1
        info['with_image'] = with_image
        return info
    infos = parallel_map(process, ranges)
    ret = defaultdict(int)
    for i in infos:
        for k, v in i.items():
            ret[k] += v
    assert ret['total'] == len(source)
    for i, info in enumerate(infos):
        if not info['with_image']:
            for j in range(i + 1, len(infos)):
                assert not info['with_image']

    out_file = dataset.get_data(split, out_type)
    tsv_writer((
        ('num_valid_vl_pair', ret['with_valid_image']),
        ('num_l_only_pair', ret['total'] - ret['with_valid_image']),
        ('num_total', ret['total']),
    ), out_file)

def generate_num_vl_data_old(data, split, out_type='key_idximage_idxcaption_num_valid_image'):
    # this is mainly used by VisionLanguagePlusLanguageBatchSampler
    dataset = TSVDataset(data)
    source_list = load_list_file(dataset.get_data(split + 'X'))
    num_valid_image = 0
    num_total = 0
    with_image = True
    for s, in tqdm(TSVSplitProperty(data, split,
                               'key_idximage_idxcaption_idxsource')):
        if source_list[int(s)] != 'd':
            assert with_image
            num_valid_image += 1
        elif with_image:
            with_image = False
        num_total += 1
    out_file = dataset.get_data(split, out_type)
    tsv_writer((
        ('num_valid_vl_pair', num_valid_image),
        ('num_l_only_pair', num_total - num_valid_image),
        ('num_total', num_total),
    ), out_file)

def generate_num_each_tsv(data, split,
                          idxsource_type='key_idximage_idxcaption_idxsource',
                          out_type='key_idximage_idxcaption_num_each_tsv',
                          ):
    result = []
    dataset = TSVDataset(data)
    #for s, in tqdm(TSVSplitProperty(data, split, 'key_idximage_idxcaption_idxsource')):
            # TSVSplitProperty here is twice slower
    total = dataset.num_rows(split, t=idxsource_type)
    ranges = split_to_chunk_to_range(total, num_chunk=64)

    def chunk_processor(x):
        start, end = x
        tsv = TSVSplitProperty(data, split, idxsource_type)
        info = defaultdict(int)
        prev_s = -1
        for i in tqdm(range(start, end)):
            s = int(tsv[i][0])
            info[s] += 1
            if prev_s == -1:
                prev_s = s
            elif prev_s < s:
                prev_s = s
            else:
                assert prev_s == s, (i, prev_s, s)
        return info

    infos = parallel_map(chunk_processor, ranges, num_worker=64)
    for i in range(len(infos) - 1):
        assert max(infos[i].keys()) <= min(infos[i + 1].keys())
    result = defaultdict(int)
    for i in infos:
        for k, v in i.items():
            result[k] += v

    # we assumed the last tsv is not empty. If it is, it will crash and we need
    # to append more zeros here.
    num_tsv = len(load_list_file(dataset.get_data(split + 'X')))
    assert min(result.keys()) >= 0
    assert max(result.keys()) < num_tsv

    dataset.write_data(((result.get(i, 0),) for i in range(num_tsv)), split, out_type,)

def generate_num_each_tsv_old(data, split, idxsource_type='key_idximage_idxcaption_idxsource'):
    result = []
    curr_num = 0
    curr_idx = -1
    dataset = TSVDataset(data)
    #for s, in tqdm(TSVSplitProperty(data, split, 'key_idximage_idxcaption_idxsource')):
            # TSVSplitProperty here is twice slower
    total = dataset.num_rows(split, t=idxsource_type)
    with File.open(dataset.get_data(split, idxsource_type), 'r') as fp:
        for line in tqdm(fp, total=total):
            s = int(line)
            if s != curr_idx:
                if curr_idx != -1:
                    # the order should not be random
                    assert len(result) == curr_idx
                    result.append(curr_num)
                while curr_idx + 1 < s:
                    result.append(0)
                    curr_idx += 1
                assert s == curr_idx + 1, (curr_idx, s)
                curr_idx = s
                curr_num = 0
            curr_num += 1

    assert len(result) == curr_idx, (len(result), curr_idx)
    result.append(curr_num)

    # we assumed the last tsv is not empty. If it is, it will crash and we need
    # to append more zeros here.
    num_tsv = len(load_list_file(dataset.get_data(split + 'X')))
    assert num_tsv == len(result), (num_tsv, len(result))
    dataset.write_data(((r,) for r in result),
                       split,
                       'key_idximage_idxcaption_num_each_tsv',
                       )

#@deprecated('use generate_idximage_idxcaption_idxsource_parallel')
#def generate_key_idximage_idxcaption_idxsource(data, split):
    #logging.info(f'{data}/{split}')
    #generate_key_idximage_idxcaption(data, split)
    #k_img_cap = TSVSplitProperty(data, split, 'key_idximage_idxcaption')
    #dataset = TSVDataset(data)
    #if dataset.has(split, 'key_idximage_idxcaption_idxsource'):
        #return
    #x_tsv = dataset.get_data(split + 'X', 'caption')
    #if File.isfile(x_tsv):
        #all_idx_source = [int(idx_source) for idx_source, _ in
                          #tqdm(TSVFile(dataset.get_shuffle_file(split)))]
        #logging.info('loading composite source idx')
        #result = ((all_idx_source[int(idx_img)],) for _, idx_img, _ in
                  #tqdm(k_img_cap))
        #dataset.write_data(result, split, 'key_idximage_idxcaption_idxsource')
    #else:
        #dataset.write_data([(0,)] * len(k_img_cap), split, 'key_idximage_idxcaption_idxsource')

def generate_idximage_idxcaption_idxsource(data, split):
    logging.info(f'{data}/{split}')
    generate_idximage_idxcaption_parallel(data, split)
    k_img_cap = TSVSplitProperty(data, split, 'idximage_idxcaption')
    dataset = TSVDataset(data)
    if dataset.has(split, 'idximage_idxcaption_idxsource'):
        return
    x_tsv = dataset.get_data(split + 'X', 'caption')
    if File.isfile(x_tsv):
        shuffle_tsv = TSVFile(dataset.get_shuffle_file(split))
        def row_processor(row):
            key, idximage, _ = row
            ret = int(shuffle_tsv[int(idximage)][0])
            return (ret, )
        parallel_tsv_process(
            row_processor,
            k_img_cap,
            dataset.get_data(split, 'idximage_idxcaption_idxsource'),
            64,
        )
    else:
        dataset.write_data([(0,)] * len(k_img_cap), split, 'idximage_idxcaption_idxsource')

@deprecated('use generate_idxsource_of_idximage_idxcaption')
def generate_idxsource_of_idximage_idxcaption_parallel(*args, **kwargs):
    generate_idxsource_of_idximage_idxcaption(*args, **kwargs)

def generate_idxsource_of_idximage_idxcaption(
    data, split, in_type='key_idximage_idxcaption', out_type='key_idximage_idxcaption_idxsource'):
    logging.info(f'{data}/{split}')
    if in_type == 'key_idximage_idxcaption':
        generate_key_idximage_idxcaption(data, split)
    elif in_type == 'idximage_idxcaption':
        generate_idximage_idxcaption(data, split)
    k_img_cap = TSVSplitProperty(data, split, in_type)
    dataset = TSVDataset(data)
    if dataset.has(split, out_type):
        return
    x_tsv = dataset.get_data(split + 'X', 'caption')
    if File.isfile(x_tsv):
        shuffle_tsv = TSVFile(dataset.get_shuffle_file(split))
        def row_processor(row):
            idximage = row[-2]
            ret = int(shuffle_tsv[int(idximage)][0])
            return (ret, )
        parallel_tsv_process(
            row_processor,
            k_img_cap,
            dataset.get_data(split, out_type),
            64,
        )
    else:
        dataset.write_data([(0,)] * len(k_img_cap), split, out_type)


@deprecated('use generate_idxsource_of_idximage_idxcaption_parallel')
def generate_key_idximage_idxcaption_idxsource_parallel(*args, **kwargs):
    generate_idxsource_of_idximage_idxcaption_parallel(*args, **kwargs)

@deprecated('use generate_idxsource_of_idximage_idxcaption_parallel')
def generate_key_idximage_idxcaption_idxsource(*args, **kwargs):
    generate_idxsource_of_idximage_idxcaption_parallel(*args, **kwargs)


def generate_cache_tsv(data):
    dataset = TSVDataset(data)
    all_file = []
    for t in [None, 'caption']:
        files = load_list_file(dataset.get_data('trainX', t=t))
        all_file.extend(files)
    all_file = [f for f in all_file if f != 'd']
    all_file.extend([get_tsv_associates(f)[0] for f in all_file])
    ret = ','.join(all_file)
    return ret

def get_precache_tsv_files(data):
    dataset = TSVDataset(data)
    all_fs = []
    for t in [None, 'caption']:
        if File.isfile(dataset.get_data('trainX', t=t)):
            fs = load_list_file(dataset.get_data('trainX', t=t))
            fs = [f for f in fs if f != 'd']
            fs.append(dataset.get_shuffle_file('train'))
        else:
            fs = [dataset.get_data('train', t=t)]
        fs.extend([x for f in fs for x in get_tsv_associates(f)])
        all_fs.extend(fs)
    return ','.join(set(all_fs))

def shuffle_dataset_by_file(in_data, out_data):
    in_dataset = TSVDataset(in_data)
    out_dataset = TSVDataset(out_data)
    ts = [None, 'caption']
    old2new = None
    random.seed(666)
    for t in ts:
        from_file = in_dataset.get_data('trainX', t=t)
        out_file = out_dataset.get_data('trainX', t=t)
        fnames = load_list_file(from_file)
        if old2new is None:
            old2new = list(range(len(fnames)))
            random.shuffle(old2new)
        new_out = [None] * len(fnames)
        for i, j in enumerate(old2new):
            new_out[j] = fnames[i]
        write_to_file('\n'.join(new_out), out_file)

    def mapper(ret, row, idx):
        i = int(row[0])
        if 'x' not in ret:
            ret['x'] = []
        ret = ret['x']
        if len(ret) == 0 or ret[-1]['img_tsv_idx'] != i:
            ret.append({
                'start': idx,
                'end': idx,
                'img_tsv_idx': i,
            })
        else:
            assert ret[-1]['img_tsv_idx'] == i
            ret[-1]['end'] = idx

    def reducer(rets):
        result = []
        for ret in rets:
            r = ret['x']
            for _i, curr_r in enumerate(r):
                if len(result) == 0:
                    result.append(curr_r)
                elif result[-1]['img_tsv_idx'] == curr_r['img_tsv_idx']:
                    assert result[-1]['end'] == curr_r['start'] - 1
                    result[-1]['end'] = curr_r['end']
                else:
                    result.append(curr_r)
        return result

    results = parallel_tsv_aggregator(
        mapper,
        reducer,
        in_tsv_file=in_dataset.get_shuffle_file('train'),
        with_row_idx=True,
        num_process=64,
    )

    for i in range(len(results) - 1):
        assert results[i]['img_tsv_idx'] < results[i + 1]['img_tsv_idx']
    random.shuffle(results)
    def process(r):
        folder = get_tmp_folder()
        new_idx_img = old2new[r['img_tsv_idx']]
        tmp_file = '{}/{}.tsv'.format(folder, new_idx_img)
        def gen_rows():
            in_dataset = TSVDataset(in_data)
            tsv = TSVFile(in_dataset.get_shuffle_file('train'))
            for i in range(r['start'], r['end'] + 1):
                old_idx_img, idx_caption = tsv[i]
                assert old_idx_img == str(r['img_tsv_idx'])
                yield new_idx_img, idx_caption
        tsv_writer(gen_rows(), tmp_file)

    parallel_map(process, results, num_worker=64)
    folder = get_tmp_folder()
    tmp_files = ['{}/{}.tsv'.format(folder, i) for i in range(len(results))]
    logging.info(len(tmp_files))
    tmp_files = [t for t in tmp_files if op.isfile(t)]
    logging.info(len(tmp_files))
    concat_tsv_files(tmp_files, out_dataset.get_shuffle_file('train'))
    delete_tsv_files(tmp_files)

def populate_vl_dataset(data, split='train'):
    generate_idximage_idxcaption(data, split)
    from qd.process_tsv import generate_idxsource_of_idximage_idxcaption
    generate_idxsource_of_idximage_idxcaption(
        data, split,
        in_type='idximage_idxcaption',
    )
    from qd.process_tsv import generate_num_each_tsv
    generate_num_each_tsv(data, split)
    from qd.process_tsv import generate_num_vl_data
    generate_num_vl_data(data, split)

def create_simple_tax(data):
    out_data = 'Tax' + data
    dataset = TSVDataset(data)
    out_dataset = TSVDataset(out_data)
    for split in ['train', 'val', 'test', 'trainval']:
        if not dataset.has(split):
            continue
        for t in [None, 'caption']:
            src_file = dataset.get_data(split, t)
            write_to_file(
                src_file,
                out_dataset.get_data(split + 'X', t)
            )
        num = dataset.num_rows(split)
        tsv_writer(((0, i) for i in range(num)),
                   out_dataset.get_shuffle_file(split))

def convert_cap_to_tag(predict_file, tag_predict):
    def gen_rows():
        if isinstance(predict_file, str):
            iter_pred = tsv_reader(predict_file)
        else:
            iter_pred = predict_file
        for key, s in iter_pred:
            s = json.loads(s)
            assert len(s) == 1
            tags = map(lambda x: x.strip(), s[0]['caption'].split(','))
            ret = [{'class': t, 'conf': 1.} for t in tags]
            yield key, json_dump(ret)
    tsv_writer(gen_rows(), tag_predict)

def create_question_annotation_json(data, split):
    gt = TSVSplitProperty(data, split, 'caption')
    questions = []
    annotations = []
    for image_id, s in gt:
        s = json.loads(s)
        for i in s:
            q = {
                'image_id': image_id,
                'question_id': i.get('question_id'),
                'question': i['question'],
            }
            questions.append(q)
            a = copy.deepcopy(q)
            answers = [{
                'answer': ans,
            } for ans in i['answers']]
            a['answers'] = answers
            a['question_type'] = 'null'
            a['answer_type'] = 'null'
            annotations.append(a)

    # list of dict (image_id, question, question_id), image_id and question_id
    # are integer
    question_info = {
        'info': None,
        'task_type': 'Open-Ended',
        'data_type': 'mscoco',
        'license': None,
        'data_subtype': None,
        'questions': questions,
    }
    annotation_info = {
        'info': None,
        'task_type': 'Open-Ended',
        'data_type': 'mscoco',
        'license': None,
        'data_subtype': None,
        'annotations': annotations,
    }
    out_f = f'data/{data}/{split}.caption.question.json'
    write_to_file(json_dump(question_info), out_f)
    out_f = f'data/{data}/{split}.caption.annotation.json'
    write_to_file(json_dump(annotation_info), out_f)

if __name__ == '__main__':
    from .common import parse_general_args
    init_logging()
    kwargs = parse_general_args()
    logging.info('param:\n{}'.format(pformat(kwargs)))
    function_name = kwargs['type']
    del kwargs['type']
    locals()[function_name](**kwargs)