Upload 9 files

utils/language_utils.py

@@ -0,0 +1,315 @@
+from curses import A_ATTRIBUTES
+
+import numpy
+import torch
+from pip import main
+from sentence_transformers import SentenceTransformer, util
+
+# predefined shape text
+upper_length_text = [
+    'sleeveless', 'without sleeves', 'sleeves have been cut off', 'tank top',
+    'tank shirt', 'muscle shirt', 'short-sleeve', 'short sleeves',
+    'with short sleeves', 'medium-sleeve', 'medium sleeves',
+    'with medium sleeves', 'sleeves reach elbow', 'long-sleeve',
+    'long sleeves', 'with long sleeves'
+]
+upper_length_attr = {
+    'sleeveless': 0,
+    'without sleeves': 0,
+    'sleeves have been cut off': 0,
+    'tank top': 0,
+    'tank shirt': 0,
+    'muscle shirt': 0,
+    'short-sleeve': 1,
+    'with short sleeves': 1,
+    'short sleeves': 1,
+    'medium-sleeve': 2,
+    'with medium sleeves': 2,
+    'medium sleeves': 2,
+    'sleeves reach elbow': 2,
+    'long-sleeve': 3,
+    'long sleeves': 3,
+    'with long sleeves': 3
+}
+lower_length_text = [
+    'three-point', 'medium', 'short', 'covering knee', 'cropped',
+    'three-quarter', 'long', 'slack', 'of long length'
+]
+lower_length_attr = {
+    'three-point': 0,
+    'medium': 1,
+    'covering knee': 1,
+    'short': 1,
+    'cropped': 2,
+    'three-quarter': 2,
+    'long': 3,
+    'slack': 3,
+    'of long length': 3
+}
+socks_length_text = [
+    'socks', 'stocking', 'pantyhose', 'leggings', 'sheer hosiery'
+]
+socks_length_attr = {
+    'socks': 0,
+    'stocking': 1,
+    'pantyhose': 1,
+    'leggings': 1,
+    'sheer hosiery': 1
+}
+hat_text = ['hat', 'cap', 'chapeau']
+eyeglasses_text = ['sunglasses']
+belt_text = ['belt', 'with a dress tied around the waist']
+outer_shape_text = [
+    'with outer clothing open', 'with outer clothing unzipped',
+    'covering inner clothes', 'with outer clothing zipped'
+]
+outer_shape_attr = {
+    'with outer clothing open': 0,
+    'with outer clothing unzipped': 0,
+    'covering inner clothes': 1,
+    'with outer clothing zipped': 1
+}
+
+upper_types = [
+    'T-shirt', 'shirt', 'sweater', 'hoodie', 'tops', 'blouse', 'Basic Tee'
+]
+outer_types = [
+    'jacket', 'outer clothing', 'coat', 'overcoat', 'blazer', 'outerwear',
+    'duffle', 'cardigan'
+]
+skirt_types = ['skirt']
+dress_types = ['dress']
+pant_types = ['jeans', 'pants', 'trousers']
+rompers_types = ['rompers', 'bodysuit', 'jumpsuit']
+
+attr_names_list = [
+    'gender', 'hair length', '0 upper clothing length',
+    '1 lower clothing length', '2 socks', '3 hat', '4 eyeglasses', '5 belt',
+    '6 opening of outer clothing', '7 upper clothes', '8 outer clothing',
+    '9 skirt', '10 dress', '11 pants', '12 rompers'
+]
+
+
+def generate_shape_attributes(user_shape_texts):
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+    parsed_texts = user_shape_texts.split(',')
+
+    text_num = len(parsed_texts)
+
+    human_attr = [0, 0]
+    attr = [1, 3, 0, 0, 0, 3, 1, 1, 0, 0, 0, 0, 0]
+
+    changed = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    for text_id, text in enumerate(parsed_texts):
+        user_embeddings = model.encode(text)
+        if ('man' in text) and (text_id == 0):
+            human_attr[0] = 0
+            human_attr[1] = 0
+
+        if ('woman' in text or 'lady' in text) and (text_id == 0):
+            human_attr[0] = 1
+            human_attr[1] = 2
+
+        if (not changed[0]) and (text_id == 1):
+            # upper length
+            predefined_embeddings = model.encode(upper_length_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            attr[0] = upper_length_attr[upper_length_text[arg_idx]]
+            changed[0] = 1
+
+        if (not changed[1]) and ((text_num == 2 and text_id == 1) or
+                                 (text_num > 2 and text_id == 2)):
+            # lower length
+            predefined_embeddings = model.encode(lower_length_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            attr[1] = lower_length_attr[lower_length_text[arg_idx]]
+            changed[1] = 1
+
+        if (not changed[2]) and (text_id > 2):
+            # socks length
+            predefined_embeddings = model.encode(socks_length_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            if similarities[0][arg_idx] > 0.7:
+                attr[2] = arg_idx + 1
+                changed[2] = 1
+
+        if (not changed[3]) and (text_id > 2):
+            # hat
+            predefined_embeddings = model.encode(hat_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            if similarities[0][0] > 0.7:
+                attr[3] = 1
+                changed[3] = 1
+
+        if (not changed[4]) and (text_id > 2):
+            # glasses
+            predefined_embeddings = model.encode(eyeglasses_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            if similarities[0][arg_idx] > 0.7:
+                attr[4] = arg_idx + 1
+                changed[4] = 1
+
+        if (not changed[5]) and (text_id > 2):
+            # belt
+            predefined_embeddings = model.encode(belt_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            if similarities[0][arg_idx] > 0.7:
+                attr[5] = arg_idx + 1
+                changed[5] = 1
+
+        if (not changed[6]) and (text_id == 3):
+            # outer coverage
+            predefined_embeddings = model.encode(outer_shape_text)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            if similarities[0][arg_idx] > 0.7:
+                attr[6] = arg_idx
+                changed[6] = 1
+
+        if (not changed[10]) and (text_num == 2 and text_id == 1):
+            # dress_types
+            predefined_embeddings = model.encode(dress_types)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            similarity_skirt = util.dot_score(user_embeddings,
+                                              model.encode(skirt_types))
+            if similarities[0][0] > 0.5 and similarities[0][
+                    0] > similarity_skirt[0][0]:
+                attr[10] = 1
+                attr[7] = 0
+                attr[8] = 0
+                attr[9] = 0
+                attr[11] = 0
+                attr[12] = 0
+
+                changed[0] = 1
+                changed[10] = 1
+                changed[7] = 1
+                changed[8] = 1
+                changed[9] = 1
+                changed[11] = 1
+                changed[12] = 1
+
+        if (not changed[12]) and (text_num == 2 and text_id == 1):
+            # rompers_types
+            predefined_embeddings = model.encode(rompers_types)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            max_similarity = torch.max(similarities).item()
+            if max_similarity > 0.6:
+                attr[12] = 1
+                attr[7] = 0
+                attr[8] = 0
+                attr[9] = 0
+                attr[10] = 0
+                attr[11] = 0
+
+                changed[12] = 1
+                changed[7] = 1
+                changed[8] = 1
+                changed[9] = 1
+                changed[10] = 1
+                changed[11] = 1
+
+        if (not changed[7]) and (text_num > 2 and text_id == 1):
+            # upper_types
+            predefined_embeddings = model.encode(upper_types)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            max_similarity = torch.max(similarities).item()
+            if max_similarity > 0.6:
+                attr[7] = 1
+                changed[7] = 1
+
+        if (not changed[8]) and (text_id == 3):
+            # outer_types
+            predefined_embeddings = model.encode(outer_types)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            arg_idx = torch.argmax(similarities).item()
+            if similarities[0][arg_idx] > 0.7:
+                attr[6] = outer_shape_attr[outer_shape_text[arg_idx]]
+                attr[8] = 1
+                changed[8] = 1
+
+        if (not changed[9]) and (text_num > 2 and text_id == 2):
+            # skirt_types
+            predefined_embeddings = model.encode(skirt_types)
+            similarity_skirt = util.dot_score(user_embeddings,
+                                              predefined_embeddings)
+            similarity_dress = util.dot_score(user_embeddings,
+                                              model.encode(dress_types))
+            if similarity_skirt[0][0] > 0.7 and similarity_skirt[0][
+                    0] > similarity_dress[0][0]:
+                attr[9] = 1
+                attr[10] = 0
+                changed[9] = 1
+                changed[10] = 1
+
+        if (not changed[11]) and (text_num > 2 and text_id == 2):
+            # pant_types
+            predefined_embeddings = model.encode(pant_types)
+            similarities = util.dot_score(user_embeddings,
+                                          predefined_embeddings)
+            max_similarity = torch.max(similarities).item()
+            if max_similarity > 0.6:
+                attr[11] = 1
+                attr[9] = 0
+                attr[10] = 0
+                attr[12] = 0
+                changed[11] = 1
+                changed[9] = 1
+                changed[10] = 1
+                changed[12] = 1
+
+    return human_attr + attr
+
+
+def generate_texture_attributes(user_text):
+    parsed_texts = user_text.split(',')
+
+    attr = []
+    for text in parsed_texts:
+        if ('pure color' in text) or ('solid color' in text):
+            attr.append(4)
+        elif ('spline' in text) or ('stripe' in text):
+            attr.append(3)
+        elif ('plaid' in text) or ('lattice' in text):
+            attr.append(5)
+        elif 'floral' in text:
+            attr.append(1)
+        elif 'denim' in text:
+            attr.append(0)
+        else:
+            attr.append(17)
+
+    if len(attr) == 1:
+        attr.append(attr[0])
+        attr.append(17)
+
+    if len(attr) == 2:
+        attr.append(17)
+
+    return attr
+
+
+if __name__ == "__main__":
+    user_request = input('Enter your request: ')
+    while user_request != '\\q':
+        attr = generate_shape_attributes(user_request)
+        print(attr)
+        for attr_name, attr_value in zip(attr_names_list, attr):
+            print(attr_name, attr_value)
+        user_request = input('Enter your request: ')

utils/logger.py

@@ -0,0 +1,112 @@
+import datetime
+import logging
+import time
+
+
+class MessageLogger():
+    """Message logger for printing.
+
+    Args:
+        opt (dict): Config. It contains the following keys:
+            name (str): Exp name.
+            logger (dict): Contains 'print_freq' (str) for logger interval.
+            train (dict): Contains 'niter' (int) for total iters.
+            use_tb_logger (bool): Use tensorboard logger.
+        start_iter (int): Start iter. Default: 1.
+        tb_logger (obj:`tb_logger`): Tensorboard logger. Default： None.
+    """
+
+    def __init__(self, opt, start_iter=1, tb_logger=None):
+        self.exp_name = opt['name']
+        self.interval = opt['print_freq']
+        self.start_iter = start_iter
+        self.max_iters = opt['max_iters']
+        self.use_tb_logger = opt['use_tb_logger']
+        self.tb_logger = tb_logger
+        self.start_time = time.time()
+        self.logger = get_root_logger()
+
+    def __call__(self, log_vars):
+        """Format logging message.
+
+        Args:
+            log_vars (dict): It contains the following keys:
+                epoch (int): Epoch number.
+                iter (int): Current iter.
+                lrs (list): List for learning rates.
+
+                time (float): Iter time.
+                data_time (float): Data time for each iter.
+        """
+        # epoch, iter, learning rates
+        epoch = log_vars.pop('epoch')
+        current_iter = log_vars.pop('iter')
+        lrs = log_vars.pop('lrs')
+
+        message = (f'[{self.exp_name[:5]}..][epoch:{epoch:3d}, '
+                   f'iter:{current_iter:8,d}, lr:(')
+        for v in lrs:
+            message += f'{v:.3e},'
+        message += ')] '
+
+        # time and estimated time
+        if 'time' in log_vars.keys():
+            iter_time = log_vars.pop('time')
+            data_time = log_vars.pop('data_time')
+
+            total_time = time.time() - self.start_time
+            time_sec_avg = total_time / (current_iter - self.start_iter + 1)
+            eta_sec = time_sec_avg * (self.max_iters - current_iter - 1)
+            eta_str = str(datetime.timedelta(seconds=int(eta_sec)))
+            message += f'[eta: {eta_str}, '
+            message += f'time: {iter_time:.3f}, data_time: {data_time:.3f}] '
+
+        # other items, especially losses
+        for k, v in log_vars.items():
+            message += f'{k}: {v:.4e} '
+            # tensorboard logger
+            if self.use_tb_logger and 'debug' not in self.exp_name:
+                self.tb_logger.add_scalar(k, v, current_iter)
+
+        self.logger.info(message)
+
+
+def init_tb_logger(log_dir):
+    from torch.utils.tensorboard import SummaryWriter
+    tb_logger = SummaryWriter(log_dir=log_dir)
+    return tb_logger
+
+
+def get_root_logger(logger_name='base', log_level=logging.INFO, log_file=None):
+    """Get the root logger.
+
+    The logger will be initialized if it has not been initialized. By default a
+    StreamHandler will be added. If `log_file` is specified, a FileHandler will
+    also be added.
+
+    Args:
+        logger_name (str): root logger name. Default: base.
+        log_file (str | None): The log filename. If specified, a FileHandler
+            will be added to the root logger.
+        log_level (int): The root logger level. Note that only the process of
+            rank 0 is affected, while other processes will set the level to
+            "Error" and be silent most of the time.
+
+    Returns:
+        logging.Logger: The root logger.
+    """
+    logger = logging.getLogger(logger_name)
+    # if the logger has been initialized, just return it
+    if logger.hasHandlers():
+        return logger
+
+    format_str = '%(asctime)s.%(msecs)03d - %(levelname)s: %(message)s'
+    logging.basicConfig(format=format_str, level=log_level)
+
+    if log_file is not None:
+        file_handler = logging.FileHandler(log_file, 'w')
+        file_handler.setFormatter(logging.Formatter(format_str))
+        file_handler.setLevel(log_level)
+        logger.addHandler(file_handler)
+
+    return logger

utils/options.py

@@ -0,0 +1,129 @@
+import os
+import os.path as osp
+from collections import OrderedDict
+
+import yaml
+
+
+def ordered_yaml():
+    """Support OrderedDict for yaml.
+
+    Returns:
+        yaml Loader and Dumper.
+    """
+    try:
+        from yaml import CDumper as Dumper
+        from yaml import CLoader as Loader
+    except ImportError:
+        from yaml import Dumper, Loader
+
+    _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
+
+    def dict_representer(dumper, data):
+        return dumper.represent_dict(data.items())
+
+    def dict_constructor(loader, node):
+        return OrderedDict(loader.construct_pairs(node))
+
+    Dumper.add_representer(OrderedDict, dict_representer)
+    Loader.add_constructor(_mapping_tag, dict_constructor)
+    return Loader, Dumper
+
+
+def parse(opt_path, is_train=True):
+    """Parse option file.
+
+    Args:
+        opt_path (str): Option file path.
+        is_train (str): Indicate whether in training or not. Default: True.
+
+    Returns:
+        (dict): Options.
+    """
+    with open(opt_path, mode='r') as f:
+        Loader, _ = ordered_yaml()
+        opt = yaml.load(f, Loader=Loader)
+
+    gpu_list = ','.join(str(x) for x in opt['gpu_ids'])
+    if opt.get('set_CUDA_VISIBLE_DEVICES', None):
+        os.environ['CUDA_VISIBLE_DEVICES'] = gpu_list
+        print('export CUDA_VISIBLE_DEVICES=' + gpu_list, flush=True)
+    else:
+        print('gpu_list: ', gpu_list, flush=True)
+
+    opt['is_train'] = is_train
+
+    # paths
+    opt['path'] = {}
+    opt['path']['root'] = osp.abspath(
+        osp.join(__file__, osp.pardir, osp.pardir))
+    if is_train:
+        experiments_root = osp.join(opt['path']['root'], 'experiments',
+                                    opt['name'])
+        opt['path']['experiments_root'] = experiments_root
+        opt['path']['models'] = osp.join(experiments_root, 'models')
+        opt['path']['log'] = experiments_root
+        opt['path']['visualization'] = osp.join(experiments_root,
+                                                'visualization')
+
+        # change some options for debug mode
+        if 'debug' in opt['name']:
+            opt['debug'] = True
+            opt['val_freq'] = 1
+            opt['print_freq'] = 1
+            opt['save_checkpoint_freq'] = 1
+    else:  # test
+        results_root = osp.join(opt['path']['root'], 'results', opt['name'])
+        opt['path']['results_root'] = results_root
+        opt['path']['log'] = results_root
+        opt['path']['visualization'] = osp.join(results_root, 'visualization')
+
+    return opt
+
+
+def dict2str(opt, indent_level=1):
+    """dict to string for printing options.
+
+    Args:
+        opt (dict): Option dict.
+        indent_level (int): Indent level. Default: 1.
+
+    Return:
+        (str): Option string for printing.
+    """
+    msg = ''
+    for k, v in opt.items():
+        if isinstance(v, dict):
+            msg += ' ' * (indent_level * 2) + k + ':[\n'
+            msg += dict2str(v, indent_level + 1)
+            msg += ' ' * (indent_level * 2) + ']\n'
+        else:
+            msg += ' ' * (indent_level * 2) + k + ': ' + str(v) + '\n'
+    return msg
+
+
+class NoneDict(dict):
+    """None dict. It will return none if key is not in the dict."""
+
+    def __missing__(self, key):
+        return None
+
+
+def dict_to_nonedict(opt):
+    """Convert to NoneDict, which returns None for missing keys.
+
+    Args:
+        opt (dict): Option dict.
+
+    Returns:
+        (dict): NoneDict for options.
+    """
+    if isinstance(opt, dict):
+        new_opt = dict()
+        for key, sub_opt in opt.items():
+            new_opt[key] = dict_to_nonedict(sub_opt)
+        return NoneDict(**new_opt)
+    elif isinstance(opt, list):
+        return [dict_to_nonedict(sub_opt) for sub_opt in opt]
+    else:
+        return opt

utils/util.py

@@ -0,0 +1,123 @@
+import logging
+import os
+import random
+import sys
+import time
+from shutil import get_terminal_size
+
+import numpy as np
+import torch
+
+logger = logging.getLogger('base')
+
+
+def make_exp_dirs(opt):
+    """Make dirs for experiments."""
+    path_opt = opt['path'].copy()
+    if opt['is_train']:
+        overwrite = True if 'debug' in opt['name'] else False
+        os.makedirs(path_opt.pop('experiments_root'), exist_ok=overwrite)
+        os.makedirs(path_opt.pop('models'), exist_ok=overwrite)
+    else:
+        os.makedirs(path_opt.pop('results_root'))
+
+
+def set_random_seed(seed):
+    """Set random seeds."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+class ProgressBar(object):
+    """A progress bar which can print the progress.
+
+    Modified from:
+    https://github.com/hellock/cvbase/blob/master/cvbase/progress.py
+    """
+
+    def __init__(self, task_num=0, bar_width=50, start=True):
+        self.task_num = task_num
+        max_bar_width = self._get_max_bar_width()
+        self.bar_width = (
+            bar_width if bar_width <= max_bar_width else max_bar_width)
+        self.completed = 0
+        if start:
+            self.start()
+
+    def _get_max_bar_width(self):
+        terminal_width, _ = get_terminal_size()
+        max_bar_width = min(int(terminal_width * 0.6), terminal_width - 50)
+        if max_bar_width < 10:
+            print(f'terminal width is too small ({terminal_width}), '
+                  'please consider widen the terminal for better '
+                  'progressbar visualization')
+            max_bar_width = 10
+        return max_bar_width
+
+    def start(self):
+        if self.task_num > 0:
+            sys.stdout.write(f"[{' ' * self.bar_width}] 0/{self.task_num}, "
+                             f'elapsed: 0s, ETA:\nStart...\n')
+        else:
+            sys.stdout.write('completed: 0, elapsed: 0s')
+        sys.stdout.flush()
+        self.start_time = time.time()
+
+    def update(self, msg='In progress...'):
+        self.completed += 1
+        elapsed = time.time() - self.start_time
+        fps = self.completed / elapsed
+        if self.task_num > 0:
+            percentage = self.completed / float(self.task_num)
+            eta = int(elapsed * (1 - percentage) / percentage + 0.5)
+            mark_width = int(self.bar_width * percentage)
+            bar_chars = '>' * mark_width + '-' * (self.bar_width - mark_width)
+            sys.stdout.write('\033[2F')  # cursor up 2 lines
+            sys.stdout.write(
+                '\033[J'
+            )  # clean the output (remove extra chars since last display)
+            sys.stdout.write(
+                f'[{bar_chars}] {self.completed}/{self.task_num}, '
+                f'{fps:.1f} task/s, elapsed: {int(elapsed + 0.5)}s, '
+                f'ETA: {eta:5}s\n{msg}\n')
+        else:
+            sys.stdout.write(
+                f'completed: {self.completed}, elapsed: {int(elapsed + 0.5)}s, '
+                f'{fps:.1f} tasks/s')
+        sys.stdout.flush()
+
+
+class AverageMeter(object):
+    """
+    Computes and stores the average and current value
+    Imported from
+    https://github.com/pytorch/examples/blob/master/imagenet/main.py#L247-L262
+    """
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0  # running average = running sum / running count
+        self.sum = 0  # running sum
+        self.count = 0  # running count
+
+    def update(self, val, n=1):
+        # n = batch_size
+
+        # val = batch accuracy for an attribute
+        # self.val = val
+
+        # sum = 100 * accumulative correct predictions for this attribute
+        self.sum += val * n
+
+        # count = total samples so far
+        self.count += n
+
+        # avg = 100 * avg accuracy for this attribute
+        # for all the batches so far
+        self.avg = self.sum / self.count