def __init__(self, image_size, train=True): args = get_args() assert args.fp16 or args.bf16 self.data_type = torch.half if args.fp16 else torch.bfloat16 if train: self.transform = T.Compose([ T.RandomResizedCrop(image_size), T.RandomHorizontalFlip(), T.ColorJitter(0.4, 0.4, 0.4, 0.1), ImageNetPolicy(), T.ToTensor(), T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), T.ConvertImageDtype(self.data_type) ]) else: self.transform = T.Compose([ T.Resize(image_size), T.CenterCrop(image_size), T.ToTensor(), T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), T.ConvertImageDtype(self.data_type) ])
def get_transform_imagenet(mode: str, use_tuple: bool = False, auto_augment: bool = False) -> transforms.Compose: if mode == 'train': transform_list = [ transforms.RandomResizedCrop((224, 224) if use_tuple else 224), transforms.RandomHorizontalFlip(), # transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), # noqa ] if auto_augment: transform_list.append( transforms.AutoAugment(transforms.AutoAugmentPolicy.IMAGENET)) transform_list.append(transforms.PILToTensor()) transform_list.append(transforms.ConvertImageDtype(torch.float)) transform = transforms.Compose(transform_list) else: # TODO: torchvision.prototypes.transforms._presets.ImageClassificationEval transform = transforms.Compose([ transforms.Resize((256, 256) if use_tuple else 256), transforms.CenterCrop((224, 224) if use_tuple else 224), transforms.PILToTensor(), transforms.ConvertImageDtype(torch.float) ]) return transform
def get_transform_cifar( mode: str, auto_augment: bool = False, cutout: bool = False, cutout_length: int = None, data_shape: list[int] = [3, 32, 32]) -> transforms.Compose: if mode != 'train': return transforms.Compose([ transforms.PILToTensor(), transforms.ConvertImageDtype(torch.float) ]) cutout_length = cutout_length or data_shape[-1] // 2 transform_list = [ transforms.RandomCrop(data_shape[-2:], padding=data_shape[-1] // 8), transforms.RandomHorizontalFlip(), ] if auto_augment: transform_list.append( transforms.AutoAugment(transforms.AutoAugmentPolicy.CIFAR10)) transform_list.append(transforms.PILToTensor()) transform_list.append(transforms.ConvertImageDtype(torch.float)) if cutout: transform_list.append(Cutout(cutout_length)) return transforms.Compose(transform_list)
def test_float_to_float(self): input_dtype = torch.float32 output_dtype = torch.float64 input_image = torch.tensor((0.0, 1.0), dtype=input_dtype) transform = transforms.ConvertImageDtype(output_dtype) transform_script = torch.jit.script(F.convert_image_dtype) output_image = transform(input_image) output_image_script = transform_script(input_image, output_dtype) # TODO(b/181966788) Uncomment after upgrade to pytorch 1.9.0 is done. # torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6) actual_min, actual_max = output_image.tolist() self.assertAlmostEqual(0, actual_min) self.assertAlmostEqual(1, actual_max)
def __init__(self, imgs, latent_values, color_mode='rgb'): self.imgs = imgs self.latent_values = latent_values image_transforms = [trans.ToTensor(), trans.ConvertImageDtype(torch.float32), trans.Lambda(lambda x: x.flatten())] if color_mode == 'hsv': image_transforms.insert(0, trans.Lambda(rgb2hsv)) latent_transforms = [trans.Lambda(lambda x: x * self.lat_sizes), trans.Lambda(lambda x: torch.from_numpy(x).to( dtype=torch.float32))] self.transform = trans.Compose(image_transforms) self.target_transform = trans.Compose(latent_transforms)
async def initialize_job(self, job_args): return_type = job_args.get("return_type", "serialize") if return_type == "save": job_args["return_type"] = BGSplittingMapper.ReturnType.SAVE elif return_type == "serialize": job_args["return_type"] = BGSplittingMapper.ReturnType.SERIALIZE else: raise ValueError(f"Unknown return type: {return_type}") # Get checkpoint data if job_args["checkpoint_path"] == 'TEST': model = Model(num_main_classes=2, num_aux_classes=1) else: map_location = torch.device( 'cuda') if self.use_cuda else torch.device('cpu') checkpoint_state = torch.load(job_args["checkpoint_path"], map_location=map_location) from collections import OrderedDict new_state_dict = OrderedDict() for k, v in checkpoint_state['state_dict'].items(): name = k[7:] # remove `module.` new_state_dict[name] = v if 'model_kwargs' in checkpoint_state: kwargs = checkpoint_state['model_kwargs'] num_aux_classes = kwargs['num_aux_classes'] else: num_aux_classes = 1 # Create model model = Model(num_main_classes=2, num_aux_classes=num_aux_classes) # Load model weights model.load_state_dict(new_state_dict) model.eval() if self.use_cuda: model = model.cuda() job_args["model"] = model job_args["transform"] = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ConvertImageDtype(torch.float32), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) job_args["n_chunks_saved"] = 0 return job_args
def get_transform(self, mode: str, normalize: bool = None) -> transforms.Compose: r"""Get dataset transform based on :attr:`self.transform`. * ``None |'none'`` (:any:`torchvision.transforms.PILToTensor` and :any:`torchvision.transforms.ConvertImageDtype`) * ``'bit'`` (transform used in BiT network) * ``'pytorch'`` (pytorch transform used in ImageNet training). Args: mode (str): The dataset mode (e.g., ``'train' | 'valid'``). normalize (bool | None): Whether to use :any:`torchvision.transforms.Normalize` in dataset transform. Defaults to ``self.normalize``. Returns: torchvision.transforms.Compose: The transform sequence. """ normalize = normalize if normalize is not None else self.normalize if self.transform == 'bit': return get_transform_bit(mode, self.data_shape) elif self.data_shape == [3, 224, 224]: transform = get_transform_imagenet( mode, use_tuple=self.transform != 'pytorch', auto_augment=self.auto_augment) elif self.transform != 'none' and self.data_shape in ([3, 16, 16 ], [3, 32, 32]): transform = get_transform_cifar(mode, auto_augment=self.auto_augment, cutout=self.cutout, cutout_length=self.cutout_length, data_shape=self.data_shape) else: transform = transforms.Compose([ transforms.PILToTensor(), transforms.ConvertImageDtype(torch.float) ]) if normalize and self.norm_par is not None: transform.transforms.append( transforms.Normalize(mean=self.norm_par['mean'], std=self.norm_par['std'])) return transform
def test_convert_image_dtype(device, in_dtype, out_dtype): tensor, _ = _create_data(26, 34, device=device) batch_tensors = torch.rand(4, 3, 44, 56, device=device) in_tensor = tensor.to(in_dtype) in_batch_tensors = batch_tensors.to(in_dtype) fn = T.ConvertImageDtype(dtype=out_dtype) scripted_fn = torch.jit.script(fn) if (in_dtype == torch.float32 and out_dtype in (torch.int32, torch.int64)) or \ (in_dtype == torch.float64 and out_dtype == torch.int64): with pytest.raises(RuntimeError, match=r"cannot be performed safely"): _test_transform_vs_scripted(fn, scripted_fn, in_tensor) with pytest.raises(RuntimeError, match=r"cannot be performed safely"): _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors) return _test_transform_vs_scripted(fn, scripted_fn, in_tensor) _test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors)
def test_sort(): # img = Image.open('/Users/shuqin/Downloads/2DMOT2015/train/ETH-Sunnyday/img1/000001.jpg') # x = transform(img)[None] model = SORT() model.eval() transform = T.Compose([ T.PILToTensor(), T.ConvertImageDtype(torch.float) ]) img_list = ['000001.jpg', '000002.jpg', '000003.jpg'] dir_path = '/Users/shuqin/Downloads/2DMOT2015/train/ETH-Sunnyday/img1' for img in img_list: img = os.path.join(dir_path, img) x = transform(Image.open(img))[None] bbox = model(x) img = x.cpu().numpy().squeeze().transpose(1, 2, 0) plot_bbox(img, bbox)
def get_transform_npy(opt, params=None, grayscale=False, scale='A'): transform_list = [ transforms.ToTensor(), transforms.ConvertImageDtype(torch.float) ] if not opt.no_flip: if params is None: transform_list.append(transforms.RandomHorizontalFlip()) elif params['flip']: transform_list.append( transforms.Lambda(lambda img: __flip_npy(img, params['flip']))) if 'crop' in opt.preprocess: if params is None: transform_list.append(transforms.RandomCrop(opt.crop_size)) else: transform_list.append( transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.crop_size))) if scale == 'A': if grayscale: transform_list += [transforms.Normalize((0.5, ), (0.5, ))] else: transform_list += [ transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] elif scale == 'B': if grayscale: transform_list += [ transforms.Normalize((opt.B_bias, ), (opt.B_range, )) ] else: transform_list += [ transforms.Normalize((opt.B_bias, opt.B_bias, opt.B_bias), (opt.B_range, opt.B_range, opt.B_range)) ] return transform_list
def build_train_valid_datasets(data_path, crop_size=224, color_jitter=True): # training dataset train_data_path = os.path.join(data_path[0], "train") normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) process = [ transforms.RandomResizedCrop(crop_size), transforms.RandomHorizontalFlip(), ] if color_jitter: process += [ transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1 ) ] fp16_t = transforms.ConvertImageDtype(torch.half) process += [ImageNetPolicy(), transforms.ToTensor(), normalize, fp16_t] transform_train = transforms.Compose(process) train_data = datasets.ImageFolder( root=train_data_path, transform=transform_train ) # validation dataset val_data_path = os.path.join(data_path[0], "val") transform_val = transforms.Compose( [ transforms.Resize(crop_size), transforms.CenterCrop(crop_size), transforms.ToTensor(), normalize, fp16_t ] ) val_data = datasets.ImageFolder( root=val_data_path, transform=transform_val ) return train_data, val_data
out_path = os.path.join(prepared_path, f"set_{index + 1}", "images") if os.path.exists(out_path): if input(f"set_{index + 1} exists. Delete? (y/N)") == "y": shutil.rmtree(out_path) else: index += 1 cur_size = cur_size * 2 continue os.makedirs(out_path) transformation = transforms.Compose([ transforms.Resize((cur_size, cur_size)), transforms.ToTensor(), transforms.ConvertImageDtype(float), ]) images = datasets.ImageFolder(os.path.join(dest_fold, ".."), transformation) dataset = torch.utils.data.DataLoader( images, batch_size=16, shuffle=True, num_workers=3, ) for batch, _ in tqdm(dataset): for im in batch: image_name = f"image-{image}.png"
def get_data(batch_size, test_batch_size): # Transformations applied to both training and testing transform = list() transform.append(T.ConvertImageDtype(torch.float)) transform.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ) transform.append(T.Resize((256, 128))) # Transformations applied to training only training_transform = list() training_transform.append(T.RandomRotation(5)) training_transform.append(T.RandomCrop((256, 128), 10)) training_transform.append(T.RandomHorizontalFlip()) # Get data from the dataset full_training_data = Market1501Dataset( os.path.join("dataset", "train"), os.path.join("dataset", "annotations_train.csv"), transform=T.Compose(transform + training_transform), ) test_data = Market1501Dataset( os.path.join("dataset", "test"), transform=T.Compose(transform), ) query_data = Market1501Dataset( os.path.join("dataset", "queries"), transform=T.Compose(transform), ) # Create train and validation splits num_samples = len(full_training_data) training_samples = int(num_samples * 0.7 + 1) # Find the last person in the training set so to not cut data person_id = full_training_data.dict[training_samples][1] while (person_id == full_training_data.dict[training_samples][1]): training_samples += 1 person_id = full_training_data.dict[training_samples][1] # Create training and validation subset training_data = torch.utils.data.Subset( full_training_data, list(range(0, training_samples)), ) validation_data = torch.utils.data.Subset( full_training_data, list(range(training_samples, num_samples)), ) # Initialize dataloaders train_loader = torch.utils.data.DataLoader( training_data, batch_size, shuffle=True, num_workers=0, ) val_loader = torch.utils.data.DataLoader( validation_data, test_batch_size, shuffle=False, num_workers=0, ) test_loader = torch.utils.data.DataLoader( test_data, test_batch_size, shuffle=False, num_workers=0, ) query_loader = torch.utils.data.DataLoader( query_data, test_batch_size, shuffle=False, num_workers=0, ) return train_loader, val_loader, test_loader, query_loader, person_id
def __init__(self, directory: str, fname: str = 'index.csv', labels: str = 'label.csv', reverse_index: str = 'reverse_index.json', mean: List[float] = [0.48898, 0.46544, 0.42956], std: List[float] = [1, 1, 1], skip_image: bool = False, skip_masks: bool = False, target_concept: Union[BrodenConcept, List[BrodenConcept]] = None, categories: List[str] = ['object', 'part', 'material'], return_index: bool = False): # Compose index file path self.directory = directory # Read index from file index = os.path.join(directory, fname) with open(index, 'r') as fp: csv_reader = DictReader(fp) self.index = [row for row in csv_reader] # Read labels from file labels_path = os.path.join(directory, labels) with open(labels_path, 'r') as fp: csv_reader = DictReader(fp) self.labels = {int(row['number']): {**row} for row in csv_reader} # Reverse index if reverse_index: reverse_index_path = os.path.join(directory, reverse_index) with open(reverse_index_path, 'r') as fp: self.reverse_index = json.load(fp) # Convert string IDs to int IDs self.reverse_index = { int(k): v for k, v in self.reverse_index.items() } # Store preferences self.skip_image = skip_image self.skip_masks = skip_masks self.categories = categories self.target_concept = target_concept self.return_index = return_index # Adjust path for row in self.index: row['path'] = os.path.join(self.directory, 'images', row['image']) # Parse integers for row in self.index: for key in row: if key in ['ih', 'iw', 'sh', 'sw']: row[key] = int(row[key]) # Split lists for row in self.index: for key in row: if key in self.categories: if row[key]: row[key] = row[key].split(';') # Normalize self.mean = mean self.std = std self.normalizer = transforms.Compose([ transforms.ConvertImageDtype(torch.float32), transforms.Normalize(mean=self.mean, std=self.std) ])
def main(): import argparse from tqdm import tqdm import matplotlib.pyplot as plt from pprint import pprint import random from torch.utils.data import DataLoader from distutils.util import strtobool from pathlib import Path import shutil parser = argparse.ArgumentParser(description='datasetクラス単体テスト', formatter_class=argparse.ArgumentDefaultsHelpFormatter, fromfile_prefix_chars='@') parser.add_argument('-d','--dataset_dir', default="dataset/train", help='') parser.add_argument('-bs', '--batch_size', type=int, default=2, help='バッチサイズ') parser.add_argument('--workers', type=int, default=4, metavar='N', help='dataloader threads') parser.add_argument('--no-cuda', action='store_true', default= False, help='disables CUDA training') parser.add_argument('-s','--split', type=str, default='train', help='') parser.add_argument('-hf', '--horizontal_flip', type=str, default='True', help='') parser.add_argument('-hsr', '--horizontal_shift_ratio', type=float, default=0.125, help='') parser.add_argument('-vsr', '--vertical_shift_ratio', type=float, default=0.125, help='') parser.add_argument('-re', '--random_erasing', type=str, default='True', help='') parser.add_argument('-mu', '--random_mix_up', type=str, default='True', help='') args = parser.parse_args() pprint(args.__dict__) # 再現性を上げるためrandomを使用している場合はrandom.seed()でseedを設定する random.seed(0) # numpyで再現性を上げるためのの設定 np.random.seed(0) # pytorchで再現性を上げるための設定 torch.manual_seed(0) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False pipeline = [ tr.ConvertImageDtype(torch.float32), tr.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] if strtobool(args.horizontal_flip) == 1: pipeline.append(tr.RandomHorizontalFlip(p=0.5)) pipeline.append(tr.RandomAffine(0,translate=(args.horizontal_shift_ratio,args.vertical_shift_ratio))) if strtobool(args.random_erasing) == 1: pipeline.append(tr.RandomErasing()) if args.no_cuda is strtobool(args.random_mix_up): pipeline.append(K.RandomMixUp()) transform = nn.Sequential(*pipeline) if args.no_cuda is False: transform.to(torch.device('cuda:0')) dataset=PlantPathologyDataset(args, split=args.split, transform=transform) kwargs = {'num_workers': args.workers, 'pin_memory': True} train_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, drop_last=True, **kwargs) # mean,std=(0.485, 0.456, 0.406), (0.229, 0.224, 0.225) mean,std=(0.5, 0.5, 0.5), (0.5, 0.5, 0.5) output_dir=Path('augumented_images') if output_dir.exists(): shutil.rmtree(str(output_dir)) output_dir.mkdir(parents=True, exist_ok=True) tbar = tqdm(train_loader) num_img_tr = len(train_loader) for index, sample in enumerate(tbar): images, targets = sample['image'],sample['label'] if args.no_cuda is False: images, targets = images.cpu().detach().numpy(), targets.cpu().detach().numpy() else: images, targets = images.detach().numpy(), targets.detach().numpy() print(targets) for image_num, image in enumerate(images): img=image.transpose(1,2,0) img*=std img+=mean img*=255. img=img.astype(np.uint8) plt.imshow(img) plt.savefig(str(output_dir)+os.sep+str(index)+"_"+str(image_num)+".jpg") # plt.show() """
return out, self.loss(out, labels) return out model = CustomResNet18(10) # Casting a model's parameters model = model.half() # Prepare the data transform = transforms.Compose([ transforms.Grayscale(num_output_channels=3), transforms.Resize(224), transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, )), transforms.ConvertImageDtype(torch.half) ]) train_dataset = torchvision.datasets.FashionMNIST("./datasets/", transform=transform, download=True, train=True) test_dataset = torchvision.datasets.FashionMNIST("./datasets/", transform=transform, download=True, train=False) # Optimizer and loss scaling optimizer = poptorch.optim.SGD(model.parameters(), lr=0.001, loss_scaling=1000) # Set PopTorch's options opts = poptorch.Options()
def train(config, checkpoint=None): # Load constants. c_lambda = int(config.get("gradient_lambda", 10)) noise_size = int(config.get("noise_length", 512)) device = config.get("device", "cuda") beta_1 = float(config.get("beta_1", 0.00)) beta_2 = float(config.get("beta_2", 0.99)) learning_rate = float(config.get("lr", 0.001)) critic_repeats = int(config.get("critic_repeats", 1)) use_r1_loss = str(config.get("use_r1", "True")) == "True" num_workers = int(config.get("dataloader_threads", 2)) display_step = int(config.get("display_step", 250)) checkpoint_step = int(config.get("checkpoint_step", 2000)) refresh_stat_step = int(config.get("refresh_stat_step", 5)) # The batch size in each image size progression. batch_progression = config.get("batch_progression").split(",") batch_progression = list(map(int, batch_progression)) # The number of epochs in each image size progression. epoch_progresson = config.get("epoch_progression").split(",") epoch_progresson = list(map(int, epoch_progresson)) # Percentage of each step that will be a fade in. fade_in_percentage = float(config.get("fade_percentage", 0.5)) transformation = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True), transforms.ConvertImageDtype(float), ]) # Path to dataset. data_path = config.get("data", None) if not os.path.exists(os.path.join(data_path, "prepared")): raise OSError("Did not detect prepared dataset!") # Initialize Generator gen = Generator().to(device) gen_opt = torch.optim.Adam( [ { "params": gen.to_w_noise.parameters(), "lr": (learning_rate * 0.01), }, { "params": gen.gen_blocks.parameters() }, { "params": gen.to_rgbs.parameters() }, ], lr=learning_rate, betas=(beta_1, beta_2), ) gen = nn.DataParallel(gen) gen.train() # Initialize Critic critic = Critic().to(device) critic_opt = torch.optim.Adam(critic.parameters(), lr=learning_rate, betas=(beta_1, beta_2)) critic = nn.DataParallel(critic) critic.train() # Create a constant set of noise vectors to show image progression. show_noise = get_truncated_noise(25, 512, 0.75).to(device) # Some other variables to track. iters = 0 c_loss_history = [] g_loss_history = [] if checkpoint is not None: save = torch.load(checkpoint) gen.load_state_dict(save["gen"]) critic.load_state_dict(save["critic"]) iters = save["iter"] im_count = save["im_count"] last_step = save["step"] last_epoch = save["epoch"] else: last_step = None last_epoch = None for index, step_epochs in enumerate(epoch_progresson): if last_step is not None and index + 1 < last_step: continue steps = int(index + 1) im_count = 0 images = datasets.ImageFolder( os.path.join(data_path, "prepared", f"set_{steps}"), transformation) dataset = torch.utils.data.DataLoader( images, batch_size=batch_progression[index], shuffle=True, num_workers=num_workers, ) fade_in = fade_in_percentage * step_epochs * len(dataset) print(f"STARTING STEP #{steps}") for epoch in range(step_epochs): if last_epoch is not None and epoch < last_epoch: continue else: last_epoch = None pbar = tqdm(dataset) for real_im, _ in pbar: cur_batch_size = len(real_im) set_requires_grad(critic, True) set_requires_grad(gen, False) for i in range(critic_repeats): z_noise = get_truncated_noise(cur_batch_size, noise_size, 0.75).to(device) alpha = im_count / fade_in if alpha > 1.0: alpha = None fake_im = gen(z_noise, steps=steps, alpha=alpha) real_im = (torch.nn.functional.interpolate( real_im, size=(fake_im.shape[2], fake_im.shape[3]), mode="bilinear", ).to(device, dtype=torch.float).requires_grad_()) critic_fake_pred = critic(fake_im.detach(), steps, alpha) critic_real_pred = critic(real_im, steps, alpha) critic.zero_grad() if use_r1_loss: c_loss = critic.module.get_r1_loss( critic_fake_pred, critic_real_pred, real_im, fake_im, steps, alpha, c_lambda, ) else: c_loss = critic.module.get_wgan_loss( critic_fake_pred, critic_real_pred, real_im, steps, alpha, c_lambda, ) critic_opt.step() im_count += cur_batch_size c_loss_history.append(c_loss.item()) set_requires_grad(critic, False) set_requires_grad(gen, True) noise = get_truncated_noise(cur_batch_size, noise_size, 0.75).to(device) alpha = im_count / fade_in if alpha > 1.0: alpha = None fake_images = gen(noise, steps=steps, alpha=alpha) critic_fake_pred = critic(fake_images, steps, alpha) if use_r1_loss: g_loss = gen.module.get_r1_loss(critic_fake_pred) else: g_loss = gen.module.get_wgan_loss(critic_fake_pred) gen.zero_grad() g_loss.backward() gen_opt.step() g_loss_history.append(g_loss.item()) iters += 1 if iters > 0 and iters % refresh_stat_step == 0: avg_c_loss = (sum(c_loss_history[-refresh_stat_step:]) / refresh_stat_step) avg_g_loss = (sum(g_loss_history[-refresh_stat_step:]) / refresh_stat_step) pbar.set_description( f"g_loss: {avg_g_loss:.3} c_loss: {avg_c_loss:.3} epoch: {epoch + 1}", refresh=True, ) with torch.no_grad(): examples = gen(show_noise, alpha=alpha, steps=steps) if iters > 0 and iters % display_step == 0: display_image( torch.clamp(examples, 0, 1), save_to_disk=True, filename="s-{}".format(iters), title="Iteration {}".format(iters), num_display=25, ) if iters > 0 and iters % checkpoint_step == 0: torch.save( { "gen": gen.state_dict(), "critic": critic.state_dict(), "iter": iters, "im_count": im_count, "step": steps, "epoch": epoch, "alpha": alpha, }, f"./checkpoints/chk-{iters}.pth", ) # TRAINING FINISHED - save final set of samples and save model. examples = gen(show_noise, alpha=alpha, steps=steps) torch.save( { "gen": gen.state_dict(), "critic": critic.state_dict(), "iter": iters, "im_count": im_count, "step": steps, "epoch": epoch, "alpha": None, }, "./checkpoints/FINAL.pth", ) print("TRAINING IS FINISHED - MODEL SAVED!")
def get_transform(name, args): # # GENERIC # if name == "Lambda": t = T.Lambda(**args) # # TRANSFORM MULTI ON IMGS ONLY # elif name == "RandomChoice": tt = config_transform(args["transforms"]) t = T.RandomChoice(tt) elif name == "RandomOrder": tt = config_transform(args["transforms"]) t = T.RandomOrder(tt) # # TRANSFORM MULTI ON TENSOR + PIL IMAGE # elif name == "RandomApply": tt = config_transform(args["transforms"]) t = T.RandomApply(tt, p=args['p']) # # TRANSFORM ON TENSOR + PIL IMAGE # elif name == "ColorJitter": t = T.ColorJitter(**args) elif name == "Grayscale": t = T.Grayscale(**args) elif name == "Pad": t = T.Pad(**args) elif name == "RandomAffine": t = T.RandomAffine(**args) elif name == "RandomGrayscale": t = T.RandomGrayscale(**args) elif name == "RandomHorizontalFlip": t = T.RandomHorizontalFlip(**args) elif name == "RandomPerspective": t = T.RandomPerspective(**args) elif name == 'RandomResizedCrop': t = T.RandomResizedCrop(**args) elif name == "RandomRotation": t = T.RandomRotation(**args) elif name == "RandomVerticalFlip": t = T.RandomVerticalFlip(**args) elif name == "Resize": t = T.Resize(**args) elif name == "GaussianBlur": t = T.GaussianBlur(**args) # # TRANSFORM ON TENSOR ONLY # elif name == "Normalize": t = T.Normalize(**args) elif name == "RandomErasing": t = T.RandomErasing(**args) elif name == "ConvertImageDtype": t = T.ConvertImageDtype(**args) elif name == "ToPILImage": t = T.ToPILImage(**args) elif name == "ToTensor": t = T.ToTensor() else: raise NotImplementedError(transform_name) return t
def test_convert_image_dtype_save_load(tmpdir): fn = T.ConvertImageDtype(dtype=torch.uint8) _test_fn_save_load(fn, tmpdir)
def test_convert_image_dtype_save(): fn = T.ConvertImageDtype(dtype=torch.uint8) scripted_fn = torch.jit.script(fn) with get_tmp_dir() as tmp_dir: scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt"))
import torchvision.transforms as transforms import torchvision.models as models from torch.utils.data import Dataset sys.path.append(os.getcwd()) from dataset import FlickrDataLoader from cunet import Conditional_UNet if __name__ == '__main__': # os.makedirs(os.path.join(save_path, 'out'), exist_ok=True) cols = ['tempC', 'uvIndex', 'visibility', 'windspeedKmph', 'cloudcover', 'humidity', 'pressure', 'DewPointC'] transform = nn.Sequential( # transforms.Resize((args.input_size,) * 2), transforms.ConvertImageDtype(torch.float32), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ) temp = pd.read_pickle('/mnt/fs2/2019/Takamuro/m2_research/flicker_data/wwo/2016_17/lambda_0/outdoor_all_dbdate_wwo_weather_2016_17_delnoise_WoPerson_sky-10_L-05.pkl') df_ = temp.loc[:, cols].fillna(0) df_mean = df_.mean() df_std = df_.std() df_max = df_.max() df_min = df_.min() df = pd.read_pickle(args.pkl_path) df.loc[:, cols] = (df.loc[:, cols].fillna(0) - df_mean) / df_std df_sep = df[df['mode'] == 'test']
def main(args): if args.apex and amp is None: raise RuntimeError( "Failed to import apex. Please install apex from https://www.github.com/nvidia/apex " "to enable mixed-precision training.") if args.output_dir: utils.mkdir(args.output_dir) utils.init_distributed_mode(args) print(args) print("torch version: ", torch.__version__) print("torchvision version: ", torchvision.__version__) device = torch.device(args.device) torch.backends.cudnn.benchmark = True # Data loading code print("Loading data") traindir = os.path.join(args.data_path, args.train_dir) valdir = os.path.join(args.data_path, args.val_dir) normalize = T.Normalize(mean=[0.43216, 0.394666, 0.37645], std=[0.22803, 0.22145, 0.216989]) print("Loading training data") st = time.time() cache_path = _get_cache_path(traindir) transform_train = torchvision.transforms.Compose([ ConvertBHWCtoBCHW(), T.ConvertImageDtype(torch.float32), T.Resize((128, 171)), T.RandomHorizontalFlip(), normalize, T.RandomCrop((112, 112)), ConvertBCHWtoCBHW() ]) if args.cache_dataset and os.path.exists(cache_path): print("Loading dataset_train from {}".format(cache_path)) dataset, _ = torch.load(cache_path) dataset.transform = transform_train else: if args.distributed: print("It is recommended to pre-compute the dataset cache " "on a single-gpu first, as it will be faster") dataset = torchvision.datasets.Kinetics400( traindir, frames_per_clip=args.clip_len, step_between_clips=1, transform=transform_train, frame_rate=15, extensions=( 'avi', 'mp4', )) if args.cache_dataset: print("Saving dataset_train to {}".format(cache_path)) utils.mkdir(os.path.dirname(cache_path)) utils.save_on_master((dataset, traindir), cache_path) print("Took", time.time() - st) print("Loading validation data") cache_path = _get_cache_path(valdir) transform_test = torchvision.transforms.Compose([ ConvertBHWCtoBCHW(), T.ConvertImageDtype(torch.float32), T.Resize((128, 171)), normalize, T.CenterCrop((112, 112)), ConvertBCHWtoCBHW() ]) if args.cache_dataset and os.path.exists(cache_path): print("Loading dataset_test from {}".format(cache_path)) dataset_test, _ = torch.load(cache_path) dataset_test.transform = transform_test else: if args.distributed: print("It is recommended to pre-compute the dataset cache " "on a single-gpu first, as it will be faster") dataset_test = torchvision.datasets.Kinetics400( valdir, frames_per_clip=args.clip_len, step_between_clips=1, transform=transform_test, frame_rate=15, extensions=( 'avi', 'mp4', )) if args.cache_dataset: print("Saving dataset_test to {}".format(cache_path)) utils.mkdir(os.path.dirname(cache_path)) utils.save_on_master((dataset_test, valdir), cache_path) print("Creating data loaders") train_sampler = RandomClipSampler(dataset.video_clips, args.clips_per_video) test_sampler = UniformClipSampler(dataset_test.video_clips, args.clips_per_video) if args.distributed: train_sampler = DistributedSampler(train_sampler) test_sampler = DistributedSampler(test_sampler) data_loader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, sampler=train_sampler, num_workers=args.workers, pin_memory=True, collate_fn=collate_fn) data_loader_test = torch.utils.data.DataLoader(dataset_test, batch_size=args.batch_size, sampler=test_sampler, num_workers=args.workers, pin_memory=True, collate_fn=collate_fn) print("Creating model") model = torchvision.models.video.__dict__[args.model]( pretrained=args.pretrained) model.to(device) if args.distributed and args.sync_bn: model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) criterion = nn.CrossEntropyLoss() lr = args.lr * args.world_size optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=args.momentum, weight_decay=args.weight_decay) if args.apex: model, optimizer = amp.initialize(model, optimizer, opt_level=args.apex_opt_level) # convert scheduler to be per iteration, not per epoch, for warmup that lasts # between different epochs warmup_iters = args.lr_warmup_epochs * len(data_loader) lr_milestones = [len(data_loader) * m for m in args.lr_milestones] lr_scheduler = WarmupMultiStepLR(optimizer, milestones=lr_milestones, gamma=args.lr_gamma, warmup_iters=warmup_iters, warmup_factor=1e-5) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu]) model_without_ddp = model.module if args.resume: 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: evaluate(model, criterion, data_loader_test, device=device) return print("Start training") start_time = time.time() for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader, device, epoch, args.print_freq, args.apex) evaluate(model, criterion, data_loader_test, device=device) if args.output_dir: checkpoint = { 'model': model_without_ddp.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch, 'args': args } utils.save_on_master( checkpoint, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch))) utils.save_on_master( checkpoint, os.path.join(args.output_dir, 'checkpoint.pth')) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str))
def main(args): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if args.use_deterministic_algorithms: torch.backends.cudnn.benchmark = False torch.use_deterministic_algorithms(True) else: torch.backends.cudnn.benchmark = True p = args.labels_per_batch k = args.samples_per_label batch_size = p * k model = EmbeddingNet() if args.resume: model.load_state_dict(torch.load(args.resume)) model.to(device) criterion = TripletMarginLoss(margin=args.margin) optimizer = Adam(model.parameters(), lr=args.lr) transform = transforms.Compose([ transforms.Lambda(lambda image: image.convert("RGB")), transforms.Resize((224, 224)), transforms.PILToTensor(), transforms.ConvertImageDtype(torch.float), ]) # Using FMNIST to demonstrate embedding learning using triplet loss. This dataset can # be replaced with any classification dataset. train_dataset = FashionMNIST(args.dataset_dir, train=True, transform=transform, download=True) test_dataset = FashionMNIST(args.dataset_dir, train=False, transform=transform, download=True) # targets is a list where the i_th element corresponds to the label of i_th dataset element. # This is required for PKSampler to randomly sample from exactly p classes. You will need to # construct targets while building your dataset. Some datasets (such as ImageFolder) have a # targets attribute with the same format. targets = train_dataset.targets.tolist() train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=PKSampler(targets, p, k), num_workers=args.workers) test_loader = DataLoader(test_dataset, batch_size=args.eval_batch_size, shuffle=False, num_workers=args.workers) if args.test_only: # We disable the cudnn benchmarking because it can noticeably affect the accuracy torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True evaluate(model, test_loader, device) return for epoch in range(1, args.epochs + 1): print("Training...") train_epoch(model, optimizer, criterion, train_loader, device, epoch, args.print_freq) print("Evaluating...") evaluate(model, test_loader, device) print("Saving...") save(model, epoch, args.save_dir, "ckpt.pth")
def test_convert_image_dtype_save(tmpdir): fn = T.ConvertImageDtype(dtype=torch.uint8) scripted_fn = torch.jit.script(fn) scripted_fn.save(os.path.join(tmpdir, "t_convert_dtype.pt"))
from torch.utils.data import DataLoader from torchvision import transforms as T from tqdm import tqdm import dataset import config_baseline as config import engine from utils import seed_everything, set_debug_apis import timm if __name__ == "__main__": seed_everything(42) set_debug_apis(False) train_trasforms = T.Compose([ T.ConvertImageDtype(torch.float32), T.Resize((config.IMG_WIDTH, config.IMG_HEIGHT)), T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) full_dataset = dataset.RetinopathyDataset(config.TRAIN_DIR, config.CSV_PATH, transforms=train_trasforms) train_size = int(config.TRAIN_SPLIT * len(full_dataset)) test_size = len(full_dataset) - train_size train_dataset, val_dataset = torch.utils.data.random_split( full_dataset, [train_size, test_size]) train_loader = DataLoader(full_dataset,
# ---------------------------------------------------- # # -------------- Training (Fine-tuning) -------------- # # ---------------------------------------------------- # num_epochs = 200 # total number of epochs to train bsize_train = 4 # training data batch sizes bsize_val = 4 # validation data batch sizes lr = 0.001 # learning rate # More hyperparam-s below: "optimizer_ft": optimizer, "exp_lr_scheduler": lr policy # Pre-processing settings (defaults for ImageNet dataset) img_size = 512 transform = T.Compose([T.ToPILImage(), T.RandomRotation((-3,3)), T.RandomResizedCrop(img_size, scale=(0.8, 1.0)), T.RandomHorizontalFlip(), T.ToTensor(), T.ConvertImageDtype(dtype), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]) val_transform = T.Compose([T.ToPILImage(), T.Resize(img_size), T.ToTensor(), T.ConvertImageDtype(dtype), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]) test_transform = val_transform # ----------- Initialize and split datasets ------------ # np.random.seed(42) #seed np RNG for consistency # Split the original training data into 85% / 15% train/val datasets datasets = LoadTrainingData(train_csv, train_data_path, transform=transform, split=True, train_percent=80, val_transform=val_transform) print(f"Training dataset: {len(datasets['train'])} samples.",
def trial_process(self, trial, optimizer, learning_rate, horizontal_flip, horizontal_shift_ratio, vertical_shift_ratio, random_erasing): self.best_pred = 0.0 self.start_run(trial) # mlflowにtrialごとの情報をロギング self.log_trial(trial) self.model = EfficientNet.from_pretrained(self.args.backbone) # Unfreeze model weights for param in self.model.parameters(): param.requires_grad = True num_ftrs = self.model._fc.in_features self.model._fc = nn.Linear(num_ftrs, self.args.nclass) if self.args.smry_viz: from torchinfo import summary from torchviz import make_dot dummy_image = torch.zeros((2, 3, 32, 32)) dummy_output = self.model(dummy_image) make_dot(dummy_output, params=dict( self.model.named_parameters())).render("torchviz", format="png") summary(self.model, (1, 3, 32, 32)) import sys sys.exit() if self.args.cuda: self.model = self.model.to('cuda') if optimizer == 'SGD': self.optimizer = optim.SGD(self.model.parameters(), lr=learning_rate) elif optimizer == 'Adam': self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate) # DataLoaderのセットアップ kwargs = {'num_workers': self.args.workers, 'pin_memory': True} """ composed_transforms = nn.Sequential( tr.RandomHorizontalFlip(), # tr.RandomScaleCrop(base_size=self.args.base_size, crop_size=self.args.crop_size), # tr.RandomGaussianBlur(), tr.ConvertImageDtype(torch.float32), tr.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), # tr.ToTensor() )#.to(torch.device('cuda:0')) """ pipeline = [ # tr.ToTensor(), tr.ConvertImageDtype(torch.float32), tr.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] if strtobool(horizontal_flip) == 1: pipeline.append(tr.RandomHorizontalFlip(p=0.5)) pipeline.append( tr.RandomAffine(0, translate=(horizontal_shift_ratio, vertical_shift_ratio))) if strtobool(random_erasing) == 1: pipeline.append(tr.RandomErasing()) # transform = tr.Compose(pipeline) transform = nn.Sequential(*pipeline) if self.args.no_cuda is False: transform.to(torch.device('cuda:0')) # train train_set = PlantPathologyDataset(self.args, self.args.dataset_dir + os.sep + "train", split='train', transform=transform) self.train_loader = DataLoader(train_set, batch_size=self.args.batch_size, shuffle=True, drop_last=True, **kwargs) # val val_set = PlantPathologyDataset(self.args, self.args.dataset_dir + os.sep + "val", split='val', transform=transform) self.val_loader = DataLoader(val_set, batch_size=self.args.batch_size, shuffle=True, drop_last=True, **kwargs) self.criterion = nn.BCELoss() for epoch in range(self.args.start_epoch, self.args.epochs): self.training(epoch) if not self.args.no_val and epoch % self.args.eval_interval == ( self.args.eval_interval - 1): best_score = self.validating(epoch) self.end_run() # scoring by best return 1.0 - best_score