def active_pascal(
path="/tmp",
*args,
transform=transforms.ToTensor(),
test_transform=transforms.ToTensor(),
**kwargs,
):
"""Get active Pascal-VOC 2102 datasets.
Arguments:
path : str
The root folder for the Pascal dataset
Returns:
ActiveLearningDataset
the active learning dataset, training data
Dataset
the evaluation dataset
"""
return (
ActiveLearningDataset(
datasets.VOCSegmentation(path,
image_set='train',
transform=transform,
download=False,
*args,
**kwargs)),
datasets.VOCSegmentation(path,
image_set='val',
transform=test_transform,
download=False,
*args,
**kwargs),
)
def load_data(self,
transform=None,
target_transform=None,
dataset='cifar10'):
if dataset == 'cifar10':
train_data = datasets.CIFAR10(self.data_dir,
train=True,
download=True,
transform=transform)
test_data = datasets.CIFAR10(self.data_dir,
train=False,
download=True,
transform=transform)
self.model_name += '_cifar'
elif dataset == 'vocseg':
train_data = datasets.VOCSegmentation(
self.data_dir,
image_set='train',
download=True,
transform=transform,
target_transform=target_transform)
test_data = datasets.VOCSegmentation(
self.data_dir,
image_set='val',
download=True,
transform=transform,
target_transform=target_transform)
self.model_name += '_vocseg'
elif dataset == 'imagenet':
train_data = datasets.ImageNet(self.data_dir,
train=True,
download=True,
transform=transform)
test_data = datasets.ImageNet(self.data_dir,
train=False,
download=True,
transform=transform)
self.model_name += '_imagenet'
else:
# raise an error?
pass
train_sampler, valid_sampler = self._train_valid_samplers(train_data)
self.train_loader = DataLoader(train_data,
batch_size=self.batch_size,
sampler=train_sampler,
num_workers=self.num_workers)
self.valid_loader = DataLoader(train_data,
batch_size=self.batch_size,
sampler=valid_sampler,
num_workers=self.num_workers)
self.test_loader = DataLoader(test_data,
batch_size=self.batch_size,
num_workers=self.num_workers)
def get_dataset_train_VOC(batch_size, angle, size, dataroot_voc):
def to_tensor_target(img):
img = np.array(img)
# border
img[img == 255] = 0 # border = background
return torch.LongTensor(img)
def rotate_pil(img, fill=0):
img = TF.rotate(img, angle=angle, fill=fill)
return img
transform_input = transforms.Compose([
transforms.Resize(size),
transforms.Lambda(rotate_pil),
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD),
])
transform_mask = transforms.Compose([
transforms.Resize(size),
transforms.Lambda(rotate_pil),
transforms.Lambda(to_tensor_target)
])
train_dataset = dset.VOCSegmentation(dataroot_voc,
year='2012',
image_set='train',
download=True,
transform=transform_input,
target_transform=transform_mask)
dataloader_train = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size)
return dataloader_train
def dataloader():
"""Data loader for loading images and labels
https://github.com/pytorch/examples/tree/master/imagenet
Returns:
data_loader (DataLoader): a PyTorch DataLoader to load in imagenet
"""
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = datasets.VOCSegmentation(
'./voc',
year='2012',
image_set='trainval',
download=True,
transform=transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
normalize
]),
target_transform=transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor()
]))
data_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=1, shuffle=True, pin_memory=True)
return data_loader
def __init__(self, root, split):
assert split in ["train", "trainval", "val"]
self.split = split
self.dataset = datasets.VOCSegmentation(root,
image_set=split,
download=True)
self.sample_img, self.sample_seg = self._process_data(*self.dataset[0])
def voc():
return itertools.chain(*[
collect_download_configs(
lambda: datasets.VOCSegmentation(ROOT, year=year, download=True),
name=f"VOC, {year}",
file="voc",
) for year in ("2007", "2007-test", "2008", "2009", "2010", "2011",
"2012")
])
def __init__(self, mode, directory):
self.data = datasets.VOCSegmentation(os.path.join(
'/Data/segmentation', directory),
image_set=mode,
download=False)
self.labels = [
'airplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car',
'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tv'
]
def voc():
download_configs = []
for year in ("2007", "2007-test", "2008", "2009", "2010", "2011", "2012"):
with contextlib.suppress(Exception), log_download_attempts(
download_url_target="torchvision.datasets.voc.download_url"
) as urls_and_md5s:
datasets.VOCSegmentation(".", year=year, download=True)
download_configs.extend(
make_download_configs(urls_and_md5s, f"VOC, {year}"))
return download_configs
def VOC2012_SEGMENTATION_DATASET(root='./data',
train=True,
transform=None,
target_transform=None,
download=False):
return datasets.VOCSegmentation(root,
image_set='train' if train else 'val',
transform=transform,
target_transform=target_transform,
download=download)
def __init__(self):
super().__init__()
_path = Config().data.data_path
self.mean = [0.45734706, 0.43338275, 0.40058118]
self.std = [0.23965294, 0.23532275, 0.2398498]
_transform = transforms.Compose([
transforms.Resize((96, 96)),
transforms.ToTensor(),
])
self.trainset = datasets.VOCSegmentation(root=_path,
year='2012',
image_set='train',
download=True,
transform=_transform,
target_transform=_transform)
self.testset = datasets.VOCSegmentation(root=_path,
year='2012',
image_set='val',
download=True,
transform=_transform,
target_transform=_transform)
def __new__(cls, root, train=True, transform=None, download=False):
if train:
return datasets.SBDataset(root,
image_set='train_noval',
mode='segmentation',
download=download,
transforms=transform)
else:
return datasets.VOCSegmentation(root,
image_set='val',
download=download,
transforms=transform)
def __new__(cls, root, train=True, transform=None, download=False):
root = pathlib.Path(root).parent
if train:
return VD.SBDataset(root / "sbd",
image_set='train_noval',
mode='segmentation',
transforms=transform,
download=download)
else:
return VD.VOCSegmentation(root / "voc",
image_set="val",
transforms=transform,
download=download)
def PascalVOC2012_dataset(stage="train",
use_sbd_dataset=False,
download=True,
root='datasets/'):
if stage == "train":
voc_train = datasets.VOCSegmentation(
root,
year='2012',
image_set='train',
download=download,
transforms=CustomCompose([
CustomRandomHorizontalFlip(),
CustomRandomScaleCrop(base_size=513, crop_size=513),
CustomRandomGaussianBlur(),
# NOTE: original repo has args parameter
# CustomRandomScaleCrop(base_size=args.base_size, crop_size=args.crop_size),
CustomNormalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
CustomToTensor(),
]))
if use_sbd_dataset:
sbd_train = SB_dataset(stage, download=download)
print('Merging PascalVOC2012 and SB datasets')
return torch.utils.data.ConcatDataset([voc_train, sbd_train])
else:
return voc_train
else:
return datasets.VOCSegmentation(root,
year='2012',
image_set='val',
download=download,
transforms=CustomCompose([
CustomFixScaleCrop(crop_size=513),
CustomNormalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
CustomToTensor(),
]))
def load_data(mode, dataset_root, img_resolution, batch_size, download=False):
""" Load transforms and images into a DataLoader. """
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if mode == 'train':
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(img_resolution),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
])
elif mode == 'val':
if batch_size == 1: # Keep original image dimensions
data_transforms = transforms.Compose(
[transforms.ToTensor(), normalize])
else:
data_transforms = transforms.Compose([
transforms.Resize(int(img_resolution * 1.05)),
transforms.CenterCrop(img_resolution),
transforms.ToTensor(), normalize
])
else:
raise Exception(f'Invalid dataset mode specified: {mode}')
num_classes = 20
if mode == 'val' and batch_size == 1:
target_transform = SegmentationMapAndMultiClass(num_classes)
else:
target_transform = SegmentationMapToMultiClass(num_classes)
imagefolder = datasets.VOCSegmentation(dataset_root,
'2012',
mode,
download=download,
transform=data_transforms,
target_transform=target_transform)
shuffle = mode == 'train'
dataloader = DataLoader(imagefolder,
batch_size=batch_size,
shuffle=shuffle)
return dataloader
def get_loader(dataset,
batch_size,
train=True,
shuffle=True,
subset=1.0,
force_resize=0,
noise=False,
permutation=False):
kwargs = {
# 'num_workers': 1,
# 'pin_memory': False,
}
if dataset == 'amazon':
train = 'train' if train else 'valid'
dataset = load_dataset('amazon_reviews_multi',
'en',
cache_dir=data_dir,
split=train)
return dataset
elif dataset == 'celeba':
train = 'train' if train else 'valid'
params = {
'mean': (0.5063, 0.4258, 0.3832),
'std': (0.3106, 0.2904, 0.2897),
'im_size': cfg.im_size[dataset]
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
dataset = datasets.CelebA(cfg.data_dir,
split=train,
download=cfg.download,
transform=transform,
target_type='landmarks')
if subset < 1:
indices = _get_subset_index(dataset.attr, subset)
dataset = Subset(dataset, indices)
loader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'cifar':
params = {
'mean': (0.4914, 0.4822, 0.4465),
'std': (0.2023, 0.1994, 0.2010),
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
loader = torch.utils.data.DataLoader(datasets.CIFAR10(
cfg.data_dir,
train=train,
download=cfg.download,
transform=transform),
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'coco':
train = 'train' if train else 'val'
params = {
'mean': (0.4701, 0.4469, 0.4076),
'std': (0.2463, 0.2424, 0.2596),
'im_size': cfg.im_size[dataset]
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
target_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((cfg.im_size[dataset], cfg.im_size[dataset])),
transforms.Lambda(
lambda x: torch.from_numpy(np.array(x).astype(int))),
])
dataset = Coco(
root='{}/coco/{}2017'.format(cfg.data_dir, train),
annFile='{}/coco/annotations/instances_{}2017.json'.format(
cfg.data_dir, train),
transform=transform,
target_transform=target_transform,
)
if subset < 1:
indices = _get_subset_index(list(range(len(dataset))), subset)
dataset = Subset(dataset, indices)
loader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'fmnist':
params = {
'mean': (0.2861, ),
'std': (0.3530, ),
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
loader = torch.utils.data.DataLoader(datasets.FashionMNIST(
cfg.data_dir,
train=train,
download=cfg.download,
transform=transform),
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'mnist':
params = {
'mean': (0.1307, ),
'std': (0.3081, ),
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
loader = torch.utils.data.DataLoader(datasets.MNIST(
cfg.data_dir,
train=train,
download=cfg.download,
transform=transform),
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'svhn':
train = 'train' if train else 'test'
params = {
'mean': (0.4377, 0.4438, 0.4728),
'std': (0.1980, 0.2010, 0.1970),
}
if force_resize:
params['im_size'] = force_resize
if noise:
params['noise'] = noise
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
loader = torch.utils.data.DataLoader(datasets.SVHN(
'{}/SVHN'.format(cfg.data_dir),
split=train,
download=cfg.download,
transform=transform),
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
elif dataset == 'voc':
train = 'train' if train else 'val'
params = {
'mean': (0.4568, 0.4432, 0.4083),
'std': (0.2440, 2414, 2591),
'im_size': cfg.im_size[dataset]
}
if noise:
params['noise'] = noise
if force_resize:
params['im_size'] = force_resize
if permutation:
params['permutation'] = permutation
transform = _get_transform(params)
target_transform = transforms.Compose([
transforms.Resize((cfg.im_size[dataset], cfg.im_size[dataset])),
transforms.Lambda(
lambda x: torch.from_numpy(np.array(x).astype(int))),
transforms.Lambda(
lambda x: torch.clamp(x, max=cfg.output_sizes[dataset] - 1)),
])
loader = torch.utils.data.DataLoader(datasets.VOCSegmentation(
'{}/VOC'.format(cfg.data_dir),
image_set=train,
download=cfg.download,
transform=transform,
target_transform=target_transform),
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
return loader
from scaling.ScalingApproach import ScalingApproach
from attack.QuadrScaleAttack import QuadraticScaleAttack
from attack.direct_attacks.DirectNearestScaleAttack import DirectNearestScaleAttack
from attack.ScaleAttackStrategy import ScaleAttackStrategy
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
torch.cuda.empty_cache()
batch_size = 4
img_size = (520, 520) # original input size to the model is (520,520) but all images in dataset are of different sizes
trans = T.Compose([T.Resize(img_size), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
#T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]
dataset = datasets.VOCSegmentation(r'/home/shk/PascalVOC/', year = '2012',
image_set = 'trainval',download = False, transform = trans,
target_transform = T.Resize(img_size), transforms = None)
X, y, yrep = [], [], []
for i in range(batch_size):
num = torch.randint(0,1449,(1,1)).item()
X.append(dataset[num][0])
y.append(np.asarray(dataset[num][1]))
yrep.append(dataset[num][1])
X, y = torch.stack(X), torch.tensor(y)
net = models.segmentation.deeplabv3_resnet101(pretrained=True, progress=True, num_classes=21, aux_loss=None).eval()
yp = net(X)['out']
yp.size()
pred = torch.argmax(yp,1)
IoUAcc(y, pred)
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 0, 'pin_memory': True} if args.cuda else {}
# Data loaders
root_dir = '/media/sda1/vision2020_01/Data' # Change this based on the server you are using
train_loader = torch.utils.data.DataLoader(
datasets.VOCSegmentation(
root_dir, image_set='train', download=False, year='2012',
transform=transforms.Compose([
transforms.Resize((256, 256)),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])]),
target_transform=transforms.Compose([
transforms.Resize((256, 256), interpolation=Image.NEAREST),
transforms.ToTensor()])
),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.VOCSegmentation(
root_dir, image_set='val', download=False, year='2012',
transform=transforms.Compose([
transforms.Resize((256, 256)),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])]),
target_transform=transforms.Compose([
transforms.Resize((256, 256), interpolation=Image.NEAREST),
def get_voc_data(dataset='seg',
batch_size=64,
test_batch_size=1,
year='2008',
root='../data/VOCdevkit',
download=False):
shuffle = False
kwargs = {}
transformations = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
# mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
#)
])
def proc_img(img):
arr = np.array(img)
arr.dtype = np.int8
return arr
trgt_transformations = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.Lambda(proc_img),
transforms.ToTensor()
])
dataset_train = None
dataset_test = None
if dataset == 'seg':
dataset_train = datasets.VOCSegmentation(
root,
year=year,
image_set="train",
download=download,
transform=transformations,
target_transform=trgt_transformations)
dataset_test = datasets.VOCSegmentation(
root,
year=year,
image_set="val",
download=download,
transform=transformations,
target_transform=trgt_transformations)
elif dataset == 'det':
dataset_train = datasets.VOCDetection(
root,
year=year,
image_set="train",
download=download,
transform=transformations,
target_transform=trgt_transformations)
dataset_test = datasets.VOCDetection(
root,
year=year,
image_set="val",
download=download,
transform=transformations,
target_transform=trgt_transformations)
train_loader = torch.utils.data.DataLoader(dataset_train,
batch_size=batch_size,
shuffle=shuffle,
num_workers=4,
**kwargs)
test_loader = torch.utils.data.DataLoader(dataset_test,
batch_size=test_batch_size,
num_workers=4,
shuffle=shuffle,
**kwargs)
return train_loader, test_loader
import matplotlib.gridspec as gridspec
%matplotlib inline
from sklearn.metrics import accuracy_score
import numpy as np
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
torch.cuda.empty_cache()
batch_size = 4
img_size = (520,520) # original input size to the model is (520,520) but all images in dataset are of different sizes in PascalVOC
trans = T.Compose([T.Resize(img_size),T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
dataset = datasets.VOCSegmentation(r'/datasets/PascalVOC/....', year = '2012', image_set = 'val',download = False, transform = trans,
target_transform = T.Resize(img_size), transforms = None) # Path to be updated for local use.
X, y, yrep = [], [], []
for i in range(batch_size):
num = torch.randint(0,1449,(1,1)).item()
X.append(dataset[num][0])
y.append(np.asarray(dataset[num][1]))
yrep.append(dataset[num][1])
X, y = torch.stack(X), torch.tensor(y).unsqueeze(1)
#print(X.size(), y.size())
net = models.segmentation.deeplabv3_resnet101(pretrained=True, progress=True, num_classes=21, aux_loss=None).eval() #Any pre-trained model from pytorch can be made used of.
class_names = {1:'background', 2:'aeroplane', 3:'bicycle', 4:'bird', 5:'boat', 6:'bottle', 7:'bus', 8:'car', 9:'cat',
10:'chair', 11:'cow', 12:'diningtable', 13:'dog', 14:'horse', 15:'motorbike', 16:'person', 17:'pottedplant',
def _load_dataset(root='',
name='cifar10',
train=True,
download=True,
transform=None,
from_folder=''):
""" Initialize dataset from torchvision or from folder
Args:
root: (str) Directory where dataset is stored
name: (str) Name of the dataset (e.g. cifar10, cifar100)
train: (bool) Use the training set
download: (bool) Download the dataset
transform: (torchvision.transforms.Compose) image transformations
from_folder: (str) Path to directory holding the images to load.
Returns:
A torchvision dataset
Raises:
ValueError: If the specified dataset doesn't exist
"""
if from_folder and os.path.exists(from_folder):
# load data from directory
dataset = _load_dataset_from_folder(from_folder,
transform)
elif name.lower() == 'cifar10' and root:
# load cifar10
dataset = datasets.CIFAR10(root,
train=train,
download=download,
transform=transform)
elif name.lower() == 'cifar100' and root:
# load cifar100
dataset = datasets.CIFAR100(root,
train=train,
download=download,
transform=transform)
elif name.lower() == 'cityscapes' and root:
# load cityscapes
root = os.path.join(root, 'cityscapes/')
split = 'train' if train else 'val'
dataset = datasets.Cityscapes(root,
split=split,
transform=transform)
elif name.lower() == 'stl10' and root:
# load stl10
split = 'train' if train else 'test'
dataset = datasets.STL10(root,
split=split,
download=download,
transform=transform)
elif name.lower() == 'voc07-seg' and root:
# load pascal voc 07 segmentation dataset
image_set = 'train' if train else 'val'
dataset = datasets.VOCSegmentation(root,
year='2007',
image_set=image_set,
download=download,
transform=transform)
elif name.lower() == 'voc12-seg' and root:
# load pascal voc 12 segmentation dataset
image_set = 'train' if train else 'val'
dataset = datasets.VOCSegmentation(root,
year='2012',
image_set=image_set,
download=download,
transform=transform)
elif name.lower() == 'voc07-det' and root:
# load pascal voc 07 object detection dataset
image_set = 'train' if train else 'val'
dataset = datasets.VOCDetection(root,
year='2007',
image_set=image_set,
download=True,
transform=transform)
elif name.lower() == 'voc12-det' and root:
# load pascal voc 12 object detection dataset
image_set = 'train' if train else 'val'
dataset = datasets.VOCDetection(root,
year='2012',
image_set=image_set,
download=True,
transform=transform)
else:
raise ValueError(
'The specified dataset (%s) or datafolder (%s) does not exist '
% (name, from_folder))
return dataset
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 0, 'pin_memory': True} if args.cuda else {}
# Data loaders
root_dir = '/media/sda1/vision2020_01/Data' # Change this based on the server you are using
train_loader = torch.utils.data.DataLoader(datasets.VOCSegmentation(
root_dir,
image_set='train',
download=False,
year='2012',
transform=transforms.Compose([
transforms.Resize((256, 256)),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])
]),
target_transform=transforms.Compose([
transforms.Resize((256, 256), interpolation=Image.BILINEAR),
transforms.ToTensor()
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
test_loader = torch.utils.data.DataLoader(datasets.VOCSegmentation(
root_dir,
image_set='val',
download=False,
year='2012',
def __init__(self, config):
self.config = config
if config.data_mode == 'download':
self.train_loader = torch.utils.data.DataLoader(
datasets.VOCSegmentation('./data/',
#batch_size=self.config.batch_size,
#train=True,
download=True,
#shuffle=True,
#num_workers=self.config.data_loader_workers,
#pin_memory=self.config.pin_memory,
transform= transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]))
)
self.test_loader = torch.utils.data.DataLoader(
datasets.VOCSegmentation('./data/',
#batch_size=self.config.batch_size,
#train=False,
#shuffle=False,
#num_workers=self.config.data_loader_workers,
#pin_memory=self.config.pin_memory,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]))
)
assert self.config.mode in ['train', 'test', 'random']
mean_std = ([103.939, 116.779, 123.68], [1.0, 1.0, 1.0])
self.input_transform = standard_transforms.Compose([
standard_transforms.Resize((256, 256), interpolation=PIL.Image.BILINEAR),
extended_transforms.FlipChannels(),
standard_transforms.ToTensor(),
standard_transforms.Lambda(lambda x: x.mul_(255)),
standard_transforms.Normalize(*mean_std)
])
self.target_transform = standard_transforms.Compose([
standard_transforms.Resize((256, 256), interpolation=PIL.Image.NEAREST),
extended_transforms.MaskToTensor()
])
self.restore_transform = standard_transforms.Compose([
extended_transforms.DeNormalize(*mean_std),
standard_transforms.Lambda(lambda x: x.div_(255)),
standard_transforms.ToPILImage(),
extended_transforms.FlipChannels()
])
self.visualize = standard_transforms.Compose([
standard_transforms.Resize(400),
standard_transforms.CenterCrop(400),
standard_transforms.ToTensor()
])
if self.config.mode == 'random':
train_data = torch.randn(self.config.batch_size, self.config.input_channels, self.config.img_size,
self.config.img_size)
train_labels = torch.ones(self.config.batch_size, self.config.img_size, self.config.img_size).long()
valid_data = train_data
valid_labels = train_labels
self.len_train_data = train_data.size()[0]
self.len_valid_data = valid_data.size()[0]
self.train_iterations = (self.len_train_data + self.config.batch_size - 1) // self.config.batch_size
self.valid_iterations = (self.len_valid_data + self.config.batch_size - 1) // self.config.batch_size
train = TensorDataset(train_data, train_labels)
valid = TensorDataset(valid_data, valid_labels)
self.train_loader = DataLoader(train, batch_size=config.batch_size, shuffle=True)
self.valid_loader = DataLoader(valid, batch_size=config.batch_size, shuffle=False)
elif self.config.mode == 'train':
train_set = VOC('train', self.config.data_root,
transform=self.input_transform, target_transform=self.target_transform)
valid_set = VOC('val', self.config.data_root,
transform=self.input_transform, target_transform=self.target_transform)
self.train_loader = DataLoader(train_set, batch_size=self.config.batch_size, shuffle=True,
num_workers=self.config.data_loader_workers,
pin_memory=self.config.pin_memory)
self.valid_loader = DataLoader(valid_set, batch_size=self.config.batch_size, shuffle=False,
num_workers=self.config.data_loader_workers,
pin_memory=self.config.pin_memory)
self.train_iterations = (len(train_set) + self.config.batch_size) // self.config.batch_size
self.valid_iterations = (len(valid_set) + self.config.batch_size) // self.config.batch_size
elif self.config.mode == 'test':
test_set = VOC('test', self.config.data_root,
transform=self.input_transform, target_transform=self.target_transform)
self.test_loader = DataLoader(test_set, batch_size=self.config.batch_size, shuffle=False,
num_workers=self.config.data_loader_workers,
pin_memory=self.config.pin_memory)
self.test_iterations = (len(test_set) + self.config.batch_size) // self.config.batch_size
else:
raise Exception('Please choose a proper mode for data loading')
split='train',
mode='fine',
target_type='semantic',
transforms=get_summary_transforms())
cityscapes_val = datasets.Cityscapes(data_root_dir + "/cityscapes/",
split='val',
mode='fine',
target_type='semantic',
transforms=get_summary_transforms())
# coco_train = get_coco(data_root_dir+'/coco/', image_set='train', transforms=get_summary_transforms())
# coco_val = get_coco(data_root_dir+'/coco/', image_set='val', transforms=get_summary_transforms())
voc_train = datasets.VOCSegmentation(data_root_dir + "/PascalVOC2012/",
year='2012',
image_set='train',
download=False,
transforms=get_summary_transforms())
voc_val = datasets.VOCSegmentation(data_root_dir + "/PascalVOC2012/",
year='2012',
image_set='val',
download=False,
transforms=get_summary_transforms())
datasets = {
'sbd': {
'train': sbd_train,
'val': sbd_val
},
# 'coco' : {'train' : coco_train, 'val': coco_val},
'voc': {
import os
import torch
import numpy as np
import scipy.io as sio
import torch
from PIL import Image
from torch.utils import data
import torchvision.datasets as datasets
root = '/home/dayun/data/'
# Download VOC dataset if not exists.
if os.path.isdir(root+'TrainVal') == False:
voc = datasets.VOCSegmentation(root, year='2011', download=True)
voc_root = root + 'TrainVal/VOCdevkit/VOC2011/'
# Load image and mask path from txt file
def make_dataset(mode):
assert mode in ['train', 'val']
items = []
if mode == 'train':
img_path = os.path.join(voc_root, 'JPEGImages')
mask_path = os.path.join(voc_root, 'SegmentationClass')
data_list = [l.strip('\n') for l in open(os.path.join(
voc_root, 'ImageSets', 'Segmentation', 'train.txt')).readlines()]
for it in data_list:
item = (os.path.join(img_path, it + '.jpg'), os.path.join(mask_path, it + '.png'))
items.append(item)
