def get_mini_imagenet_data_loader(task, num_per_class=1, split='train',shuffle = False,train_query_argue=False,train_support_argue=False): normalize = transforms.Normalize(mean=[0.92206, 0.92206, 0.92206], std=[0.08426, 0.08426, 0.08426]) Arguementation = T.Compose([ T.RandomCrop(84, padding=8), T.RandomHorizontalFlip(), T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), T.ToTensor(), normalize, T.RandomErasing(0.5) ]) Arguementation_support = transforms.Compose([ transforms.Resize(84), # transforms.RandomHorizontalFlip(), # transforms.RandomVer transforms.ToTensor(), normalize ]) # 针对Support不做增强 if split == 'train' and train_support_argue == False: dataset = MiniImagenet(task,split=split,transform=transforms.Compose([transforms.ToTensor(),normalize])) sampler = ClassBalancedSamplerOld(num_per_class,task.num_classes, task.train_num,shuffle=shuffle) elif split == 'train' and train_support_argue == True: dataset = MiniImagenet(task,split=split,transform=Arguementation_support) sampler = ClassBalancedSamplerOld(num_per_class,task.num_classes, task.train_num,shuffle=shuffle) # 只针对训练中的query set做增强,但对训练中的support set不做增强 else: if train_query_argue == False: dataset = MiniImagenet(task,split=split,transform=transforms.Compose([transforms.ToTensor(),normalize])) sampler = ClassBalancedSampler(task.num_classes, task.test_num,shuffle=shuffle) else: dataset = MiniImagenet(task,split=split,transform=Arguementation) sampler = ClassBalancedSampler(task.num_classes, task.test_num,shuffle=shuffle) loader = DataLoader(dataset, batch_size=num_per_class*task.num_classes, sampler=sampler) return loader
def __init__(self, img_size: int, original_size: int, mean: float = 0, std: float = 1, brightness: float = 0.3, contrast: float = 0.5, saturation: float = 0.5, hue: float = 0.3, rotation_degree: int = 10, hflip: float = 0.5, debug: bool = False): self.original_size = original_size self.target_size = img_size self.to_pil = transforms.ToPILImage() self.color_jitter = transforms.ColorJitter(brightness=brightness, contrast=contrast, saturation=saturation, hue=hue) self.resize = transforms.Resize(img_size) self.to_tensor = transforms.ToTensor() self.normalize = transforms.Normalize(mean, std) self.r_horizontal_flip = RandomHorizontalFlip(p=hflip) self.r_rotation = RandomRotation(rotation_degree) self.debug = debug
def get_transform(train): transforms = [] if train: # transforms.append(T.random_affine(degrees=1.98, translate=0.05, scale=0.05, shear=0.641)) transforms.append(T.ColorJitter(brightness=0.5, saturation=0.5)) transforms.append(T.RandomRotation()) transforms.append(T.ToTensor()) transforms.append(T.RandomHorizontalFlip(0.5)) else: transforms.append(T.ToTensor()) return T.Compose(transforms)
def apply_transorms(self, img, target): transorm_flip = transforms.RandomHorizontalFlip(0.5) normalize = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) jitter = transforms.ColorJitter(brightness=0.3, contrast=0.2, hue=0.1) img = jitter(img) img = F.to_tensor(img) img, target = transorm_flip(img, target) #img = normalize(img) return img, target
def __init__(self, base_size, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), contrast=1, brightness=1, sigma=1): self.contrast_initial = contrast self.contrast_final = contrast if (contrast == 1): self.contrast_final = contrast else: self.contrast_final = self.contrast_initial - 1 self.brightness_initial = brightness self.brightness_final = brightness if (brightness == 1): self.brightness_final = brightness else: self.brightness_final = self.brightness_initial - 1 self.sigma_initial = sigma self.sigma_final = sigma if (sigma == 1): self.sigma_final = sigma else: self.sigma_final = self.sigma_initial - 1 print("Contrast: ({}, {})".format(self.contrast_final, self.contrast_initial)) print("Brightness: ({}, {})".format(self.brightness_final, self.brightness_initial)) print("Sigma: ({}, {})".format(self.sigma_final, self.sigma_initial)) self.transforms = T.Compose([ T.RandomResize(base_size, base_size), T.PILToTensor(), T.ConvertImageDtype(torch.float), T.ColorJitter(contrast=(self.contrast_final, self.contrast_initial), brightness=(self.brightness_final, self.brightness_initial)), #T.GaussianBlur(kernel_size=19, sigma=(self.sigma_final, self.sigma_initial)), T.Normalize(mean=mean, std=std), ])
def get_transform(train): base_size = 1000 crop_size = 768 min_size = int((0.5 if train else 1.0) * base_size) max_size = int((2.0 if train else 1.0) * base_size) transforms = [] transforms.append(T.RandomResize(min_size, max_size)) if train: transforms.append(T.ColorJitter(0.5, 0.5, 0.5, 0.5)) transforms.append(T.RandomHorizontalFlip(0.5)) transforms.append(T.RandomVerticalFlip(0.5)) transforms.append(T.RandomCrop(crop_size)) transforms.append(T.ToTensor()) transforms.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])) return T.Compose(transforms)
def __init__(self, data_path, split, augment=True, load_everything=True): self.count = 0 file_path = os.path.join(data_path, 'miniplaces_256_{}.h5'.format(split)) self.dataset = h5py.File(file_path) self.normalize = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = [ transforms.Scale(256), transforms.RandomCrop(224), # transforms.RandomResizedCrop(224) ] if augment: transform.extend([ transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05), transforms.RandomHorizontalFlip(), # transforms.RandomVerticalFlip(), ]) transform += [transforms.ToTensor()] if augment: transform.append( affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant') ) # if augment: # transform.append( # affine_transforms.Affine(rotation_range=10.0, translation_range=0.1, zoom_range=(0.5, 1.0), fill_mode='constant') # ) transform += [ self.normalize] self.preprocess = transforms.Compose(transform) self.split = split if split != 'test': self.labels = np.array(self.dataset['labels']) self.load_everything = load_everything if self.load_everything: self.images = np.array(self.dataset['images'])
def get(args): """ Entry point. Call this function to get all Charades dataloaders """ normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_file = args.train_file val_file = args.val_file train_dataset = Charades( args.data, 'train', train_file, args.cache, transform=transforms.Compose([ transforms.RandomResizedCrop(args.inputsize), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), # missing PCA lighting jitter normalize, ])) val_dataset = Charades(args.data, 'val', val_file, args.cache, transform=transforms.Compose([ transforms.Resize( int(256. / 224 * args.inputsize)), transforms.CenterCrop(args.inputsize), transforms.ToTensor(), normalize, ])) valvideo_dataset = Charades(args.data, 'val_video', val_file, args.cache, transform=transforms.Compose([ transforms.Resize( int(256. / 224 * args.inputsize)), transforms.CenterCrop(args.inputsize), transforms.ToTensor(), normalize, ])) return train_dataset, val_dataset, valvideo_dataset
def get_train_dataloader(data_path, image_size, batch_size, mean, std): train_transforms = transforms.Compose([ transforms.Resize(image_size), transforms.RandomHorizontalFlip(), transforms.ColorJitter(), transforms.ToTensor(), transforms.Normalize(mean, std), ]) train_dataset = CamVid( data_path, 'train', transforms=train_transforms, ) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.b, num_workers=4, shuffle=True) return train_loader
def build_transforms(is_train, size, crop_size,mode="baseline"): mean = (0.485, 0.456, 0.406) std = (0.229, 0.224, 0.225) fill = tuple([int(v * 255) for v in mean]) ignore_value = 255 transforms=[] min_scale=1 max_scale=1 if is_train: min_scale=0.5 max_scale=2 transforms.append(T.RandomResize(int(min_scale*size),int(max_scale*size))) if is_train: if mode=="baseline": pass elif mode=="randaug": transforms.append(T.RandAugment(2,1/3,prob=1.0,fill=fill,ignore_value=ignore_value)) elif mode=="custom1": transforms.append(T.ColorJitter(0.5,0.5,(0.5,2),0.05)) transforms.append(T.AddNoise(10)) transforms.append(T.RandomRotation((-10,10), mean=fill, ignore_value=0)) else: raise NotImplementedError() transforms.append( T.RandomCrop( crop_size,crop_size, fill, ignore_value, random_pad=is_train )) transforms.append(T.RandomHorizontalFlip(0.5)) transforms.append(T.ToTensor()) transforms.append(T.Normalize( mean, std )) return T.Compose(transforms)
os.makedirs(checkpoint_path) checkpoint_path = os.path.join(checkpoint_path, '{net}-{epoch}-{type}.pth') #tensorboard log directory log_path = os.path.join(settings.LOG_DIR, args.net, settings.TIME_NOW) if not os.path.exists(log_path): os.makedirs(log_path) writer = SummaryWriter(log_dir=log_path) #get dataloader train_transforms = transforms.Compose([ transforms.ToCVImage(), #transforms.RandomResizedCrop(settings.IMAGE_SIZE), transforms.Resize(settings.IMAGE_SIZE), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.4, saturation=0.4, hue=0.4), #transforms.RandomErasing(), #transforms.CutOut(56), transforms.ToTensor(), transforms.Normalize(settings.TRAIN_MEAN, settings.TRAIN_STD) ]) test_transforms = transforms.Compose([ transforms.ToCVImage(), #transforms.CenterCrop(settings.IMAGE_SIZE), transforms.Resize(settings.IMAGE_SIZE), transforms.ToTensor(), transforms.Normalize(settings.TRAIN_MEAN, settings.TRAIN_STD) ]) train_dataloader = get_train_dataloader(settings.DATA_PATH,
return images def h5_loader(path): # 关于HDF5的文件操作,详见https://blog.csdn.net/yudf2010/article/details/50353292 h5f = h5py.File(path, "r") # r是读的意思 rgb = np.array(h5f['rgb']) # 使用array()函数可以将python的array_like数据转变成数组形式,使用matrix()函数转变成矩阵形式。 # 基于习惯,在实际使用中较常用array而少用matrix来表示矩阵。 rgb = np.transpose(rgb, (1, 2, 0)) # 关于np.transpose()对高维数组的转置,详见https://www.cnblogs.com/sunshinewang/p/6893503.html depth = np.array(h5f['depth']) return rgb, depth iheight, iwidth = 480, 640 # raw image size oheight, owidth = 228, 304 # image size after pre-processing color_jitter = transforms.ColorJitter(0.4, 0.4, 0.4) # 数据增强(论文中的方法) def train_transform(rgb, depth): s = np.random.uniform(1.0, 1.5) # random scaling # print("scale factor s={}".format(s)) depth_np = depth / s angle = np.random.uniform(-5.0, 5.0) # random rotation degrees do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip # perform 1st part of data augmentation transform = transforms.Compose([ transforms.Resize(250.0 / iheight), # this is for computational efficiency, since rotation is very slow transforms.Rotate(angle), transforms.Resize(s), transforms.CenterCrop((oheight, owidth)),
# use_gpu = torch.cuda.is_avilable() cudnn.benchmark = True use_gpu = True ## Data loading code # normalization to be applied to the training and validation tensors. normalize = augment.Normalize(mean = [ 0.485, 0.456, 0.406 ], std = [ 0.229, 0.224, 0.225 ]) # Dataset setup # Choose what sort of data transformations and augmentations you wish to apply to # the training. # A set of random transformations which can be applied. random_Transform_List = [transforms.RandomHorizontalFlip(),transforms.RandomRotation(30), transforms.ColorJitter(brightness=0.5),transforms.Grayscale(num_output_channels=3)] data_transforms = { 'train': augment.Compose([ #augment.ScalePad((1024,1024)), #augment.RandomRotate(60), #augment.RandomHorizontalFlip(), augment.AnisotropicScale((224,224)), transforms.RandomApply(random_Transform_List,p=0.5), augment.ToTensor(), normalize ]), 'val': augment.Compose([ #augment.ScalePad((1024,1024)), augment.AnisotropicScale((224,224)), augment.ToTensor(),
checkpoint_path = os.path.join(checkpoint_path, '{epoch}-{type}.pth') if not os.path.exists(log_dir): os.makedirs(log_dir) writer = SummaryWriter(log_dir=log_dir) train_dataset = CamVid(settings.DATA_PATH, 'train') valid_dataset = CamVid(settings.DATA_PATH, 'val') train_transforms = transforms.Compose([ transforms.RandomRotation(value=train_dataset.ignore_index), transforms.RandomScale(value=train_dataset.ignore_index), transforms.RandomGaussianBlur(), transforms.RandomHorizontalFlip(), transforms.ColorJitter(), transforms.Resize(settings.IMAGE_SIZE), transforms.ToTensor(), transforms.Normalize(settings.MEAN, settings.STD), ]) valid_transforms = transforms.Compose([ transforms.Resize(settings.IMAGE_SIZE), transforms.ToTensor(), transforms.Normalize(settings.MEAN, settings.STD), ]) train_dataset.transforms = train_transforms valid_dataset.transforms = valid_transforms train_loader = torch.utils.data.DataLoader(train_dataset,
def main(): SIZE_IMG = 224 # 224 global args args = parser.parse_args() # create model if args.arch.startswith('resnet50'): model = model_defs.resnet50_oneway(num_classes=2) model = nn.DataParallel(model.model) # dirty trick # open log file if args.train == 1: log_dir = 'logs' log_name = args.arch + '_new.csv' if not os.path.isdir(log_dir): os.mkdir(log_dir) log_handle = get_file_handle(os.path.join(log_dir, log_name), 'wb+') log_handle.write('Epoch, LearningRate, Momentum, WeightDecay,' + \ 'Loss, Precision, Recall, Accuracy(IoU), FgWeight, BgWeight\n') log_handle.close() # check model directory model_dir = 'models' if not os.path.isdir(model_dir): os.mkdir(model_dir) # resume learning based on cmdline arguments if ((args.start_epoch > 1) and (args.train == 1)): load_epoch = args.start_epoch - 1 elif (args.train == 0): load_epoch = args.load_epoch else: load_epoch = 0 if load_epoch > 0: print("=> loading checkpoint for epoch = '{}'".format(load_epoch)) checkpoint_name = args.arch + '_ep_' + str(load_epoch) + '.pth.tar' checkpoint = torch.load(os.path.join(model_dir, checkpoint_name)) model.load_state_dict(checkpoint['state_dict']) # model = add_dropout2d(model); model.cuda() # transfer to cuda print(model) mean = load_pickle('./mean') std = load_pickle('./std') if args.train == 1: train_data_dir, train_gt_dir = args.data, args.gt train_loader = torch.utils.data.DataLoader(datasets.ImageFolder( train_data_dir, train_gt_dir, transform_joint=transforms.Compose_Joint([ transforms.RandomCrop(SIZE_IMG), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), ]), transform=transforms.Compose([ transforms.ColorJitter(0.3, 0.3, 0.3, 0), transforms.ToTensor(), transforms.Normalize(mean=mean, std=std), ]), target_transform=transforms.Compose([ transforms.ToTensorTarget(), ]), do_copy=True, ), batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) weights = torch.from_numpy(np.array([1., 1.01])).float() criterion = nn.CrossEntropyLoss(weights).cuda() if args.optim == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay) elif args.optim == 'sgd': optimizer = torch.optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) for epoch in range(args.start_epoch, args.end_epoch + 1): # train for one epoch stats_epoch = train(train_loader, model, criterion, optimizer, epoch) model_name = args.arch + '_ep_' + str(epoch) + '.pth.tar' # get current parameters of optimizer for param_group in optimizer.param_groups: cur_lr = param_group['lr'] cur_wd = param_group['weight_decay'] if param_group.has_key('momentum'): cur_momentum = param_group['momentum'] else: cur_momentum = 'n/a' break # constant parameters throughout the network if epoch % args.save_interval == 0: state = { 'epoch': epoch, 'arch': args.arch, 'state_dict': model.state_dict(), 'learning_rate': cur_lr, 'moemntum': cur_momentum, 'weight_decay': cur_wd, 'fg_weight': weights[1], 'bg_weight': weights[0], } torch.save(state, os.path.join(model_dir, model_name)) # write logs using logHandle log_handle = get_file_handle(os.path.join(log_dir, log_name), 'ab') log_handle.write( str(epoch) + ',' + str(cur_lr) + ',' + str(cur_momentum) + ',' + str(cur_wd) + ',' + str(stats_epoch['loss']) + ',' + str(stats_epoch['prec']) + ',' + str(stats_epoch['recall']) + ',' + str(stats_epoch['acc']) + ',' + str(weights[1]) + ',' + str(weights[0]) + '\n') log_handle.close() # adjust_learning_rate(optimizer, epoch, 10); # adjust learning rate elif args.train == 0: # test testdir = args.data outdir = args.out stride = args.test_stride test_batch_size = args.test_batch_size test_transformer = transforms.Compose([ # transforms.RandomHorizontalFlip(), # transforms.RandomVerticalFlip(), transforms.ToTensor(), transforms.Normalize(mean=mean, std=std), ]) # test(testdir, outdir, test_transformer, model, load_epoch, stride, SIZE_IMG); test_batch_form(testdir, outdir, test_transformer, model, load_epoch, stride, SIZE_IMG, test_batch_size)
def __init__(self, args, use_gpu): super(DataManager, self).__init__() self.args = args self.use_gpu = use_gpu print("Initializing dataset {}".format(args.dataset)) dataset = datasets.init_imgfewshot_dataset(name=args.dataset, root=args.root) if args.load: transform_train = T.Compose([ T.RandomCrop(84, padding=8), T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), T.RandomErasing(0.5) ]) transform_test = T.Compose([ T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) elif args.cifar: transform_train = T.Compose([ T.RandomCrop(32, padding=4), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.507, 0.487, 0.441], std=[0.267, 0.256, 0.276]), T.RandomErasing(0.5) ]) transform_test = T.Compose([ T.ToTensor(), T.Normalize(mean=[0.507, 0.487, 0.441], std=[0.267, 0.256, 0.276]), ]) else: transform_train = T.Compose([ T.RandomResizedCrop((84, 84)), T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), T.RandomHorizontalFlip(), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), T.RandomErasing(0.5) ]) transform_test = T.Compose([ T.Resize((92, 92)), T.CenterCrop((84, 84)), 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 self.trainloader = DataLoader( dataset_loader.init_loader( name='train_loader', dataset=dataset.train, labels2inds=dataset.train_labels2inds, labelIds=dataset.train_labelIds, nKnovel=args.nKnovel, nExemplars=args.nExemplars, nTestNovel=args.train_nTestNovel, epoch_size=args.train_epoch_size, transform=transform_train, load=args.load, tiered=args.tiered, ), batch_size=args.train_batch, shuffle=True, num_workers=args.workers, pin_memory=pin_memory, drop_last=True, ) self.valloader = DataLoader( dataset_loader.init_loader( name='test_loader', dataset=dataset.val, labels2inds=dataset.val_labels2inds, labelIds=dataset.val_labelIds, nKnovel=args.nKnovel, nExemplars=args.nExemplars, nTestNovel=args.nTestNovel, epoch_size=args.epoch_size, transform=transform_test, load=args.load, tiered=args.tiered, ), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, ) self.testloader = DataLoader( dataset_loader.init_loader( name='test_loader', dataset=dataset.test, labels2inds=dataset.test_labels2inds, labelIds=dataset.test_labelIds, nKnovel=args.nKnovel, nExemplars=args.nExemplars, nTestNovel=args.nTestNovel, epoch_size=args.epoch_size, transform=transform_test, load=args.load, tiered=args.tiered, ), batch_size=args.test_batch, shuffle=False, num_workers=args.workers, pin_memory=pin_memory, drop_last=False, )
def train(self): use_cuda = torch.cuda.is_available() path = os.path.join('./out_models/' + self.model_name + '_' + self.task_name + '_' + self.job_id) ## get logger logger = self.get_logger(self.model_name, self.task_name, self.job_id, path) logger.info("Job_id : {}".format(self.job_id)) logger.info("gpus_device_ids : {}".format(self.device_ids)) logger.info("Task Name : {}".format(self.task_name)) logger.info("Backbone_name : {}".format(self.model_name)) logger.info("input_shape : ({},{}.{})".format(self.input_shape[0], self.input_shape[1], self.input_shape[2])) logger.info("batch_size : {}".format(self.batch_size)) logger.info("num_epochs : {}".format(self.num_epochs)) logger.info("warmup_steps : {}".format(self.warmup_steps)) logger.info("resume_from : {}".format(self.resume_from)) logger.info("pretrained : {}".format(self.pretrained)) logger.info("mixup : {}".format(self.mixup)) logger.info("cutmix : {}".format(self.cutmix)) ## tensorboard writer log_dir = os.path.join(path, "{}".format("tensorboard_log")) if not os.path.isdir(log_dir): os.mkdir(log_dir) writer = SummaryWriter(log_dir) ## get model of train net = get_model(self.model_name) net = torch.nn.DataParallel(net, device_ids=self.device_ids) net = net.cuda(device=self.device_ids[0]) ## loss criterion = nn.CrossEntropyLoss() ## optimizer if self.optimizers == 'SGD': optimizer = optim.SGD(net.parameters(), lr=self.init_lr, momentum=0.9, weight_decay=self.weight_decay) elif self.optimizers == 'Adam': optimizer = optim.Adam(net.parameters(), lr=self.init_lr, weight_decay=self.weight_decay) milestones = [80, 150, 200, 300] scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1) logger.info(("===========opti==========")) logger.info("Optimizer:{}".format(self.optimizers)) logger.info("lr:{}".format(self.init_lr)) logger.info("weight_decay:{}".format(self.weight_decay)) logger.info("lr_scheduler: MultiStepLR") logger.info("milestones:{}".format(milestones)) ## augumation normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ## train aug transform_train = transforms.Compose([ transforms.RandomCrop(int(self.input_shape[-1])), transforms.RandomHorizontalFlip(), transforms.RandomBrightness(brightness = self.brightness, brightness_ratio=self.brightness_ratio), transforms.RandomBlur(blur_ratio = self.blur_ratio), transforms.RandomRotation(degrees = self.degrees, rotation_ratio = 0.1), transforms.ColorJitter(brightness = self.color_brightnesss, contrast = self.color_contrast,\ saturation = self.color_saturation, hue=0), transforms.ToTensor(), #normalize, ]) ## test aug transform_test = transforms.Compose([ transforms.CenterCrop(int(self.input_shape[-1])), transforms.ToTensor(), #normalize, ]) logger.info(("============aug===========")) logger.info("crop: RandomCrop") logger.info("RandomHorizontalFlip: True") logger.info("brightness:{}".format(self.brightness)) logger.info("brightness_ratio:{}".format(self.brightness_ratio)) logger.info("blur_ratio:{}".format(self.blur_ratio)) logger.info("degrees:{}".format(self.degrees)) logger.info("color_brightnesss:{}".format(self.color_brightnesss)) logger.info("color_contrast:{}".format(self.color_contrast)) logger.info("color_saturation:{}".format(self.color_saturation)) ## prepara data print('==> Preparing data..') logger.info(("==========Datasets=========")) logger.info("train_datasets:{}".format(self.train_datasets)) logger.info("val_datasets:{}".format(self.val_datasets)) logger.info("test_datasets:{}".format(self.test_datasets)) #trainset = DataLoader(split = 'Training', transform=transform_train) trainset = DataLoader(self.train_datasets, self.val_datasets, self.test_datasets, split='Training', transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=self.batch_size * len(self.device_ids), shuffle=True) Valset = DataLoader(self.train_datasets, self.val_datasets, self.test_datasets, split='Valing', transform=transform_test) Valloader = torch.utils.data.DataLoader(Valset, batch_size=64 * len(self.device_ids), shuffle=False) Testset = DataLoader(self.train_datasets, self.val_datasets, self.test_datasets, split='Testing', transform=transform_test) Testloader = torch.utils.data.DataLoader(Testset, batch_size=64 * len(self.device_ids), shuffle=False) ## train logger.info(("======Begain Training======")) #self.train_model(net, criterion, optimizer, scheduler, trainloader, Valloader, Testloader, logger, writer, path) self.train_model(net, criterion, optimizer, scheduler, trainloader, Valloader, Testloader, logger, writer, path) logger.info(("======Finsh Training !!!======")) logger.info(("best_val_acc_epoch: %d, best_val_acc: %0.3f" % (self.best_Val_acc_epoch, self.best_Val_acc))) logger.info(("best_test_acc_epoch: %d, best_test_acc: %0.3f" % (self.best_Test_acc_epoch, self.best_Test_acc)))
print('==> snapshot "{0}" loaded (epoch {1})'.format( args.path, epoch)) else: raise FileNotFoundError('no snapshot found at "{0}"'.format( args.path)) else: epoch = 0 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) preprocess = transforms.Compose([ transforms.Scale(256), transforms.RandomCrop(224), transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05), transforms.RandomHorizontalFlip(), transforms.ToTensor(), affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant'), normalize ]) # testing the model images = np.load('./preprocess/miniplaces_256_test.npz')['arr_0'] # print(images.files) model.eval() answers = [] inds = [] ls = []
def main(args): init_distributed_mode(args) print(args) device = torch.device(args.device) results_file = "results{}.txt".format( datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) # Data loading code print("Loading data") data_transform = { "train": transforms.Compose([ transforms.SSDCropping(), transforms.Resize(), transforms.ColorJitter(), transforms.ToTensor(), transforms.RandomHorizontalFlip(), transforms.Normalization(), transforms.AssignGTtoDefaultBox() ]), "val": transforms.Compose([ transforms.Resize(), transforms.ToTensor(), transforms.Normalization() ]) } VOC_root = args.data_path # check voc root if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False: raise FileNotFoundError( "VOCdevkit dose not in path:'{}'.".format(VOC_root)) # load train data set train_data_set = VOC2012DataSet(VOC_root, data_transform["train"], train_set='train.txt') # load validation data set val_data_set = VOC2012DataSet(VOC_root, data_transform["val"], train_set='val.txt') print("Creating data loaders") if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_data_set) test_sampler = torch.utils.data.distributed.DistributedSampler( val_data_set) else: train_sampler = torch.utils.data.RandomSampler(train_data_set) test_sampler = torch.utils.data.SequentialSampler(val_data_set) if args.aspect_ratio_group_factor >= 0: # 统计所有图像比例在bins区间中的位置索引 group_ids = create_aspect_ratio_groups( train_data_set, k=args.aspect_ratio_group_factor) train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, args.batch_size) else: train_batch_sampler = torch.utils.data.BatchSampler(train_sampler, args.batch_size, drop_last=True) data_loader = torch.utils.data.DataLoader( train_data_set, batch_sampler=train_batch_sampler, num_workers=args.workers, collate_fn=train_data_set.collate_fn) data_loader_test = torch.utils.data.DataLoader( val_data_set, batch_size=1, sampler=test_sampler, num_workers=args.workers, collate_fn=train_data_set.collate_fn) print("Creating model") model = create_model(num_classes=args.num_classes + 1, device=device) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu]) model_without_ddp = model.module params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma) # lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma) # 如果传入resume参数,即上次训练的权重地址,则接着上次的参数训练 if args.resume: # If map_location is missing, torch.load will first load the module to CPU # and then copy each parameter to where it was saved, # which would result in all processes on the same machine using the same set of devices. checkpoint = torch.load( args.resume, map_location='cpu') # 读取之前保存的权重文件(包括优化器以及学习率策略) model_without_ddp.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) args.start_epoch = checkpoint['epoch'] + 1 if args.test_only: utils.evaluate(model, data_loader_test, device=device) return train_loss = [] learning_rate = [] val_map = [] print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) mean_loss, lr = utils.train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq, warmup=True) # only first process to save training info if args.rank in [-1, 0]: train_loss.append(mean_loss.item()) learning_rate.append(lr) # update learning rate lr_scheduler.step() # evaluate after every epoch coco_info = utils.evaluate(model, data_loader_test, device=device) if args.rank in [-1, 0]: # write into txt with open(results_file, "a") as f: # 写入的数据包括coco指标还有loss和learning rate result_info = [ str(round(i, 4)) for i in coco_info + [mean_loss.item(), lr] ] txt = "epoch:{} {}".format(epoch, ' '.join(result_info)) f.write(txt + "\n") val_map.append(coco_info[1]) # pascal mAP if args.output_dir: # 只在主节点上执行保存权重操作 save_on_master( { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'args': args, 'epoch': epoch }, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str)) if args.rank in [-1, 0]: # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
def main(argv): epochs = 50 epochgroup = 10 testepochs = 2 save = False load = False train = True test = True home = expanduser("~") traindata = home + '/Robotics/NeuralNetworks/DataSets/cone-square/train' testdata = home + '/Robotics/NeuralNetworks/DataSets/cone-square/test' transformlist = [] minimaltransformlist = [] verbose = 0 net = None px = 64 parser = argparse.ArgumentParser() parser.add_argument('--epochs', help='Epochs') parser.add_argument('--epochgroup', help='Epochs between test set') parser.add_argument('--testepochs', help='Test Epochs') parser.add_argument('--net', help='Network') parser.add_argument('--save', help='Save Network') parser.add_argument('--load', help='Load Network') parser.add_argument('--traindata', help='Training Data') parser.add_argument('--testdata', help='Testing Data') parser.add_argument('--notrain', action='store_true', help='Do not train network') parser.add_argument('--notest', action='store_true', help='Do not test network') parser.add_argument('--transforms', help='Transforms to use, all or none') parser.add_argument('--verbose', help='Verbosity') parser.add_argument('--px', help='x,y pixel number') args = parser.parse_args() if args.epochs: epochs = int(args.epochs) if args.epochgroup: epochgroup = int(args.epochgroup) if args.testepochs: testepochs = int(args.testepochs) if args.px: px = int(args.px) if args.net: if args.net == "cnn": net = CNN(px=px) if args.net == "nn": net = NN(px=px) if args.net == "t1": net = NNorCNN(px=px, clayers=[]) if args.net == "t2": net = NNorCNN(px=px, clayers=[(5, 6, 2)]) if args.net == "t3": net = NNorCNN(px=px, clayers=[(5, 6, 2), (5, 16, 2)]) if args.net == "t4": net = NNorCNN(px=px, clayers=[(5, 6, 2), (5, 16, 2), (5, 7, 2)]) if args.net == "t5": net = NNorCNN(px=px, clayers=[(5, 6, 2), (5, 16, 2), (5, 7, 2)], layers=[100, 2]) if args.net == "t6": net = NNorCNN(px=px, layers=[128, 64, 32, 2]) if args.net == "d": net = NNorCNN(px=px) if args.net == "tf": # the same as the TensorFlow cat dog example net = NNorCNN(px=px, clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)], layers=[128, 128, 2]) if args.net == "tfd": # the same as the TensorFlow cat dog example, with dropout net = NNorCNN(px=px, clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)], layers=[128, 128, 2], convolution_dropout=0.1, linear_dropout=0.1) if args.net == "tfd2": # the same as the TensorFlow cat dog example, with dropout net = NNorCNN(px=px, clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)], layers=[128, 128, 2], linear_dropout=0.1) if args.save: save = args.save if args.load: load = args.load if args.traindata: traindata = args.traindata if args.testdata: testdata = args.testdata if args.notrain: train = False if args.notest: test = False if args.verbose: verbose = int(args.verbose) if load: net = torch.load(load) transformlist.append(newtransforms.Resize([px, px])) minimaltransformlist.append(newtransforms.Resize([px, px])) if args.transforms == "none": pass else: transformlist.append(imageUtils.RandomRotate((-10, 10))) # imageUtils.GaussianBlurring(0.6), # needs shape fix # imageUtils.AddGaussianNoise(0.0,0.1), transformlist.append( newtransforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1)) # newtransforms.ColorJitter(brightness=0.6,contrast=0.5,saturation=0.4,hue=0.3), # transforms.Rotate(20), transformlist.append(transforms.RandomHorizontalFlip()) transformlist.append(transforms.ToTensor()) transformlist.append(normalize) selectedtransforms = transforms.Compose(transformlist) minimaltransformlist.append(transforms.ToTensor()) minimaltransformlist.append(normalize) minimaltransforms = transforms.Compose(minimaltransformlist) if not net: net = CNN(px=px) traindata = ImageFolder(root=traindata, transform=selectedtransforms) # testdata = ImageFolder(root=testdata, transform=selectedtransforms) testdata = ImageFolder(root=testdata, transform=minimaltransforms) num_epochs = 0 last_test_score = 0 num_no_progress_epochs = 0 while num_epochs < epochs: if train: if verbose > 1: print("Train Images") print(traindata.imgs) print("Classes train:", traindata.classes) trainloader = DataLoader(traindata, shuffle=True) trainer = Trainer(net, trainloader) tot, l = trainer.run(epochgroup) num_epochs += epochgroup if verbose > 0: print('Trained samples:', tot, "loss: %.4f" % l) if test: if verbose > 1: print("Test Images") print(testdata.imgs) print("Classes test:", testdata.classes) testloader = DataLoader(testdata, shuffle=True) if verbose > 0: print("Testing: ", end='') tester = Tester(net, testloader) tot, c = tester.run(testepochs) if c / tot <= last_test_score: num_no_progress_epochs += epochgroup else: num_no_progress_epochs = 0 if verbose > 0: print() if verbose > 0: print('Test:', c, "of", tot, ": %.4f" % (c / tot)) last_test_score = c / tot print('Epoch:', num_epochs, "Training loss: %.4f" % l, "Testing success: %.4f" % (c / tot), "No progress epochs", num_no_progress_epochs) if save: torch.save(net, save)
'data', image_set='train', download=True ) valid_dataset = CamVid( 'data', image_set='val', download=True ) train_transforms = transforms.Compose([ transforms.Resize(settings.IMAGE_SIZE), transforms.RandomRotation(15, fill=train_dataset.ignore_index), transforms.RandomGaussianBlur(), transforms.RandomHorizontalFlip(), transforms.ColorJitter(0.4, 0.4), transforms.ToTensor(), transforms.Normalize(settings.MEAN, settings.STD), ]) valid_transforms = transforms.Compose([ transforms.Resize(settings.IMAGE_SIZE), transforms.ToTensor(), transforms.Normalize(settings.MEAN, settings.STD), ]) train_dataset.transforms = train_transforms valid_dataset.transforms = valid_transforms train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=8, num_workers=4, shuffle=True)
def main(parser_data): device = torch.device( parser_data.device if torch.cuda.is_available() else "cpu") print("Using {} device training.".format(device.type)) if not os.path.exists("save_weights"): os.mkdir("save_weights") results_file = "results{}.txt".format( datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) data_transform = { "train": transforms.Compose([ transforms.SSDCropping(), transforms.Resize(), transforms.ColorJitter(), transforms.ToTensor(), transforms.RandomHorizontalFlip(), transforms.Normalization(), transforms.AssignGTtoDefaultBox() ]), "val": transforms.Compose([ transforms.Resize(), transforms.ToTensor(), transforms.Normalization() ]) } VOC_root = parser_data.data_path # check voc root if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False: raise FileNotFoundError( "VOCdevkit dose not in path:'{}'.".format(VOC_root)) # VOCdevkit -> VOC2012 -> ImageSets -> Main -> train.txt train_dataset = VOCDataSet(VOC_root, "2012", data_transform['train'], train_set='train.txt') # 注意训练时,batch_size必须大于1 batch_size = parser_data.batch_size assert batch_size > 1, "batch size must be greater than 1" # 防止最后一个batch_size=1,如果最后一个batch_size=1就舍去 drop_last = True if len(train_dataset) % batch_size == 1 else False nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers print('Using %g dataloader workers' % nw) train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=True, num_workers=nw, collate_fn=train_dataset.collate_fn, drop_last=drop_last) # VOCdevkit -> VOC2012 -> ImageSets -> Main -> val.txt val_dataset = VOCDataSet(VOC_root, "2012", data_transform['val'], train_set='val.txt') val_data_loader = torch.utils.data.DataLoader( val_dataset, batch_size=batch_size, shuffle=False, num_workers=nw, collate_fn=train_dataset.collate_fn) model = create_model(num_classes=args.num_classes + 1) model.to(device) # define optimizer params = [p for p in model.parameters() if p.requires_grad] optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005) # learning rate scheduler lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.3) # 如果指定了上次训练保存的权重文件地址,则接着上次结果接着训练 if parser_data.resume != "": checkpoint = torch.load(parser_data.resume, map_location='cpu') model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) parser_data.start_epoch = checkpoint['epoch'] + 1 print("the training process from epoch{}...".format( parser_data.start_epoch)) train_loss = [] learning_rate = [] val_map = [] # 提前加载验证集数据,以免每次验证时都要重新加载一次数据,节省时间 val_data = get_coco_api_from_dataset(val_data_loader.dataset) for epoch in range(parser_data.start_epoch, parser_data.epochs): mean_loss, lr = utils.train_one_epoch(model=model, optimizer=optimizer, data_loader=train_data_loader, device=device, epoch=epoch, print_freq=50) train_loss.append(mean_loss.item()) learning_rate.append(lr) # update learning rate lr_scheduler.step() coco_info = utils.evaluate(model=model, data_loader=val_data_loader, device=device, data_set=val_data) # write into txt with open(results_file, "a") as f: # 写入的数据包括coco指标还有loss和learning rate result_info = [ str(round(i, 4)) for i in coco_info + [mean_loss.item()] ] + [str(round(lr, 6))] txt = "epoch:{} {}".format(epoch, ' '.join(result_info)) f.write(txt + "\n") val_map.append(coco_info[1]) # pascal mAP # save weights save_files = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch)) # plot loss and lr curve if len(train_loss) != 0 and len(learning_rate) != 0: from plot_curve import plot_loss_and_lr plot_loss_and_lr(train_loss, learning_rate) # plot mAP curve if len(val_map) != 0: from plot_curve import plot_map plot_map(val_map)
faster_rcnn = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True) # get number of input features for the classifier in_features = faster_rcnn.roi_heads.box_predictor.cls_score.in_features # replace the pre-trained head with a new one faster_rcnn.roi_heads.box_predictor = FastRCNNPredictor(in_features, classes) return faster_rcnn # %% # use our dataset and defined transformations transformations = T.Compose( [ T.RandomHorizontalFlip(), T.RandomGrayscale(), T.ColorJitter(), T.RandomResizedCrop(size=(256, 256)), T.ToTensor(), ] ) test_transformations = T.Compose([T.ToTensor(),]) dataset_train = dataset.FRCNNFrameDataset( "data/images", "data/annotations/instances_default.json", transforms=transformations, ) dataset_test = dataset.FRCNNFrameDataset( "data/images",
best_top_5 = 0 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = [ transforms.Scale(256), transforms.RandomCrop(224), # transforms.RandomResizedCrop(224) ] # transform.extend([transforms.RandomResizedCrop(224)]) transform.extend([ # for inception 1 # transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.1, hue=0.0), transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.35, hue=0.1), # transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.3, hue=0.1), transforms.RandomHorizontalFlip(), ]) transform += [transforms.ToTensor()] # transform.append( # affine_transforms.Affine(rotation_range=20.0, translation_range=0.02, fill_mode='constant') # ) transform += [normalize] preprocess = transforms.Compose(transform)