def setup(self, stage=None):
self.ds_train = datasets.Cityscapes(
root=self.root,
split='train',
mode=self.mode,
target_type='semantic',
transforms=self.get_transforms(train=True),
)
if self.mode == 'coarse':
self.ds_train = ComposeDataset(
self.ds_train,
datasets.Cityscapes(
root=self.root,
split='train_extra',
mode=self.mode,
target_type='semantic',
transforms=self.get_transforms(train=True),
))
self.ds_val = datasets.Cityscapes(
root=self.root,
split='val',
mode=self.mode,
target_type='semantic',
transforms=self.get_transforms(train=False),
)
if self.mode == 'fine':
self.ds_test = datasets.Cityscapes(
root=self.root,
split='test',
mode=self.mode,
target_type='semantic',
transforms=self.get_transforms(train=False),
)
def load_data(DATADIR, batch_size=1, shuffle=False):
transform = transforms.Compose([
# you can add other transformations in this list
transforms.ToTensor()
])
params = {
'mode': 'fine',
'target_type': 'semantic',
'transform': transform,
'target_transform': transform
}
train_set = datasets.Cityscapes(DATADIR, split='train', **params)
train_generator = DataLoader(train_set,
batch_size=batch_size,
shuffle=shuffle)
val_set = datasets.Cityscapes(DATADIR, split='val', **params)
val_generator = DataLoader(val_set, batch_size=batch_size, shuffle=shuffle)
test_set = datasets.Cityscapes(DATADIR, split='test', **params)
test_generator = DataLoader(test_set,
batch_size=batch_size,
shuffle=shuffle)
data_generator = {
"train": train_generator,
"val": val_generator,
"test": test_generator
}
return data_generator
def load_data(path, data_type, resize=True, split='train'):
"""
Loads Cityscapes data from path input via command line.
:param path: Path to root data directory
:param data_type: dataset located at specified path (cityscapes or imagenet)
:param resize: Set to true to size down the images. Default=True
:return: torchvision cityscapes dataset object
"""
if resize:
resize_size = 256
print("Resizing images to {}x{}".format(resize_size, resize_size))
input_transform = input_image_transform(resize_size)
output_transform = output_image_transform(resize_size)
else:
input_transform = input_image_transform(0)
output_transform = output_image_transform(0)
if data_type == 'cityscapes':
dataset = datasets.Cityscapes(path,
split=split,
mode='fine',
target_type='semantic',
transform=input_transform,
target_transform=output_transform)
elif data_type == 'imagenet':
dataset = datasets.ImageFolder(os.path.join(path, 'train'), transform=input_transform)
return dataset
def get_cityscape_data(dataset='seg', test_batch_size=1, year='2008'):
batch_size = 64
shuffle = False
kwargs = {}
transformations = transforms.Compose([
transforms.ToTensor(),
])
trgt_transformations = transforms.Compose([
transforms.ToTensor(),
])
dataset_train = datasets.Cityscapes('../data',
split='train',
mode='fine',
target_type='semantic',
transform=transformations,
target_transform=trgt_transformations)
dataset_test = datasets.Cityscapes('../data',
split='val',
mode='fine',
target_type='semantic',
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
def __init__(self,
root_dir: str,
labels: dict,
crop_size: tuple = (480, 852),
split_type: str = 'validation'):
super().__init__(root_dir, labels)
self.root_dir = root_dir
self.labels = labels
self.crop_size = crop_size
self.cityscape_set = datasets.Cityscapes(root_dir,
split=split_type,
mode='fine',
target_type='semantic')
def training():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
data_root = "/home/glazkova/ProbabilisticUnet/data"
img_transform_func = transforms.Compose([
transforms.Resize((256, 512), interpolation=PIL.Image.BILINEAR),
transforms.ToTensor(),
])
labels_transform_func = transforms.Compose([
transforms.Resize((256, 512), interpolation=PIL.Image.NEAREST),
transforms.Lambda(lambda x: id_to_train_id[x]),
transforms.ToTensor()
])
train_dataset = TransformedCityDataset(root=data_root,
mode="fine",
split="train",
target_type="semantic")
test_dataset = datasets.Cityscapes(root=data_root,
mode="fine",
split="val",
target_type="semantic",
transform=img_transform_func,
target_transform=labels_transform_func)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=train_batch_size)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=test_batch_size)
#iter_num = 240000
#n_epochs = iter_num // (len(train_dataset) // batch_size)
n_epochs = 100
model = ProbUNet(num_classes, latent_space_size)
#model.load_state_dict(torch.load("results/model"))
model.cuda()
opt = torch.optim.Adam(model.parameters(), lr=0.0001)
scheduler = StepLR(opt, step_size=5, gamma=0.9)
train_utils.train(model,
opt,
scheduler,
n_epochs,
train_loader,
test_loader,
save_path="results/final_3D/")
def __init__(
self,
*,
data_root=const.DEFAULT_DATA_ROOT,
split="train",
transforms=None,
**kwargs,
):
self.root = os.path.join(data_root, CITYSCAPES_LOCAL_PATH)
self.split = split
self.download(CITYSCAPES_GCS_PATH)
self._cityscapes = datasets.Cityscapes(
self.root,
split=split,
mode="fine",
target_type="semantic",
transforms=transforms,
)
def getData(dset_name, batch_size, data_transform):
dataPath = "../data"
os.makedirs(dataPath, exist_ok=True)
if dset_name == "CIFAR10":
trainset = dset.CIFAR10(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.CIFAR10(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "LSUN":
trainset = dset.LSUN(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.LSUN(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "FakeData":
trainset = dset.FakeData(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.FakeData(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "CocoCaptions":
trainset = dset.CocoCaptions(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.CocoCaptions(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "MNIST":
trainset = dset.MNIST(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.MNIST(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "CIFAR100":
trainset = dset.CIFAR100(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.CIFAR100(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "SVHN":
trainset = dset.SVHN(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.SVHN(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "Flickr8k":
trainset = dset.Flickr8k(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.Flickr8k(dataPath,
train=False,
download=True,
transform=data_transform)
elif dset_name == "Cityscapes":
trainset = dset.Cityscapes(dataPath,
train=True,
download=True,
transform=data_transform)
testset = dset.Cityscapes(dataPath,
train=False,
download=True,
transform=data_transform)
return torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True),len(trainset),\
torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True), len(testset),
model = SegNet_ASPP()
path = "/datasets"
spl = "val"
im_tf = transforms.Compose(
[transforms.Resize((256, 512)),
transforms.ToTensor()])
targ_tf = transforms.Compose([
transforms.Resize((256, 512), interpolation=Image.NEAREST),
transforms.ToTensor()
])
load_model(0, best_model=True)
dst = datasets.Cityscapes(path,
split=spl,
mode='fine',
target_type='semantic',
transform=im_tf,
target_transform=targ_tf)
trainloader = torch.utils.data.DataLoader(dataset=dst,
batch_size=2,
shuffle=False,
num_workers=0)
TP = 0
TN = 0
FP = 0
FN = 0
F1 = 0
JS = 0
total = 0
for i, d in enumerate(trainloader):
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
def get_dataset(args):
trans = lambda im_size: tforms.Compose(
[tforms.Resize((im_size, im_size)),
tforms.ToTensor(), add_noise])
if args.data == "mnist_puzzle":
im_dim = 1
im_size = 28 if args.imagesize is None else args.imagesize
if args.imagesize is None:
args.imagesize = 28
train_set = dset.MNIST(root="./data/mnist/MNIST/",
train=True,
transform=trans(im_size),
download=True)
test_set = dset.MNIST(root="./data/mnist/MNIST/",
train=False,
transform=trans(im_size),
download=True)
elif args.data == "fashionmnist_puzzle":
im_dim = 1
im_size = 28 if args.imagesize is None else args.imagesize
if args.imagesize is None:
args.imagesize = 28
train_set = dset.FashionMNIST(root="./data/fashionmnist/fashionMNIST/",
train=True,
transform=trans(im_size),
download=True)
test_set = dset.FashionMNIST(root="./data/fashionmnist/fashionMNIST/",
train=False,
transform=trans(im_size),
download=True)
elif args.data == "coco_puzzle":
im_dim = 3
im_size = 64 if args.imagesize is None else args.imagesize
if args.imagesize is None:
args.imagesize = 64
train_set = dset.CocoDetection(
"./data/coco/images/train2017/",
"./data/coco/annotations/annotations/instances_train2017.json",
transform=trans(im_size))
test_set = dset.CocoDetection(
"./data/coco/images/val2017/",
"./data/coco/annotations/annotations/instances_val2017.json",
transform=trans(im_size))
elif args.data == "celeba_puzzle":
im_dim = 3
im_size = 64 if args.imagesize is None else args.imagesize
train_set = celeba('./data/celeba_hq/imgs/',
'./data/celeba_hq/splits/',
'train',
im_size,
normalize=args.normalize,
noise=args.add_noise)
test_set = celeba('./data/celeba_hq/imgs/',
'./data/celeba_hq/splits/',
'test',
im_size,
normalize=args.normalize,
noise=args.add_noise)
elif args.data == "cityscapes_puzzle":
im_dim = 3
im_size = 64 if args.imagesize is None else args.imagesize
train_set = dset.Cityscapes(root="./data/cityscapes/train", \
split='train', \
mode='fine', \
target_type='instance', \
transform=trans(im_size), \
target_transform=None)
test_set = dset.Cityscapes(root="./data/cityscapes/test", \
split='test', \
mode='fine', \
target_type='instance', \
transform=trans(im_size), \
target_transform=None)
elif args.data == "cifar_puzzle":
im_dim = 3
im_size = 64 if args.imagesize is None else args.imagesize
if args.imagesize is None:
args.imagesize = 64
train_set = dset.CIFAR10(root="./data/cifar10/",
train=True,
transform=trans(im_size),
download=True)
test_set = dset.CIFAR10(root="./data/cifar10/",
train=False,
transform=trans(im_size),
download=True)
elif args.data == "lsun_puzzle":
im_dim = 3
im_size = 64 if args.imagesize is None else args.imagesize
if args.imagesize is None:
args.imagesize = 64
train_set = dset.LSUN('./data/lsun/', ['bedroom_train'],
transform=trans(im_size))
test_set = dset.LSUN('./data/lsun/', ['bedroom_val'],
transform=trans(im_size))
data_shape = (im_dim, im_size // args.puzzle_size,
im_size // args.puzzle_size)
test_loader = torch.utils.data.DataLoader(dataset=test_set,
batch_size=args.batch_size,
shuffle=False,
drop_last=True)
return train_set, test_loader, data_shape
from torch.utils.data import DataLoader
from torch.utils.data import sampler
from torchvision import datasets, transforms
bs = 3
DATADIR = 'datasets/citys'
transform = transforms.Compose([
# you can add other transformations in this list
transforms.ToTensor()
])
target_type = 'color'
dataset = datasets.Cityscapes(DATADIR,
split='train',
mode='fine',
target_type=target_type,
transform=transform,
target_transform=transform)
trainloader = DataLoader(dataset, batch_size=bs, shuffle=False, num_workers=0)
for i, data in enumerate(trainloader):
imgs, mask = data[0], data[1]
imgs = np.transpose(imgs, [0, 2, 3, 1])
if target_type == 'semantic':
mask = np.squeeze(mask)
elif target_type == 'color':
mask = np.transpose(mask, [0, 2, 3, 1])[:, :, :, :3]
f, axarr = plt.subplots(bs, 2)
import time
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
from torch.autograd import Variable
import sys
from models import ConvDeconv as cd
from models import ConvDeconvWithSkipConnection as cds
from models import SegNet as s
from models import SegNetWithSkipConnection as ss
data_path = "/home/sur/SegNet/cityscape/"
# Loading the dataset
train = datasets.Cityscapes(data_path, split = 'train', mode = 'fine', target_type = 'semantic',transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]),target_transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]))
test = datasets.Cityscapes(data_path, split = 'test', mode = 'fine', target_type = 'semantic' ,transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]),target_transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]))
val = datasets.Cityscapes(data_path, split = 'val', mode = 'fine', target_type = 'semantic' ,transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]),target_transform=transforms.Compose([transforms.Resize((256,512)),transforms.ToTensor()]))
trainset = torch.utils.data.DataLoader(train, batch_size=2, shuffle=True) #1488 images
testset = torch.utils.data.DataLoader(test, batch_size=2, shuffle=False) #763 images
valset = torch.utils.data.DataLoader(val, batch_size=2, shuffle=True) #250 images
# print(trainset.size())
output_visualization =1
learing_rate = 0.001
epoachs = 1
def main():
# CHecking tha availability of the GPU and running
def __init__(self, split, mode, directory):
self.data = datasets.Cityscapes(os.path.join('/Data/segmentation',
directory, 'data'),
split=split,
mode=mode,
target_type='semantic')
self.labels = [
'road',
'sidewalk',
'building',
'wall',
'fence',
'pole',
'traffic light',
'traffic sign',
'vegetation',
'terrain',
'sky',
'person',
'rider',
'car',
'truck',
'bus',
'train',
'motorcycle',
'bicycle',
]
self.translater = {
0: 0,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 1,
8: 2,
9: 0,
10: 0,
11: 3,
12: 4,
13: 5,
14: 0,
15: 0,
16: 0,
17: 6,
18: 0,
19: 7,
20: 8,
21: 9,
22: 10,
23: 11,
24: 12,
25: 13,
26: 14,
27: 15,
28: 16,
29: 0,
30: 0,
31: 17,
32: 18,
33: 19,
-1: 0,
}
def main():
num_epochs = 20
# Load and normalize data
transform = transforms.Compose([
transforms.Resize((256, 256)),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.2869, 0.3251, 0.2839),
(0.1761, 0.1810, 0.1777))
])
target_transform = transforms.Compose([
transforms.Resize((256, 256)),
transforms.CenterCrop(224),
ToTensor()
])
train_data = datasets.Cityscapes('./data/cityscapes',
split='train',
mode='coarse',
target_type='semantic',
transform=transform,
target_transform=target_transform)
data_loader = torch.utils.data.DataLoader(train_data,
batch_size=3,
shuffle=True,
num_workers=4)
results = {'Adam': [], 'SGDNesterov': [], 'AdaGrad': []}
colors = {'Adam': 'r', 'SGDNesterov': 'g', 'AdaGrad': 'b'}
for name in ['Adam', 'SGDNesterov', 'AdaGrad']:
print('Starting', name)
model = models.segmentation.fcn_resnet50(pretrained=False,
num_classes=20)
model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
if name == 'Adam':
optimizer = MyAdamOptimizer(model.parameters(),
weight_decay=0.01,
lr=0.0001)
elif name == 'SGDNesterov':
optimizer = optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.01,
nesterov=True)
elif name == 'AdaGrad':
optimizer = optim.Adagrad(model.parameters(),
weight_decay=0.01,
lr=0.001)
# Train
for i in tqdm(range(num_epochs)):
loss = 0
for x, y in tqdm(data_loader):
x = x.cuda().type(torch.float32)
y = y.cuda()
optimizer.zero_grad()
y_pred = model(x)['out']
train_loss = criterion(y_pred, y)
train_loss.backward()
optimizer.step()
loss += train_loss.item()
print(loss / len(data_loader))
results[name].append(loss / len(data_loader))
#results[name] = pickle.load(open('results/cityscapes/' + name + '.p', 'rb'))
torch.save(model, name + '.pt')
plt.plot(np.arange(num_epochs),
results[name],
label=name,
c=colors[name],
linewidth=1)
pickle.dump(results[name], open(name + '.p', 'wb'))
plt.yscale('log')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.xticks(np.arange(num_epochs))
plt.title('Cityscapes FCNN')
plt.legend()
plt.tight_layout()
plt.savefig('out.png', dpi=300)
plt.show()
sbd_train = datasets.SBDataset(data_root_dir + "/sbd/",
image_set='train',
mode='segmentation',
download=False,
transforms=get_summary_transforms())
sbd_val = datasets.SBDataset(data_root_dir + "/sbd/",
image_set='val',
mode='segmentation',
download=False,
transforms=get_summary_transforms())
cityscapes_train = datasets.Cityscapes(data_root_dir + "/cityscapes/",
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,