def valid(args, dataloaders, models=None): valid_source_dataloader = dataloaders['valid_source'] valid_target_dataloader = dataloaders['valid_target'] if models is None: try: load = torch.load( f"./result/{args.source}2{args.target}/best_model.pth") model = resnet(args) #model = Model() model.load_state_dict(load['M']) except Exception as inst: model = resnet(args) model.eval() model.to(args.device) else: model = models model.eval() src_accs = [] for i, (imgs, lbls) in enumerate(valid_source_dataloader): bsize = imgs.size(0) imgs, lbls = imgs.to(args.device), lbls.to(args.device) output = model(imgs) acc = accuracy_(output[:, :args.num_classes], lbls) src_accs.append(acc) print(f"\t [{i+1}/{len(valid_target_dataloader)}]", end=" \r") tar_accs1 = [] tar_accs2 = [] for i, (imgs, lbls) in enumerate(valid_target_dataloader): bsize = imgs.size(0) imgs, lbls = imgs.to(args.device), lbls.to(args.device) output = model(imgs) acc = accuracy_(output[:, args.num_classes:], lbls) tar_accs1.append(acc) acc = accuracy_( output[:, args.num_classes:] + output[:, :args.num_classes], lbls) tar_accs2.append(acc) print(f"\t [{i+1}/{len(valid_target_dataloader)}]", end=" \r") mean_src_acc, mean_tar_acc1, mean_tar_acc2 = mean_(src_accs), mean_( tar_accs1), mean_(tar_accs2) #print(f"\t Valid, src acc:%.3f, tar acc:%.3f" % (mean_src_acc, # mean_tar_acc)) return mean_src_acc, mean_tar_acc1, mean_tar_acc2
def bulid_bert_resnet_model(vocab, inputs, is_training, bert_config=None, resnet_config=None): if bert_config is None: bert_config = bert.BertConfig(len(vocab['Word']), max_position_embeddings=512, type_vocab_size=len(vocab['Entity'])) if resnet_config is None: resnet_config = resnet.ResnetConfig() def splits(datas, num, name='split_squeeze'): with tf.variable_scope(name): datas = tf.split(datas, num, axis=1) outputs = [] for data in datas: outputs.append(tf.squeeze(data, axis=1)) return outputs input_ids, token_position_ids, token_type_ids, input_mask = splits( inputs, 4) model = bert.BertModel(bert_config, is_training, input_ids, input_mask=input_mask, token_type_ids=token_type_ids, token_position_ids=token_position_ids) bert_features = model.get_sequence_output() resnet_features = resnet.resnet(bert_features, resnet_config) features = tf.reduce_max(resnet_features, axis=1) # max_pool logits = tf.layers.dense(features, len(vocab['Relation']), name='logits') return logits
def _load_model(self): print('loading model...') if self.args.model == 'resnet': from models.resnet import resnet self.model = resnet(**self.args.model_args) elif self.args.model == 'densenet': from models.densenet import densenet self.model = densenet(**self.args.model_args) self.policies = self.model.parameters() #self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpus).cuda() if self.args.resume: if os.path.isfile(self.args.resume): print(("=> loading checkpoint '{}'".format(self.args.resume))) checkpoint = torch.load(self.args.resume) d = collections.OrderedDict() for key, value in checkpoint['state_dict'].items(): tmp = key[7:] d[tmp] = value self.args.start_epoch = checkpoint['epoch'] #self.model.load_state_dict(checkpoint['state_dict']) self.model.load_state_dict(d) print(("=> loaded checkpoint '{}' (epoch {})".format( self.args.phase, checkpoint['epoch']))) else: print(("=> no checkpoint found at '{}'".format( self.args.resume))) print('model load finished!')
def Model_Construct(args): if args.arch.find('alexnet') == 0: ## the required model is vgg structure model = alexnet(args) return model elif args.arch.find('resnet') == 0: model = resnet(args) return model else: raise ValueError('the request model is not exist')
def get_model(model, args): if model == 'alexnet': return alexnet() if model == 'resnet': return resnet(dataset=args.dataset) if model == 'wideresnet': return WideResNet(args.layers, args.dataset == 'cifar10' and 10 or 100, args.widen_factor, dropRate=args.droprate, gbn=args.gbn) if model == 'densenet': return densenet()
def create_model(model_name, in_channels, out_channels): if model_name == 'resnet': model = resnet(in_channels=in_channels, out_channels=out_channels) elif model_name == 'resnetS': model = resnetS(in_channels=in_channels, out_channels=out_channels) elif model_name == 'resnetSS': model = resnetSS(in_channels=in_channels, out_channels=out_channels) elif model_name == 'simple': model = simple(in_channels=in_channels, out_channels = out_channels) return model
def __init__(self, n_channels, n_classes, court_img, target_size, court_poi=None, bilinear=True, resnet_name='resnetreg50', resnet_pretrained=None, warp_with_nearest=False, img2input=False): super(Reconstructor, self).__init__() self.n_channels = n_channels self.n_classes = n_classes self.bilinear = bilinear self.img2input = img2input # UNet: self.inc = DoubleConv(n_channels, 64) self.down1 = Down(64, 128) self.down2 = Down(128, 256) self.down3 = Down(256, 512) factor = 2 if bilinear else 1 self.down4 = Down(512, 1024 // factor) self.up1 = Up(1024, 512 // factor, bilinear) self.up2 = Up(512, 256 // factor, bilinear) self.up3 = Up(256, 128 // factor, bilinear) self.up4 = Up(128, 64, bilinear) self.outc = OutConv(64, n_classes) # UNet regressor that outputs the first 3x3 transformation matrix: # self.conv_top = nn.Conv2d(1024 // factor, n_classes, kernel_size=1) # self.unet_reg = Reconstructor.make_regressor(n_classes) # ResNet regressor that outputs the second 3x3 transformation matrix: in_classes = n_classes+3 if img2input else n_classes self.resnet_reg = resnet(resnet_name, resnet_pretrained, in_classes) # The court template image and court points of interest. # This court template will be warped by the learnt transformation matrix: self.court_img = court_img self.court_poi = court_poi # STN warper: h, w = target_size[1], target_size[0] if warp_with_nearest is False: self.warper = kornia.HomographyWarper(h, w) else: # It seems mode='nearest' has a bug when used during training self.warper = kornia.HomographyWarper(h, w, mode='nearest')
def init_model(model_path, num_class, model_name): if 'lite' in model_name: model = lite_faster_rcnn(num_class) elif 'pva' in model_name: model = pva_net(num_class) elif 'resnet' in model_name: model = resnet(num_class, num_layers=101) #model = resnet(num_class, num_layers=101) checkpoint = torch.load(model_path) model.create_architecture() model.load_state_dict(checkpoint['state_dict']) model = model.cuda() model.eval() return model
def getModel(model): if model == 'resnet18': from models.resnet import resnet net = resnet(groups=[1, 1, 1, 1], depth=18, width=[64, 128, 256, 512], dataset="cifar100").cuda() elif model == 'mobilenet': from models.mobilenet import mobilenet net = mobilenet(num_classes=100, cifar=True).cuda() else: print('check the name of the model') sys.exit() return net
def main(): global args, best_prec1 args = opts() if args.arch.find('resnet') != -1: model = resnet(args) else: raise ValueError('Unavailable model architecture!!!') # define-multi GPU model = torch.nn.DataParallel(model).cuda() print(model) if not os.path.isdir(args.log): os.makedirs(args.log) log = open(os.path.join(args.log, 'log.txt'), 'a') state = {k: v for k, v in args._get_kwargs()} log.write(json.dumps(state) + '\n') log.close() log = open(os.path.join(args.log, 'log.txt'), 'a') log.write('\n-------------------------------------------\n') log.write(time.asctime(time.localtime(time.time()))) log.write('\n-------------------------------------------') log.close() cudnn.benchmark = True # process the data and prepare the dataloaders. # source_train_loader, source_val_loader, target_train_dataset, val_loader, source_val_loader_cluster, val_loader_cluster = generate_dataloader(args) source_train_loader_ce, source_train_dataset, target_train_loader_ce, target_train_dataset, source_val_loader, target_val_loader = generate_dataloader( args) if args.pseudo_type == 'cluster': ### the AO of CAN clusering_labels_for_path = download_feature_and_pca_clustering( 0, source_val_loader, target_val_loader, model, args) elif args.pseudo_type == 'lp': clusering_labels_for_path = download_feature_and_pca_label_prob( 0, source_val_loader, target_val_loader, model, args) else: raise NotImplementedError
def main(): print("Start time: " + time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())) global best_acc start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch if not os.path.isdir(args.checkpoint): mkdir_p(args.checkpoint) # Data loading code traindir = os.path.join(args.data, 'train') valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_loader = torch.utils.data.DataLoader(datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])), batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ])), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=True) # create model model = resnet( depth=args.depth, recalibration_type=args.recalibration_type, ) model = torch.nn.DataParallel(model).cuda() cudnn.benchmark = True print(model) print(' Total params: %.4fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() optimizer = set_optimizer(model, args) # Resume title = 'Resnet{}-{}'.format(args.depth, args.recalibration_type) if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile( args.resume), 'Error: no checkpoint directory found!' args.checkpoint = os.path.dirname(args.resume) checkpoint = torch.load(args.resume) best_acc = checkpoint['best_acc'] start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True) elif args.pretrained: # Load checkpoint. print('==> Start from pretrained checkpoint..') assert os.path.isfile( args.pretrained), 'Error: no checkpoint directory found!' args.checkpoint = os.path.dirname(args.pretrained) checkpoint = torch.load(args.pretrained) model.load_state_dict(checkpoint['state_dict']) logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title) logger.set_names([ 'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.', 'Train Acc.5', 'Valid Acc.5', 'Train Time', 'Test Time' ]) else: logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title) logger.set_names([ 'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.', 'Train Acc.5', 'Valid Acc.5', 'Train Time', 'Test Time' ]) if args.evaluate: print('\nEvaluation only') test_loss, test_acc, test_acc5, _ = test(val_loader, model, criterion, start_epoch, use_cuda) print(' Test Loss: %.8f, Test Acc: %.2f (Top-1), %.2f (Top-5)' % (test_loss, test_acc, test_acc5)) return # Train and val for epoch in range(start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr'])) train_loss, train_acc, train_acc5, train_time = train( train_loader, model, criterion, optimizer, epoch, use_cuda) test_loss, test_acc, test_acc5, test_time = test( val_loader, model, criterion, epoch, use_cuda) # append logger file logger.append([ state['lr'], train_loss, test_loss, train_acc, test_acc, train_acc5, test_acc5, train_time, test_time ]) # save model is_best = test_acc > best_acc best_acc = max(test_acc, best_acc) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'acc': test_acc, 'best_acc': best_acc, 'optimizer': optimizer.state_dict(), }, is_best, checkpoint=args.checkpoint) logger.close() print('Best acc:') print(best_acc) print("Finish time: " + time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
def main_worker(args): global best_prec1, dtype best_prec1 = 0 dtype = torch_dtypes.get(args.dtype) torch.manual_seed(args.seed) time_stamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S') if args.evaluate: args.results_dir = '/tmp' if args.save is '': args.save = time_stamp save_path = path.join(args.results_dir, args.save) args.distributed = args.local_rank >= 0 or args.world_size > 1 if args.distributed: dist.init_process_group(backend=args.dist_backend, init_method=args.dist_init, world_size=args.world_size, rank=args.local_rank) args.local_rank = dist.get_rank() args.world_size = dist.get_world_size() if args.dist_backend == 'mpi': # If using MPI, select all visible devices args.device_ids = list(range(torch.cuda.device_count())) else: args.device_ids = [args.local_rank] # if not (args.distributed and args.local_rank > 0): if not path.exists(save_path): makedirs(save_path) dump_args(args, path.join(save_path, 'args.txt')) setup_logging(path.join(save_path, 'log.txt'), resume=args.resume is not '', dummy=False) results_path = path.join(save_path, 'results') results = ResultsLog(results_path, title='Training Results - %s' % args.save) logging.info("saving to %s", save_path) logging.debug("run arguments: %s", args) logging.info("creating model %s", args.model) if 'cuda' in args.device and torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed) torch.cuda.set_device(args.device_ids[0]) cudnn.benchmark = True else: args.device_ids = None # All parameters to the model should be passed via this dict. model_config = { 'dataset': args.dataset, 'dp_type': args.dropout_type, 'dp_percentage': args.dropout_perc, 'dropout': args.drop_rate, 'device': args.device } if args.model_config is not '': model_config = dict(model_config, **literal_eval(args.model_config)) # create Resnet model model = resnet(**model_config) logging.info("created model with configuration: %s", model_config) num_parameters = sum([l.nelement() for l in model.parameters()]) logging.info("number of parameters: %d", num_parameters) # # optionally resume from a checkpoint # if args.evaluate: # if not path.isfile(args.evaluate): # parser.error('invalid checkpoint: {}'.format(args.evaluate)) # checkpoint = torch.load(args.evaluate, map_location="cpu") # # Overrride configuration with checkpoint info # args.model = checkpoint.get('model', args.model) # args.model_config = checkpoint.get('config', args.model_config) # # load checkpoint # model.load_state_dict(checkpoint['state_dict']) # logging.info("loaded checkpoint '%s' (epoch %s)", # args.evaluate, checkpoint['epoch']) # # if args.resume: # checkpoint_file = args.resume # if path.isdir(checkpoint_file): # results.load(path.join(checkpoint_file, 'results.csv')) # checkpoint_file = path.join( # checkpoint_file, 'model_best.pth.tar') # if path.isfile(checkpoint_file): # logging.info("loading checkpoint '%s'", args.resume) # checkpoint = torch.load(checkpoint_file, map_location="cpu") # if args.start_epoch < 0: # not explicitly set # args.start_epoch = checkpoint['epoch'] # best_prec1 = checkpoint['best_prec1'] # model.load_state_dict(checkpoint['state_dict']) # optim_state_dict = checkpoint.get('optim_state_dict', None) # logging.info("loaded checkpoint '%s' (epoch %s)", # checkpoint_file, checkpoint['epoch']) # else: # logging.error("no checkpoint found at '%s'", args.resume) # else: # optim_state_dict = None # define loss function (criterion) and optimizer loss_params = {} if args.label_smoothing > 0: loss_params['smooth_eps'] = args.label_smoothing criterion = getattr(model, 'criterion', CrossEntropyLoss)(**loss_params) criterion.to(args.device, dtype) model.to(args.device, dtype) # Batch-norm should always be done in float if 'half' in args.dtype: FilterModules(model, module=is_bn).to(dtype=torch.float) # optimizer configuration optim_regime = getattr(model, 'regime', [{ 'epoch': 0, 'optimizer': args.optimizer, 'lr': args.lr, 'momentum': args.momentum, 'weight_decay': args.weight_decay }]) optimizer = optim_regime if isinstance(optim_regime, OptimRegime) \ else OptimRegime(model, optim_regime, use_float_copy='half' in args.dtype) # if optim_state_dict is not None: # optimizer.load_state_dict(optim_state_dict) trainer = Trainer(model, criterion, optimizer, device_ids=args.device_ids, device=args.device, dtype=dtype, distributed=args.distributed, local_rank=args.local_rank, mixup=args.mixup, loss_scale=args.loss_scale, grad_clip=args.grad_clip, print_freq=args.print_freq, adapt_grad_norm=args.adapt_grad_norm) if args.tensorwatch: trainer.set_watcher(filename=path.abspath( path.join(save_path, 'tensorwatch.log')), port=args.tensorwatch_port) # Evaluation Data loading code args.eval_batch_size = args.eval_batch_size if args.eval_batch_size > 0 else args.batch_size val_data = DataRegime(getattr(model, 'data_eval_regime', None), defaults={ 'datasets_path': args.datasets_dir, 'name': args.dataset, 'split': 'val', 'augment': False, 'input_size': args.input_size, 'batch_size': args.eval_batch_size, 'shuffle': False, 'num_workers': args.workers, 'pin_memory': True, 'drop_last': False }) if args.evaluate: results = trainer.validate(val_data.get_loader()) logging.info(results) return # Training Data loading code train_data_defaults = { 'datasets_path': args.datasets_dir, 'name': args.dataset, 'split': 'train', 'augment': True, 'input_size': args.input_size, 'batch_size': args.batch_size, 'shuffle': True, 'num_workers': args.workers, 'pin_memory': True, 'drop_last': True, 'distributed': args.distributed, 'duplicates': args.duplicates, 'autoaugment': args.autoaugment, 'cutout': { 'holes': 1, 'length': 16 } if args.cutout else None } if hasattr(model, 'sampled_data_regime'): sampled_data_regime = model.sampled_data_regime probs, regime_configs = zip(*sampled_data_regime) regimes = [] for config in regime_configs: defaults = {**train_data_defaults} defaults.update(config) regimes.append(DataRegime(None, defaults=defaults)) train_data = SampledDataRegime(regimes, probs) else: train_data = DataRegime(getattr(model, 'data_regime', None), defaults=train_data_defaults) logging.info('optimization regime: %s', optim_regime) args.start_epoch = max(args.start_epoch, 0) trainer.training_steps = args.start_epoch * len(train_data) for epoch in range(args.start_epoch, args.epochs): trainer.epoch = epoch train_data.set_epoch(epoch) val_data.set_epoch(epoch) logging.info('\nStarting Epoch: {0}\n'.format(epoch + 1)) # train for one epoch train_results = trainer.train(train_data.get_loader(), chunk_batch=args.chunk_batch) # evaluate on validation set val_results = trainer.validate(val_data.get_loader()) # # save weights heatmap # w = model._modules['layer3']._modules['5']._modules['conv2']._parameters['weight'].view(64, -1).cpu().detach().numpy() # heat_maps_dir = 'C:\\Users\\Pavel\\Desktop\\targeted_dropout_pytorch\\pics\\experiment_0' # plot = sns.heatmap(w, center=0) # name = str(datetime.now()).replace(':', '_').replace('-', '_').replace('.', '_').replace(' ', '_') + '.png' # plot.get_figure().savefig(path.join(heat_maps_dir, name)) # plt.clf() if args.distributed and args.local_rank > 0: continue # remember best prec@1 and save checkpoint is_best = val_results['prec1'] > best_prec1 best_prec1 = max(val_results['prec1'], best_prec1) if args.drop_optim_state: optim_state_dict = None else: optim_state_dict = optimizer.state_dict() save_checkpoint( { 'epoch': epoch + 1, 'model': args.model, 'config': args.model_config, 'state_dict': model.state_dict(), 'optim_state_dict': optim_state_dict, 'best_prec1': best_prec1 }, is_best, path=save_path, save_all=False) logging.info('\nResults - Epoch: {0}\n' 'Training Loss {train[loss]:.4f} \t' 'Training Prec@1 {train[prec1]:.3f} \t' 'Training Prec@5 {train[prec5]:.3f} \t' 'Validation Loss {val[loss]:.4f} \t' 'Validation Prec@1 {val[prec1]:.3f} \t' 'Validation Prec@5 {val[prec5]:.3f} \t\n'.format( epoch + 1, train=train_results, val=val_results)) values = dict(epoch=epoch + 1, steps=trainer.training_steps) values.update({'training ' + k: v for k, v in train_results.items()}) values.update({'validation ' + k: v for k, v in val_results.items()}) results.add(**values) results.plot(x='epoch', y=['training loss', 'validation loss'], legend=['training', 'validation'], title='Loss', ylabel='loss') results.plot(x='epoch', y=['training error1', 'validation error1'], legend=['training', 'validation'], title='Error@1', ylabel='error %') results.plot(x='epoch', y=['training error5', 'validation error5'], legend=['training', 'validation'], title='Error@5', ylabel='error %') if 'grad' in train_results.keys(): results.plot(x='epoch', y=['training grad'], legend=['gradient L2 norm'], title='Gradient Norm', ylabel='value') results.save()
def main(): args = parse_args() img_path = args.img_path save_dir = args.save_dir if not os.path.isdir(save_dir): os.mkdir(save_dir) if 'lite' in args.network: model = lite_faster_rcnn(args.classes) elif 'pva' in args.network: model = pva_net(args.classes) elif 'resnet' in args.network: model = resnet(args.classes, num_layers=101) checkpoint = torch.load(args.model) model.create_architecture() model.load_state_dict(checkpoint['state_dict']) model = model.cuda() model = torch.nn.DataParallel(model).cuda() model.eval() imgs = glob(os.path.join(args.img_path, "*.*")) print(args.img_path) batch_size = 1 std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32) mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32) std = torch.from_numpy(std).cuda() mean = torch.from_numpy(mean).cuda() results_file = open("./outputs/resluts.csv", "a+") for ix, img_name in enumerate(imgs): #print(ix, img_name) im = cv2.imread(img_name) if im is None: continue import time #start_t = time.clock() data = prepareTestData(864, im, 32, 1440) start_t = time.clock() results = im_detect(data, model, batch_size, std, mean, args.classes) end_t = time.clock() print(ix, img_name, ' time consume is: ', end_t - start_t) draw_img = im.copy() #results_file = open("./output/resluts.csv","a+") name = os.path.basename(img_name) for boxes in results: for box in boxes: x1 = int(box[0]) y1 = int(box[1]) x2 = int(box[2]) y2 = int(box[3]) score = float(box[4]) label = int(box[5]) draw_label = '' #if label < 7: # draw_label = 'd' #else: # draw_label = 'd' cv2.rectangle(draw_img, (x1, y1), (x2, y2), (0, label * 6, 255), 1) w = x2 - x1 h = y2 - y1 #cv2.putText(draw_img, '%.1f'%score+draw_label, (x1+(w>>1), y1+(h>>1)), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3) #cv2.putText(draw_img, '%.1f'%score+str(label), (x1+(w>>1), y1+(h>>1)), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3) results_file.write(name + "," + class_list[label] + "," + str(x1) + "," + str(x2) + "," + str(y1) + "," + str(y2) + "\n") cv2.imwrite(save_dir + '/' + name, draw_img)
def main(): global args, best_prec1 args = opts() # ipdb.set_trace() # args = parser.parse_args() model_source, model_target = resnet(args) # define-multi GPU model_source = torch.nn.DataParallel(model_source).cuda() model_target = torch.nn.DataParallel(model_target).cuda() print('the memory id should be same for the shared feature extractor:') print(id(model_source.module.resnet_conv)) # the memory is shared here print(id(model_target.module.resnet_conv)) print('the memory id should be different for the different classifiers:') print(id(model_source.module.fc)) # the memory id shared here. print(id(model_target.module.fc)) # define loss function(criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() np.random.seed(1) ### fix the random data. random.seed(1) # optimizer = torch.optim.SGD(model.parameters(), # To apply different learning rate to different layer if args.meta_sgd: meta_train_lr = [] for param in model_target.parameters(): meta_train_lr.append( torch.FloatTensor(param.data.size()).fill_( args.meta_train_lr).cuda()) if args.pretrained: print('the pretrained setting of optimizer') if args.auxiliary_dataset == 'imagenet': optimizer = torch.optim.SGD([ { 'params': model_source.module.resnet_conv.parameters(), 'name': 'pre-trained' }, { 'params': model_source.module.fc.parameters(), 'name': 'pre-trained' }, { 'params': model_target.module.fc.parameters(), 'name': 'new-added' }, ], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) elif args.auxiliary_dataset == 'l_bird': optimizer = torch.optim.SGD([ { 'params': model_source.module.resnet_conv.parameters(), 'name': 'pre-trained' }, { 'params': model_source.module.fc.parameters(), 'name': 'pre-trained' }, { 'params': model_target.module.fc.parameters(), 'name': 'new-added' }, ], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: print('the from scratch setting of optimizer') optimizer = torch.optim.SGD([ { 'params': model_source.module.resnet_conv.parameters(), 'name': 'new-added' }, { 'params': model_source.module.fc.parameters(), 'name': 'new-added' }, { 'params': model_target.module.fc.parameters(), 'name': 'new-added' }, ], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) #optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): # raise ValueError('the resume function is not finished') print("==> loading checkpoints '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] if args.meta_sgd: meta_train_lr = checkpoint['meta_train_lr'] best_prec1 = checkpoint['best_prec1'] model_source.load_state_dict(checkpoint['source_state_dict']) model_target.load_state_dict(checkpoint['target_state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("==> loaded checkpoint '{}'(epoch {})".format( args.resume, checkpoint['epoch'])) else: raise ValueError('The file to be resumed from is not exited', args.resume) if not os.path.isdir(args.log): os.makedirs(args.log) log = open(os.path.join(args.log, 'log.txt'), 'w') state = {k: v for k, v in args._get_kwargs()} log.write(json.dumps(state) + '\n') log.close() cudnn.benchmark = True # process the data and prepare the dataloaders. dataloader_returned = generate_dataloader(args) dataloader_number_returned = len(dataloader_returned) print('the number of dataloader number returned is: ', dataloader_number_returned) if dataloader_number_returned != 2: train_loader_source, val_loader_source, train_loader_target, val_loader_target = dataloader_returned else: train_loader_target, val_loader_target = dataloader_returned train_loader_source = None # train_loader, val_loader = generate_dataloader(args) # test only if args.test_only: if dataloader_number_returned == 2: validate(None, val_loader_target, model_source, model_target, criterion, 0, args) else: validate(val_loader_source, val_loader_target, model_source, model_target, criterion, 0, args) # if args.auxiliary_dataset == 'imagenet': # validate(val_loader_source, val_loader_target, model_source, model_target, criterion, 0, args) # else: # validate(None, val_loader_target, model_source, model_target, criterion, 0, args) return print('begin training') if train_loader_source: train_loader_source_batch = enumerate(train_loader_source) else: train_loader_source_batch = None train_loader_target_batch = enumerate(train_loader_target) for epoch in range(args.start_epoch, args.epochs): # train for one epoch if args.meta_sgd: train_loader_source_batch, train_loader_target_batch, meta_train_lr = train( train_loader_source, train_loader_source_batch, train_loader_target, train_loader_target_batch, model_source, model_target, criterion, optimizer, epoch, args, meta_train_lr) else: train_loader_source_batch, train_loader_target_batch = train( train_loader_source, train_loader_source_batch, train_loader_target, train_loader_target_batch, model_source, model_target, criterion, optimizer, epoch, args, None) # train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on the val data if (epoch + 1) % args.test_freq == 0 or (epoch + 1) % args.epochs == 0: if dataloader_number_returned == 2: prec1 = validate(None, val_loader_target, model_source, model_target, criterion, epoch, args) else: prec1 = validate(val_loader_source, val_loader_target, model_source, model_target, criterion, epoch, args) # prec1 = 1 # record the best prec1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) if is_best: log = open(os.path.join(args.log, 'log.txt'), 'a') log.write(' \nTarget_T1 acc: %3f' % (best_prec1)) log.close() if args.meta_sgd: save_checkpoint( { 'epoch': epoch + 1, 'meta_train_lr': meta_train_lr, 'arch': args.arch, 'source_state_dict': model_source.state_dict(), 'target_state_dict': model_target.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best, args, epoch) else: save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'source_state_dict': model_source.state_dict(), 'target_state_dict': model_target.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best, args, epoch + 1)
def main(): global args, best_prec1 args = opts() current_epoch = 0 # define base model model = resnet(args) # define multi-GPU model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() criterion_afem = AdaptiveFilteringEMLossForTarget(eps=args.eps).cuda() np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) if torch.cuda.device_count() > 1: torch.cuda.manual_seed_all(args.seed) # apply different learning rates to different layers lr_fe = args.lr * 0.1 if args.pretrained else args.lr if args.arch.find('resnet') != -1: params_list = [ { 'params': model.module.conv1.parameters(), 'lr': lr_fe }, { 'params': model.module.bn1.parameters(), 'lr': lr_fe }, { 'params': model.module.layer1.parameters(), 'lr': lr_fe }, { 'params': model.module.layer2.parameters(), 'lr': lr_fe }, { 'params': model.module.layer3.parameters(), 'lr': lr_fe }, { 'params': model.module.layer4.parameters(), 'lr': lr_fe }, { 'params': model.module.fc1.parameters() }, { 'params': model.module.fc2.parameters() }, ] if args.optimizer == 'sgd': optimizer = torch.optim.SGD(params_list, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=args.nesterov) if args.lr_scheduler == 'dann': lr_lambda = lambda epoch: 1 / pow( (1 + 10 * epoch / args.epochs), 0.75) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1) elif args.lr_scheduler == 'cosine': scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, T_max=args.epochs, eta_min=0, last_epoch=-1) elif args.lr_scheduler == 'step': lr_lambda = lambda epoch: args.gamma**( epoch + 1 > args.decay_epoch[ 1] and 2 or epoch + 1 > args.decay_epoch[0] and 1 or 0) scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-1) else: raise ValueError('Unavailable model architecture!!!') if args.resume: print("==> loading checkpoints '{}'".format(args.resume)) checkpoint = torch.load(args.resume) current_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) scheduler.load_state_dict(checkpoint['scheduler_state_dict']) print("==> loaded checkpoint '{}'(epoch {})".format( args.resume, checkpoint['epoch'])) if not os.path.isdir(args.log): os.makedirs(args.log) log = open(os.path.join(args.log, 'log.txt'), 'a') state = {k: v for k, v in args._get_kwargs()} log.write(json.dumps(state) + '\n') log.close() # start time log = open(os.path.join(args.log, 'log.txt'), 'a') log.write('\n-------------------------------------------\n') log.write(time.asctime(time.localtime(time.time()))) log.write('\n-------------------------------------------') log.close() cudnn.benchmark = True # process data and prepare dataloaders train_loader_source, train_loader_target, val_loader_target, val_loader_source = generate_dataloader( args) if args.eval_only: prec1 = evaluate(val_loader_target, model, criterion, -1, args) print(' * Eval acc@1: {:.3f}'.format(prec1)) return print('begin training') train_loader_source_batch = enumerate(train_loader_source) train_loader_target_batch = enumerate(train_loader_target) batch_number = count_epoch_on_large_dataset(train_loader_target, train_loader_source) num_itern_total = args.epochs * batch_number test_freq = int(num_itern_total / 200) print('test_freq: ', test_freq) args.start_epoch = current_epoch cs_1 = Variable( torch.cuda.FloatTensor(args.num_classes, model.module.feat1_dim).fill_(0)) ct_1 = Variable( torch.cuda.FloatTensor(args.num_classes, model.module.feat1_dim).fill_(0)) cs_2 = Variable( torch.cuda.FloatTensor(args.num_classes, model.module.feat2_dim).fill_(0)) ct_2 = Variable( torch.cuda.FloatTensor(args.num_classes, model.module.feat2_dim).fill_(0)) for itern in range(args.start_epoch * batch_number, num_itern_total): # train for one iteration train_loader_source_batch, train_loader_target_batch, cs_1, ct_1, cs_2, ct_2 = train_compute_class_mean( train_loader_source, train_loader_source_batch, train_loader_target, train_loader_target_batch, model, criterion, criterion_afem, optimizer, itern, current_epoch, cs_1, ct_1, cs_2, ct_2, args) # evaluate on target if (itern + 1) % batch_number == 0 or (itern + 1) % test_freq == 0: prec1 = evaluate(val_loader_target, model, criterion, current_epoch, args) # record the best prec1 is_best = prec1 > best_prec1 if is_best: best_prec1 = prec1 log = open(os.path.join(args.log, 'log.txt'), 'a') log.write( '\n best acc: %3f' % (best_prec1)) log.close() # update learning rate if (itern + 1) % batch_number == 0: scheduler.step() current_epoch += 1 # save checkpoint save_checkpoint( { 'epoch': current_epoch, 'arch': args.arch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'best_prec1': best_prec1, }, is_best, args) if current_epoch > args.stop_epoch: break # end time log = open(os.path.join(args.log, 'log.txt'), 'a') log.write('\n * best acc: %3f' % best_prec1) log.write('\n-------------------------------------------\n') log.write(time.asctime(time.localtime(time.time()))) log.write('\n-------------------------------------------\n') log.close()
def main(): global args, best_prec1 args = opts() # args = parser.parse_args() model = resnet(args.arch, args.pretrain, args) # define-multi GPU model = torch.nn.DataParallel(model).cuda() #print(model) # define loss function(criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() # optimizer = torch.optim.SGD(model.parameters(), # To apply different learning rate to different layer #print(model.module) optimizer = torch.optim.SGD([{ 'params': model.module.conv1.parameters(), 'name': 'pre-trained' }, { 'params': model.module.bn1.parameters(), 'name': 'pre-trained' }, { 'params': model.module.layer1.parameters(), 'name': 'pre-trained' }, { 'params': model.module.layer2.parameters(), 'name': 'pre-trained' }, { 'params': model.module.layer3.parameters(), 'name': 'pre-trained' }, { 'params': model.module.layer4.parameters(), 'name': 'pre-trained' }, { 'params': model.module.fc.parameters(), 'lr': args.lr * 10, 'name': 'new-added' }], lr=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("==> loading checkpoints '{}'".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("==> loaded checkpoint '{}'(epoch {})".format( args.resume, checkpoint['epoch'])) else: raise ValueError('The file to be resumed from is not exited', args.resume) else: if not os.path.isdir(args.log): os.makedirs(args.log) log = open(os.path.join(args.log, 'log.txt'), 'w') state = {k: v for k, v in args._get_kwargs()} log.write(json.dumps(state) + '\n') log.close() cudnn.benchmark = True # process the data and prepare the dataloaders. train_loader, val_loader = generate_dataloader(args) #test only if args.test_only: validate(val_loader, model, criterion) return for epoch in range(args.start_epoch, args.epochs): # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on the val data prec1 = validate(val_loader, model, criterion, epoch, args) # record the best prec1 and save checkpoint is_best = prec1 > best_prec1 if is_best: log = open(os.path.join(args.log, 'log.txt'), 'a') log.write(" best result is %3f" % (prec1)) log.close() best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, epoch, is_best, args)
def main(): global args, best_prec1 # Check the save_dir exists or not if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) if args.arch == 'vgg': model = vgg16_bn() elif args.arch == 'alexnet': model = alexnet( num_classes=10) if args.dataset == 'cifar10' else alexnet( num_classes=100) elif args.arch == 'wide_resnet': if args.dataset == 'cifar10': model = wide_WResNet(num_classes=10, depth=16, dataset='cifar10') else: model = wide_WResNet(num_classes=100, depth=16, dataset='cifar100') elif args.arch == 'resnet': if args.dataset == 'cifar10': model = resnet(num_classes=10, dataset='cifar10') else: model = resnet(num_classes=100, dataset='cifar100') model.cuda() cudnn.benchmark = True # define loss function (criterion) and pptimizer criterion = nn.CrossEntropyLoss().cuda() if args.half: model.half() criterion.half() 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("=> 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_state_dict']) print(("=> loaded checkpoint '{}' (epoch {})".format( args.evaluate, checkpoint['epoch']))) else: print("=> no checkpoint found at '{}'".format(args.resume)) if args.evaluate: validate(val_loader, model, criterion) return for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch cubic_train(model, criterion, optimizer, epoch) # evaluate on validation set prec1 = validate(val_loader, model, criterion) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'best_prec1': best_prec1, }, is_best, filename=os.path.join(args.save_dir, 'checkpoint_{}.tar'.format(epoch)))
logger.info("Loading teacher model from {}".format(args.teacher)) model_teacher = densenet.densenet( num_classes=num_classes, depth=args.depth_dense, block=densenet.Bottleneck, growthRate=args.growthRate, compressionRate=args.compressionRate, dropRate=args.drop, ) checkpoint_path = args.teacher + "/model_best.pth.tar" model_teacher.load_state_dict(torch.load(checkpoint_path)['state_dict']) logger.info(model_teacher) logger.info("Initializing student model...") model = resnet.resnet(depth=args.depth, num_classes=num_classes, num_blocks=num_blocks) logger.info(model) if args.cuda: model_teacher.cuda() model.cuda() optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume))
def train(args, dataloaders): train_source_dataloader = dataloaders['train_source'] train_target_dataloader = dataloaders['train_target'] # model model = resnet(args).to(args.device) #model = Model().to(args.device) model.train() # loss Loss_Src_Class = DClassifierForTarget(nClass=args.num_classes).to( args.device) Loss_Tar_Class = DClassifierForSource(nClass=args.num_classes).to( args.device) Loss_Tar_EM = EMLossForTarget(nClass=args.num_classes).to(args.device) BCE = nn.BCEWithLogitsLoss() CE = nn.CrossEntropyLoss() models = model # optimizer optimizer = torch.optim.SGD( [ { 'params': model.conv1.parameters(), 'name': 'pre-trained' }, { 'params': model.bn1.parameters(), 'name': 'pre-trained' }, { 'params': model.layer1.parameters(), 'name': 'pre-trained' }, { 'params': model.layer2.parameters(), 'name': 'pre-trained' }, { 'params': model.layer3.parameters(), 'name': 'pre-trained' }, { 'params': model.layer4.parameters(), 'name': 'pre-trained' }, #{'params': model.fc.parameters(), 'name': 'pre-trained'} { 'params': model.fc.parameters(), 'name': 'new-added' } ], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) ''' optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay), nesterov=True) ''' # lr schedule ''' steplr_after = StepLR(optimizer, step_size=10, gamma=1.0) lr_scheduler = WarmupScheduler(optimizer, multiplier=1, total_epoch=args.warmup_epochs, after_scheduler=steplr_after) ''' ############################################################# ########################### Train ########################### train_source_dataloader_iter = circle_iterator(train_source_dataloader) train_target_dataloader_iter = circle_iterator(train_target_dataloader) best_tar_acc = 0 for epoch in range(1, args.epochs + 1): class_losses = [] generate_losses = [] len_dataloader = min(len(train_source_dataloader), len(train_target_dataloader)) model.train() for i in range(len_dataloader): src_imgs, src_lbls = next(train_source_dataloader_iter) tar_imgs, tar_lbls = next(train_target_dataloader_iter) #for i,((src_imgs, src_lbls), (tar_imgs, tar_lbls)) in enumerate( # zip(train_source_dataloader, train_target_dataloader)): src_imgs, src_lbls = src_imgs.to(args.device),\ src_lbls.to(args.device) tar_imgs, tar_lbls = tar_imgs.to(args.device),\ tar_lbls.to(args.device) ################### Train Domain_predictor ################### src_lbls_tmp = src_lbls + args.num_classes output = model(src_imgs) loss_Cs_src = CE(output[:, :args.num_classes], src_lbls) loss_Ct_src = CE(output[:, args.num_classes:], src_lbls) loss_Cst_domain_part1 = Loss_Src_Class(output) loss_Cst_category_Gen = 0.5 * CE(output, src_lbls) + \ 0.5 * CE(output, src_lbls_tmp) output = model(tar_imgs) loss_Cst_domain_part2 = Loss_Tar_Class(output) loss_Cst_domain_Gen = 0.5 * Loss_Tar_Class(output) + \ 0.5 * Loss_Src_Class(output) loss_em_tar = Loss_Tar_EM(output) ########################### Loss ############################ lamb = 2 / (1 + math.exp(-1 * 10 * epoch / args.epochs)) - 1 #lamb = 0.1 if args.flag == 'no_em': C_loss = loss_Cs_src + loss_Ct_src + \ loss_Cst_domain_part1 + loss_Cst_domain_part2 G_loss = loss_Cst_category_Gen + \ lamb * (loss_Cst_domain_Gen) elif args.flag == 'symnet': lamb = 2 / (1 + math.exp(-1 * 1 * epoch / args.epochs)) - 1 #lamb = 2 / (1 + math.exp(-1 * 0.1 * epoch / args.epochs)) - 1 C_loss = loss_Cs_src + loss_Ct_src + \ loss_Cst_domain_part1 + loss_Cst_domain_part2 G_loss = loss_Cst_category_Gen + \ lamb * (loss_Cst_domain_Gen + loss_em_tar) elif args.flag == 'test': lamb = 2 / (1 + math.exp(-1 * 5 * epoch / args.epochs)) - 1 C_loss = (loss_Cs_src + loss_Ct_src) + \ loss_Cst_domain_part1 + loss_Cst_domain_part2 G_loss = loss_Cst_category_Gen + \ lamb * (loss_Cst_domain_Gen + loss_em_tar) else: raise ValueError('unrecognized flag:', args.flag) ''' #nn.utils.clip_grad_norm_(model.parameters(), 0.01) optimizer.zero_grad() C_loss.backward(retain_graph=True) optimizer.step() optimizer.zero_grad() G_loss.backward() optimizer.step() ''' #compute gradient and do SGD step optimizer.zero_grad() C_loss.backward(retain_graph=True) temp_grad = [] for param in model.parameters(): temp_grad.append(param.grad.data.clone()) grad_for_classifier = temp_grad optimizer.zero_grad() G_loss.backward() temp_grad = [] for param in model.parameters(): temp_grad.append(param.grad.data.clone()) grad_for_featureExtractor = temp_grad #print(list(model.parameters())[-2:],len(list(model.parameters()))) #input() count = 0 for param in model.parameters(): temp_grad = param.grad.data.clone() temp_grad.zero_() if count < 60: #159 #### feauter extrac of the ResNet-50 #60 #### Resnet18 #5層: 20 temp_grad = temp_grad + grad_for_featureExtractor[count] else: temp_grad = temp_grad + grad_for_classifier[count] temp_grad = temp_grad param.grad.data = temp_grad count = count + 1 optimizer.step() ################### logging ##################### class_losses.append(C_loss.item()) generate_losses.append(G_loss.item()) wandb.log({ 'class_loss': C_loss.item(), 'generate_loss': G_loss.item() }) if i % 5 == 0: print(" [%d/%d] Loss C:%.2f G:%.2f" % (i + 1, len_dataloader, C_loss.item(), G_loss.item()), end=' \r') # lr scheduler update #lr_scheduler.step() # validating valid_src_acc, valid_tar_acc, valid_tar_acc_mix = valid( args, dataloaders, models) wandb.log({ 'valid_src_acc': valid_src_acc, 'valid_tar_acc': valid_tar_acc, 'valid_tar_acc_mix': valid_tar_acc_mix }) print(f" Epoch %d, Loss C:%.3f G:%.3f" ", src_acc:%.3f tar_acc1:%.3f tar_acc2:%.3f " % (epoch, mean_(class_losses), mean_(generate_losses), valid_src_acc, valid_tar_acc, valid_tar_acc_mix)) if valid_tar_acc > 0.2 and best_tar_acc < valid_tar_acc: best_tar_acc = valid_tar_acc save_dir = f"./result/{args.source}2{args.target}/" os.system(f"mkdir -p {save_dir}") torch.save({'M': model.state_dict()}, f"{save_dir}/best_model.pth") print("\t save best weight")
def test(args, model_epoch=None): base_cfg = Config.fromfile(args.base_config) det_cfg = Config.fromfile(args.config) cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg) if model_epoch is not None: cfg.model = os.path.join(cfg.TRAIN.save_dir, cfg.TRAIN.model_name + model_epoch) print(cfg.model) if not os.path.exists(cfg.model): return 0, 0, 0, 0, 0 gpus = ",".join('%s' % id for id in cfg.TEST.gpus) os.environ['CUDA_VISIBLE_DEVICES'] = gpus thresh = cfg.TEST.thresh # 0.8 nms_thresh = cfg.TEST.nms_thresh # 0.35 iou_thresh = cfg.TEST.iou_thresh classes = len(cfg.class_list) if 'lite' in cfg.MODEL.BACKBONE: model = lite_faster_rcnn(cfg, classes) elif 'pva' in cfg.MODEL.BACKBONE: model = pva_net(classes) elif 'resnet' in cfg.MODEL.BACKBONE: model = resnet(classes, num_layers=101) model.create_architecture(cfg) checkpoint = torch.load(cfg.model) model.load_state_dict(checkpoint['state_dict']) if torch.cuda.is_available(): model = model.cuda() print("using gpu...") model.eval() imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml")) # print(cfg.TEST.img_path) batch_size = 1 std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32) mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32) std = torch.from_numpy(std).cuda() mean = torch.from_numpy(mean).cuda() total_image_nums = len(imgs) for ix, img_name in enumerate(imgs): img_name = img_name.replace(".xml", ".jpg") # print(ix, img_name) im = cv2.imread(img_name) if im is None: continue import time # start_t = time.clock() data = prepareTestData(cfg.TEST.TEST_SCALE, im, cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE) start_t = time.time() results = im_detect(data, model, batch_size, std, mean, classes, thresh, nms_thresh) end_t = time.time() # print(ix, "/", total_image_nums, img_name, ' time consume is: ', # end_t - start_t, len(results)) print(ix, "/", total_image_nums, img_name, ' time consume is: ', end_t - start_t) xml_name = img_name.replace(".jpg", ".xml") xml_dicts = xml2dict(cfg.rename_class_list, xml_name, cfg.class_list) det_dicts = det_results2dict(results, cfg.class_list) txt_name = os.path.basename(xml_name).replace('.xml', '.txt') # os.remove("mAP/input/ground-truth/") if not os.path.exists("mAP/input/ground-truth/"): os.makedirs("mAP/input/ground-truth/") # os.remove("mAP/input/detection-results/") if not os.path.exists("mAP/input/detection-results/"): os.makedirs("mAP/input/detection-results/") # GT with open("mAP/input/ground-truth/" + txt_name, 'w') as f: for key in cfg.class_list: if key == '__background__': continue if key == 'FC': break for gt_id, gt_box in enumerate(xml_dicts[key]): f.write(key + " " + str(gt_box[0]) + " " + str(gt_box[1]) + " " + str(gt_box[2]) + " " + str(gt_box[3]) + "\n") f.close() # DET results with open("mAP/input/detection-results/" + txt_name, 'w') as f: for key in cfg.class_list: if key == '__background__': continue if key == 'FC': break for det_id, det_box in enumerate(det_dicts[key]): f.write(key + " " + str(det_box[-1]) + " " + str(det_box[0]) + " " + str(det_box[1]) + " " + str(det_box[2]) + " " + str(det_box[3]) + "\n") f.close()
def get_network(args, use_gpu=True): """ return given network """ if args.net == 'vgg16': net = torchvision.models.vgg16_bn(pretrained=args.bool_pretrained) net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True) elif args.net == 'vgg13': net = torchvision.models.vgg13_bn(pretrained=args.bool_pretrained) net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True) elif args.net == 'vgg11': net = torchvision.models.vgg11_bn(pretrained=args.bool_pretrained) net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True) elif args.net == 'vgg19': net = torchvision.models.vgg19_bn(pretrained=args.bool_pretrained) net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True) ####effcientnet elif args.net == 'efficientnet-b5': from efficientnet_pytorch import EfficientNet if args.bool_pretrained == True: net = EfficientNet.from_pretrained('efficientnet-b5') else: net = EfficientNet.from_name('efficientnet-b5') net._fc = nn.Linear(2048, args.num_classes, bias=True) elif args.net == 'densenet121': from models.densenet import densenet121 net = densenet121() elif args.net == 'densenet161': net = torchvision.models.densenet161(pretrained=args.bool_pretrained) in_features = net.classifier.in_features net.classifier = nn.Linear(in_features, args.num_classes, bias=True) elif args.net == 'densenet169': net = torchvision.models.densenet169(pretrained=args.bool_pretrained) in_features = net.classifier.in_features net.classifier = nn.Linear(in_features, args.num_classes, bias=True) elif args.net == 'densenet201': net = torchvision.models.densenet201(pretrained=args.bool_pretrained) in_features = net.classifier.in_features net.classifier = nn.Linear(in_features, args.num_classes, bias=True) elif args.net == 'googlenet': from models.googlenet import googlenet net = googlenet() elif args.net == 'inceptionv3': from models.inceptionv3 import inceptionv3 net = inceptionv3() elif args.net == 'inceptionv4': from models.inceptionv4 import inceptionv4 net = inceptionv4() elif args.net == 'inceptionresnetv2': from models.inceptionv4 import inception_resnet_v2 net = inception_resnet_v2() elif args.net == 'xception': from models.xception import xception net = xception() ################## ResNet ######################################################## elif args.net == 'resnet18': from models.resnet import resnet net = resnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'resnet34': from models.resnet import resnet net = resnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'resnet50': from models.resnet import resnet net = resnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'resnet101': from models.resnet import resnet net = resnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'resnet152': from models.resnet import resnet net = resnet(args.num_classes, 2, args.pretrained, args.net) ################################################################################## elif args.net == 'preactresnet18': from models.preactresnet import preactresnet18 net = preactresnet18() elif args.net == 'preactresnet34': from models.preactresnet import preactresnet34 net = preactresnet34() elif args.net == 'preactresnet50': from models.preactresnet import preactresnet50 net = preactresnet50() elif args.net == 'preactresnet101': from models.preactresnet import preactresnet101 net = preactresnet101() elif args.net == 'preactresnet152': from models.preactresnet import preactresnet152 net = preactresnet152() ################################################################## elif args.net == 'se_resnext50': from models.resnext import se_resnext net = se_resnext(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'se_resnext101': from models.resnext import se_resnext net = se_resnext(args.num_classes, 2, args.pretrained, args.net) ################################################################# elif args.net == 'shufflenet': from models.shufflenet import shufflenet net = shufflenet() elif args.net == 'shufflenetv2': from models.shufflenetv2 import shufflenetv2 net = shufflenetv2() elif args.net == 'squeezenet': from models.squeezenet import squeezenet net = squeezenet() elif args.net == 'mobilenet': from models.mobilenet import mobilenet net = mobilenet() elif args.net == 'mobilenetv2': from models.mobilenetv2 import mobilenetv2 net = mobilenetv2() elif args.net == 'nasnet': from models.nasnet import nasnet net = nasnet() elif args.net == 'attention56': from models.attention import attention56 net = attention56() elif args.net == 'attention92': from models.attention import attention92 net = attention92() ######################################################### elif args.net == 'se_resnet50': from models.senet import seresnet net = seresnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'se_resnet101': from models.senet import seresnet net = seresnet(args.num_classes, 2, args.pretrained, args.net) elif args.net == 'se_resnet152': from models.senet import seresnet net = seresnet(args.num_classes, 2, args.pretrained, args.net) else: print('the network name you have entered is not supported yet') sys.exit() if use_gpu: net = net.cuda() return net
def training(): batch_size = 64 epochs = 200 fine_tune_epochs = 50 lr = 0.1 x_train, y_train, x_test, y_test, nb_classes = load_data(args.data) print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') y_train = keras.utils.to_categorical(y_train, nb_classes) y_test = keras.utils.to_categorical(y_test, nb_classes) datagen = ImageDataGenerator(horizontal_flip=True, width_shift_range=5. / 32, height_shift_range=5. / 32) data_iter = datagen.flow(x_train, y_train, batch_size=batch_size, shuffle=True) if args.model == 'resnet': model = resnet.resnet(nb_classes, depth=args.depth, wide_factor=args.wide_factor, sparse_factor=args.sparse_factor) save_name = 'resnet_{}_{}_{}'.format(args.depth, args.wide_factor, args.data) else: model = VGGnet.vgg(nb_classes, sparse_factor=args.sparse_factor) save_name = 'VGGnet_{}'.format(args.data) opt = keras.optimizers.SGD(lr=lr, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) model.summary() history = model.fit_generator(data_iter, steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, callbacks=[onetenth_60_120_160(lr)], validation_data=(x_test, y_test)) if not os.path.exists('./results/'): os.mkdir('./results/') plot_history(history, './results/', save_name) save_history(history, './results/', save_name) model.save_weights('./results/{}_weights.h5'.format(save_name)) freeze_SR_layer(model, args.prune_rate) # todo: a little change opt = keras.optimizers.SGD(lr=0.0001, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) model.save_weights('./results/{}_{}_weights.h5'.format( save_name, 'fine_tuned')) model.fit_generator(data_iter, steps_per_epoch=x_train.shape[0] // batch_size, epochs=fine_tune_epochs, validation_data=(x_test, y_test)) # create compact model if args.model == 'resnet': model = resnet.resnet(nb_classes, depth=args.depth, wide_factor=args.wide_factor, sparse_factor=args.sparse_factor, prune_rate=args.prune_rate) else: model = VGGnet.vgg(nb_classes, sparse_factor=args.sparse_factor, prune_rate=args.prune_rate) compact_model.summary() set_compact_model_weights(model, compact_model) opt = keras.optimizers.SGD(lr=0.0001, momentum=0.9, nesterov=True) compact_model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) score = compact_model.evaluate(x_test, y_test, verbose=0) print('loss: {}'.format(score[0])) print('acc: {}'.format(score[1])) compact_model.save_weights('./results/{}_{}_weights.h5'.format( save_name, 'channel_pruned'))
def main(): args = parse_args() base_cfg = Config.fromfile(args.base_config) det_cfg = Config.fromfile(args.config) cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg) gpus = ",".join('%s' % id for id in cfg.TEST.gpus) os.environ['CUDA_VISIBLE_DEVICES'] = gpus thresh = cfg.TEST.thresh nms_thresh = cfg.TEST.nms_thresh save_dir = cfg.TEST.save_dir classes = len(cfg.class_list) if not os.path.isdir(save_dir): os.makedirs(save_dir) if 'lite' in cfg.MODEL.BACKBONE: model = lite_faster_rcnn(cfg, classes) elif 'pva' in cfg.MODEL.BACKBONE: model = pva_net(classes) elif 'resnet' in cfg.MODEL.BACKBONE: model = resnet(classes, num_layers=101) model.create_architecture(cfg) checkpoint = torch.load(cfg.model) model.load_state_dict(checkpoint['state_dict']) if torch.cuda.is_available(): model = model.cuda() print("using gpu...") model.eval() imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml")) print(cfg.TEST.img_path) batch_size = 1 std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32) mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32) std = torch.from_numpy(std).cuda() mean = torch.from_numpy(mean).cuda() color_list = defaultdict(list) for key in cfg.class_list: bgr = (np.random.randint(10, 255), np.random.randint( 10, 255), np.random.randint(10, 255)) color_list[key].append(bgr) total_image_nums = len(imgs) undetected_sample = [] for ix, img_name in enumerate(imgs): save_flag = 0 img_name = img_name.replace(".xml", cfg.image_postfix) # print(ix, img_name) im = cv2.imread(img_name) image_cpy = im.copy() xml_image = im.copy() gt_image = im.copy() if im is None: continue import time # start_t = time.clock() # if args.gama: # im = adjust_gamma(im, 2.0) data = prepareTestData(cfg.TEST.TEST_SCALE, im, cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE) start_t = time.time() results = im_detect(data, model, batch_size, std, mean, cfg, nms_thresh) end_t = time.time() print(ix, "/", total_image_nums, img_name, ' time consume is: ', end_t - start_t, len(results)) # show undetected sample gt xml_name = img_name.replace(cfg.image_postfix, ".xml") if os.path.exists(xml_name): xml_dicts = xml2dict(cfg.rename_class_list, xml_name, cfg.class_list) det_dicts = det_results2dict(results, cfg.class_list) is_undetected = 0 for key in cfg.class_list: if key == '__background__': continue is_match_gt = np.zeros(len(xml_dicts[key])) is_match_det = np.zeros(len(det_dicts[key])) for det_id, det_box in enumerate(det_dicts[key]): max_iou, max_iou_id = 0, 0 for gt_id, gt_box in enumerate(xml_dicts[key]): if abs(is_match_gt[gt_id]) > 0: continue iou = calc_iou(det_box[0:-1], gt_box[0:-1]) if iou > max_iou: max_iou = iou max_iou_id = gt_id if max_iou > cfg.TEST.iou_thresh: is_match_gt[max_iou_id] = 1.0 is_match_det[det_id] = 1.0 for object_id in range(len(is_match_gt)): if is_match_gt[object_id] == 0: # is_undetected += 1 # # show_gt_image # if is_undetected == 1: # xml_image = im.copy() # xml_image_name = img_name.replace(".jpg", ".bmp") # save_image_gt(xml_image, xml_image_name, color_list, save_dir, # cfg.rename_class_list, xml_name, cfg.class_list) gt_box = xml_dicts[key][object_id] save_dir = cfg.TEST.save_dir name = os.path.basename(xml_name).split( ".xml")[0] + "_" + str(object_id) + ".bmp" dst_file = save_dir + '/undetected_sample/' + key + "/" if not os.path.exists(dst_file): os.makedirs(dst_file) dst_file += name image_roi = image_cpy[ gt_box[1]:gt_box[3], gt_box[0]:gt_box[2]] if not os.path.exists(dst_file): cv2.imwrite(dst_file, image_roi, [ int(cv2.IMWRITE_JPEG_QUALITY), 100]) g, b, r = color_list[key][0] x1, x2 = gt_box[0], gt_box[2] y1, y2 = gt_box[1], gt_box[3] w = x2 - x1 h = y2 - y1 cv2.rectangle( xml_image, (x1, y1), (x2, y2), (g, b, r), 1) cv2.putText(xml_image, key, (x1 + w//2, y1 + h//2), cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1) if save_flag == 0 or save_flag == 3: if key in cfg.defect_class_list: save_flag = 2 else: save_flag = 3 for object_id in range(len(is_match_det)): if is_match_det[object_id] == 0: det_box = det_dicts[key][object_id] save_dir = cfg.TEST.save_dir name = os.path.basename(xml_name).split( ".xml")[0] + "_" + str(object_id) + ".bmp" dst_file = save_dir + '/detected_sample_is_error/' + key + "/" if not os.path.exists(dst_file): os.makedirs(dst_file) dst_file += name image_roi = image_cpy[ int(det_box[1]):int(det_box[3]), int(det_box[0]):int(det_box[2])] if not os.path.exists(dst_file): cv2.imwrite(dst_file, image_roi, [ int(cv2.IMWRITE_JPEG_QUALITY), 100]) draw_img = im.copy() save_xml = False if save_xml: imgFolderPath = os.path.dirname(img_name) imgFolderName = os.path.split(imgFolderPath)[-1] imgFileName = os.path.basename(img_name) image = cv2.imread(img_name) imageShape = [image.shape[0], image.shape[1], image.shape[2]] writer = PascalVocWriter(imgFolderName, imgFileName, imageShape, localImgPath=img_name) writer.verified = False if save_flag >= 2: # show_gt_image xml_path = img_name.replace(cfg.image_postfix, ".xml") if os.path.exists(xml_path): # save_image_gt xml_image_name = os.path.basename( img_name).replace(cfg.image_postfix, "_gt.bmp") save_image_gt(gt_image, xml_image_name, color_list, save_dir, cfg.rename_class_list, xml_path, cfg.class_list) for boxes in results: for box in boxes: # for box_id, box in enumerate(boxes): x1 = int(box[0]) y1 = int(box[1]) x2 = int(box[2]) y2 = int(box[3]) score = float(box[4]) label = int(box[5]) w = x2 - x1 h = y2 - y1 label_name = cfg.class_list[label] if 0: # 'KP' == label_name and max(w, h) <= 16: image_roi = im[y1:y2, x1:x2] # saliency = cv2.saliency.StaticSaliencyFineGrained_create() # (success, saliencyMap) = saliency.computeSaliency( # cv2.cvtColor(image_roi, cv2.COLOR_RGB2LAB)) # saliencyMap = (saliencyMap * 255).astype("uint8") # threshMap = cv2.threshold(saliencyMap.astype("uint8"), 0, 255, # cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] image_gray = cv2.cvtColor(image_roi, cv2.COLOR_RGB2gray) threshMap = cv2.threshold(image_gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] # cv2.imwrite(save_dir + 'horizon/' + # str(box_id) + "_" + name.replace(".jpg", ".bmp"), image_roi, [ # int(cv2.IMWRITE_JPEG_QUALITY), 100]) cv2.imwrite(save_dir + '/' + "A0_" + name, image_roi) cv2.imwrite(save_dir + '/' + "A1_" + name, image_gray) cv2.imwrite(save_dir + '/' + "A2_" + name, threshMap) # if label_name != 'HH': # continue # else: # save_flag = 1 g, b, r = color_list[label_name][0] # label * 50, label * 100, label * 150 if 1: # label_name in ["HH"]: # save_flag = 1 cv2.rectangle(draw_img, (x1, y1), (x2, y2), (g, b, r), 1) cv2.putText(draw_img, label_name, (x1 + w//2, y1 + h//2), cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1) # label*50, label*100, label*100 cv2.putText(draw_img, str(round(score, 3)), (x1 + w // 2 + 10, y1 + h // 2 + 10), cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1) # label * 50, label * 100, label * 100 # if save_xml: # if 'M' == label_name or 'SL' == label_name or 'HH' == label_name: # continue # difficult = 0 # writer.addBndBox(x1, y1, x2, y2, label_name, difficult) if save_xml: writer.save(targetFile='./outputs/' + name.replace(cfg.image_postfix, '.xml')) if len(results) > 0 and save_flag >= 2: name = os.path.basename(img_name) cv2.imwrite(save_dir + '/' + name, draw_img) name = os.path.basename(img_name).replace( cfg.image_postfix, "_undetected.bmp") if save_flag == 2: if not os.path.exists(save_dir + '/FN_defect/'): os.makedirs(save_dir + '/FN_defect/') cv2.imwrite(save_dir + '/FN_defect/' + name, xml_image) cv2.imwrite(save_dir + '/' + name, xml_image) # hard_sample_dir = "/data/zhangcc/data/det_whiteshow_defect/1/hard_sample/" # shutil.copy(img_name, hard_sample_dir + # os.path.basename(img_name)) # xml_name_cpy = img_name.replace(".bmp", ".xml") # shutil.copy(xml_name_cpy, hard_sample_dir + # os.path.basename(xml_name_cpy)) elif save_flag == 3: if not os.path.exists(save_dir + '/FN_device/'): os.makedirs(save_dir + '/FN_device/') cv2.imwrite(save_dir + '/FN_device/' + name, xml_image) cv2.imwrite(save_dir + '/' + name, xml_image) else: # undetected_sample.append(name) # shutil.copyfile(img_name, save_dir + 'undetected_sample/' + name) # shutil.copyfile(img_name.replace(".jpg", ".xml"), save_dir + 'undetected_sample/' + # name.replace(".jpg", ".xml")) print('no object in this picture') return undetected_sample
def load_trained_model(model_name, train_set, device=torch.device('cpu')): """ Loads a pre-trained model from a state dict. Assumes that your models are saved in 'bayesian-calibration/models' and that your state dicts are saved in 'bayesian-calibration/models/checkpoints' Args: model_name: str ; train_set: str ; device: str; cpu by default Returns: A trained PyTorch model in eval mode. """ print('\nLoading pre-trained model') print('----| Model: {} Train set: {}'.format(model_name, train_set)) train_set = train_set.lower() if train_set.startswith('cifar'): # Load local cifar-trained models num_classes = {'cifar100': 100, 'cifar10': 10, 'cifar10imba': 10} train_set = train_set.lower().strip() model_name = model_name.lower().strip() # Load the saved state dict path_str = 'models/checkpoints/{}_{}.tar'.format(model_name, train_set) checkpoint_path = pathlib.Path(path_str).resolve() checkpoint = torch.load(checkpoint_path) state_dict = checkpoint['state_dict'] if model_name == 'resnet-110': from models.resnet import resnet state_dict = _strip_parallel_model(state_dict) model = resnet(num_classes=num_classes[train_set], depth=110, block_name='BasicBlock') elif model_name == 'alexnet': from models.alexnet import alexnet state_dict = _strip_parallel_model(state_dict) model = alexnet(num_classes=num_classes[train_set]) elif model_name == 'vgg19-bn': from models.vgg import vgg19_bn state_dict = _strip_parallel_model(state_dict) model = vgg19_bn(num_classes=num_classes[train_set]) elif model_name == 'wrn-28-10': from models.wrn import wrn state_dict = _strip_parallel_model(state_dict) model = wrn(num_classes=num_classes[train_set], depth=28, widen_factor=10, dropRate=0.3) else: raise NotImplementedError model.load_state_dict(state_dict) elif train_set == 'imagenet': # Thin wrapper to load PyTorch pretrained imagenet models import torchvision.models as models model = getattr(models, model_name)(pretrained=True) else: raise NotImplementedError model.eval() return model.to(device)
def main(args, model_epoch=None): base_cfg = Config.fromfile(args.base_config) det_cfg = Config.fromfile(args.config) cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg) if model_epoch is not None: cfg.model = os.path.join(cfg.TRAIN.save_dir, cfg.TRAIN.model_name + model_epoch) print(cfg.model) if not os.path.exists(cfg.model): return 0, 0, 0, 0, 0 gpus = ",".join('%s' % id for id in cfg.TEST.gpus) os.environ['CUDA_VISIBLE_DEVICES'] = gpus thresh = cfg.TEST.thresh # 0.8 nms_thresh = cfg.TEST.nms_thresh # 0.35 iou_thresh = cfg.TEST.iou_thresh classes = len(cfg.class_list) if 'lite' in cfg.MODEL.BACKBONE: model = lite_faster_rcnn(cfg, classes) elif 'pva' in cfg.MODEL.BACKBONE: model = pva_net(classes) elif 'resnet' in cfg.MODEL.BACKBONE: model = resnet(classes, num_layers=101) model.create_architecture(cfg) checkpoint = torch.load(cfg.model) model.load_state_dict(checkpoint['state_dict']) if torch.cuda.is_available(): model = model.cuda() print("using gpu...") model.eval() imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml")) # print(cfg.TEST.img_path) batch_size = 1 std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32) mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32) std = torch.from_numpy(std).cuda() mean = torch.from_numpy(mean).cuda() all_detections = [] gt_box_num_datasets = dict.fromkeys(cfg.class_list, 0) det_box_num_datasets = dict.fromkeys(cfg.class_list, 0) undetected_sample = [] undetected_sample_size = defaultdict(list) precsion_dicts = det_init_dict(cfg.class_list, 0) recall_dicts = det_init_dict(cfg.class_list, 0) TP = det_init_dict(cfg.class_list, 0) FP = det_init_dict(cfg.class_list, 0) FN = det_init_dict(cfg.class_list, 0) total_image_nums = len(imgs) for ix, img_name in enumerate(tqdm(imgs)): img_name = img_name.replace(".xml", ".jpg") # print(ix, img_name) im = cv2.imread(img_name) if im is None: continue import time # start_t = time.clock() data = prepareTestData(cfg.TEST.TEST_SCALE, im, cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE) start_t = time.time() results = im_detect(data, model, batch_size, std, mean, cfg, nms_thresh) end_t = time.time() # print(ix, "/", total_image_nums, img_name, ' time consume is: ', # end_t - start_t) if 1: # len(results) > 0: xml_name = img_name.replace(".jpg", ".xml") xml_dicts = xml2dict(cfg.rename_class_list, xml_name, cfg.class_list) det_dicts = det_results2dict(results, cfg.class_list) small_object_size = cfg.TEST.small_object_size for key in cfg.class_list: if key == '__background__': continue ignore_gt_box_num_per_cls = dict.fromkeys(cfg.class_list, 0) ignore_det_box_num_per_cls = dict.fromkeys(cfg.class_list, 0) is_match_gt = np.zeros(len(xml_dicts[key])) is_match_det = np.zeros(len(det_dicts[key])) for gt_id, gt_box in enumerate(xml_dicts[key]): gt_s0 = gt_box[3] - gt_box[1] gt_s1 = gt_box[2] - gt_box[0] if gt_s0 < small_object_size or gt_s1 < small_object_size: ignore_gt_box_num_per_cls[key] += 1.0 is_match_gt[gt_id] = -1.0 gt_box_num = len( xml_dicts[key]) - ignore_gt_box_num_per_cls[key] gt_box_num_datasets[key] += gt_box_num # print(xml_name, key, gt_box_num, gt_box_num_datasets[key]) for det_id, det_box in enumerate(det_dicts[key]): det_s0 = det_box[3] - det_box[1] det_s1 = det_box[2] - det_box[0] if det_s0 < small_object_size or det_s1 < small_object_size: ignore_det_box_num_per_cls[key] += 1.0 is_match_det[det_id] = -1.0 continue max_iou, max_iou_id = 0, 0 for gt_id, gt_box in enumerate(xml_dicts[key]): if abs(is_match_gt[gt_id]) > 0: continue iou = calc_iou(det_box[0:-1], gt_box[0:-1]) if iou > max_iou: max_iou = iou max_iou_id = gt_id if gt_id == len(xml_dicts[key]) - 1: if max_iou > iou_thresh: is_match_gt[max_iou_id] = 1.0 is_match_det[det_id] = 1.0 det_box_num = len( det_dicts[key]) - ignore_det_box_num_per_cls[key] det_box_num_datasets[key] += det_box_num for object_id in range(len(is_match_gt)): if is_match_gt[object_id] == 0: gt_box = xml_dicts[key][object_id] gt_s0 = gt_box[3] - gt_box[1] gt_s1 = gt_box[2] - gt_box[0] undetected_sample_size[key].append( (os.path.basename(xml_name), object_id, gt_s0, gt_s1)) # print(img_name, len( # xml_dicts[key]) - ignore_gt_box_num_per_cls[key]) # save_dir = cfg.TEST.save_dir # name = os.path.basename(img_name) # shutil.copyfile(img_name, save_dir + # 'undetected_sample/' + name) # shutil.copyfile(img_name.replace(".jpg", ".xml"), save_dir + 'undetected_sample/' + # name.replace(".jpg", ".xml")) tp = np.sum(is_match_det) fp = np.sum(abs(is_match_det - 1)) fn = np.sum(abs(is_match_gt - 1)) TP[key][0] += tp FP[key][0] += fp FN[key][0] += fn recall_cls = np.sum(is_match_gt) recall_dicts[key].append(recall_cls) if gt_box_num > 0 and recall_cls / gt_box_num < 1.0 and not ( xml_name in undetected_sample): undetected_sample.append(xml_name) precision_cls = np.sum(is_match_gt) precsion_dicts[key].append(precision_cls) # if ix > 100: # break avg_precision = 0.0 avg_recall = 0.0 avg_fscore = 0.0 cls_num = 0.0 for key in cfg.defect_class_list: # print("recall: ", np.sum(recall_dicts[key]), # "gt_box_num_datasets: ", gt_box_num_datasets[key], # "det_box_num_datasets: ", det_box_num_datasets[key]) # recall_per_cls, precision_per_cls = 0, 0 # if gt_box_num_datasets[key] > 0: # cls_num = cls_num + 1 # recall_per_cls = np.sum( # recall_dicts[key]) / gt_box_num_datasets[key] # if det_box_num_datasets[key] > 0: # precision_per_cls = np.sum( # precsion_dicts[key]) / det_box_num_datasets[key] recall_per_cls = TP[key][0] / (TP[key][0] + FN[key][0]) precision_per_cls = TP[key][0] / (TP[key][0] + FP[key][0]) fscore_per_cls = 2 * recall_per_cls * precision_per_cls / ( recall_per_cls + precision_per_cls) cls_num = cls_num + 1 if gt_box_num_datasets[key] > 0: print("class_name: ", key, "recall_per_cls: ", recall_per_cls, "precision_per_cls: ", precision_per_cls, "fscore_per_cls: ", fscore_per_cls, "gt_box_num_datasets: ", gt_box_num_datasets[key], "det_box_num_datasets: ", det_box_num_datasets[key]) avg_recall += recall_per_cls avg_precision += precision_per_cls avg_fscore += fscore_per_cls avg_recall = avg_recall / cls_num avg_precision = avg_precision / cls_num avg_fscore = avg_fscore / cls_num undetected_ratio = len(undetected_sample) / len(imgs) print("avg_recall: ", avg_recall) print("avg_precision: ", avg_precision) print("avg_fscore: ", avg_fscore) print("undetected_ratio: ", undetected_ratio) # print("undetected_sample: ", undetected_sample) with open("undetected_sample_size.txt", 'w') as f: for key in undetected_sample_size.keys(): for undetected_gt_size in undetected_sample_size[key]: # print("key: ", key, undetected_gt_size) f.write("key: " + key + " " + str(undetected_gt_size) + "\n") if key in cfg.defect_class_list: save_dir = cfg.TEST.save_dir name = undetected_gt_size[0] src_file = save_dir + name.replace(".xml", ".jpg") dst_file = save_dir + 'undetected_sample/' + \ name.replace(".xml", ".jpg") if not os.path.exists(dst_file) and os.path.exists( src_file): shutil.copyfile(src_file, dst_file) src_file = save_dir + name.replace(".xml", ".bmp") dst_file = save_dir + 'undetected_sample/' + name.replace( ".xml", ".bmp") if not os.path.exists(dst_file) and os.path.exists( src_file): shutil.copyfile(src_file, dst_file) f.close() # with open("undetected_sample.txt", 'w') as f: # for key in undetected_sample_size.keys(): # for undetected_gt_size in undetected_sample_size[key]: # f.write(str(undetected_gt_size[0]) + "\n") # f.close() return avg_recall, avg_precision, avg_fscore, undetected_ratio, 1
import torch import time import numpy as np from models.efficientnet import efficientnet from models.vgg import vgg import torch.nn as nn from models.resnet import resnet vgg16 = vgg(False, 'vgg16', 1000, False) vgg16.classifier = nn.Sequential(*list(vgg16.classifier.children())[:-1]) resnet50 = resnet(False, 'resnet50', 1000, False) resnet50 = nn.Sequential(*list(resnet50.children())[:-1]) resnet101 = resnet(False, 'resnet101', 1000, False) resnet101 = nn.Sequential(*list(resnet101.children())[:-1]) models = { 'efficientnetb0': efficientnet(False, 'b0', 1000, False, 1280), 'efficientnetb1': efficientnet(False, 'b1', 1000, False, 1280), 'efficientnetb4': efficientnet(False, 'b4', 1000, False, 1280), 'vgg16': vgg16, 'resnet50': resnet50, 'resnet101': resnet101 } batch_sizes = [1, 10, 25] patch_sizes = [168, 224] devices = ['cpu', 'cuda'] for key, model in models.items(): print('==> model: {}'.format(key)) for dev in devices:
def training(): batch_size = 64 epochs = 200 fine_tune_epochs = 30 lr = 0.1 x_train, y_train, x_test, y_test, nb_classes = load_data(args.data) print('x_train shape:', x_train.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') y_train = keras.utils.to_categorical(y_train, nb_classes) y_test = keras.utils.to_categorical(y_test, nb_classes) datagen = ImageDataGenerator(horizontal_flip=True, width_shift_range=5. / 32, height_shift_range=5. / 32) data_iter = datagen.flow(x_train, y_train, batch_size=batch_size, shuffle=True) if args.model == 'resnet': model = resnet.resnet(nb_classes, depth=args.depth, wide_factor=args.wide_factor) save_name = 'resnet_{}_{}_{}'.format(args.depth, args.wide_factor, args.data) elif args.model == 'densenet': model = densenet.densenet(nb_classes, args.growth_rate, depth=args.depth) save_name = 'densenet_{}_{}_{}'.format(args.depth, args.growth_rate, args.data) elif args.model == 'inception': model = inception.inception_v3(nb_classes) save_name = 'inception_{}'.format(args.data) elif args.model == 'vgg': model = vggnet.vgg(nb_classes) save_name = 'vgg_{}'.format(args.data) else: raise ValueError('Does not support {}'.format(args.model)) model.summary() learning_rate_scheduler = LearningRateScheduler(schedule=schedule) if args.model == 'vgg': callbacks = None model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) else: callbacks = [learning_rate_scheduler] model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.SGD(lr=lr, momentum=0.9, nesterov=True), metrics=['accuracy']) # pre-train history = model.fit_generator(data_iter, steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, callbacks=callbacks, validation_data=(x_test, y_test)) if not os.path.exists('./results/'): os.mkdir('./results/') save_history(history, './results/', save_name) model.save_weights('./results/{}_weights.h5'.format(save_name)) # prune weights # save masks for weight layers masks = {} layer_count = 0 # not compress first convolution layer first_conv = True for layer in model.layers: weight = layer.get_weights() if len(weight) >= 2: if not first_conv: w = deepcopy(weight) tmp, mask = prune_weights(w[0], compress_rate=args.compress_rate) masks[layer_count] = mask w[0] = tmp layer.set_weights(w) else: first_conv = False layer_count += 1 # evaluate model after pruning score = model.evaluate(x_test, y_test, verbose=0) print('val loss: {}'.format(score[0])) print('val acc: {}'.format(score[1])) # fine-tune for i in range(fine_tune_epochs): for _ in range(x_train.shape[0] // batch_size): X, Y = data_iter.next() # train on each batch model.train_on_batch(X, Y) # apply masks for layer_id in masks: w = model.layers[layer_id].get_weights() w[0] = w[0] * masks[layer_id] model.layers[layer_id].set_weights(w) score = model.evaluate(x_test, y_test, verbose=0) print('val loss: {}'.format(score[0])) print('val acc: {}'.format(score[1])) # save compressed weights compressed_name = './results/compressed_{}_weights'.format(args.model) save_compressed_weights(model, compressed_name)
def main(): global args, best_prec1 args = opts() # args = parser.parse_args() model = resnet(args) # define-multi GPU model = torch.nn.DataParallel(model).cuda() print(model) # define loss function(criterion) and optimizer criterion = nn.CrossEntropyLoss().cuda() # optimizer = torch.optim.SGD(model.parameters(), # train with stanford dogs from scratch if args.new_fc: optimizer = torch.optim.SGD( [ { 'params': model.module.conv1.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, { 'params': model.module.bn1.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, { 'params': model.module.layer1.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, { 'params': model.module.layer2.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, { 'params': model.module.layer3.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, { 'params': model.module.layer4.parameters(), 'lr': args.lr, 'name': 'pre-trained' }, # {'params': model.module.fc.parameters(), 'lr': args.lr, 'name': 'pre-trained'} { 'params': model.module.fc.parameters(), 'lr': args.lr, 'name': 'new-added' } ], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.SGD(model.parameters(), lr=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("==> loading checkpoints '{}'".format(args.resume)) checkpoint = torch.load(args.resume) # args.start_epoch = checkpoint['epoch'] # best_prec1 = checkpoint['best_prec1'] model_state_dict = checkpoint['target_state_dict'] model_state_dict_tmp = copy.deepcopy(model_state_dict) if args.new_fc: model_state_dict_init = model.state_dict() for k_tmp in model_state_dict_tmp.keys(): if k_tmp.find('.resnet_conv') != -1: k = k_tmp.replace('.resnet_conv', '') model_state_dict[k] = model_state_dict.pop(k_tmp) if args.new_fc: # initialize fc layer if k_tmp.find('.fc') != -1: model_state_dict[k_tmp] = model_state_dict_init[k_tmp] model.load_state_dict(model_state_dict) # optimizer.load_state_dict(checkpoint['optimizer']) print("==> loaded checkpoint '{}'(epoch {})".format( args.resume, checkpoint['epoch'])) else: raise ValueError('The file to be resumed from is not exited', args.resume) # else: if not os.path.isdir(args.log): os.makedirs(args.log) log = open(os.path.join(args.log, 'log.txt'), 'w') state = {k: v for k, v in args._get_kwargs()} log.write(json.dumps(state) + '\n') log.close() cudnn.benchmark = True # process the data and prepare the dataloaders. train_loader, val_loader = generate_dataloader(args) #test only if args.test_only: validate(val_loader, model, criterion, -1, args) return for epoch in range(args.start_epoch, args.epochs): # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on the val data prec1 = validate(val_loader, model, criterion, epoch, args) # record the best prec1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) if is_best: log = open(os.path.join(args.log, 'log.txt'), 'a') log.write(' \nTop1 acc: %3f' % (best_prec1)) log.close() save_checkpoint( { 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best, args)
batch_num = args.hessian_batch_size // args.mini_hessian_batch_size if batch_num == 1: for inputs, labels in train_loader: hessian_dataloader = (inputs, labels) break else: hessian_dataloader = [] for i, (inputs, labels) in enumerate(train_loader): hessian_dataloader.append((inputs, labels)) if i == batch_num - 1: break # get model model = resnet(num_classes=10, depth=20, residual_not=args.residual, batch_norm_not=args.batch_norm) if args.cuda: model = model.cuda() model = torch.nn.DataParallel(model) criterion = nn.CrossEntropyLoss() # label loss ################### # Get model checkpoint, get saving folder ################### if args.resume == '': raise Exception("please choose the trained model") model.load_state_dict(torch.load(args.resume)) ######################################################
def main(): args = parse_args() img_path = args.img_path save_dir = args.save_dir args.classes = len(class_list) if not os.path.isdir(save_dir): os.mkdir(save_dir) if 'lite' in args.network: model = lite_faster_rcnn(args.classes) elif 'pva' in args.network: model = pva_net(args.classes) elif 'resnet' in args.network: model = resnet(args.classes, num_layers=101) checkpoint = torch.load(args.model) model.create_architecture() model.load_state_dict(checkpoint['state_dict']) model = model.cuda() model = torch.nn.DataParallel(model).cuda() model.eval() imgs = glob(os.path.join(args.img_path, "*.jpg")) print(args.img_path) batch_size = 1 std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32) mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32) std = torch.from_numpy(std).cuda() mean = torch.from_numpy(mean).cuda() for ix, img_name in enumerate(imgs): #print(ix, img_name) im = cv2.imread(img_name) name = os.path.basename(img_name) if im is None: continue import time #start_t = time.clock() if args.gama: im = adjust_gamma(im, 2.0) data = prepareTestData(640, im, 32, 1440) start_t = time.clock() results = im_detect(data, model, batch_size, std, mean, args.classes) end_t = time.clock() print(ix, img_name, ' time consume is: ', end_t - start_t) draw_img = im.copy() save_xml = False if save_xml: imgFolderPath = os.path.dirname(img_name) imgFolderName = os.path.split(imgFolderPath)[-1] imgFileName = os.path.basename(img_name) image = cv2.imread(img_name) imageShape = [image.shape[0], image.shape[1], image.shape[2]] writer = PascalVocWriter(imgFolderName, imgFileName, imageShape, localImgPath=img_name) writer.verified = False save_flag = 0 for boxes in results: for box in boxes: x1 = int(box[0]) y1 = int(box[1]) x2 = int(box[2]) y2 = int(box[3]) score = float(box[4]) label = int(box[5]) w = x2 - x1 h = y2 - y1 label_name = class_list[label] if label_name != 'HH': continue else: save_flag = 1 cv2.rectangle(draw_img, (x1, y1), (x2, y2), (label * 50, label * 100, label * 100), 1) cv2.putText(draw_img, label_name, (x1 + w // 2, y1 + h // 2), cv2.FONT_HERSHEY_COMPLEX, 1, (label * 50, label * 100, label * 100), 1) cv2.putText(draw_img, str(round(score, 3)), (x1 + w // 2 + 10, y1 + h // 2 + 10), cv2.FONT_HERSHEY_COMPLEX, 1, (label * 50, label * 100, label * 100), 1) #if save_xml: # if 'M' == label_name or 'SL' == label_name or 'HH' == label_name: # continue # difficult = 0 # writer.addBndBox(x1, y1, x2, y2, label_name, difficult) if save_xml: writer.save(targetFile='./outputs/' + name.replace('.jpg', '.xml')) if len(results) > 0 and save_flag: cv2.imwrite(save_dir + '/' + name, draw_img)