def dense_process_data(index): images = list() for ind in indices['dense']: ptr = int(ind) if ptr <= record.num_frames: imgs = self._load_image(record.path, ptr) else: imgs = self._load_image(record.path, record.num_frames) images.extend(imgs) if self.phase == 'Fntest': images = [np.asarray(im) for im in images] clip_input = np.concatenate(images, axis=2) self.t = transforms.Compose([ transforms.Resize(256)]) clip_input = self.t(clip_input) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) if record.crop_pos == 0: self.transform = transforms.Compose([ transforms.CenterCrop((256, 256)), transforms.ToTensor(), normalize, ]) elif record.crop_pos == 1: self.transform = transforms.Compose([ transforms.CornerCrop2((256, 256),), transforms.ToTensor(), normalize, ]) elif record.crop_pos == 2: self.transform = transforms.Compose([ transforms.CornerCrop1((256, 256)), transforms.ToTensor(), normalize, ]) return self.transform(clip_input) return self.transform(images)
cuda_available = torch.cuda.is_available() # directory results if not os.path.exists(RESULTS_PATH): os.makedirs(RESULTS_PATH) # Load dataset mean = m std_dev = s transform_train = transforms.Compose([ transforms.RandomApply([transforms.ColorJitter(0.1, 0.1, 0.1, 0.1)], p=0.5), transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean, std_dev) ]) transform_test = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean, std_dev) ]) training_set = LocalDataset(IMAGES_PATH, TRAINING_PATH, transform=transform_train) validation_set = LocalDataset(IMAGES_PATH, VALIDATION_PATH, transform=transform_test)
# valloader = torch.utils.data.DataLoader(CSDataSet(args.data_dir, './dataset/list/cityscapes/val.lst', crop_size=(1024, 2048), mean=IMG_MEAN, scale=False, mirror=False), # batch_size=2, shuffle=False, pin_memory=True) value_scale = 255 mean = [0.485, 0.456, 0.406] mean = [item * 255 for item in mean] std = [0.229, 0.224, 0.225] std = [item * 255 for item in std] train_transform = my_trans.Compose([ # my_trans.Resize((args.height, args.width)), # my_trans.RandScale([0.5, 2.0]), # my_trans.RandomGaussianBlur(), my_trans.RandomHorizontalFlip(), # my_trans.Crop([args.height, args.width],crop_type='rand', padding=mean, ignore_label=255), my_trans.ToTensor(), # without div 255 my_trans.Normalize(mean=mean, std=std) ]) val_transform = my_trans.Compose([ # my_trans.Resize((args.height, args.width)), my_trans.ToTensor(), # without div 255 my_trans.Normalize(mean=mean, std=std) ]) data_dir = '/data/zzg/CamVid/' train_dataset = CamVid(data_dir, mode='train', p=None, transform=train_transform) trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True,
def main(): global args, best_record args = parser.parse_args() if args.augment: transform_train = joint_transforms.Compose([ joint_transforms.RandomCrop(256), joint_transforms.Normalize(), joint_transforms.ToTensor(), ]) else: transform_train = None dataset_train = Data.WData(args.data_root, transform_train) dataloader_train = data.DataLoader(dataset_train, batch_size=args.batch_size, shuffle=True, num_workers=16) dataset_val = Data.WData(args.val_root, transform_train) dataloader_val = data.DataLoader(dataset_val, batch_size=args.batch_size, shuffle=None, num_workers=16) model = SFNet(input_channels=37, dilations=[2, 4, 8], num_class=2) # multi gpu model = torch.nn.DataParallel(model) print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) model = model.cuda() cudnn.benchmark = True # define loss function (criterion) and pptimizer criterion = torch.nn.CrossEntropyLoss(ignore_index=-1).cuda() optimizer = torch.optim.SGD([{ 'params': get_1x_lr_params(model) }, { 'params': get_10x_lr_params(model), 'lr': 10 * args.learning_rate }], lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch train(dataloader_train, model, criterion, optimizer, epoch) # evaluate on validation set acc, mean_iou, val_loss = validate(dataloader_val, model, criterion, epoch) is_best = mean_iou > best_record['miou'] if is_best: best_record['epoch'] = epoch best_record['val_loss'] = val_loss.avg best_record['acc'] = acc best_record['miou'] = mean_iou save_checkpoint( { 'epoch': epoch + 1, 'val_loss': val_loss.avg, 'accuracy': acc, 'miou': mean_iou, 'model': model, }, is_best) print( '------------------------------------------------------------------------------------------------------' ) print('[epoch: %d], [val_loss: %5f], [acc: %.5f], [miou: %.5f]' % (epoch, val_loss.avg, acc, mean_iou)) print( 'best record: [epoch: {epoch}], [val_loss: {val_loss:.5f}], [acc: {acc:.5f}], [miou: {miou:.5f}]' .format(**best_record)) print( '------------------------------------------------------------------------------------------------------' )
parser.add_argument("--batch_size", type=int, default=1, help="Size of the batches") parser.add_argument("--lr", type=float, default=0.0002, help="Adams learning rate") args = parser.parse_args() device = ('cuda:0' if torch.cuda.is_available() else 'cpu') transforms = T.Compose([ T.Resize((256, 256)), T.ToTensor(), T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) # models print('Defining models!') generator = UnetGenerator().to(device) discriminator = ConditionalDiscriminator().to(device) # optimizers g_optimizer = torch.optim.Adam(generator.parameters(), lr=args.lr, betas=(0.5, 0.999)) d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=args.lr, betas=(0.5, 0.999)) # loss functions g_criterion = GeneratorLoss(alpha=100) d_criterion = DiscriminatorLoss()
if __name__=='__main__': args = parse_args() wandb.init(config=args, project=f'dlcv_naive_{args.source}2{args.target}') size = 64 t0 = transforms.Compose([ transforms.Resize(size), transforms.ColorJitter(), transforms.RandomRotation(15, fill=(0,)), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) t1 = transforms.Compose([ transforms.Resize(size), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) root = '../hw3_data/digits/' # dataset source, target = args.source, args.target train_source_dataset = Digits_Dataset(root+f'{source}/train', source, t0) train_target_dataset = Digits_Dataset(root+f'{target}/train', target, t0) valid_source_dataset = Digits_Dataset(root+f'{source}/test', source, t1) valid_target_dataset = Digits_Dataset(root+f'{target}/test', target, t1)
def inference(args): if args.target=='mnistm': args.source = 'usps' elif args.target=='usps': args.source = 'svhn' elif args.target=='svhn': args.source = 'mnistm' else: raise NotImplementedError(f"{args.target}: not implemented!") size = args.img_size t1 = transforms.Compose([ transforms.Resize(size), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) valid_target_dataset = Digits_Dataset_Test(args.dataset_path, t1) valid_target_dataloader = DataLoader(valid_target_dataset, batch_size=512, num_workers=6) load = torch.load( f"./p3/result/3_2/{args.source}2{args.target}/best_model.pth", map_location='cpu') feature_extractor = FeatureExtractor() feature_extractor.load_state_dict(load['F']) feature_extractor.cuda() feature_extractor.eval() label_predictor = LabelPredictor() label_predictor.load_state_dict(load['C']) label_predictor.cuda() label_predictor.eval() out_preds = [] out_fnames = [] count=0 for i,(imgs, fnames) in enumerate(valid_target_dataloader): bsize = imgs.size(0) imgs = imgs.cuda() features = feature_extractor(imgs) class_output = label_predictor(features) _, preds = class_output.max(1) preds = preds.detach().cpu() out_preds.append(preds) out_fnames += fnames count+=bsize print(f"\t [{count}/{len(valid_target_dataloader.dataset)}]", end=" \r") out_preds = torch.cat(out_preds) out_preds = out_preds.cpu().numpy() d = {'image_name':out_fnames, 'label':out_preds} df = pd.DataFrame(data=d) df = df.sort_values('image_name') df.to_csv(args.out_csv, index=False) print(f' [Info] finish predicting {args.dataset_path}')
default='cuda:0', help='cpu or cuda:0 or cuda:1') args = parser.parse_args() if string is None else parser.parse_args(string) return args if __name__ == '__main__': args = parse_args() wandb.init(config=args, project='dlcv_gan_face') transform = transforms.Compose([ transforms.Resize(args.img_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.5] * 3, [0.5] * 3) ]) train_dataset = Face_Dataset('../hw3_data/face/train', transform) valid_dataset = Face_Dataset('../hw3_data/face/test', transform) train_dataloader = DataLoader(train_dataset, batch_size=args.batch, shuffle=True, num_workers=args.num_workers) valid_dataloader = DataLoader(valid_dataset, batch_size=args.batch, num_workers=args.num_workers) train(args, train_dataloader, valid_dataloader)