def cache_func(self, i):
# caches the ith chunk of images
# custom function for using HDF5Cache
lr_images = []
hr_images = []
offset = i * self.cache.cache_size // self.mult
for idx in range(self.cache.cache_size // self.mult):
if offset + idx + 1 > 800:
idx -= self.cache.cache_size
img_hr_name = ("./datasets/saved/DIV2K_train_HR/" +
str(offset + idx + 1).zfill(4) + ".png")
img_lr_name = (
f"./datasets/saved/DIV2K_train_LR_bicubic/X{self.factor}/" +
str(offset + idx + 1).zfill(4) + f"x{self.factor}.png")
# C,H,W
img_hr = Image.open(img_hr_name)
img_lr = Image.open(img_lr_name)
hr_size = self.size * self.factor
f = self.factor
for j in range(self.mult):
ii, j, k, l = RandomCrop.get_params(
img_hr,
(hr_size, hr_size)) # can't use i as variable name :/
hr_crop = TF.crop(img_hr, ii, j, k, l)
lr_crop = TF.crop(img_lr, ii // f, j // f, k // f, l // f)
lr_images.append(ToTensor()(lr_crop))
hr_images.append(ToTensor()(hr_crop))
lr_stacked = np.stack(lr_images)
hr_stacked = np.stack(hr_images)
# print(lr_stacked.shape)
lr_type = lr_stacked.astype(np.float32)
hr_type = hr_stacked.astype(np.float32)
self.cache.cache_images(i, lr_type, hr_type)
def train_hr_transform(crop_size):
return Compose([
RandomCrop(crop_size),
# Resize((128,128), interpolation=Image.BICUBIC),
ToTensor()
# Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
def transform_target(crop_size):
"""Ground truth image
"""
return Compose([
RandomCrop(crop_size),
RandomHorizontalFlip(),
])
def img_transform(self, crop_size):
normalize = Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
return Compose(
[Resize([512, 384]),
RandomCrop(crop_size),
ToTensor(), normalize])
def __init__(self, opts):
self.dataroot = opts.dataroot
self.num_domains = opts.num_domains
self.input_dim = opts.input_dim
self.nz = opts.input_nz
domains = [chr(i) for i in range(ord('A'),ord('Z')+1)]
self.images = [None]*self.num_domains
stats = ''
for i in range(self.num_domains):
img_dir = os.path.join(self.dataroot, opts.phase + domains[i])
ilist = os.listdir(img_dir)
self.images[i] = [os.path.join(img_dir, x) for x in ilist]
stats += '{}: {}'.format(domains[i], len(self.images[i]))
stats += ' images'
self.dataset_size = max([len(self.images[i]) for i in range(self.num_domains)])
# setup image transformation
transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)]
if opts.phase == 'train':
transforms.append(RandomCrop(opts.img_size))
else:
transforms.append(CenterCrop(opts.img_size))
if not opts.no_flip:
transforms.append(RandomHorizontalFlip())
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
self.transforms = Compose(transforms)
return
def transform_train(self, data, targets=None, batch_size=None):
short_edge_length = min(data.shape[1], data.shape[2])
common_list = [
Normalize(torch.Tensor(self.mean), torch.Tensor(self.std))
]
if self.augment:
compose_list = [
ToPILImage(),
RandomCrop(data.shape[1:3], padding=4),
RandomHorizontalFlip(),
ToTensor()
] + common_list + [
Cutout(n_holes=Constant.CUTOUT_HOLES,
length=int(short_edge_length * Constant.CUTOUT_RATIO))
]
else:
compose_list = common_list
dataset = self._transform(compose_list, data, targets)
if batch_size is None:
batch_size = Constant.MAX_BATCH_SIZE
batch_size = min(len(data), batch_size)
return DataLoader(dataset, batch_size=batch_size, shuffle=True)
def __init__(self, opt, val=False):
super(CustomCIFAR100, self).__init__()
dir_dataset = opt.dir_dataset
if val:
self.dataset = CIFAR100(root=dir_dataset,
train=False,
download=True)
self.transform = Compose([
ToTensor(),
Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276])
])
else:
self.dataset = CIFAR100(root=dir_dataset,
train=True,
download=True)
self.transform = Compose([
RandomCrop((32, 32),
padding=4,
fill=0,
padding_mode='constant'),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276])
])
def __getitem__(self, index):
input = load_img(self.image_filenames[index]) #input是预先合成的4通道RGDB图片
#数据增强
if self.crop:
input = RandomCrop(64)(input) #取patch
input = RandomHorizontalFlip()(input) #水平翻转
input = RandomVerticalFlip()(input) #竖直翻转
input = RandomRotation(180)(input) #随机旋转
input_tensor = ToTensor()(input)
rgb_tensor = torch.zeros(3, input_tensor.shape[1],
input_tensor.shape[2])
depth_tensor = torch.zeros(1, input_tensor.shape[1],
input_tensor.shape[2])
rgb_tensor[0, :, :] = input_tensor[0, :, :]
rgb_tensor[1, :, :] = input_tensor[1, :, :]
rgb_tensor[2, :, :] = input_tensor[2, :, :]
depth_tensor[0, :, :] = input_tensor[3, :, :]
depth = ToPILImage()(depth_tensor)
size = min(depth.size[0], depth.size[1])
guide = ToPILImage()(rgb_tensor)
target = depth.copy()
guide = guide.convert('L')
#生成LR
depth = downsampling(depth, self.upscale_factor)
depth = Resize(size=size, interpolation=Image.BICUBIC)(depth)
depth = ToTensor()(depth)
guide = ToTensor()(guide)
depth = torch.cat((depth, guide), 0) #concatenate 生成输入张量
target = ToTensor()(target)
return depth, target
def transform_d(self, image, mask):
"""
Random crop + Random horizontal flipping + Random vertical flipping
"""
# Random crop
i, j, h, w = RandomCrop.get_params(image,
output_size=(self.crop_size,
self.crop_size))
image = TF.crop(image, i, j, h, w)
mask = TF.crop(mask, i, j, h, w)
# resize
image = image
image = TF.resize(image, (self.crop_size // self.upscale_factor,
self.crop_size // self.upscale_factor))
# Random horizontal flipping
if random.random() > 0.5:
image = TF.hflip(image)
mask = TF.hflip(mask)
# Random vertical flipping
if random.random() > 0.5:
image = TF.vflip(image)
mask = TF.vflip(mask)
# Transform to tensor
image = TF.to_tensor(image)
mask = TF.to_tensor(mask)
return image, mask
def get_transforms(augment):
valid_t = Compose([Resize(256),
CenterCrop(224),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
if augment == False:
train_t = valid_t
elif augment == True:
train_t = Compose([RandomResizedCrop(224),
RandomHorizontalFlip(),
ToTensor(),
ColorJitter(),
Lighting(_ImageNet['PCA']),
Normalize(**_ImageNet['Normalize'])])
elif augment == "torchvision":
train_t = Compose([RandomResizedCrop(224),
RandomHorizontalFlip(),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
elif augment == "torchvision2":
train_t = Compose([Resize(256),
RandomCrop(224),
RandomHorizontalFlip(),
ToTensor(),
Normalize(**_ImageNet['Normalize'])])
else:
assert(False)
transforms = {
'training': train_t,
'validation': valid_t
}
return transforms
def transform_train(self, data, targets=None, batch_size=None):
""" Transform the training data, perform random cropping data augmentation and basic random flip augmentation.
Args:
batch_size: int batch_size.
targets: the target of training set.
Returns:
A DataLoader class instance.
"""
short_edge_length = min(data.shape[1], data.shape[2])
common_list = [Normalize(torch.Tensor(self.mean), torch.Tensor(self.std))]
if self.augment:
compose_list = [ToPILImage(),
RandomCrop(data.shape[1:3], padding=4),
RandomHorizontalFlip(),
ToTensor()
] + common_list + [Cutout(n_holes=Constant.CUTOUT_HOLES,
length=int(short_edge_length * Constant.CUTOUT_RATIO))]
else:
compose_list = common_list
if len(data.shape) != 4:
compose_list = []
dataset = self._transform(compose_list, data, targets)
if batch_size is None:
batch_size = Constant.MAX_BATCH_SIZE
batch_size = min(len(data), batch_size)
return DataLoader(dataset, batch_size=batch_size, shuffle=True)
def image_crop_rescale(sample, crop_size, color_mode):
image = ToPILImage(mode=color_mode)(sample)
cropped_image = RandomCrop(crop_size)(image)
rescaled_image = Resize((sample.shape[1], sample.shape[2]),
interpolation=0)(cropped_image)
cropped_rescaled_sample = ToTensor()(rescaled_image)
return cropped_rescaled_sample
def main(args):
# --- CONFIG
device = torch.device(f"cuda:{args.cuda}"
if torch.cuda.is_available() and
args.cuda >= 0 else "cpu")
n_batches = 5
# ---------
# --- TRANSFORMATIONS
train_transform = transforms.Compose([
RandomCrop(28, padding=4),
ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
test_transform = transforms.Compose([
ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# ---------
# --- SCENARIO CREATION
mnist_train = MNIST('./data/mnist', train=True,
download=True, transform=train_transform)
mnist_test = MNIST('./data/mnist', train=False,
download=True, transform=test_transform)
scenario = nc_scenario(
mnist_train, mnist_test, n_batches, task_labels=False, seed=1234)
# ---------
# MODEL CREATION
model = SimpleMLP(num_classes=scenario.n_classes)
# choose some metrics and evaluation method
interactive_logger = InteractiveLogger()
eval_plugin = EvaluationPlugin(
accuracy_metrics(
minibatch=True, epoch=True, experience=True, stream=True),
loss_metrics(minibatch=True, epoch=True, experience=True, stream=True),
ExperienceForgetting(),
loggers=[interactive_logger])
# CREATE THE STRATEGY INSTANCE (NAIVE)
cl_strategy = Naive(model, torch.optim.Adam(model.parameters(), lr=0.001),
CrossEntropyLoss(),
train_mb_size=100, train_epochs=4, eval_mb_size=100, device=device,
plugins=[ReplayPlugin(mem_size=10000)],
evaluator=eval_plugin
)
# TRAINING LOOP
print('Starting experiment...')
results = []
for experience in scenario.train_stream:
print("Start of experience ", experience.current_experience)
cl_strategy.train(experience)
print('Training completed')
print('Computing accuracy on the whole test set')
results.append(cl_strategy.eval(scenario.test_stream))
def __init__(self, seq_name, vis_threshold, P, K, max_per_person, crop_H, crop_W,
transform, normalize_mean=None, normalize_std=None):
self.data_dir = osp.join(cfg.DATA_DIR, 'cuhk03_release')
self.raw_mat_path = osp.join(self.data_dir, 'cuhk-03.mat')
if not osp.exists(self.raw_mat_path):
raise RuntimeError("'{}' is not available".format(self.raw_mat_path))
self.seq_name = seq_name
self.P = P
self.K = K
self.max_per_person = max_per_person
self.crop_H = crop_H
self.crop_W = crop_W
if transform == "random":
self.transform = Compose([RandomCrop((crop_H, crop_W)), RandomHorizontalFlip(), ToTensor(), Normalize(normalize_mean, normalize_std)])
elif transform == "center":
self.transform = Compose([CenterCrop((crop_H, crop_W)), ToTensor(), Normalize(normalize_mean, normalize_std)])
else:
raise NotImplementedError("Tranformation not understood: {}".format(transform))
if seq_name:
assert seq_name in ['labeled', 'detected']
self.data = self.load_images()
else:
self.data = []
self.build_samples()
def __getitem__(self, index):
image = Image.open(os.path.join(
self.root,
self.list_paths[index])) # Open image from the given path.
# Get transform list
list_transforms = list()
if self.crop_size > 0:
list_transforms.append(RandomCrop(
(self.crop_size, self.crop_size)))
if self.flip:
coin = random.random() > 0.5
if coin:
list_transforms.append(RandomHorizontalFlip())
transforms = Compose(list_transforms)
image = transforms(image) # Implement common transform
input_image = Grayscale(num_output_channels=1)(
image) # For input image, we need to make it B/W.
input_tensor, target_tensor = ToTensor()(input_image), ToTensor()(
image) # Make input, target as torch.Tensor
input_tensor = Normalize(mean=[0.5], std=[0.5])(
input_tensor) # As the input tensor has only one channel,
# Normalize parameters also have one value each.
target_tensor = Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])(
target_tensor) # As the target tensor has
# three channels Normalize parameters also have three values each.
return input_tensor, target_tensor
def __init__(self,
root,
list_file,
patch_size=96,
shrink_size=2,
noise_level=1,
down_sample_method=None,
transform=None):
self.root = root
self.transform = transform
self.random_cropper = RandomCrop(size=patch_size)
self.img_augmenter = ImageAugment(shrink_size, noise_level,
down_sample_method)
self.transform = transform
self.fnames = []
if isinstance(list_file, list):
tmp_file = '/tmp/listfile.txt'
os.system('cat %s > %s' % (' '.join(list_file), tmp_file))
list_file = tmp_file
with open(list_file) as f:
lines = f.readlines()
self.num_imgs = len(lines)
for line in lines:
self.fnames.append(line)
def _video_transform(self, mode: str):
"""
This function contains example transforms using both PyTorchVideo and TorchVision
in the same Callable. For 'train' mode, we use augmentations (prepended with
'Random'), for 'val' mode we use the respective determinstic function.
"""
args = self.args
return ApplyTransformToKey(
key="video",
transform=Compose(
[
UniformTemporalSubsample(args.video_num_subsampled),
Normalize(args.video_means, args.video_stds),
]
+ (
[
RandomShortSideScale(
min_size=args.video_min_short_side_scale,
max_size=args.video_max_short_side_scale,
),
RandomCrop(args.video_crop_size),
RandomHorizontalFlip(p=args.video_horizontal_flip_p),
]
if mode == "train"
else [
ShortSideScale(args.video_min_short_side_scale),
CenterCrop(args.video_crop_size),
]
)
),
)
def _get_headpose_dataset(dataset, opt, mean, std, attrs):
train_transform = Compose(
[Resize(240),
RandomCrop(224),
ToTensor(),
Normalize(mean, std)])
val_transform = Compose([
Resize((opt.face_size, opt.face_size)),
ToTensor(),
Normalize(mean, std)
])
target_transform = ToMaskedTargetTensor(attrs)
if dataset == '300W_LP':
root = os.path.join(opt.root_path, '300W_LP')
train_data = Pose_300W_LP(root,
transform=train_transform,
target_transform=target_transform,
training=True)
val_data = Pose_300W_LP(root,
transform=val_transform,
target_transform=target_transform,
training=False)
else:
raise Exception('Error: not a valid dataset name')
return split_dataset_into_train_val(train_data, val_data, val_ratio=0.05)
def get_train_test_loaders(dataset_name, path, batch_size, num_workers):
assert dataset_name in datasets.__dict__, "Unknown dataset name {}".format(dataset_name)
fn = datasets.__dict__[dataset_name]
train_transform = Compose([
Pad(2),
RandomCrop(32),
RandomHorizontalFlip(),
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
test_transform = Compose([
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)),
])
train_ds = fn(root=path, train=True, transform=train_transform, download=True)
test_ds = fn(root=path, train=False, transform=test_transform, download=False)
train_loader = DataLoader(train_ds, batch_size=batch_size, num_workers=num_workers, pin_memory=True)
test_loader = DataLoader(test_ds, batch_size=batch_size * 2, num_workers=num_workers, pin_memory=True)
return train_loader, test_loader
def __init__(self, image_dir, patch_size, scale_factor, data_augmentation=True):
super(DatasetFromFolder, self).__init__()
self.filenames = [str(filename) for filename in Path(image_dir).glob('*') if filename.suffix in ['.bmp', '.jpg', '.png']]
self.patch_size = patch_size
self.scale_factor = scale_factor
self.data_augmentation = data_augmentation
self.crop = RandomCrop(self.patch_size)
def prepare_data(self):
"Prepare supervised and unsupervised datasets from cifar"
dataset_path = self.hparams.dataset_path
n_labeled = self.hparams.n_labeled
n_overlap = self.hparams.n_overlap
seed = self.hparams.seed
if self.hparams.dataset == "cifar":
n = self.hparams.randaug_n
m = self.hparams.randaug_m
if self.hparams.strong_tfm:
train_tfm = Compose([RandAugment(n, m), ToTensor(), Normalize(*CIFAR_STATS)])
else:
train_tfm = Compose([RandomCrop(32, 4, padding_mode="reflect"), RandomHorizontalFlip(), ToTensor(), Normalize(*CIFAR_STATS)])
valid_tfm = Compose([ToTensor(), Normalize(*CIFAR_STATS)])
sup_ds, unsup_ds = Cifar.uda_ds(dataset_path, n_labeled, n_overlap, train_tfm, seed=seed)
val_ds = Cifar.val_ds(dataset_path, valid_tfm)
if self.hparams.dataset == "quickdraw":
train_tfm = Compose([ExpandChannels, SketchDeformation, RandomHorizontalFlip(), RandomRotation(30), RandomCrop(128, 18), ToTensor()])
valid_tfm = Compose([ExpandChannels, ToTensor()])
sup_ds, unsup_ds = QuickDraw.uda_ds(dataset_path, n_labeled, n_overlap, train_tfm, seed=seed)
val_ds = QuickDraw.val_ds(dataset_path, valid_tfm)
self.train_ds = sup_ds
self.valid_ds = val_ds
print("Loaded {} train examples and {} validation examples".format(len(self.train_ds), len(self.valid_ds)))
def _input_transform(crop_size, upscale_factor, patch_size=None):
return Compose([
CenterCrop(crop_size),
Resize(crop_size // upscale_factor),
RandomCrop(patch_size if patch_size is not None else crop_size // upscale_factor),
ToTensor(),
])
def ImageTransform(loadSize, cropSize):
return Compose([
Resize(size=loadSize, interpolation=Image.BICUBIC),
RandomCrop(size=cropSize),
RandomHorizontalFlip(p=0.5),
ToTensor(),
])
def get_train_transform(length=T):
trans_list = [ToPILImage(),
Pad((length // 2, 0)),
RandomCrop((1, length)),
ToTensor(),
Centring(MAX_INT)]
return transforms.Compose([ConvertToTuple(default_transforms) for default_transforms in trans_list])
def __init__(self, seq_name, vis_threshold, P, K, max_per_person, crop_H, crop_W,
transform, normalize_mean=None, normalize_std=None):
self.data_dir = osp.join(cfg.DATA_DIR, 'Market-1501-v15.09.15')
self.seq_name = seq_name
self.P = P
self.K = K
self.max_per_person = max_per_person
self.crop_H = crop_H
self.crop_W = crop_W
if transform == "random":
self.transform = Compose([RandomCrop((crop_H, crop_W)), RandomHorizontalFlip(), ToTensor(), Normalize(normalize_mean, normalize_std)])
elif transform == "center":
self.transform = Compose([CenterCrop((crop_H, crop_W)), ToTensor(), Normalize(normalize_mean, normalize_std)])
else:
raise NotImplementedError("Tranformation not understood: {}".format(transform))
if seq_name:
assert seq_name in ['bounding_box_test', 'bounding_box_train', 'gt_bbox'], \
'Image set does not exist: {}'.format(seq_name)
self.data = self.load_images()
else:
self.data = []
self.build_samples()
def HR_8_transform(crop_size):
return Compose([
RandomCrop(crop_size),
RandomScale(),
#RandomRotate(),
RandomHorizontalFlip(),
])
def build_dataset(source_domain_name,
target_domain_name):
""" Build torch DataSet
Args:
source_domain_name (string): name of source domain dataset.
target_domain_name (string): name of target domain dataset.
Returns:
datasets (dict): dictionary mapping domain_name (string) to torch Dataset.
"""
# Define transforms for training and evaluation
transform_train = Compose([Resize([256, 256]),
RandomCrop([224, 224]),
RandomHorizontalFlip(),
RandomRotation(degrees=30, fill=128),
ToTensor(),
Normalize(IMAGENET_MEAN, IMAGENET_STD)])
transform_eval = Compose([Resize([256, 256]),
CenterCrop([224, 224]),
ToTensor(),
Normalize(IMAGENET_MEAN, IMAGENET_STD)])
datasets = {}
datasets['train_source'] = ImageFolder(root=root_dir[source_domain_name],
transform=transform_train)
datasets['train_target'] = ImageFolder(root=root_dir[target_domain_name],
transform=transform_train)
datasets['test'] = ImageFolder(root=root_dir[target_domain_name],
transform=transform_eval)
return datasets
def default_transforms(self) -> Dict[str, Callable]:
if self.training:
post_tensor_transform = [
RandomShortSideScale(min_size=256, max_size=320),
RandomCrop(244),
RandomHorizontalFlip(p=0.5),
]
else:
post_tensor_transform = [
ShortSideScale(256),
]
return {
"post_tensor_transform":
Compose([
ApplyTransformToKey(
key="video",
transform=Compose([UniformTemporalSubsample(8)] +
post_tensor_transform),
),
]),
"per_batch_transform_on_device":
Compose([
ApplyTransformToKey(
key="video",
transform=K.VideoSequential(K.Normalize(
torch.tensor([0.45, 0.45, 0.45]),
torch.tensor([0.225, 0.225, 0.225])),
data_format="BCTHW",
same_on_frame=False)),
]),
}
def __init__(self, opts):
self.dataroot = opts.dataroot
# A
images_A = os.listdir(os.path.join(self.dataroot, opts.phase + 'A'))
self.A = [os.path.join(self.dataroot, opts.phase + 'A', x) for x in images_A]
# B
images_B = os.listdir(os.path.join(self.dataroot, opts.phase + 'B'))
self.B = [os.path.join(self.dataroot, opts.phase + 'B', x) for x in images_B]
self.A_size = len(self.A)
self.B_size = len(self.B)
self.dataset_size = max(self.A_size, self.B_size)
self.input_dim_A = opts.input_dim_a
self.input_dim_B = opts.input_dim_b
# setup image transformation
transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)]
if opts.phase == 'train':
transforms.append(RandomCrop(opts.crop_size))
else:
transforms.append(CenterCrop(opts.crop_size))
if not opts.no_flip:
transforms.append(RandomHorizontalFlip())
transforms.append(ToTensor())
transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
self.transforms = Compose(transforms)
print('A: %d, B: %d images'%(self.A_size, self.B_size))
return
def test_twice_transform(self):
from torchvision.transforms import Compose, RandomCrop, RandomRotation, ColorJitter, ToTensor
transforms = SequentialWrapperTwice(com_transform=Compose(
[RandomRotation(45), RandomCrop(224)], ),
image_transform=Compose([
ColorJitter(
brightness=[0.8, 1.2],
contrast=[0.8, 1.2],
saturation=1),
ToTensor()
]),
target_transform=ToLabel(),
total_freedom=False)
dataset = ACDCDataset(
root_dir=self._root,
mode="train",
transforms=transforms,
)
(image1, image2, target1, target2), filename = dataset[4]
from deepclustering3.viewer import multi_slice_viewer_debug
import matplotlib.pyplot as plt
multi_slice_viewer_debug(torch.cat([image1, image2], dim=0),
torch.cat([target1, target2], dim=0),
no_contour=True)
plt.show()
