def main(): import argparse parser = argparse.ArgumentParser(description="Pytorch Image CNN training from Configure Files") parser.add_argument('--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') best_prec1 = 0 args.script_name = get_stem(__file__) current_time_str = get_date_str() # if args.resume is None: if args.save_directory is None: save_directory = get_dir(os.path.join(project_root, 'ckpts2', '{:s}'.format(args.name), '{:s}-{:s}'.format(args.ID, current_time_str))) else: save_directory = get_dir(os.path.join(project_root, 'ckpts2', args.save_directory)) # else: # save_directory = os.path.dirname(args.resume) print("Save to {}".format(save_directory)) log_file = os.path.join(save_directory, 'log-{0}.txt'.format(current_time_str)) logger = log_utils.get_logger(log_file) log_utils.print_config(vars(args), logger) print_func = logger.info print_func('ConfigFile: {}'.format(config_file)) args.log_file = log_file if args.device: os.environ["CUDA_VISIBLE_DEVICES"]=args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) visual_model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) visual_model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.freeze: visual_model = CNN_utils.freeze_all_except_fc(visual_model) if os.path.isfile(args.text_ckpt): print_func("=> loading checkpoint '{}'".format(args.text_ckpt)) text_data = torch.load(args.text_ckpt, map_location=lambda storage, loc:storage) text_model = TextCNN(text_data['args_model']) # load_state_dict(text_model, text_data['state_dict']) text_model.load_state_dict(text_data['state_dict'], strict=True) text_model.eval() print_func("=> loaded checkpoint '{}' for text classification" .format(args.text_ckpt)) args.vocab_size = text_data['args_model'].vocab_size else: print_func("=> no checkpoint found at '{}'".format(args.text_ckpt)) return args.tag2clsidx = text_data['args_data'].tag2idx args.vocab_size = len(args.tag2clsidx) args.text_embed = loadpickle(args.text_embed) args.idx2tag = loadpickle(args.idx2tag)['idx2tag'] if args.gpu is not None: visual_model = visual_model.cuda(args.gpu) text_model = text_model.cuda((args.gpu)) elif args.distributed: visual_model.cuda() visual_model = torch.nn.parallel.DistributedDataParallel(visual_model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): visual_model.features = torch.nn.DataParallel(visual_model.features) visual_model.cuda() else: visual_model = torch.nn.DataParallel(visual_model).cuda() text_model = torch.nn.DataParallel(text_model).cuda() criterion = nn.CrossEntropyLoss(ignore_index=-1).cuda(args.gpu) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, visual_model.parameters()), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.lr_schedule: print_func("Using scheduled learning rate") scheduler = lr_scheduler.MultiStepLR( optimizer, [int(i) for i in args.lr_schedule.split(',')], gamma=0.1) else: scheduler = lr_scheduler.ReduceLROnPlateau( optimizer, 'min', patience=args.lr_patience) # optimizer = torch.optim.SGD(model.parameters(), args.lr, # momentum=args.momentum, # weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) import collections if isinstance(checkpoint, collections.OrderedDict): load_state_dict(visual_model, checkpoint) else: load_state_dict(visual_model, checkpoint['state_dict']) print_func("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True model_total_params = sum(p.numel() for p in visual_model.parameters()) model_grad_params = sum(p.numel() for p in visual_model.parameters() if p.requires_grad) print_func("Total Parameters: {0}\t Gradient Parameters: {1}".format(model_total_params, model_grad_params)) # Data loading code val_dataset = get_instance(custom_datasets, '{0}'.format(args.valloader), args) if val_dataset is None: val_loader = None else: val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, collate_fn=none_collate) if args.evaluate: print_func('Validation Only') validate(val_loader, visual_model, criterion, args, print_func) return else: train_dataset = get_instance(custom_datasets, '{0}'.format(args.trainloader), args) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler, collate_fn=none_collate) for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) if args.lr_schedule: # CNN_utils.adjust_learning_rate(optimizer, epoch, args.lr) scheduler.step() current_lr = optimizer.param_groups[0]['lr'] print_func("Epoch: [{}], learning rate: {}".format(epoch, current_lr)) # train for one epoch train(train_loader, visual_model, text_model, criterion, optimizer, epoch, args, print_func) # evaluate on validation set if val_loader: prec1, val_loss = validate(val_loader, visual_model, criterion, args, print_func) else: prec1 = 0 val_loss = 0 # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) CNN_utils.save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': visual_model.state_dict(), 'best_prec1': best_prec1, 'optimizer' : optimizer.state_dict(), }, is_best, file_directory=save_directory, epoch=epoch) if not args.lr_schedule: scheduler.step(val_loss)
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') best_prec1 = 0 args.script_name = get_stem(__file__) current_time_str = get_date_str() print_func = print if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: # model = torch.nn.DataParallel(model).cuda() model = model.cuda() if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) import collections if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) else: load_state_dict( model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) return else: print_func( "=> This script is for fine-tuning only, please double check '{}'". format(args.resume)) print_func("Now using randomly initialized parameters!") cudnn.benchmark = True from PyUtils.pickle_utils import loadpickle from PublicEmotionDatasets.Deepemotion.constants import emotion2idx, idx2emotion from PyUtils.dict_utils import string_list2dict import numpy as np from torchvision.datasets.folder import default_loader tag_wordvectors = loadpickle(args.tag_embeddings) tag_words = [] tag_matrix = [] label_words = [] label_matrix = [] for x_tag in tag_wordvectors: tag_words.append(x_tag) tag_matrix.append(tag_wordvectors[x_tag]) if x_tag in emotion2idx: label_words.append(x_tag) label_matrix.append(tag_wordvectors[x_tag]) idx2tag, tag2idx = string_list2dict(tag_words) idx2label, label2idx = string_list2dict(label_words) tag_matrix = np.array(tag_matrix) label_matrix = np.array(label_matrix) label_matrix = label_matrix.squeeze(1) tag_matrix = tag_matrix.squeeze(1) val_list = loadpickle(args.val_file) from CNNs.datasets.multilabel import get_val_simple_transform val_transform = get_val_simple_transform() model.eval() correct = 0 total = len(val_list) * 1.0 for i, (input_image_file, target, _) in enumerate(val_list): # measure data loading time image_path = os.path.join(args.data_dir, input_image_file) input_image = default_loader(image_path) input_image = val_transform(input_image) if args.gpu is not None: input_image = input_image.cuda(args.gpu, non_blocking=True) input_image = input_image.unsqueeze(0).cuda() # target_idx = target.nonzero() [:,1] # compute output output, output_proj = model(input_image) output_proj = output_proj.cpu().data.numpy() dot_product_label = cosine_similarity(output_proj, label_matrix)[0] output_label = np.argmax(dot_product_label) if output_label == target: correct += 1 dot_product_tag = cosine_similarity(output_proj, tag_matrix)[0] out_tags = np.argsort(dot_product_tag)[::-1][:10] print("* {} Image: {} GT label: {}, predicted label: {}".format( i, input_image_file, idx2emotion[target], idx2label[output_label])) print(" == closest tags: {}".format(', '.join([ '{}({:.02f})'.format(idx2tag[x], dot_product_tag[x]) for x in out_tags ]))) print("Accuracy {:.4f}".format(correct / total))
dataset_directory = '/home/zwei/datasets/PublicEmotion/EMOTIC' data_split = 'test' text_annotation_file = os.path.join(dataset_directory, 'annotations/samples', '{}.txt'.format(data_split)) annotaitons_person_crop = [] annotaitons_whole_image = [] raw_annotation_list = load_json_list(text_annotation_file)[0] for s_annotation in tqdm.tqdm(raw_annotation_list, desc="Processing data"): s_file_name = os.path.join(s_annotation['folder'], s_annotation['filename']) s_file_name_stem = get_stem(s_file_name) s_file_extension = s_file_name.split('.')[-1] if isinstance(s_annotation['person'], list): pass else: s_annotation['person'] = [s_annotation['person']] for s_person_idx, s_person in enumerate(s_annotation['person']): s_bbox = s_person['body_bbox'] annotated_categories = [] if not isinstance(s_person['annotations_categories'], list): s_person['annotations_categories'] = [s_person['annotations_categories']] s_person['combined_continuous'] = s_person['annotations_continuous'] for s_single_annotation in s_person['annotations_categories']:
def main(): best_prec1 = 0 args = parser.parser.parse_args() if args.config is not None: args = parse_config(args.config) script_name_stem = get_stem(__file__) current_time_str = get_date_str() if args.save_directory is None: raise FileNotFoundError( "Saving directory should be specified for feature extraction tasks" ) save_directory = get_dir(args.save_directory) print("Save to {}".format(save_directory)) log_file = os.path.join(save_directory, 'log-{0}.txt'.format(current_time_str)) logger = log_utils.get_logger(log_file) log_utils.print_config(vars(args), logger) print_func = logger.info args.log_file = log_file if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn( 'You have chosen a specific GPU. This will completely disable data parallelism.' ) args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.arch == 'resnet50_feature_extractor': print_func("=> using pre-trained model '{}' to LOAD FEATURES".format( args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes, param_name=args.paramname) else: print_func( "This is only for feature extractors!, Please double check the parameters!" ) return # if args.freeze: # model = CNN_utils.freeze_all_except_fc(model) if args.gpu is not None: model = model.cuda(args.gpu) else: print_func( 'Please only specify one GPU since we are working in batch size 1 model' ) return cudnn.benchmark = True model_total_params = sum(p.numel() for p in model.parameters()) model_grad_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print_func("Total Parameters: {0}\t Gradient Parameters: {1}".format( model_total_params, model_grad_params)) # Data loading code val_dataset = get_instance(custom_datasets, '{0}'.format(args.dataset.name), args, **args.dataset.args) import tqdm import numpy as np if args.individual_feat: feature_save_directory = get_dir( os.path.join(save_directory, 'individual-features')) created_paths = set() else: data_dict = {} feature_save_directory = os.path.join(save_directory, 'feature.pkl') model.eval() for s_data in tqdm.tqdm(val_dataset, desc="Extracting Features"): if s_data is None: continue s_image_name = s_data[1] s_image_data = s_data[0] if args.gpu is not None: s_image_data = s_image_data.cuda(args.gpu, non_blocking=True) output = model(s_image_data.unsqueeze_(0)) output = output.cpu().data.numpy() image_rel_path = os.path.join( *(s_image_name.split(os.sep)[-args.rel_path_depth:])) if args.individual_feat: image_directory = os.path.dirname(image_rel_path) if image_directory in created_paths: np.save( os.path.join(feature_save_directory, '{}.npy'.format(image_rel_path)), output) else: get_dir(os.path.join(feature_save_directory, image_directory)) np.save( os.path.join(feature_save_directory, '{}.npy'.format(image_rel_path)), output) created_paths.add(image_directory) else: data_dict[image_rel_path] = output # image_name = os.path.basename(s_image_name) # # if args.individual_feat: # # image_name = os.path.basename(s_image_name) # # np.save(os.path.join(feature_save_directory, '{}.npy'.format(image_name)), output) # # created_paths.add(image_directory) # else: # data_dict[get_stem(image_name)] = output if args.individual_feat: print_func("Done") else: from PyUtils.pickle_utils import save2pickle print_func("Saving to a single big file!") save2pickle(feature_save_directory, data_dict) print_func("Done")
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') # best_prec1 = 0 args.script_name = get_stem(__file__) # current_time_str = get_date_str() print_func = print if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # model = model.cuda() if args.visual_model: if os.path.isfile(args.visual_model): print_func("=> loading checkpoint '{}'".format(args.visual_model)) checkpoint = torch.load(args.visual_model) model.load_state_dict(checkpoint['state_dict'], strict=True) # import collections # if isinstance(checkpoint, collections.OrderedDict): # load_state_dict(model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) # # # else: # load_state_dict(model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) # print_func("=> loaded checkpoint '{}' (epoch {})" # .format(args.visual_model, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format( args.visual_model)) return else: print_func( "=> This script is for fine-tuning only, please double check '{}'". format(args.visual_model)) print_func("Now using randomly initialized parameters!") cudnn.benchmark = True from PyUtils.pickle_utils import loadpickle import numpy as np from PublicEmotionDatasets.Emotic.constants import emotion_full_words_690 as emotion_self_words from torchvision.datasets.folder import default_loader tag_wordvectors = loadpickle(args.text_embed) print_func(" => loading word2vec parameters: {}".format(args.text_embed)) emotic_emotion_explaintations = {} for x_key in emotion_self_words: x_words = emotion_self_words[x_key].split(',') x_feature = [tag_wordvectors[x] for x in x_words] item = {} item['pred'] = [] item['label'] = [] item['target_matrix'] = np.array(x_feature) item['description'] = x_words emotic_emotion_explaintations[x_key] = item val_list = loadpickle(args.val_file) image_directory = args.data_dir from CNNs.datasets.multilabel import get_val_simple_transform val_transform = get_val_simple_transform() model.eval() import tqdm for i, (input_image_file, target, _, _) in tqdm.tqdm(enumerate(val_list), desc="Evaluating Peace", total=len(val_list)): # measure data loading time image_path = os.path.join(image_directory, input_image_file) input_image = default_loader(image_path) input_image = val_transform(input_image) if args.gpu is not None: input_image = input_image.cuda(args.gpu, non_blocking=True) input_image = input_image.unsqueeze(0).cuda() # target_idx = target.nonzero() [:,1] # compute output output, output_proj = model(input_image) output_proj = output_proj.cpu().data.numpy() target_labels = set([x[0] for x in target.most_common()]) for x_key in emotic_emotion_explaintations: dot_product_label = cosine_similarity( output_proj, emotic_emotion_explaintations[x_key]['target_matrix'])[0] pred_score = np.average(dot_product_label) emotic_emotion_explaintations[x_key]['pred'].append(pred_score) if x_key in target_labels: emotic_emotion_explaintations[x_key]['label'].append(1) else: emotic_emotion_explaintations[x_key]['label'].append(0) from sklearn.metrics import average_precision_score full_AP = [] for x_key in emotic_emotion_explaintations: full_pred = np.array(emotic_emotion_explaintations[x_key]['pred']) full_label = np.array(emotic_emotion_explaintations[x_key]['label']) AP = average_precision_score(full_label, full_pred) if np.isnan(AP): print("{} is Nan".format(x_key)) continue full_AP.append(AP) print("{}\t{:.4f}".format(x_key, AP * 100)) AvgAP = np.mean(full_AP) print("Avg AP: {:.2f}".format(AvgAP * 100))
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') best_prec1 = 0 args.script_name = get_stem(__file__) current_time_str = get_date_str() if args.save_directory is None: save_directory = get_dir( os.path.join(project_root, args.ckpts_dir, '{:s}'.format(args.name), '{:s}-{:s}'.format(args.ID, current_time_str))) else: save_directory = get_dir( os.path.join(project_root, args.ckpts_dir, args.save_directory)) print("Save to {}".format(save_directory)) log_file = os.path.join(save_directory, 'log-{0}.txt'.format(current_time_str)) logger = log_utils.get_logger(log_file) log_utils.print_config(vars(args), logger) print_func = logger.info print_func('ConfigFile: {}'.format(config_file)) args.log_file = log_file if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.freeze: model = CNN_utils.freeze_all_except_fc(model) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: print_func( 'Please only specify one GPU since we are working in batch size 1 model' ) return if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) import collections if not args.evaluate: if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) else: load_state_dict( model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, strict=True) else: load_state_dict(model, checkpoint['state_dict'], strict=True) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) return else: print_func( "=> This script is for fine-tuning only, please double check '{}'". format(args.resume)) print_func("Now using randomly initialized parameters!") cudnn.benchmark = True model_total_params = sum(p.numel() for p in model.parameters()) model_grad_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print_func("Total Parameters: {0}\t Gradient Parameters: {1}".format( model_total_params, model_grad_params)) # Data loading code # val_dataset = get_instance(custom_datasets, '{0}'.format(args.valloader), args) from PyUtils.pickle_utils import loadpickle from torchvision.datasets.folder import default_loader val_dataset = loadpickle(args.val_file) image_directory = args.data_dir from CNNs.datasets.multilabel import get_val_simple_transform val_transform = get_val_simple_transform() import tqdm import numpy as np if args.individual_feat: feature_save_directory = get_dir( os.path.join(save_directory, 'individual-features')) created_paths = set() else: data_dict = {} feature_save_directory = os.path.join(save_directory, 'feature.pkl') model.eval() for s_data in tqdm.tqdm(val_dataset, desc="Extracting Features"): if s_data is None: continue image_path = os.path.join(image_directory, s_data[0]) try: input_image = default_loader(image_path) except: print("WARN: {} Problematic!, Skip!".format(image_path)) continue input_image = val_transform(input_image) if args.gpu is not None: input_image = input_image.cuda(args.gpu, non_blocking=True) output = model(input_image.unsqueeze_(0)) output = output.cpu().data.numpy() # image_rel_path = os.path.join(*(s_image_name.split(os.sep)[-int(args.rel_path_depth):])) if args.individual_feat: if image_directory in created_paths: np.save( os.path.join(feature_save_directory, '{}.npy'.format(s_data[0])), output) else: get_dir(os.path.join(feature_save_directory, image_directory)) np.save( os.path.join(feature_save_directory, '{}.npy'.format(s_data[0])), output) created_paths.add(image_directory) else: data_dict[s_data[0]] = output # image_name = os.path.basename(s_image_name) # # if args.individual_feat: # # image_name = os.path.basename(s_image_name) # # np.save(os.path.join(feature_save_directory, '{}.npy'.format(image_name)), output) # # created_paths.add(image_directory) # else: # data_dict[get_stem(image_name)] = output if args.individual_feat: print_func("Done") else: from PyUtils.pickle_utils import save2pickle print_func("Saving to a single big file!") save2pickle(feature_save_directory, data_dict) print_func("Done")
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') best_prec1 = 0 args.script_name = get_stem(__file__) current_time_str = get_date_str() print_func = print if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: # model = torch.nn.DataParallel(model).cuda() model = model.cuda() if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) import collections if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) else: load_state_dict( model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) return else: print_func( "=> This script is for fine-tuning only, please double check '{}'". format(args.resume)) print_func("Now using randomly initialized parameters!") cudnn.benchmark = True from PyUtils.pickle_utils import loadpickle # from PublicEmotionDatasets.Deepemotion.constants import emotion2idx, idx2emotion from PyUtils.dict_utils import string_list2dict import numpy as np from torchvision.datasets.folder import default_loader tag_wordvectors = loadpickle( '/home/zwei/Dev/AttributeNet3/TextClassification/visualizations/Embeddings/FullVocab_BN_transformed_l2_regularization.pkl' ) tag_words = [] tag_matrix = [] label_words = [] label_matrix = [] from TextClassification.model_DAN_2constraints import CNN text_ckpt = torch.load( '/home/zwei/Dev/AttributeNet3/TextClassification/models/model_feature_regularization.pth.tar' ) text_saved_model = text_ckpt['model'] params = { "MAX_SENT_LEN": text_saved_model['MAX_SENT_LEN'], "BATCH_SIZE": text_saved_model['BATCH_SIZE'], "WORD_DIM": text_saved_model['WORD_DIM'], "FILTER_NUM": text_saved_model['FILTER_NUM'], "VOCAB_SIZE": text_saved_model['VOCAB_SIZE'], "CLASS_SIZE": text_saved_model['CLASS_SIZE'], "DROPOUT_PROB": 0.5, } text_model = CNN(**params).cuda() text_model.load_state_dict(text_saved_model.state_dict(), strict=True) embedding_tag2idx = text_ckpt['tag2idx'] text_model.eval() from torch.autograd import Variable target_keywords_list = ['peace', 'relaxed', 'satisfied'] # peace emotion_category = 'Peace' target_padded_list = target_keywords_list + [ len(text_saved_model['VOCAB_SIZE']) ] * (text_saved_model['MAX_SENT_LEN'] - len(target_keywords_list)) target_vector = Variable( torch.LongTensor(target_padded_list).unsqueeze(0)).cuda() target_feature, _, _ = model(target_vector) target_feature = target_feature.squeeze(0) # # target_keywords_list = ['engagement', 'curious', 'interested'] # emotion_category = 'Engagement' # # target_keywords_list = ['embarrassment', 'ashamed', 'guilty', 'shame'] # emotion_category = 'Embarrassment' for x_tag in target_keywords_list: tag_matrix.append(tag_wordvectors[x_tag]) tag_matrix = np.array(tag_matrix) tag_matrix = tag_matrix.squeeze(1) val_list = loadpickle( '/home/zwei/datasets/PublicEmotion/EMOTIC/z_data/test_image_based_single_person_only.pkl' ) image_directory = '/home/zwei/datasets/PublicEmotion/EMOTIC/images' from CNNs.datasets.multilabel import get_val_simple_transform val_transform = get_val_simple_transform() model.eval() correct = 0 total = len(val_list) * 1.0 full_label = [] full_pred = [] import tqdm for i, (input_image_file, target, _, _) in tqdm.tqdm(enumerate(val_list), desc="Evaluating Peace", total=len(val_list)): # measure data loading time image_path = os.path.join(image_directory, input_image_file) input_image = default_loader(image_path) input_image = val_transform(input_image) if args.gpu is not None: input_image = input_image.cuda(args.gpu, non_blocking=True) input_image = input_image.unsqueeze(0).cuda() # target_idx = target.nonzero() [:,1] # compute output output, output_proj = model(input_image) output_proj = output_proj.cpu().data.numpy() dot_product_label = cosine_similarity(output_proj, tag_matrix)[0] pred_score = np.max(dot_product_label) full_pred.append(pred_score) target_labels = set([x[0] for x in target.most_common()]) if emotion_category in target_labels: full_label.append(1) else: full_label.append(0) from sklearn.metrics import average_precision_score full_pred = np.array(full_pred) full_label = np.array(full_label) AP = average_precision_score(full_label, full_pred) print("DB")
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') args.script_name = get_stem(__file__) current_time_str = get_date_str() if args.resume is None: if args.save_directory is None: save_directory = get_dir( os.path.join(project_root, 'ckpts', '{:s}'.format(args.name), '{:s}-{:s}'.format(args.ID, current_time_str))) else: save_directory = get_dir( os.path.join(project_root, 'ckpts', args.save_directory)) else: if args.save_directory is None: save_directory = os.path.dirname(args.resume) else: current_time_str = get_date_str() save_directory = get_dir( os.path.join(args.save_directory, '{:s}'.format(args.name), '{:s}-{:s}'.format(args.ID, current_time_str))) print("Save to {}".format(save_directory)) log_file = os.path.join(save_directory, 'log-{0}.txt'.format(current_time_str)) logger = log_utils.get_logger(log_file) log_utils.print_config(vars(args), logger) print_func = logger.info print_func('ConfigFile: {}'.format(config_file)) args.log_file = log_file if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') #args.distributed = args.world_size > 1 args.distributed = False if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) num_datasets = args.num_datasets # model_list = [None for x in range(num_datasets)] # for j in range(num_datasets): if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.class_len) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.class_len) if args.freeze: model = CNN_utils.freeze_all_except_fc(model) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # # define loss function (criterion) and optimizer # # # Update: here # # config = {'loss': {'type': 'simpleCrossEntropyLoss', 'args': {'param': None}}} # # criterion = get_instance(loss_funcs, 'loss', config) # # criterion = criterion.cuda(args.gpu) # criterion = nn.CrossEntropyLoss(ignore_index=-1).cuda(args.gpu) # criterion = MclassCrossEntropyLoss().cuda(args.gpu) # params = list() # for j in range(num_datasets): # params += list(model_list[j].parameters()) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.lr_schedule: print_func("Using scheduled learning rate") scheduler = lr_scheduler.MultiStepLR( optimizer, [int(i) for i in args.lr_schedule.split(',')], gamma=0.1) else: scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=args.lr_patience) ''' if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) import collections if not args.evaluate: if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) else: load_state_dict(model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) print_func("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: if isinstance(checkpoint, collections.OrderedDict): load_state_dict(model, checkpoint, strict=True) else: load_state_dict(model, checkpoint['state_dict'], strict=True) print_func("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) return ''' cudnn.benchmark = True model_total_params = sum(p.numel() for p in model.parameters()) model_grad_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print_func("Total Parameters: {0}\t Gradient Parameters: {1}".format( model_total_params, model_grad_params)) # Data loading code val_loaders = [None for x in range(num_datasets)] test_loaders = [None for x in range(num_datasets)] train_loaders = [None for x in range(num_datasets)] num_iter = 0 for k in range(num_datasets): args.ind = k val_dataset = get_instance(custom_datasets, args.val_loader, args) if val_dataset is None or k == num_datasets - 1: val_loaders[args.ind] = None else: val_loaders[args.ind] = torch.utils.data.DataLoader( val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, collate_fn=none_collate) if hasattr(args, 'test_files') and hasattr(args, 'test_loader'): test_dataset = get_instance(custom_datasets, args.test_loader, args) test_loaders[args.ind] = torch.utils.data.DataLoader( test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, collate_fn=none_collate) else: # test_dataset = None test_loaders[args.ind] = None #if args.evaluate: # validate(test_loaders[args.ind], model_list[k], criterion, args, print_func) # return # if not args.evaluate: #else: # train_samplers = [None for x in range(num_datasets)] # train_dataset = get_instance(custom_datasets, args.train_loader, args) # # if args.distributed: # train_samplers[args.ind] = torch.utils.data.distributed.DistributedSampler(train_dataset) # else: # train_samplers[args.ind] = None # # train_loaders[args.ind] = torch.utils.data.DataLoader( # train_dataset, batch_size=args.batch_size, shuffle=(train_samplers[args.ind] is None), # num_workers=args.workers, pin_memory=True, sampler=train_samplers[args.ind], collate_fn=none_collate) if not args.evaluate: #else: # train_samplers = [None for x in range(num_datasets)] train_dataset = get_instance(custom_datasets, args.train_loader, args) num_iter = max(num_iter, len(train_dataset.samples)) if args.distributed: train_samplers = torch.utils.data.distributed.DistributedSampler( train_dataset) else: train_samplers = None train_loaders[args.ind] = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=train_samplers is None, num_workers=args.workers, pin_memory=True, sampler=train_samplers, collate_fn=none_collate) setattr(args, 'num_iter', num_iter) # TRAINING best_prec1 = [-1 for _ in range(num_datasets)] is_best = [None for _ in range(num_datasets)] setattr(args, 'lam', 0.5) start_data_time = time.time() train_loads_iters = [iter(train_loaders[x]) for x in range(num_datasets)] print_func("Loaded data in {:.3f} s".format(time.time() - start_data_time)) for epoch in range(args.start_epoch, args.epochs): if args.distributed: for x in range(num_datasets): train_samplers[x].set_epoch(epoch) if args.lr_schedule: # CNN_utils.adjust_learning_rate(optimizer, epoch, args.lr) scheduler.step() current_lr = optimizer.param_groups[0]['lr'] print_func("Epoch: [{}], learning rate: {}".format(epoch, current_lr)) # train for one epoch train(train_loads_iters, train_loaders, model, criterion, optimizer, epoch, args, print_func) # evaluate and save val_prec1 = [None for x in range(num_datasets)] test_prec1 = [None for x in range(num_datasets)] for j in range(num_datasets): # if j != args.ind: # load_state_dict(model_list[j], model_list[args.ind].state_dict()) # evaluate on validation set if val_loaders[j]: val_prec1[j], _ = validate(val_loaders[j], model, criterion, args, print_func, j) else: val_prec1[j] = 0 # remember best prec@1 and save checkpoint is_best[j] = val_prec1[j] > best_prec1[j] best_prec1[j] = max(val_prec1[j], best_prec1[j]) if is_best[j]: save_ind = j else: save_ind = "#" CNN_utils.save_checkpoint( { 'epoch': epoch, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1[j], 'optimizer': optimizer.state_dict(), }, is_best[j], file_directory=save_directory, epoch=epoch, save_best_only=args.save_best_only, ind=save_ind) test_prec1[j], _ = validate(test_loaders[j], model, criterion, args, print_func, j, phase='Test') print_func("Val precisions: {}".format(val_prec1)) print_func("Test precisions: {}".format(test_prec1))
def main(): best_prec1 = 0 args = parser.parser.parse_args() config_file = None if args.config is not None: config_file = args.config args = parse_config(args.config) script_name_stem = get_stem(__file__) current_time_str = get_date_str() if args.resume is None: if args.save_directory is None: save_directory = get_dir( os.path.join( project_root, 'ckpts', '{:s}'.format(args.name), '{:s}-{:s}-{:s}'.format(script_name_stem, args.ID, current_time_str))) else: save_directory = get_dir( os.path.join(project_root, 'ckpts', args.save_directory)) else: save_directory = os.path.dirname(args.resume) print("Save to {}".format(save_directory)) log_file = os.path.join(save_directory, 'log-{0}.txt'.format(current_time_str)) logger = log_utils.get_logger(log_file) log_utils.print_config(vars(args), logger) print_func = logger.info if config_file is not None: print_func('ConfigFile: {}'.format(config_file)) else: print_func('ConfigFile: None, params from argparse') args.log_file = log_file if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) # create model if args.arch == 'resnet50otherinits': print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes, param_name=args.paramname) elif args.arch == 'resnet50_feature_extractor': print_func("=> using pre-trained model '{}' to LOAD FEATURES".format( args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes, param_name=args.paramname) else: if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.freeze: model = CNN_utils.freeze_all_except_fc(model) if args.gpu is not None: model = model.cuda(args.gpu) elif args.distributed: model.cuda() model = torch.nn.parallel.DistributedDataParallel(model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer # # Update: here # config = {'loss': {'type': 'simpleCrossEntropyLoss', 'args': {'param': None}}} # criterion = get_instance(loss_funcs, 'loss', config) # criterion = criterion.cuda(args.gpu) criterion = nn.CrossEntropyLoss(ignore_index=-1).cuda(args.gpu) optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.lr_schedule: print_func("Using scheduled learning rate") scheduler = lr_scheduler.MultiStepLR( optimizer, [int(i) for i in args.lr_schedule.split(',')], gamma=0.1) else: scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=args.lr_patience) # optimizer = torch.optim.SGD(model.parameters(), args.lr, # momentum=args.momentum, # weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True model_total_params = sum(p.numel() for p in model.parameters()) model_grad_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print_func("Total Parameters: {0}\t Gradient Parameters: {1}".format( model_total_params, model_grad_params)) # Data loading code val_dataset = get_instance(custom_datasets, '{0}_val'.format(args.dataset.name), args, **args.dataset.args) if val_dataset is None: val_loader = None else: val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True, collate_fn=none_collate) if args.evaluate: validate(val_loader, model, criterion, args, print_func) return else: train_dataset = get_instance(custom_datasets, '{0}_train'.format(args.dataset.name), args, **args.dataset.args) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler, collate_fn=none_collate) for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) if args.lr_schedule: # CNN_utils.adjust_learning_rate(optimizer, epoch, args.lr) scheduler.step() current_lr = optimizer.param_groups[0]['lr'] print_func("Epoch: [{}], learning rate: {}".format(epoch, current_lr)) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args, print_func) # evaluate on validation set if val_loader: prec1, val_loss = validate(val_loader, model, criterion, args, print_func) else: prec1 = 0 val_loss = 0 # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) CNN_utils.save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best, file_directory=save_directory, epoch=epoch) if not args.lr_schedule: scheduler.step(val_loss)
def main(): import argparse parser = argparse.ArgumentParser( description="Pytorch Image CNN training from Configure Files") parser.add_argument( '--config_file', required=True, help="This scripts only accepts parameters from Json files") input_args = parser.parse_args() config_file = input_args.config_file args = parse_config(config_file) if args.name is None: args.name = get_stem(config_file) torch.set_default_tensor_type('torch.FloatTensor') best_prec1 = 0 args.script_name = get_stem(__file__) current_time_str = get_date_str() print_func = print if args.device: os.environ["CUDA_VISIBLE_DEVICES"] = args.device if args.seed is not None: random.seed(args.seed) torch.manual_seed(args.seed) cudnn.deterministic = True warnings.warn('You have chosen to seed training. ' 'This will turn on the CUDNN deterministic setting, ' 'which can slow down your training considerably! ' 'You may see unexpected behavior when restarting ' 'from checkpoints.') if args.gpu is not None: warnings.warn('You have chosen a specific GPU. This will completely ' 'disable data parallelism.') args.distributed = args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size) if args.pretrained: print_func("=> using pre-trained model '{}'".format(args.arch)) visual_model = models.__dict__[args.arch](pretrained=True, num_classes=args.num_classes) else: print_func("=> creating model '{}'".format(args.arch)) visual_model = models.__dict__[args.arch](pretrained=False, num_classes=args.num_classes) if args.gpu is not None: visual_model = visual_model.cuda(args.gpu) elif args.distributed: visual_model.cuda() visual_model = torch.nn.parallel.DistributedDataParallel(visual_model) else: if args.arch.startswith('alexnet') or args.arch.startswith('vgg'): visual_model.features = torch.nn.DataParallel( visual_model.features) visual_model.cuda() else: # model = torch.nn.DataParallel(model).cuda() visual_model = visual_model.cuda() from PyUtils.pickle_utils import loadpickle import numpy as np from PublicEmotionDatasets.Emotic.constants import emotion_explainations_words_690 as emotion_self_words from torchvision.datasets.folder import default_loader tag_wordvectors = loadpickle( '/home/zwei/Dev/AttributeNet3/TextClassification/visualizations/Embeddings/FullVocab_BN_transformed_l2_regularization.pkl' ) tag_words = [] tag_matrix = [] label_words = [] label_matrix = [] from TextClassification.model_DAN_2constraints import CNN_Embed_v2 as CNN text_ckpt = torch.load( '/home/zwei/Dev/AttributeNet3/TextClassification/models/model_feature_regularization.pth.tar' ) text_saved_model = text_ckpt['model'] params = { "MAX_SENT_LEN": text_saved_model.MAX_SENT_LEN, "BATCH_SIZE": text_saved_model.BATCH_SIZE, "WORD_DIM": text_saved_model.WORD_DIM, "FILTER_NUM": text_saved_model.FILTER_NUM, "VOCAB_SIZE": text_saved_model.VOCAB_SIZE, "CLASS_SIZE": text_saved_model.CLASS_SIZE, "DROPOUT_PROB": 0.5, } text_generator = CNN(**params).cuda() text_generator.load_state_dict(text_saved_model.state_dict(), strict=True) embedding_tag2idx = text_ckpt['tag2idx'] text_generator.eval() text_model = Text_Transformation(300, 300, 8) text_model = text_model.cuda() if args.resume: if os.path.isfile(args.resume): print_func("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) # text_model.load_state_dict(checkpoint['text_state_dict']) load_state_dict(text_model, checkpoint['text_state_dict']) import collections if isinstance(checkpoint, collections.OrderedDict): load_state_dict(visual_model, checkpoint, exclude_layers=['fc.weight', 'fc.bias']) else: load_state_dict( visual_model, checkpoint['state_dict'], exclude_layers=['module.fc.weight', 'module.fc.bias']) print_func("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) else: print_func("=> no checkpoint found at '{}'".format(args.resume)) return else: print_func( "=> This script is for fine-tuning only, please double check '{}'". format(args.resume)) print_func("Now using randomly initialized parameters!") cudnn.benchmark = True from torch.autograd import Variable emotic_emotion_explaintations = {} for x_key in emotion_self_words: x_words = emotion_self_words[x_key].split(',') x_feature = [embedding_tag2idx[x] for x in x_words] + \ [text_saved_model.VOCAB_SIZE+1]*(text_saved_model.MAX_SENT_LEN - len(x_words)) x_feature = Variable(torch.LongTensor(x_feature).unsqueeze(0)).cuda() tag_matrix = text_generator(x_feature) _, tag_feature = text_model(tag_matrix) # tag_matrix = tag_matrix.squeeze(1) item = {} item['pred'] = [] item['label'] = [] item['target_matrix'] = tag_feature.cpu().data.numpy() item['description'] = x_words emotic_emotion_explaintations[x_key] = item val_list = loadpickle( '/home/zwei/datasets/PublicEmotion/EMOTIC/z_data/test_image_based_single_person_only.pkl' ) image_directory = '/home/zwei/datasets/PublicEmotion/EMOTIC/images' from CNNs.datasets.multilabel import get_val_simple_transform val_transform = get_val_simple_transform() visual_model.eval() import tqdm for i, (input_image_file, target, _, _) in tqdm.tqdm(enumerate(val_list), desc="Evaluating Peace", total=len(val_list)): # measure data loading time image_path = os.path.join(image_directory, input_image_file) input_image = default_loader(image_path) input_image = val_transform(input_image) if args.gpu is not None: input_image = input_image.cuda(args.gpu, non_blocking=True) input_image = input_image.unsqueeze(0).cuda() # target_idx = target.nonzero() [:,1] # compute output output, output_proj = visual_model(input_image) output_proj = output_proj.cpu().data.numpy() target_labels = set([x[0] for x in target.most_common()]) for x_key in emotic_emotion_explaintations: dot_product_label = cosine_similarity( output_proj, emotic_emotion_explaintations[x_key]['target_matrix'])[0] pred_score = np.average(dot_product_label) emotic_emotion_explaintations[x_key]['pred'].append(pred_score) if x_key in target_labels: emotic_emotion_explaintations[x_key]['label'].append(1) else: emotic_emotion_explaintations[x_key]['label'].append(0) from sklearn.metrics import average_precision_score full_AP = [] for x_key in emotic_emotion_explaintations: full_pred = np.array(emotic_emotion_explaintations[x_key]['pred']) full_label = np.array(emotic_emotion_explaintations[x_key]['label']) AP = average_precision_score(full_label, full_pred) if np.isnan(AP): print("{} is Nan".format(x_key)) continue full_AP.append(AP) print("{}\t{:.4f}".format(x_key, AP * 100)) AvgAP = np.mean(full_AP) print("Avg AP: {:.2f}".format(AvgAP * 100))
create_directories = [] copy_image_list = [] for s_file in image_list_files: image_list = [] with open(s_file, 'r') as of_: lines = of_.readlines() for s_line in lines: s_line_parts = s_line.strip().split(' ') s_image_fullpath = s_line_parts[0] s_image_category = int(s_line_parts[1]) s_image_name_path = os.path.join( *s_image_fullpath.split(os.sep)[-2:]) s_target_full_path = os.path.join(target_image_directory, s_image_name_path) image_list.append([s_image_name_path, s_image_category]) s_src_full_path = os.path.join(src_image_directory, s_image_name_path) copy_image_list.append([s_src_full_path, s_target_full_path]) create_directories.append(os.path.dirname(s_target_full_path)) save2pickle('{}.pkl'.format(get_stem(s_file)), image_list) for s_created_directory in list(set(create_directories)): if not os.path.exists(s_created_directory): os.mkdir(s_created_directory) import tqdm import shutil for s_copy_item in tqdm.tqdm(copy_image_list): shutil.copyfile(s_copy_item[0], s_copy_item[1])
# Created: 14/Mar/2019 17:20 import tqdm import os from PyUtils.pickle_utils import loadpickle from PublicEmotionDatasets.Advertisement.constants import idx2emotion from PyUtils.file_utils import get_stem import shutil image_directory = '/home/zwei/datasets/PublicEmotion/Advertisement/images' image_annotations = loadpickle( '/home/zwei/datasets/PublicEmotion/Advertisement/train_list.pkl') target_directories = '/home/zwei/Dev/AttributeNet3/PublicEmotionDatasets/Advertisement/convert_stuff/examples' for idx, s_image_annotation in enumerate(tqdm.tqdm(image_annotations)): if idx % 500 == 0: s_image_path = os.path.join(image_directory, s_image_annotation[0]) if os.path.exists(s_image_path): extension_name = s_image_annotation[0].strip().split('.')[1] target_name = '{}-{}-{}.{}'.format( os.path.dirname(s_image_annotation[0]), get_stem(s_image_annotation[0]), idx2emotion[s_image_annotation[1] + 1], extension_name) target_path = os.path.join(target_directories, target_name) shutil.copyfile(s_image_path, target_path) print("{}\t{}\t{}".format(s_image_annotation[0], s_image_annotation[1], idx2emotion[s_image_annotation[1] + 1])) else: print("!!!! {} Not Found!".format(s_image_path))