def __getitem__(self, index): if self.is_train: img, target = self.train_img[index], self.train_label[index] if len(img.shape) == 2: img = np.stack([img] * 3, 2) img = Image.fromarray(img, mode="RGB") img = transforms.Resize((256, 256), Image.BILINEAR)(img) img = transforms.RandomCrop(INPUT_SIZE)(img) img = transforms.RandomHorizontalFlip()(img) img = transforms.ToTensor()(img) img = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])(img) else: img, target = self.test_img[index], self.test_label[index] if len(img.shape) == 2: img = np.stack([img] * 3, 2) img = Image.fromarray(img, mode="RGB") img = transforms.Resize((256, 256), Image.BILINEAR)(img) img = transforms.CenterCrop(INPUT_SIZE)(img) img = transforms.ToTensor()(img) img = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])(img) return img, target
def load_data(args): normalize = t.Normalize(mean=[0.445, 0.287, 0.190], std=[0.31, 0.225, 0.168]) im_transform = t.Compose([t.ToTensor(), normalize]) # Use the following code fo co_transformations e.g. random rotation or random flip etc. # co_transformer = cot.Compose([cot.RandomRotate(45)]) dsetTrain = GIANA(args.imgdir, args.gtdir, input_size=(args.input_width, args.input_height), train=True, transform=im_transform, co_transform=None, target_transform=t.ToLabel()) train_data_loader = data.DataLoader(dsetTrain, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) dsetVal = GIANA(args.imgdir, args.gtdir, train=False, transform=im_transform, co_transform=None, target_transform=t.ToLabel()) val_data_loader = data.DataLoader(dsetVal, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers) return train_data_loader, val_data_loader
def __init__(self, cms, margin_size, margin_time): self.IMAGE_SCALE = 20 self.IMAGE_SIZE = self.IMAGE_SCALE * self.IMAGE_SCALE self.train_transform = transforms.Compose([ transforms.Resize((self.IMAGE_SCALE, self.IMAGE_SCALE)), transforms.ToTensor() ]) self.test_transform = transforms.Compose([ transforms.Resize((self.IMAGE_SCALE, self.IMAGE_SCALE)), transforms.ToTensor() ]) self.CMS = cms self.MARGIN_SIZE = margin_size self.MARGIN_TIME = margin_time
def get_transform(): transforms = [] transforms.append(custom_T.ToTensor()) transforms.append(custom_T.FasterRCNNResizer()) return custom_T.Compose(transforms)
def get_transform(train): transforms = [] # converts the image, a PIL image, into a PyTorch Tensor transforms.append(T.ToTensor()) if train: # during training, randomly flip the training images # and ground-truth for data augmentation transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
def get_transform(train=False): transforms = [] if train: transforms.append(custom_T.RandomHorizontalFlip()) transforms.append(custom_T.RandomCrop()) transforms.append(custom_T.ToTensor()) transforms.append(custom_T.FasterRCNNResizer()) return custom_T.Compose(transforms)
def __init__(self, root=None, dataloader=default_loader): self.transform1 = transforms.Compose([ transforms.RandomRotation(30), transforms.Resize([256, 256]), transforms.RandomCrop(INPUT_SIZE), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=(0.9, 1.1), contrast=(0.9, 1.1), saturation=(0.9, 1.1)), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), transforms.RandomErasing(probability=0.5, sh=0.05) ]) # 增强方法2: 关注更小的区域 self.transform2 = transforms.Compose([ transforms.RandomRotation(30), transforms.Resize([336, 336]), transforms.RandomCrop(INPUT_SIZE), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=(0.9, 1.1), contrast=(0.9, 1.1), saturation=(0.9, 1.1)), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), transforms.RandomErasing(probability=0.5, sh=0.05) ]) self.dataloader = dataloader self.root = root with open(os.path.join(self.root, TRAIN_DATASET), 'r') as fid: self.imglist = fid.readlines() self.labels = [] for line in self.imglist: image_path, label = line.strip().split() self.labels.append(int(label)) self.labels = np.array(self.labels) self.labels = torch.LongTensor(self.labels)
def visualization(x_train, y_train, x_val, y_val, x_test, y_test, nb_class, ckpt, opt): # no augmentations used for linear evaluation transform_lineval = transforms.Compose([transforms.ToTensor()]) train_set_lineval = UCR2018(data=x_train, targets=y_train, transform=transform_lineval) val_set_lineval = UCR2018(data=x_val, targets=y_val, transform=transform_lineval) test_set_lineval = UCR2018(data=x_test, targets=y_test, transform=transform_lineval) train_loader_lineval = torch.utils.data.DataLoader(train_set_lineval, batch_size=128, shuffle=True) val_loader_lineval = torch.utils.data.DataLoader(val_set_lineval, batch_size=128, shuffle=False) test_loader_lineval = torch.utils.data.DataLoader(test_set_lineval, batch_size=128, shuffle=False) signal_length = x_train.shape[1] # loading the saved backbone backbone_lineval = SimConv4().cuda() # defining a raw backbone model checkpoint = torch.load(ckpt, map_location='cpu') backbone_lineval.load_state_dict(checkpoint) print('Visualization') for epoch in range(opt.epochs_test): backbone_lineval.eval() embeds = None labels = None for i, (data, target) in enumerate(test_loader_lineval): data = data.cuda() target = target.cuda().view(-1, 1) output = backbone_lineval(data).detach() if embeds is None: embeds = output.cpu().numpy() labels = target.cpu().numpy() else: embeds = np.vstack([embeds, output.cpu().numpy()]) labels = np.vstack([labels, target.cpu().numpy()]) return embeds, labels
def pretrain_InterSampleRel(x_train, y_train, opt): K = opt.K batch_size = opt.batch_size # 128 has been used in the paper tot_epochs = opt.epochs # 400 has been used in the paper feature_size = opt.feature_size ckpt_dir = opt.ckpt_dir prob = 0.2 # Transform Probability raw = transforms.Raw() cutout = transforms.Cutout(sigma=0.1, p=prob) jitter = transforms.Jitter(sigma=0.2, p=prob) scaling = transforms.Scaling(sigma=0.4, p=prob) magnitude_warp = transforms.MagnitudeWrap(sigma=0.3, knot=4, p=prob) time_warp = transforms.TimeWarp(sigma=0.2, knot=8, p=prob) window_slice = transforms.WindowSlice(reduce_ratio=0.8, p=prob) window_warp = transforms.WindowWarp(window_ratio=0.3, scales=(0.5, 2), p=prob) transforms_list = {'jitter': [jitter], 'cutout': [cutout], 'scaling': [scaling], 'magnitude_warp': [magnitude_warp], 'time_warp': [time_warp], 'window_slice': [window_slice], 'window_warp': [window_warp], 'G0': [jitter, magnitude_warp, window_slice], 'G1': [jitter, time_warp, window_slice], 'G2': [jitter, time_warp, window_slice, window_warp, cutout], 'none': [raw]} transforms_targets = list() for name in opt.aug_type: for item in transforms_list[name]: transforms_targets.append(item) train_transform = transforms.Compose(transforms_targets + [transforms.ToTensor()]) backbone = SimConv4().cuda() model = RelationalReasoning(backbone, feature_size).cuda() train_set = MultiUCR2018(data=x_train, targets=y_train, K=K, transform=train_transform) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) torch.save(model.backbone.state_dict(), '{}/backbone_init.tar'.format(ckpt_dir)) acc_max, epoch_max = model.train(tot_epochs=tot_epochs, train_loader=train_loader, opt=opt) torch.save(model.backbone.state_dict(), '{}/backbone_last.tar'.format(ckpt_dir)) return acc_max, epoch_max
def eval(args, model): if not os.path.exists(args.savedir): os.makedirs(args.savedir) listImgFiles = [ k.split('/')[-1].split('.')[0] for k in glob.glob(os.path.join(args.imgdir, '*.bmp')) ] for currFile in tqdm(listImgFiles): img = Image.open(os.path.join(args.imgdir, currFile + '.bmp')) img = t.ToTensor()(img) if args.cuda: img.cuda() output = model(Variable(img, volatile=True).unsqueeze(0)) output = t.ToPILImage()(output[0].cpu().data) newfilename = os.path.join(args.savedir, currFile + '_' + args.model + '.bmp') output.save(newfilename, 'BMP')
def get_dataloader(): # TODO(xwd): Adaptive normalization by some large image. # E.g. In medical image processing, WSI image is very large and different to ordinary images. value_scale = 255 mean = [0.485, 0.456, 0.406] mean = [item * value_scale for item in mean] std = [0.229, 0.224, 0.225] std = [item * value_scale for item in std] train_transform = transform.Compose([ transform.RandomScale([cfg['scale_min'], cfg['scale_max']]), transform.RandomRotate([cfg['rotate_min'], cfg['rotate_max']], padding=mean, ignore_label=cfg['ignore_label']), transform.RandomGaussianBlur(), transform.RandomHorizontallyFlip(), transform.RandomCrop([cfg['train_h'], cfg['train_w']], crop_type='rand', padding=mean, ignore_label=cfg['ignore_label']), transform.ToTensor(), transform.Normalize(mean=mean, std=std) ]) train_data = cityscapes.Cityscapes(cfg['data_path'], split='train', transform=train_transform) # Use data sampler to make sure each GPU loads specific parts of dataset to avoid data reduntant. train_sampler = DistributedSampler(train_data) train_loader = DataLoader(train_data, batch_size=cfg['batch_size'] // cfg['world_size'], shuffle=(train_sampler is None), num_workers=4, pin_memory=True, sampler=train_sampler, drop_last=True) return train_loader, train_sampler
def get_transform(train=False, yolo=False, aug=None): assert aug == 'dirty_camera_lens' or aug == 'gan' or aug is None, "Aug parameter not valid" transforms = [] if yolo: transforms.append(custom_T.PadToSquare()) transforms.append(custom_T.Resize(img_size=None)) if train: transforms.append(custom_T.RandomHorizontalFlip()) transforms.append(custom_T.RandomCrop()) if aug == 'dirty_camera_lens': print("Augmentation: Dirty Camera Lens") transforms.append(custom_T.DirtyCameraLens()) transforms.append(custom_T.ToTensor()) # transforms.append(custom_T.FasterRCNNResizer()) return custom_T.Compose(transforms)
def __init__(self, root=None, dataloader=default_loader): self.transform = transforms.Compose([ transforms.Resize([256, 256]), transforms.RandomCrop(INPUT_SIZE), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ]) self.dataloader = dataloader self.root = root self.imgs = [] self.labels = [] with open(os.path.join(self.root, EVAL_DATASET), 'r') as fid: for line in fid.readlines(): img_path, label = line.strip().split() img = self.dataloader(img_path) label = int(label) self.imgs.append(img) self.labels.append(label)
def deploy(path): assert os.path.exists(path), f'{path} not found : (' dataset = 'YOUR_DATASET_NAME' img_size = 256 test_transform = transforms.Compose([ transforms.Resize((img_size, img_size)), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) testA = ImageFolder(os.path.join('dataset', dataset, 'testA'), test_transform) with fluid.dygraph.guard(): testA_loader = DataLoader(testA, batch_size=1, shuffle=False) real_A, _ = next(iter(testA_loader)) in_np = real_A.numpy() # load model place = fluid.CPUPlace() exe = fluid.Executor(place) program, feed_vars, fetch_vars = fluid.io.load_inference_model(path, exe) # inference fetch, = exe.run(program, feed={feed_vars[0]: in_np}, fetch_list=fetch_vars) def img_postprocess(img): assert isinstance(img, np.ndarray), type(img) img = img * 0.5 + 0.5 img = img.squeeze(0).transpose((1, 2, 0)) # BGR to RGB img = img[:, :, ::-1] return img in_img = img_postprocess(in_np) out_img = img_postprocess(fetch) plt.subplot(121) plt.title('real A') plt.imshow(in_img) plt.subplot(122) plt.title('A to B') plt.imshow(out_img) plt.show()
def main(): net = AFENet(classes=21, pretrained_model_path=None).cuda() net.load_state_dict(torch.load(os.path.join(args['model_save_path'], args['snapshot']))) value_scale = 255 mean = [0.485, 0.456, 0.406] mean = [item * value_scale for item in mean] std = [0.229, 0.224, 0.225] std = [item * value_scale for item in std] test_transform = transform.Compose([transform.ToTensor()]) test_data = voc2012.VOC2012(split='test', data_root=args['dataset_root'], data_list=args['test_list'], transform=test_transform) test_loader = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=1) gray_folder = os.path.join(args['test_result_save_path']) # gray_folder = os.path.join(args['test_result_save_path'], 'gray') color_folder = os.path.join(args['test_result_save_path'], 'color') colors = np.loadtxt(args['colors_path']).astype('uint8') test(test_loader, test_data.data_list, net, 21, mean, std, 512, 480, 480, args['scales'], gray_folder, color_folder, colors)
def main(args=None): torch.manual_seed(args.seed) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices # torch.cuda.set_device(0) use_gpu = torch.cuda.is_available() if args.use_cpu: use_gpu = False if not args.evaluate: sys.stdout = Logger(osp.join(args.save_dir, args.log_train)) else: sys.stdout = Logger(osp.join(args.save_dir, args.log_test)) print("==========\nArgs:{}\n==========".format(args)) if use_gpu: print("Currently using GPU {}".format(args.gpu_devices)) cudnn.benchmark = True torch.cuda.manual_seed_all(args.seed) else: print("Currently using CPU (GPU is highly recommended)") print("Initializing dataset {}".format(args.dataset)) dataset = data_manager.init_dataset(name=args.dataset) transform_train = T.Compose([ T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), T.RandomErasing(), ]) transform_train2 = T.Compose([ T.Resize((args.height, args.width)), T.Random2DTranslation(args.height, args.width), ]) transform_test = T.Compose([ T.Resize((args.height, args.width)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pin_memory = False trainloader = DataLoader( VideoDataset(dataset.train, data_name=args.dataset, seq_len=args.seq_len, sample='random', transform=transform_train, transform2=transform_train2, type="train"), sampler=RandomIdentitySampler(dataset.train, num_instances=args.num_instances), batch_size=args.train_batch, num_workers=args.workers, pin_memory=pin_memory, drop_last=True, ) queryloader = DataLoader( VideoDataset(dataset.query, data_name=args.dataset, seq_len=args.seq_len, sample='dense', transform=transform_test, type="test"), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) galleryloader = DataLoader( VideoDataset(dataset.gallery, data_name=args.dataset, seq_len=args.seq_len, sample='dense', transform=transform_test, type="test"), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) print("Initializing models: {}".format(args.arch)) model = models.init_model(name=args.arch, num_classes=dataset.num_train_pids, final_dim=args.feat_dim) print("Model size: {:.5f}M".format( sum(p.numel() for p in model.parameters()) / 1000000.0)) crossEntropyLoss = CrossEntropyLabelSmooth( num_classes=dataset.num_train_pids, use_gpu=use_gpu) tripletLoss = TripletLoss(margin=args.margin) regularLoss = RegularLoss(use_gpu=use_gpu) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) scheduler = WarmupMultiStepLR(optimizer, args.stepsize, args.gamma, args.warmup_factor, args.warmup_items, args.warmup_method) start_epoch = args.start_epoch if use_gpu: model = nn.DataParallel(model).cuda() if args.evaluate: print("Evaluate only") atest(model, queryloader, galleryloader, use_gpu) return start_time = time.time() best_rank1 = -np.inf for epoch in range(start_epoch, args.max_epoch): print("==> Epoch {}/{}".format(epoch + 1, args.max_epoch)) train(model, crossEntropyLoss, tripletLoss, regularLoss, optimizer, trainloader, use_gpu) # if args.stepsize > 0: scheduler.step() if (epoch + 1) >= 200 and (epoch + 1) % args.eval_step == 0: print("==> Test") rank1 = atest(model, queryloader, galleryloader, use_gpu) is_best = rank1 > best_rank1 if is_best: best_rank1 = rank1 if use_gpu: state_dict = model.module.state_dict() else: state_dict = model.state_dict() save_checkpoint({ 'state_dict': state_dict, }, is_best, osp.join( args.save_dir, args.model_name + str(epoch + 1) + '.pth.tar')) elapsed = round(time.time() - start_time) elapsed = str(datetime.timedelta(seconds=elapsed)) print("Finished. Total elapsed time (h:m:s): {}".format(elapsed))
def main(args=None): torch.manual_seed(args.seed) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices # torch.cuda.set_device(0) use_gpu = torch.cuda.is_available() if args.use_cpu: use_gpu = False if not args.evaluate: sys.stdout = Logger(osp.join(args.save_dir, args.log_train)) else: sys.stdout = Logger(osp.join(args.save_dir, args.log_test)) print("==========\nArgs:{}\n==========".format(args)) if use_gpu: print("Currently using GPU {}".format(args.gpu_devices)) cudnn.benchmark = True torch.cuda.manual_seed_all(args.seed) else: print("Currently using CPU (GPU is highly recommended)") print("Initializing dataset {}".format(args.dataset)) dataset = data_manager.init_dataset(name=args.dataset) transform_test = T.Compose([ T.Resize((args.height, args.width)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pin_memory = False queryloader = DataLoader( VideoDataset(dataset.query, data_name=args.dataset, seq_len=args.seq_len, sample='dense', transform=transform_test, type="test"), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) galleryloader = DataLoader( VideoDataset(dataset.gallery, data_name=args.dataset, seq_len=args.seq_len, sample='dense', transform=transform_test, type="test"), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) print("Initializing models: {}".format(args.arch)) model = models.init_model(name=args.arch, num_classes=dataset.num_train_pids, final_dim=args.feat_dim) print("Model size: {:.5f}M".format( sum(p.numel() for p in model.parameters()) / 1000000.0)) checkpoint = torch.load(args.model_path) model.load_state_dict(checkpoint['state_dict']) if use_gpu: model = nn.DataParallel(model).cuda() if args.evaluate: print("Evaluate only") atest(model, queryloader, galleryloader, use_gpu) return
def main(): net = AFENet(classes=21, pretrained_model_path=args['pretrained_model_path']).cuda() net_ori = [net.layer0, net.layer1, net.layer2, net.layer3, net.layer4] net_new = [ net.ppm, net.cls, net.aux, net.ppm_reduce, net.aff1, net.aff2, net.aff3 ] value_scale = 255 mean = [0.485, 0.456, 0.406] mean = [item * value_scale for item in mean] std = [0.229, 0.224, 0.225] std = [item * value_scale for item in std] train_transform = transform.Compose([ transform.RandScale([0.75, 2.0]), transform.RandomHorizontalFlip(), transform.Crop([480, 480], crop_type='rand', padding=mean, ignore_label=255), transform.ToTensor(), transform.Normalize(mean=mean, std=std) ]) train_data = voc2012.VOC2012(split='train', data_root=args['dataset_root'], data_list=args['train_list'], transform=train_transform) train_loader = DataLoader(train_data, batch_size=args['train_batch_size'], shuffle=True, num_workers=8, drop_last=True) val_transform = transform.Compose([ transform.Crop([480, 480], crop_type='center', padding=mean, ignore_label=255), transform.ToTensor(), transform.Normalize(mean=mean, std=std) ]) val_data = voc2012.VOC2012(split='val', data_root=args['dataset_root'], data_list=args['val_list'], transform=val_transform) val_loader = DataLoader(val_data, batch_size=args['val_batch_size'], shuffle=False, num_workers=8) if len(args['snapshot']) == 0: curr_epoch = 1 args['best_record'] = { 'epoch': 0, 'val_loss': 1e10, 'acc': 0, 'acc_cls': 0, 'mean_iu': 0, 'fwavacc': 0 } else: print('training resumes from ' + args['snapshot']) net.load_state_dict( torch.load(os.path.join(args['model_save_path'], args['snapshot']))) split_snapshot = args['snapshot'].split('_') curr_epoch = int(split_snapshot[1]) + 1 args['best_record'] = { 'epoch': int(split_snapshot[1]), 'val_loss': float(split_snapshot[3]), 'acc': float(split_snapshot[5]), 'acc_cls': float(split_snapshot[7]), 'mean_iu': float(split_snapshot[9]), 'fwavacc': float(split_snapshot[11]) } params_list = [] for module in net_ori: params_list.append(dict(params=module.parameters(), lr=args['lr'])) for module in net_new: params_list.append(dict(params=module.parameters(), lr=args['lr'] * 10)) args['index_split'] = 5 criterion = torch.nn.CrossEntropyLoss(ignore_index=255) optimizer = torch.optim.SGD(params_list, lr=args['lr'], momentum=args['momentum'], weight_decay=args['weight_decay']) if len(args['snapshot']) > 0: optimizer.load_state_dict( torch.load( os.path.join(args['model_save_path'], 'opt_' + args['snapshot']))) check_makedirs(args['model_save_path']) all_iter = args['epoch_num'] * len(train_loader) for epoch in range(curr_epoch, args['epoch_num'] + 1): train(train_loader, net, optimizer, epoch, all_iter) validate(val_loader, net, criterion, optimizer, epoch)
def get_transform(train=False): transform = [] transform.append(transforms.ToTensor()) if train: transform.append(transforms.RandomHorizontalFlip(0.5)) return transforms.Compose(transform)
def get_transform(train): transforms = [] transforms.append(T.ToTensor()) if train: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
def build_model(self): """ DataLoader """ pad = int(30 * self.img_size // 256) train_transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.Resize((self.img_size + pad, self.img_size + pad)), transforms.RandomCrop(self.img_size), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) test_transform = transforms.Compose([ transforms.Resize((self.img_size, self.img_size)), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) self.trainA = ImageFolder( os.path.join('dataset', self.dataset, 'trainA'), train_transform) self.trainB = ImageFolder( os.path.join('dataset', self.dataset, 'trainB'), train_transform) self.testA = ImageFolder( os.path.join('dataset', self.dataset, 'testA'), test_transform) self.testB = ImageFolder( os.path.join('dataset', self.dataset, 'testB'), test_transform) self.trainA_loader = DataLoader(self.trainA, batch_size=self.batch_size, shuffle=True) self.trainB_loader = DataLoader(self.trainB, batch_size=self.batch_size, shuffle=True) self.testA_loader = DataLoader(self.testA, batch_size=1, shuffle=False) self.testB_loader = DataLoader(self.testB, batch_size=1, shuffle=False) """ Define Generator, Discriminator """ self.genA2B = ResnetGenerator(input_nc=3, output_nc=3, ngf=self.ch, n_blocks=self.n_res, img_size=self.img_size, light=self.light) self.genB2A = ResnetGenerator(input_nc=3, output_nc=3, ngf=self.ch, n_blocks=self.n_res, img_size=self.img_size, light=self.light) self.disGA = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disGB = Discriminator(input_nc=3, ndf=self.ch, n_layers=7) self.disLA = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) self.disLB = Discriminator(input_nc=3, ndf=self.ch, n_layers=5) """ Define Loss """ self.L1_loss = loss.L1Loss() self.MSE_loss = loss.MSELoss() self.BCE_loss = loss.BCEWithLogitsLoss() """ Trainer """ def get_params(block): out = [] for name, param in block.named_parameters(): if 'instancenorm' in name or 'weight_u' in name or 'weight_v' in name: continue out.append(param) return out genA2B_parameters = get_params(self.genA2B) genB2A_parameters = get_params(self.genB2A) disGA_parameters = get_params(self.disGA) disGB_parameters = get_params(self.disGB) disLA_parameters = get_params(self.disLA) disLB_parameters = get_params(self.disLB) G_parameters = genA2B_parameters + genB2A_parameters D_parameters = disGA_parameters + disGB_parameters + disLA_parameters + disLB_parameters self.G_optim = fluid.optimizer.Adam( parameter_list=G_parameters, learning_rate=self.lr, beta1=0.5, beta2=0.999, regularization=fluid.regularizer.L2Decay(self.weight_decay)) self.D_optim = fluid.optimizer.Adam( parameter_list=D_parameters, learning_rate=self.lr, beta1=0.5, beta2=0.999, regularization=fluid.regularizer.L2Decay(self.weight_decay)) """ Define Rho clipper to constraint the value of rho in AdaILN and ILN"""
def evaluation(x_train, y_train, x_val, y_val, x_test, y_test, nb_class, ckpt, opt, ckpt_tosave=None): # no augmentations used for linear evaluation transform_lineval = transforms.Compose([transforms.ToTensor()]) train_set_lineval = UCR2018(data=x_train, targets=y_train, transform=transform_lineval) val_set_lineval = UCR2018(data=x_val, targets=y_val, transform=transform_lineval) test_set_lineval = UCR2018(data=x_test, targets=y_test, transform=transform_lineval) train_loader_lineval = torch.utils.data.DataLoader(train_set_lineval, batch_size=128, shuffle=True) val_loader_lineval = torch.utils.data.DataLoader(val_set_lineval, batch_size=128, shuffle=False) test_loader_lineval = torch.utils.data.DataLoader(test_set_lineval, batch_size=128, shuffle=False) signal_length = x_train.shape[1] # loading the saved backbone backbone_lineval = SimConv4().cuda() # defining a raw backbone model # backbone_lineval = OS_CNN(signal_length).cuda() # defining a raw backbone model # 64 are the number of output features in the backbone, and 10 the number of classes linear_layer = torch.nn.Linear(opt.feature_size, nb_class).cuda() # linear_layer = torch.nn.Linear(backbone_lineval.rep_dim, nb_class).cuda() checkpoint = torch.load(ckpt, map_location='cpu') backbone_lineval.load_state_dict(checkpoint) if ckpt_tosave: torch.save(backbone_lineval.state_dict(), ckpt_tosave) optimizer = torch.optim.Adam(linear_layer.parameters(), lr=opt.learning_rate_test) CE = torch.nn.CrossEntropyLoss() early_stopping = EarlyStopping(opt.patience_test, verbose=True) best_acc = 0 best_epoch = 0 print('Linear evaluation') for epoch in range(opt.epochs_test): linear_layer.train() backbone_lineval.eval() acc_trains = list() for i, (data, target) in enumerate(train_loader_lineval): optimizer.zero_grad() data = data.cuda() target = target.cuda() output = backbone_lineval(data).detach() output = linear_layer(output) loss = CE(output, target) loss.backward() optimizer.step() # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_trains.append(accuracy.item()) print('[Train-{}][{}] loss: {:.5f}; \t Acc: {:.2f}%' \ .format(epoch + 1, opt.model_name, loss.item(), sum(acc_trains) / len(acc_trains))) acc_vals = list() acc_tests = list() linear_layer.eval() with torch.no_grad(): for i, (data, target) in enumerate(val_loader_lineval): data = data.cuda() target = target.cuda() output = backbone_lineval(data).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_vals.append(accuracy.item()) val_acc = sum(acc_vals) / len(acc_vals) if val_acc > best_acc: best_acc = val_acc best_epoch = epoch for i, (data, target) in enumerate(test_loader_lineval): data = data.cuda() target = target.cuda() output = backbone_lineval(data).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_tests.append(accuracy.item()) test_acc = sum(acc_tests) / len(acc_tests) print('[Test-{}] Val ACC:{:.2f}%, Best Test ACC.: {:.2f}% in Epoch {}'. format(epoch, val_acc, test_acc, best_epoch)) early_stopping(val_acc, None) if early_stopping.early_stop: print("Early stopping") break return test_acc, best_epoch
#dataset prepare #--------------------------------- print('Loading dataset...') cache_size = 256 if args.image_size == 448: cache_size = 256 * 2 if args.image_size == 352: cache_size = 402 transform_train = transforms.Compose([ transforms.Resize((cache_size,cache_size)), #transforms.Resize((args.image_size,args.image_size)), #transforms.RandomRotation(10), transforms.RandomCrop(args.image_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485,0.456,0.406], [0.229,0.224,0.225]), ]) transform_test = transforms.Compose([ transforms.Resize((cache_size,cache_size)), transforms.CenterCrop(args.image_size), transforms.ToTensor(), transforms.Normalize([0.485,0.456,0.406], [0.229,0.224,0.225]), ]) print("Dataset Initializing...") trainset = SRDataset.SRDataset(max_person=args.max_person,image_dir=args.images_root, \ images_list=args.train_file_pre + '_images.txt',bboxes_list=args.train_file_pre + '_bbox.json', \ relations_list=args.train_file_pre + '_relation.json', image_size=args.image_size,input_transform=transform_train)
def main(): torch.manual_seed(args.seed) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices use_gpu = torch.cuda.is_available() if args.use_cpu: use_gpu = False if not args.evaluate: sys.stdout = Logger(osp.join(args.save_dir, 'log_train.txt')) else: sys.stdout = Logger(osp.join(args.save_dir, 'log_test.txt')) print("==========\nArgs:{}\n==========".format(args)) if use_gpu: print("Currently using GPU {}".format(args.gpu_devices)) cudnn.benchmark = True torch.cuda.manual_seed_all(args.seed) else: print("Currently using CPU (GPU is highly recommended)") print("Initializing dataset {}".format(args.dataset)) dataset = data_manager.init_imgreid_dataset( root=args.root, name=args.dataset, ) transform_train = T.Compose([ T.Random2DTranslation(args.height, args.width), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = T.Compose([ T.Resize((args.height, args.width)), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pin_memory = True if use_gpu else False trainloader = DataLoader( ImageDataset(dataset.train, transform=transform_train), sampler=RandomIdentitySampler(dataset.train, num_instances=args.num_instances), batch_size=args.train_batch, num_workers=args.workers, pin_memory=pin_memory, drop_last=True, ) queryloader = DataLoader( ImageDataset(dataset.test_3000_query, transform=transform_test), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) galleryloader = DataLoader( ImageDataset(dataset.test_3000_gallery, transform=transform_test), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) print("Initializing model: {}".format(args.arch)) model = models.init_model(name=args.arch, num_classes=dataset.train_vehicle_nums, loss={'xent', 'htri'}) print("Model size: {:.3f} M".format(sum(p.numel() for p in model.parameters()) / 1000000.0)) modelid = 0 if args.upload: modelid = upload_data.updatemodel(args.arch, args.lr, args.stepsize, args.gamma, args.loss, args.dataset, args.height, args.width, args.seq_len, args.train_batch, args.other) # criterion_xent = CrossEntropyLabelSmooth(num_classes=dataset.train_vehicle_nums, use_gpu=use_gpu) criterion_xent = nn.CrossEntropyLoss() criterion_htri = TripletLoss(margin=args.margin) optimizer = init_optim(args.optim, model.parameters(), args.lr, args.weight_decay) scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=args.stepsize, gamma=args.gamma) start_epoch = args.start_epoch if args.load_weights: # load pretrained weights but ignore layers that don't match in size print("Loading pretrained weights from '{}'".format(args.load_weights)) checkpoint = torch.load(args.load_weights) pretrain_dict = checkpoint['state_dict'] model_dict = model.state_dict() pretrain_dict = {k: v for k, v in pretrain_dict.items() if k in model_dict and model_dict[k].size() == v.size()} model_dict.update(pretrain_dict) model.load_state_dict(model_dict) if args.resume: checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] rank1 = checkpoint['rank1'] print("Loaded checkpoint from '{}'".format(args.resume)) print("- start_epoch: {}\n- rank1: {}".format(start_epoch, rank1)) if use_gpu: model = nn.DataParallel(model).cuda() if args.evaluate: print("Evaluate only") test(model, queryloader, galleryloader, use_gpu, return_distmat=True) return start_time = time.time() train_time = 0 best_rank1 = -np.inf best_epoch = 0 print("==> Start training") for epoch in range(start_epoch, args.max_epoch): start_train_time = time.time() train(modelid, epoch, model, criterion_xent, criterion_htri, optimizer, trainloader, use_gpu) train_time += round(time.time() - start_train_time) scheduler.step() if (epoch + 1) > args.start_eval and args.eval_step > 0 and (epoch + 1) % args.eval_step == 0 or ( epoch + 1) == args.max_epoch: print("==> Test") cmc, mAP = test(model, queryloader, galleryloader, use_gpu) rank1 = cmc[0] is_best = rank1 > best_rank1 if is_best: best_rank1 = rank1 best_epoch = epoch + 1 if use_gpu: state_dict = model.module.state_dict() else: state_dict = model.state_dict() save_checkpoint({ 'state_dict': state_dict, 'rank1': rank1, 'epoch': epoch, }, is_best, osp.join(args.save_dir, 'checkpoint_ep' + str(epoch + 1) + '.pth.tar')) if args.upload: upload_data.updatetest(modelid, epoch + 1, mAP.item(), cmc[0].item(), cmc[4].item(), cmc[9].item(), cmc[19].item()) upload_data.updaterank(modelid, best_rank1.item()) print("==> Best Rank-1 {:.1%}, achieved at epoch {}".format(best_rank1, best_epoch)) elapsed = round(time.time() - start_time) elapsed = str(datetime.timedelta(seconds=elapsed)) train_time = str(datetime.timedelta(seconds=train_time)) print("Finished. Total elapsed time (h:m:s): {}. Training time (h:m:s): {}.".format(elapsed, train_time))
def main(): # Initialize arguments args = init_arguments() # Initialize random init_seed(args.seed) # Initialize the model model, parameters, losses, accuracy_dict, accuracies, start_epoch = init_model( args) IMAGE_SCALE = 20 transform = transforms.Compose( [transforms.Resize((IMAGE_SCALE, IMAGE_SCALE)), transforms.ToTensor()]) omniglot_loader = loader.OmniglotLoader('data/omniglot', classify=False, partition=0.8, classes=True) train_loader = torch.utils.data.DataLoader( OMNIGLOT('data/omniglot', train=True, transform=transform, download=True, omniglot_loader=omniglot_loader, batch_size=parameters.episode_length), batch_size=parameters.batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(OMNIGLOT( 'data/omniglot', train=False, transform=transform, download=False, omniglot_loader=omniglot_loader, batch_size=parameters.episode_length), batch_size=parameters.batch_size, shuffle=False) criterion = nn.CrossEntropyLoss(reduce=False) optimizer = optim.Adam(model.parameters()) init_logging() accuracy_dict, losses, accuracies = train_model(model, parameters, train_loader, criterion, optimizer, args, accuracy_dict, losses, accuracies, start_epoch) loss_plot.plot([accuracies], ["Training Accuracy Percentage"], "training_stats", args.name + "/", "Percentage") loss_plot.plot([losses], ["Training Loss"], "training_loss", args.name + "/", "Average Loss") predictions, labels = evaluate(model, test_loader, criterion, parameters, args, 10) matrix_plot.plot_matrix(predictions, labels, args.name + "/", title="matrix_plot_test") scatterplot.plot(accuracy_dict, args.name + "/", parameters.batch_size, title="Prediction Accuracy after Testing")
import matplotlib.pyplot as plt from tools import prediction from utils.metrics import Evaluator args = get_args() rng = np.random.RandomState(seed=args.seed) torch.manual_seed(seed=args.seed) transform_train = trans.Compose([ trans.RandomHorizontalFlip(), #trans.FixScale((args.crop_size,args.crop_size)), trans.RandomScale((0.5, 2.0)), #trans.FixScale(args.crop_size), trans.RandomCrop(args.crop_size), trans.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), trans.ToTensor(), ]) transform_val = trans.Compose([ #trans.FixScale((args.crop_size,args.crop_size)), trans.FixScale(args.crop_size), trans.CenterCrop(args.crop_size), trans.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), trans.ToTensor(), ]) if (args.aug == True): voc_train = VOCSegmentation(root='./data', set_name='train', transform=transform_train) else: voc_train = VOCSegmentation(root='./data',
def get_data(data_dir, source, target, source_train_path, target_train_path, source_extension, target_extension, height, width, batch_size, re=0, workers=8): dataset = DA(data_dir, source, target, source_train_path, target_train_path, source_extension, target_extension) normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) source_num_classes = dataset.num_source_train_ids train_transformer = T.Compose([ T.RandomSizedRectCrop(height, width), T.RandomHorizontalFlip(), T.ToTensor(), normalizer, T.RandomErasing(EPSILON=re), ]) test_transformer = T.Compose([ T.Resize((height, width), interpolation=3), T.ToTensor(), normalizer, ]) source_train_loader = DataLoader(Preprocessor( dataset.source_train, root=osp.join(dataset.source_images_dir, dataset.source_train_path), transform=train_transformer), batch_size=batch_size, num_workers=0, shuffle=True, pin_memory=False, drop_last=True) target_train_loader = DataLoader(Preprocessor( dataset.target_train, root=osp.join(dataset.target_images_dir, dataset.target_train_path), transform=train_transformer), batch_size=batch_size, num_workers=0, shuffle=True, pin_memory=False, drop_last=True) # source_train_loader = DataLoader( # UnsupervisedCamStylePreprocessor(dataset.source_train, root=osp.join(dataset.source_images_dir, dataset.source_train_path), # camstyle_root=osp.join(dataset.source_images_dir, dataset.source_train_path), # transform=train_transformer), # batch_size=batch_size, num_workers=0, # shuffle=True, pin_memory=False, drop_last=True) # target_train_loader = DataLoader( # UnsupervisedCamStylePreprocessor(dataset.target_train, # root=osp.join(dataset.target_images_dir, dataset.target_train_path), # camstyle_root=osp.join(dataset.target_images_dir, # dataset.target_train_camstyle_path), # num_cam=dataset.target_num_cam, transform=train_transformer), # batch_size=batch_size, num_workers=workers, # shuffle=True, pin_memory=True, drop_last=True) query_loader = DataLoader(Preprocessor(dataset.query, root=osp.join( dataset.target_images_dir, dataset.query_path), transform=test_transformer), batch_size=batch_size, num_workers=workers, shuffle=False, pin_memory=True) gallery_loader = DataLoader(Preprocessor(dataset.gallery, root=osp.join( dataset.target_images_dir, dataset.gallery_path), transform=test_transformer), batch_size=batch_size, num_workers=workers, shuffle=False, pin_memory=True) return dataset, source_num_classes, source_train_loader, target_train_loader, query_loader, gallery_loader
def semisupervised_train(x_train, y_train, x_val, y_val, x_test, y_test, opt): # construct data loader # Those are the transformations used in the paper prob = 0.2 # Transform Probability cutout = transforms_ts.Cutout(sigma=0.1, p=prob) jitter = transforms_ts.Jitter(sigma=0.2, p=prob) # CIFAR10 scaling = transforms_ts.Scaling(sigma=0.4, p=prob) magnitude_warp = transforms_ts.MagnitudeWrap(sigma=0.3, knot=4, p=prob) time_warp = transforms_ts.TimeWarp(sigma=0.2, knot=8, p=prob) window_slice = transforms_ts.WindowSlice(reduce_ratio=0.8, p=prob) window_warp = transforms_ts.WindowWarp(window_ratio=0.3, scales=(0.5, 2), p=prob) transforms_list = { 'jitter': [jitter], 'cutout': [cutout], 'scaling': [scaling], 'magnitude_warp': [magnitude_warp], 'time_warp': [time_warp], 'window_slice': [window_slice], 'window_warp': [window_warp], 'G0': [jitter, magnitude_warp, window_slice], 'G1': [jitter, time_warp, window_slice], 'G2': [jitter, time_warp, window_slice, window_warp, cutout], 'none': [] } transforms_targets = list() for name in opt.aug_type: for item in transforms_list[name]: transforms_targets.append(item) if '2C' in opt.class_type: cut_piece = transforms.CutPiece2C(sigma=opt.piece_size) temp_class = 2 elif '3C' in opt.class_type: cut_piece = transforms.CutPiece3C(sigma=opt.piece_size) temp_class = 3 elif '4C' in opt.class_type: cut_piece = transforms.CutPiece4C(sigma=opt.piece_size) temp_class = 4 elif '5C' in opt.class_type: cut_piece = transforms.CutPiece5C(sigma=opt.piece_size) temp_class = 5 elif '6C' in opt.class_type: cut_piece = transforms.CutPiece6C(sigma=opt.piece_size) temp_class = 6 elif '7C' in opt.class_type: cut_piece = transforms.CutPiece7C(sigma=opt.piece_size) temp_class = 7 elif '8C' in opt.class_type: cut_piece = transforms.CutPiece8C(sigma=opt.piece_size) temp_class = 8 tensor_transform = transforms.ToTensor() train_transform_peice = transforms.Compose(transforms_targets) train_transform = transforms_ts.Compose(transforms_targets + [transforms_ts.ToTensor()]) transform_eval = transforms.Compose([transforms.ToTensor()]) train_set_labeled = UCR2018(data=x_train, targets=y_train, transform=train_transform) train_set_unlabeled = MultiUCR2018_Intra( data=x_train, targets=y_train, K=opt.K, transform=train_transform_peice, transform_cut=cut_piece, totensor_transform=tensor_transform) val_set = UCR2018(data=x_val, targets=y_val, transform=transform_eval) test_set = UCR2018(data=x_test, targets=y_test, transform=transform_eval) train_dataset_size = len(train_set_labeled) partial_size = int(opt.label_ratio * train_dataset_size) train_ids = list(range(train_dataset_size)) np.random.shuffle(train_ids) train_sampler = SubsetRandomSampler(train_ids[:partial_size]) trainloader_label = torch.utils.data.DataLoader(train_set_labeled, batch_size=128, sampler=train_sampler) trainloader_unlabel = torch.utils.data.DataLoader(train_set_unlabeled, batch_size=128) val_loader_lineval = torch.utils.data.DataLoader(val_set, batch_size=128, shuffle=False) test_loader_lineval = torch.utils.data.DataLoader(test_set, batch_size=128, shuffle=False) # loading the saved backbone backbone = SimConv4().cuda() # defining a raw backbone model # 64 are the number of output features in the backbone, and 10 the number of classes linear_layer = torch.nn.Linear(opt.feature_size, opt.nb_class).cuda() # linear_layer = torch.nn.Sequential( # torch.nn.Linear(opt.feature_size, 256), # torch.nn.BatchNorm1d(256), # torch.nn.LeakyReLU(), # torch.nn.Linear(256, nb_class), # torch.nn.Softmax(), # ).cuda() cls_head = torch.nn.Sequential( torch.nn.Linear(opt.feature_size * 2, 256), torch.nn.BatchNorm1d(256), torch.nn.LeakyReLU(), torch.nn.Linear(256, temp_class), torch.nn.Softmax(), ).cuda() optimizer = torch.optim.Adam([{ 'params': backbone.parameters() }, { 'params': linear_layer.parameters() }, { 'params': cls_head.parameters() }], lr=opt.learning_rate) CE = torch.nn.CrossEntropyLoss() early_stopping = EarlyStopping( opt.patience, verbose=True, checkpoint_pth='{}/backbone_best.tar'.format(opt.ckpt_dir)) torch.save(backbone.state_dict(), '{}/backbone_init.tar'.format(opt.ckpt_dir)) best_acc = 0 best_epoch = 0 acc_epoch_cls = 0 print('Semi-supervised Train') for epoch in range(opt.epochs): backbone.train() linear_layer.train() cls_head.train() acc_epoch = 0 acc_epoch_cls = 0 loss_epoch_label = 0 loss_epoch_unlabel = 0 loss = 0 for i, data_labeled in enumerate(trainloader_label): optimizer.zero_grad() # labeled sample (x, target) = data_labeled x = x.cuda() target = target.cuda() output = backbone(x) output = linear_layer(output) loss_label = CE(output, target) loss_epoch_label += loss_label.item() loss_label.backward() optimizer.step() # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_epoch += accuracy.item() for i, data_unlabeled in enumerate(trainloader_unlabel): optimizer.zero_grad() # unlabeled time piece (x_piece1, x_piece2, target_temp, _) = data_unlabeled x_piece1 = torch.cat(x_piece1, 0).cuda() x_piece2 = torch.cat(x_piece2, 0).cuda() target_temp = torch.cat(target_temp, 0).cuda() features_cut0 = backbone(x_piece1) features_cut1 = backbone(x_piece2) features_cls = torch.cat([features_cut0, features_cut1], 1) c_output = cls_head(features_cls) correct_cls, length_cls = run_test(c_output, target_temp) loss_unlabel = CE(c_output, target_temp) loss_unlabel.backward() optimizer.step() loss_epoch_unlabel += loss_unlabel.item() accuracy_cls = 100. * correct_cls / length_cls acc_epoch_cls += accuracy_cls.item() acc_epoch /= len(trainloader_label) acc_epoch_cls /= len(trainloader_unlabel) loss_epoch_label /= len(trainloader_label) loss_epoch_unlabel /= len(trainloader_unlabel) print('[Train-{}][{}] loss_label: {:.5f}; \tloss_unlabel: {:.5f}; \t Acc label: {:.2f}% \t Acc unlabel: {:.2f}%' \ .format(epoch + 1, opt.model_name, loss_epoch_label, loss_epoch_unlabel, acc_epoch, acc_epoch_cls)) acc_vals = list() acc_tests = list() backbone.eval() linear_layer.eval() with torch.no_grad(): for i, (x, target) in enumerate(val_loader_lineval): x = x.cuda() target = target.cuda() output = backbone(x).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_vals.append(accuracy.item()) val_acc = sum(acc_vals) / len(acc_vals) if val_acc >= best_acc: best_acc = val_acc best_epoch = epoch for i, (x, target) in enumerate(test_loader_lineval): x = x.cuda() target = target.cuda() output = backbone(x).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_tests.append(accuracy.item()) test_acc = sum(acc_tests) / len(acc_tests) print('[Test-{}] Val ACC:{:.2f}%, Best Test ACC.: {:.2f}% in Epoch {}'. format(epoch, val_acc, test_acc, best_epoch)) early_stopping(val_acc, backbone) if early_stopping.early_stop: print("Early stopping") break torch.save(backbone.state_dict(), '{}/backbone_last.tar'.format(opt.ckpt_dir)) return test_acc, best_epoch
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {} ### PARAMETERS ### # LSTM & Q Learning IMAGE_SCALE = 28 IMAGE_SIZE = IMAGE_SCALE*IMAGE_SCALE HIDDEN_LAYERS = 1 HIDDEN_NODES = 200 OUTPUT_CLASSES = args.class_vector_size ################## train_transform = transforms.Compose([ transforms.Resize((IMAGE_SCALE, IMAGE_SCALE)), transforms.ToTensor() ]) test_transform = transforms.Compose([ transforms.Resize((IMAGE_SCALE, IMAGE_SCALE)), transforms.ToTensor() ]) print("Loading trainingsets...") omniglot_loader = loader.OmniglotLoader('data/omniglot', classify=False, partition=0.8, classes=True) train_loader = torch.utils.data.DataLoader( OMNIGLOT('data/omniglot', train=True, transform=train_transform, download=True, omniglot_loader=omniglot_loader, batch_size=args.episode_size), batch_size=args.mini_batch_size, shuffle=True, **kwargs) print("Loading testset...") test_loader = torch.utils.data.DataLoader( OMNIGLOT('data/omniglot', train=False, transform=test_transform, omniglot_loader=omniglot_loader, batch_size=args.episode_size), batch_size=args.mini_batch_size, shuffle=True, **kwargs)
def supervised_train2(x_train, y_train, x_val, y_val, x_test, y_test, nb_class, opt): # construct data loader # Those are the transformations used in the paper prob = 0.2 # Transform Probability cutout = transforms_ts.Cutout(sigma=0.1, p=prob) jitter = transforms_ts.Jitter(sigma=0.2, p=prob) # CIFAR10 scaling = transforms_ts.Scaling(sigma=0.4, p=prob) magnitude_warp = transforms_ts.MagnitudeWrap(sigma=0.3, knot=4, p=prob) time_warp = transforms_ts.TimeWarp(sigma=0.2, knot=8, p=prob) window_slice = transforms_ts.WindowSlice(reduce_ratio=0.8, p=prob) window_warp = transforms_ts.WindowWarp(window_ratio=0.3, scales=(0.5, 2), p=prob) transforms_list = { 'jitter': [jitter], 'cutout': [cutout], 'scaling': [scaling], 'magnitude_warp': [magnitude_warp], 'time_warp': [time_warp], 'window_slice': [window_slice], 'window_warp': [window_warp], 'G0': [jitter, magnitude_warp, window_slice], 'G1': [jitter, time_warp, window_slice], 'G2': [jitter, time_warp, window_slice, window_warp, cutout], 'none': [] } transforms_targets = list() for name in opt.aug_type: for item in transforms_list[name]: transforms_targets.append(item) train_transform = transforms_ts.Compose(transforms_targets + [transforms_ts.ToTensor()]) transform_lineval = transforms.Compose([transforms.ToTensor()]) train_set_lineval = UCR2018(data=x_train, targets=y_train, transform=train_transform) val_set_lineval = UCR2018(data=x_val, targets=y_val, transform=transform_lineval) test_set_lineval = UCR2018(data=x_test, targets=y_test, transform=transform_lineval) train_loader_lineval = torch.utils.data.DataLoader(train_set_lineval, batch_size=128, shuffle=True) val_loader_lineval = torch.utils.data.DataLoader(val_set_lineval, batch_size=128, shuffle=False) test_loader_lineval = torch.utils.data.DataLoader(test_set_lineval, batch_size=128, shuffle=False) # loading the saved backbone backbone_lineval = SimConv4().cuda() # defining a raw backbone model # 64 are the number of output features in the backbone, and 10 the number of classes linear_layer = torch.nn.Linear(opt.feature_size, nb_class).cuda() optimizer = torch.optim.Adam([{ 'params': backbone_lineval.parameters() }, { 'params': linear_layer.parameters() }], lr=opt.learning_rate) CE = torch.nn.CrossEntropyLoss() early_stopping = EarlyStopping( opt.patience, verbose=True, checkpoint_pth='{}/backbone_best.tar'.format(opt.ckpt_dir)) torch.save(backbone_lineval.state_dict(), '{}/backbone_init.tar'.format(opt.ckpt_dir)) best_acc = 0 best_epoch = 0 print('Supervised Train') for epoch in range(opt.epochs): backbone_lineval.train() linear_layer.train() acc_trains = list() for i, (data, target) in enumerate(train_loader_lineval): optimizer.zero_grad() data = data.cuda() target = target.cuda() output = backbone_lineval(data) output = linear_layer(output) loss = CE(output, target) loss.backward() optimizer.step() # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_trains.append(accuracy.item()) print('[Train-{}][{}] loss: {:.5f}; \t Acc: {:.2f}%' \ .format(epoch + 1, opt.model_name, loss.item(), sum(acc_trains) / len(acc_trains))) acc_vals = list() acc_tests = list() backbone_lineval.eval() linear_layer.eval() with torch.no_grad(): for i, (data, target) in enumerate(val_loader_lineval): data = data.cuda() target = target.cuda() output = backbone_lineval(data).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_vals.append(accuracy.item()) val_acc = sum(acc_vals) / len(acc_vals) if val_acc >= best_acc: best_acc = val_acc best_epoch = epoch for i, (data, target) in enumerate(test_loader_lineval): data = data.cuda() target = target.cuda() output = backbone_lineval(data).detach() output = linear_layer(output) # estimate the accuracy prediction = output.argmax(-1) correct = prediction.eq(target.view_as(prediction)).sum() accuracy = (100.0 * correct / len(target)) acc_tests.append(accuracy.item()) test_acc = sum(acc_tests) / len(acc_tests) print('[Test-{}] Val ACC:{:.2f}%, Best Test ACC.: {:.2f}% in Epoch {}'. format(epoch, val_acc, test_acc, best_epoch)) early_stopping(val_acc, backbone_lineval) if early_stopping.early_stop: print("Early stopping") break torch.save(backbone_lineval.state_dict(), '{}/backbone_last.tar'.format(opt.ckpt_dir)) return test_acc, best_epoch