def __init__(self, content=None):
get = content.get_resource
self.__model = onnxruntime.InferenceSession(
get(content.model_path))
self.line_transform = Compose([
Resize((512, 512)),
ToTensor(),
Normalize([0.5], [0.5]),
Lambda(lambda img: np.expand_dims(img, 0))
])
self.hint_transform = Compose([
# input must RGBA !
Resize((128, 128), Image.NEAREST),
Lambda(lambda img: img.convert(mode='RGB')),
ToTensor(),
Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
Lambda(lambda img: np.expand_dims(img, 0))
])
self.line_draft_transform = Compose([
Resize((128, 128)),
ToTensor(),
Normalize([0.5], [0.5]),
Lambda(lambda img: np.expand_dims(img, 0))
])
self.alpha_transform = Compose([
Lambda(lambda img: self.get_alpha(img)),
])
def generate_results_file(net,
target_txt,
classes_names,
out,
bs,
dim,
is_letterbox=False):
numclass = len(classes_names)
if is_letterbox:
transform = Compose(
[IaaAugmentations([IaaLetterbox(dim)]),
ToTensor()])
else:
transform = Compose([IaaAugmentations([iaa.Scale(dim)]), ToTensor()])
ds = COCOEvalDataset(target_txt, dim, transform)
dl = DataLoader(ds,
batch_size=bs,
num_workers=4,
collate_fn=variable_shape_collate_fn)
with open_json_pred_writer(out, classes_names,
is_letterbox) as pred_writer:
predict_and_process(dl,
net,
num_classes=numclass,
batch_handler=pred_writer)
def np_nozoom_256():
# TODO: add zoom
# TODO: add mean, std
# TODO: add random_channel_shift
train_transformations = Compose([
#res
partial(resize, size=(256, 256)), # TODO: not to resize
random_shift_scale_rotate,
random_flip,
random_transpose,
NPToTensor(),
])
val_transformations = Compose([
partial(resize, size=(256, 256)),
NPToTensor(),
])
test_transformation = Compose([ # solo transform
partial(resize, size=(256, 256)),
#SpatialPick(),
# TODO: average by augmentation
NPToTensor(),
])
return {
'train': train_transformations,
'val': val_transformations,
'test': test_transformation
}
def load_data(datadir, img_size=416, crop_pct=0.875):
# Data loading code
print("Loading data")
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
scale_size = int(math.floor(img_size / crop_pct))
print("Loading training data")
st = time.time()
dataset = VOCDetection(datadir, image_set='train', download=True,
transforms=Compose([VOCTargetTransform(classes),
RandomResizedCrop((img_size, img_size), scale=(0.3, 1.0)),
RandomHorizontalFlip(),
convert_to_relative,
ImageTransform(transforms.ColorJitter(brightness=0.3, contrast=0.3,
saturation=0.1, hue=0.02)),
ImageTransform(transforms.ToTensor()), ImageTransform(normalize)]))
print("Took", time.time() - st)
print("Loading validation data")
st = time.time()
dataset_test = VOCDetection(datadir, image_set='val', download=True,
transforms=Compose([VOCTargetTransform(classes),
Resize(scale_size), CenterCrop(img_size),
convert_to_relative,
ImageTransform(transforms.ToTensor()), ImageTransform(normalize)]))
print("Took", time.time() - st)
print("Creating data loaders")
train_sampler = torch.utils.data.RandomSampler(dataset)
test_sampler = torch.utils.data.SequentialSampler(dataset_test)
return dataset, dataset_test, train_sampler, test_sampler
def np_nozoom_256():
# TODO: add mean, std
train_transformations = Compose([
#res
partial(resize, size=(192, 192)), # TODO: not to resize
random_shift_scale_rotate,
random_flip,
random_transpose,
#partial(double_channel_shift, intensity=10),
NPToTensor(),
])
val_transformations = Compose([
partial(resize, size=(192, 192)),
NPToTensor(),
])
test_transformation = SingleCompose([ # solo transform
partial(resize_single, size=(192, 192)),
SpatialPick((
{'do': lambda x: x, 'undo': lambda x: x},
{'do': partial(cv2.flip, flipCode=-1), 'undo': partial(cv2.flip, flipCode=-1)},
{'do': partial(cv2.flip, flipCode=0), 'undo': partial(cv2.flip, flipCode=0)},
{'do': partial(cv2.flip, flipCode=1), 'undo': partial(cv2.flip, flipCode=1)},
# {'do': partial(zoom, scale=1.05), 'undo': partial(zoom, scale=1/1.05)},
{'do': partial(zoom, scale=0.95), 'undo': partial(zoom, scale=1/0.95)},
#{'do': partial(channel_shift, intensity=10), 'undo': lambda x: x},
)),
ToTensor(),
])
return {'train': train_transformations, 'val': val_transformations, 'test': test_transformation}
def transform_dataset(dataset, model, train):
if train:
transform = Compose(
RGBAugmentation(["rgb"]),
Affine(
rgb_indices=["rgb"],
mask_indices=["masks"],
bbox_indices=["bboxes"],
),
ClassIds2FGClassIds(["labels"]),
AsType(["rgb", "labels", "bboxes"],
[np.float32, np.int32, np.float32]),
HWC2CHW(["rgb"]),
Dict2Tuple(["rgb", "masks", "labels", "bboxes"]),
MaskRCNNTransform(800, 1333, model.extractor.mean),
)
else:
transform = Compose(
ClassIds2FGClassIds(["labels"]),
AsType(["rgb", "labels", "bboxes"],
[np.float32, np.int32, np.float32]),
HWC2CHW(["rgb"]),
Dict2Tuple(["rgb", "masks", "labels"]),
)
return TransformDataset(dataset, transform)
def main():
'''
Runs if the module is called as a script (eg: python3 dataset.py <dataset_name> <frametime>)
Executes self tests
'''
dataset_name = argv[1] if len(argv) > 1 else "clarissa"
wait = argv[2] if len(argv) > 2 else 10
print(
"Dataset module running as script, executing dataset unit test in {}".
format(dataset_name))
if dataset_name == "adni_slices":
unit_test(image_dataset=False,
adni=True,
hiponly=True,
plt_show=True,
nworkers=4,
e2d=True)
elif dataset_name == "clarissa_slices":
unit_test(image_dataset=False,
adni=False,
hiponly=True,
plt_show=True,
nworkers=4,
e2d=True)
elif dataset_name == "concat":
from transforms import ReturnPatch, Intensity, RandomFlip, Noisify, ToTensor, CenterCrop, RandomAffine
train_transforms = Compose([
ReturnPatch(patch_size=(32, 32)),
RandomAffine(),
Intensity(),
RandomFlip(modes=['horflip']),
Noisify(),
ToTensor()
]) #default is 32 32 patch
data_transforms = {
'train': train_transforms,
'validation': train_transforms,
'test': Compose([CenterCrop(160, 160),
ToTensor()])
}
mode = "train"
data, dsizes = get_data(data_transforms=data_transforms,
db="concat",
e2d=True,
batch_size=50 + 150 * (mode != "test"))
print("Dataset sizes: {}".format(dsizes))
for o in orientations:
batch = next(iter(data[o][mode]))
display_batch(batch, o + " concat " + mode + " data")
plt.show()
else:
view_volumes(dataset_name, wait=10)
print("All tests completed!")
def load_data(datadir):
# Data loading code
print("Loading data")
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
base_size = 320
crop_size = 256
min_size = int(0.5 * base_size)
max_size = int(2.0 * base_size)
print("Loading training data")
st = time.time()
dataset = VOCSegmentation(datadir,
image_set='train',
download=True,
transforms=Compose([
RandomResize(min_size, max_size),
RandomCrop(crop_size),
RandomHorizontalFlip(0.5),
SampleTransform(
transforms.ColorJitter(brightness=0.3,
contrast=0.3,
saturation=0.1,
hue=0.02)),
ToTensor(),
SampleTransform(normalize)
]))
print("Took", time.time() - st)
print("Loading validation data")
st = time.time()
dataset_test = VOCSegmentation(datadir,
image_set='val',
download=True,
transforms=Compose([
RandomResize(base_size, base_size),
ToTensor(),
SampleTransform(normalize)
]))
print("Took", time.time() - st)
print("Creating data loaders")
train_sampler = torch.utils.data.RandomSampler(dataset)
test_sampler = torch.utils.data.SequentialSampler(dataset_test)
return dataset, dataset_test, train_sampler, test_sampler
def get_coco(root, image_set, transforms):
PATHS = {
"train":
("train2017", os.path.join("annotations", "instances_train2017.json")),
"val": ("val2017", os.path.join("annotations",
"instances_val2017.json")),
# "train": ("val2017", os.path.join("annotations", "instances_val2017.json"))
}
CAT_LIST = [
0, 5, 2, 16, 9, 44, 6, 3, 17, 62, 21, 67, 18, 19, 4, 1, 64, 20, 63, 7,
72
]
transforms = Compose([
FilterAndRemapCocoCategories(CAT_LIST, remap=True),
ConvertCocoPolysToMask(), transforms
])
img_folder, ann_file = PATHS[image_set]
img_folder = os.path.join(root, img_folder)
ann_file = os.path.join(root, ann_file)
dataset = torchvision.datasets.CocoDetection(img_folder,
ann_file,
transforms=transforms)
if image_set == "train":
dataset = _coco_remove_images_without_annotations(dataset, CAT_LIST)
return dataset
def SSDTransform(size,
color_jitter=True,
scale=(0.1, 1),
expand=(1, 4),
min_area_frac=0.25):
transforms = []
if color_jitter:
transforms.append(
InputTransform(
ColorJitter(
brightness=0.1,
contrast=0.5,
saturation=0.5,
hue=0.05,
)))
transforms += [
RandomApply([
RandomExpand(expand),
]),
RandomChoice([
UseOriginal(),
RandomSampleCrop(),
RandomResizedCrop(size,
scale=scale,
ratio=(1 / 2, 2 / 1),
min_area_frac=min_area_frac),
]),
RandomHorizontalFlip(),
Resize(size)
]
return Compose(transforms)
def main(args):
# Initiate the dataset with transforms of sampler and filter only gyroscope(x, y, z)
dataset = UtdMhadDataset(modality='inertial', transform=Compose([
Sampler(107),
FilterDimensions([0, 1, 2])
]))
# Retrieve one sample
(sample, _) = dataset[args.dataset_idx]
if args.jitter_factor:
jittering = Jittering(args.jitter_factor)
plot_data = jittering(sample)
append_to_title = ' - Jittering %d' % args.jitter_factor
else:
plot_data = sample
append_to_title = ' - Original'
if args.compare:
data = np.array([sample[:, 0], plot_data[:, 0]])
legends = ['Original', 'Jittered %d' % args.jitter_factor]
plot_inertial_gyroscope_multiple(title='Gyroscope - Jitter factor %d' % args.jitter_factor, y_label='deg/sec',
legends=legends, data=data,
save=args.save,
show_figure=args.show)
else:
plot_inertial(plot_data, title='Gyroscope' + append_to_title, y_label='deg/sec', save=args.save,
show_figure=args.show)
def main():
class imshowCollate(object):
def __init__(self):
pass
def __call__(self, batch):
images, labels = zip(*batch)
idx = 0
for img in images:
img = img.cpu().numpy().transpose((1, 2, 0)) * 255 #totensor
cv2.imwrite(
'datatest/sev_img/img' + str(idx) + '——' +
str(labels[idx]) + '.jpg', img)
# print(img.shape)
idx += 1
return images, labels
from transforms import Compose, Normalize, RandomResizedCrop, RandomHorizontalFlip, \
ColorJitter, ToTensor,Lighting
batch_size = 16
normalize = Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
dataset = FileListLabeledDataset(
'/workspace/mnt/group/algo/yangdecheng/work/multi_task/pytorch-train/datatest/test.txt',
'/workspace/mnt/group/algo/yangdecheng/work/multi_task/pytorch-train/datatest/pic',
Compose([
RandomResizedCrop((112),
scale=(0.7, 1.2),
ratio=(1. / 1., 4. / 1.)),
RandomHorizontalFlip(),
ColorJitter(brightness=[0.5, 1.5],
contrast=[0.5, 1.5],
saturation=[0.5, 1.5],
hue=0),
ToTensor(),
Lighting(1, [0.2175, 0.0188, 0.0045],
[[-0.5675, 0.7192, 0.4009], [-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]]), #0.1
# normalize,
]))
train_loader = torch.utils.data.DataLoader(dataset,
batch_size=100,
shuffle=True,
num_workers=10,
pin_memory=True,
sampler=None,
collate_fn=imshowCollate())
from multiprocessing import Process
p_list = []
for i in range(1):
p_list.append(Process(target=iter_f, args=(train_loader, )))
for p in p_list:
p.start()
for p in p_list:
p.join()
def init_seg(input_sizes,
std,
mean,
dataset,
test_base=None,
test_label_id_map=None,
city_aug=0):
if dataset == 'voc':
transform_test = Compose([
ToTensor(),
ZeroPad(size=input_sizes),
Normalize(mean=mean, std=std)
])
elif dataset == 'city' or dataset == 'gtav' or dataset == 'synthia': # All the same size
if city_aug == 2: # ERFNet and ENet
transform_test = Compose([
ToTensor(),
Resize(size_image=input_sizes, size_label=input_sizes),
LabelMap(test_label_id_map)
])
elif city_aug == 1: # City big
transform_test = Compose([
ToTensor(),
Resize(size_image=input_sizes, size_label=input_sizes),
Normalize(mean=mean, std=std),
LabelMap(test_label_id_map)
])
else:
raise ValueError
# Not the actual test set (i.e. validation set)
test_set = StandardSegmentationDataset(
root=test_base,
image_set='val',
transforms=transform_test,
data_set='city'
if dataset == 'gtav' or dataset == 'synthia' else dataset)
val_loader = torch.utils.data.DataLoader(dataset=test_set,
batch_size=1,
num_workers=0,
shuffle=False)
# Testing
return val_loader
def __init__(self, model_path, image_size):
self.augmentation = Compose(
[pre_transforms(image_size=image_size),
post_transforms()])
self.m = nn.Sigmoid()
self.model = utils.load_traced_model(model_path).cuda()
device_name = "cuda:0" if torch.cuda.is_available() else "cpu"
self.device = torch.device(device_name)
self.image_size = image_size
def load_data(datadir, img_size=416, crop_pct=0.875):
# Data loading code
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
scale_size = int(math.floor(img_size / crop_pct))
print("Loading training data")
st = time.time()
train_set = VOCDetection(datadir,
image_set='train',
download=True,
transforms=Compose([
VOCTargetTransform(VOC_CLASSES),
RandomResizedCrop((img_size, img_size),
scale=(0.3, 1.0)),
RandomHorizontalFlip(), convert_to_relative,
ImageTransform(
transforms.ColorJitter(brightness=0.3,
contrast=0.3,
saturation=0.1,
hue=0.02)),
ImageTransform(transforms.ToTensor()),
ImageTransform(normalize)
]))
print("Took", time.time() - st)
print("Loading validation data")
st = time.time()
val_set = VOCDetection(datadir,
image_set='val',
download=True,
transforms=Compose([
VOCTargetTransform(VOC_CLASSES),
Resize(scale_size),
CenterCrop(img_size), convert_to_relative,
ImageTransform(transforms.ToTensor()),
ImageTransform(normalize)
]))
print("Took", time.time() - st)
return train_set, val_set
def init(batch_size, state, input_sizes, dataset, mean, std, base, workers=10):
# Return data_loaders
# depending on whether the state is
# 0: training
# 1: fast validation by mean IoU (validation set)
# 2: just testing (test set)
# 3: just testing (validation set)
# Transformations
# ! Can't use torchvision.Transforms.Compose
transforms_test = Compose(
[Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
ToTensor(),
Normalize(mean=mean, std=std)])
transforms_train = Compose(
[Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
RandomRotation(degrees=3),
ToTensor(),
Normalize(mean=mean, std=std)])
if state == 0:
data_set = StandardLaneDetectionDataset(root=base, image_set='train', transforms=transforms_train,
data_set=dataset)
data_loader = torch.utils.data.DataLoader(dataset=data_set, batch_size=batch_size,
num_workers=workers, shuffle=True)
validation_set = StandardLaneDetectionDataset(root=base, image_set='val',
transforms=transforms_test, data_set=dataset)
validation_loader = torch.utils.data.DataLoader(dataset=validation_set, batch_size=batch_size * 4,
num_workers=workers, shuffle=False)
return data_loader, validation_loader
elif state == 1 or state == 2 or state == 3:
image_sets = ['valfast', 'test', 'val']
data_set = StandardLaneDetectionDataset(root=base, image_set=image_sets[state - 1],
transforms=transforms_test, data_set=dataset)
data_loader = torch.utils.data.DataLoader(dataset=data_set, batch_size=batch_size,
num_workers=workers, shuffle=False)
return data_loader
else:
raise ValueError
def get_transform(train=True,fixsize=False,img_size=416,min_size=800,max_size=1333,
image_mean=None,image_std=None,advanced=False):
if image_mean is None:image_mean = [0.485, 0.456, 0.406]
if image_std is None:image_std = [0.229, 0.224, 0.225]
if train:
transforms = Compose(
[
Augment(advanced),
ToTensor(),
ResizeFixSize(img_size) if fixsize else ResizeMinMax(min_size, max_size),
RandomHorizontalFlip(0.5),
Normalize(image_mean,image_std)
])
else:
transforms = Compose(
[
ToTensor(),
ResizeFixSize(img_size) if fixsize else ResizeMinMax(min_size, max_size),
# RandomHorizontalFlip(0.5),
Normalize(image_mean, image_std)
])
return transforms
def test_data(data_path,img_size,classes,useMosaic,fixsize):
seed = 100
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
torch.manual_seed(seed)
kwargs = {'num_workers': 5, 'pin_memory': True} if use_cuda else {}
transforms = Compose(
[
Augment(True,True),
# Pad(),
# ToTensor(),
# Resize(img_size),
# RandomHorizontalFlip(0.5),
# Augment(False),
# ColorJitter(), SSDCropping(),
ToTensor(),
# ResizeFixSize(img_size) if fixsize else ResizeMinMax(800, 1333),
# RandomHorizontalFlip(0.5),
])
dataset = FruitsNutsDataset(data_path,transforms=transforms,classes=classes,useMosaic=useMosaic,fixsize=fixsize)
# dataset = PascalVOCDataset(data_path,transforms=transforms,classes=classes,useMosaic=useMosaic,fixsize=fixsize)
# for img, target in dataset:
# print()
data_loader = DataLoader(dataset, batch_size=4, shuffle=False, collate_fn=collate_fn, **kwargs)
for datas, targets in data_loader:
# datas = batch(datas)
for data, target in zip(datas, targets):
# from c,h,w ->h,w,c
data = data.permute(1, 2, 0)
# to uint8
data = torch.clamp(data * 255, 0, 255).to("cpu").numpy().astype(np.uint8)
# to BGR
# data = data[...,::-1]
data = cv2.cvtColor(data, cv2.COLOR_RGB2BGR)
boxes = target["boxes"].to("cpu").numpy().astype(np.int)
labels = target["labels"].to("cpu").numpy()
for idx, (box, label) in enumerate(zip(boxes, labels)):
data = vis_rect(data, box, str(label), 0.5, label, useMask=False)
cv2.imshow("test", data)
cv2.waitKey(0)
cv2.destroyAllWindows()
def unit_test(image_dataset=True,
adni=True,
shuffle=True,
ntoshow=30,
show=True,
plt_show=True,
nworkers=0,
hiponly=True,
volume=False,
e2d=False):
'''
Tests vizualisation of a training batch of the dataset
'''
train_transforms = Compose([
ReturnPatch(patch_size=(32, 32)),
RandomAffine(),
Intensity(),
RandomFlip(modes=['horflip']),
Noisify(),
ToTensor()
])
#train_transforms = Compose((Resize(128, 128), RandomAffine(), ToTensor())) # for testing another stuff
print("Testing all orientations...")
for o in orientations:
if adni:
test = FloatHippocampusDataset(h5path=default_adni,
mode="train",
transform=train_transforms,
data_split=(0.5, 0.1, 0.4),
adni=True,
orientation=o,
hiponly=True,
return_volume=False,
e2d=True)
else:
test = FloatHippocampusDataset(mode="train",
transform=train_transforms,
orientation=o,
hiponly=hiponly,
return_volume=volume,
e2d=e2d)
test_loader = data.DataLoader(test,
batch_size=ntoshow,
shuffle=shuffle,
num_workers=0)
batch = next(iter(test_loader))
if show is True:
display_batch(batch, o + " dataloader")
if plt_show:
plt.show()
def __init__(self, root=""):
self.detected_file = os.path.join(root, self.detected_file_name)
self.annotations = get_classes(os.path.join(root,
self.label_file_name))
self._root_dir = root
self.item_dict = {
ItemEnum.IMAGE_PATH: [],
ItemEnum.BOX_COORDS: [],
ItemEnum.LABEL: []
}
self.load_label_file()
self.transform = Compose([
Scale(0.1),
Rotate(),
])
def get_transform_fixsize(train=True,img_size=416,
image_mean=None,image_std=None,advanced=False):
if image_mean is None:image_mean = [0.485, 0.456, 0.406]
if image_std is None:image_std = [0.229, 0.224, 0.225]
if train:
transforms = Compose(
[
Augment(advanced),
Pad(),
ToTensor(),
Resize(img_size),
RandomHorizontalFlip(0.5),
Normalize(image_mean,image_std)
])
else:
transforms = Compose(
[
Pad(),
ToTensor(),
Resize(img_size),
# RandomHorizontalFlip(0.5),
Normalize(image_mean, image_std)
])
return transforms
def init_lane(input_sizes, dataset, mean, std, base, workers=0):
transforms_test = Compose([
Resize(size_image=input_sizes, size_label=input_sizes),
ToTensor(),
Normalize(mean=mean, std=std)
])
validation_set = StandardLaneDetectionDataset(root=base,
image_set='val',
transforms=transforms_test,
data_set=dataset)
validation_loader = torch.utils.data.DataLoader(dataset=validation_set,
batch_size=1,
num_workers=workers,
shuffle=False)
return validation_loader
def test5():
transform = Compose([
AudioRandomChunkTransform(5000, append_method='silence'),
AudioScaleVolumeRelativeMaxTransform(0.5),
AudioAddWhiteNoiseTransform(-20.0),
AudioToTensorTransform()
])
label_maker = label_maker_factory.create('english name')
dataset = ChirpyDataset('./test_db',
'audio',
label_maker=label_maker,
transform=transform)
for i in range(len(dataset)):
xx = dataset[i]['audio']
print(xx)
def view_detection_dataset(loader, annotations):
transform = Compose([
Scale(0.2),
Rotate()
])
for img, bbox, label in tqdm(loader):
img = img.permute(1, 2, 0).cpu().numpy()
bbox = bbox.cpu().numpy()
label = label.cpu().numpy()
img, bbox = transform(img, bbox)
for i in range(bbox.shape[0]):
img = cv2.rectangle(img, (int(bbox[i, 0]), int(
bbox[i, 1])), (int(bbox[i, 2]), int(bbox[i, 3])), (255, 0, 0), 2)
print(bbox.shape)
cv2.putText(img, get_class_name_from_id(annotations, label[i]), (
int(bbox[i, 0]), int(bbox[i, 1]-20)), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (100, 255, 100), 2)
plt.figure(dpi=120)
plt.imshow(img, cmap="jet")
plt.waitforbuttonpress(0)
plt.close()
def test4():
transform = Compose([
AudioRandomChunkTransform(5000, append_method='silence'),
AudioToTensorTransform()
])
label_maker = label_maker_factory.create(
'english name', label_container_source='test.json')
dataset = ChirpyDataset('./test_db',
'audio',
label_maker=label_maker,
transform=transform)
ss = []
for i in range(len(dataset)):
xx = dataset[i]['audio']
xx = xx.double()
print(xx.mean(), xx.std())
ss.append(float(xx.std()))
print(sum(ss) / len(ss))
print(label_maker.label_map)
with open('test.json', 'w') as fout:
label_maker.to_json(fout)
def get_coco(root, image_set, transforms):
PATHS = {
"train":
("train2017", os.path.join("annotations", "semantic_train2017.json")),
"val": ("val2017", os.path.join("annotations",
"semantic_val2017.json")),
# "train": ("val2017", os.path.join("annotations", "instances_val2017.json"))
}
CAT_LIST = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84,
85, 86, 87, 88, 89, 90, 92, 93, 95, 100, 107, 109, 112, 118, 119, 122,
125, 128, 130, 133, 138, 141, 144, 145, 147, 148, 149, 151, 154, 155,
156, 159, 161, 166, 168, 171, 175, 176, 177, 178, 180, 181, 184, 185,
186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
200
]
transforms = Compose([
FilterAndRemapCocoCategories(CAT_LIST, remap=True),
ConvertCocoPolysToMask(), transforms
])
img_folder, ann_file = PATHS[image_set]
img_folder = os.path.join(root, img_folder)
ann_file = os.path.join(root, ann_file)
dataset = torchvision.datasets.CocoDetection(img_folder,
ann_file,
transforms=transforms)
if image_set == "train":
dataset = _coco_remove_images_without_annotations(dataset)
return dataset
def __init__(
self,
data,
roi_size=64,
zoom_range=(0.8, 1.25),
samples_per_epoch=100000,
):
self.data = data
self.roi_size = roi_size
rotation_pad_size = math.ceil(self.roi_size * (math.sqrt(2) - 1) / 2)
padded_roi_size = roi_size + 2 * rotation_pad_size
self.transforms = [
RandomCrop(padded_roi_size),
AffineTransform(zoom_range),
RemovePadding(rotation_pad_size),
RandomVerticalFlip(),
RandomHorizontalFlip(),
]
self.transforms = Compose(self.transforms)
self.samples_per_epoch = samples_per_epoch
def init(batch_size, state, split, input_sizes, sets_id, std, mean, keep_scale, reverse_channels, data_set,
valtiny, no_aug):
# Return data_loaders/data_loader
# depending on whether the split is
# 1: semi-supervised training
# 2: fully-supervised training
# 3: Just testing
# Transformations (compatible with unlabeled data/pseudo labeled data)
# ! Can't use torchvision.Transforms.Compose
if data_set == 'voc':
base = base_voc
workers = 4
transform_train = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
RandomResize(min_size=input_sizes[0], max_size=input_sizes[1]),
RandomCrop(size=input_sizes[0]),
RandomHorizontalFlip(flip_prob=0.5),
Normalize(mean=mean, std=std)])
if no_aug:
transform_train_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
Normalize(mean=mean, std=std)])
else:
transform_train_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
RandomResize(min_size=input_sizes[0], max_size=input_sizes[1]),
RandomCrop(size=input_sizes[0]),
RandomHorizontalFlip(flip_prob=0.5),
Normalize(mean=mean, std=std)])
transform_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
Normalize(mean=mean, std=std)])
transform_test = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
ZeroPad(size=input_sizes[2]),
Normalize(mean=mean, std=std)])
elif data_set == 'city': # All the same size (whole set is down-sampled by 2)
base = base_city
workers = 8
transform_train = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
RandomResize(min_size=input_sizes[0], max_size=input_sizes[1]),
RandomCrop(size=input_sizes[0]),
RandomHorizontalFlip(flip_prob=0.5),
Normalize(mean=mean, std=std),
LabelMap(label_id_map_city)])
if no_aug:
transform_train_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
Normalize(mean=mean, std=std)])
else:
transform_train_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
RandomResize(min_size=input_sizes[0], max_size=input_sizes[1]),
RandomCrop(size=input_sizes[0]),
RandomHorizontalFlip(flip_prob=0.5),
Normalize(mean=mean, std=std)])
transform_pseudo = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
Normalize(mean=mean, std=std),
LabelMap(label_id_map_city)])
transform_test = Compose(
[ToTensor(keep_scale=keep_scale, reverse_channels=reverse_channels),
Resize(size_image=input_sizes[2], size_label=input_sizes[2]),
Normalize(mean=mean, std=std),
LabelMap(label_id_map_city)])
else:
base = ''
# Not the actual test set (i.e.validation set)
test_set = StandardSegmentationDataset(root=base, image_set='valtiny' if valtiny else 'val',
transforms=transform_test, label_state=0, data_set=data_set)
val_loader = torch.utils.data.DataLoader(dataset=test_set, batch_size=batch_size, num_workers=workers, shuffle=False)
# Testing
if state == 3:
return val_loader
else:
# Fully-supervised training
if state == 2:
labeled_set = StandardSegmentationDataset(root=base, image_set=(str(split) + '_labeled_' + str(sets_id)),
transforms=transform_train, label_state=0, data_set=data_set)
labeled_loader = torch.utils.data.DataLoader(dataset=labeled_set, batch_size=batch_size,
num_workers=workers, shuffle=True)
return labeled_loader, val_loader
# Semi-supervised training
elif state == 1:
pseudo_labeled_set = StandardSegmentationDataset(root=base, data_set=data_set,
image_set=(str(split) + '_unlabeled_' + str(sets_id)),
transforms=transform_train_pseudo, label_state=1)
reference_set = SegmentationLabelsDataset(root=base, image_set=(str(split) + '_unlabeled_' + str(sets_id)),
data_set=data_set)
reference_loader = torch.utils.data.DataLoader(dataset=reference_set, batch_size=batch_size,
num_workers=workers, shuffle=False)
unlabeled_set = StandardSegmentationDataset(root=base, data_set=data_set,
image_set=(str(split) + '_unlabeled_' + str(sets_id)),
transforms=transform_pseudo, label_state=2)
labeled_set = StandardSegmentationDataset(root=base, data_set=data_set,
image_set=(str(split) + '_labeled_' + str(sets_id)),
transforms=transform_train, label_state=0)
unlabeled_loader = torch.utils.data.DataLoader(dataset=unlabeled_set, batch_size=batch_size,
num_workers=workers, shuffle=False)
pseudo_labeled_loader = torch.utils.data.DataLoader(dataset=pseudo_labeled_set,
batch_size=int(batch_size / 2),
num_workers=workers, shuffle=True)
labeled_loader = torch.utils.data.DataLoader(dataset=labeled_set,
batch_size=int(batch_size / 2),
num_workers=workers, shuffle=True)
return labeled_loader, pseudo_labeled_loader, unlabeled_loader, val_loader, reference_loader
else:
# Support unsupervised learning here if that's what you want
raise ValueError
def __init__(
self,
data_src,
folds2include=None,
num_folds=5,
samples_per_epoch=2000,
roi_size=96,
scale_int=(0, 255),
norm_mean=0.,
norm_sd=1.,
zoom_range=(0.90, 1.1),
prob_unseeded_patch=0.2,
int_aug_offset=None,
int_aug_expansion=None,
valid_labels=None, # if this is None it will include all the available labels
is_preloaded=False,
max_input_size=2048 #if any image is larger than this it will be splitted (only working with folds)
):
_dum = set(dir(self))
self.data_src = Path(data_src)
if not self.data_src.exists():
raise ValueError(f'`data_src` : `{data_src}` does not exists.')
self.folds2include = folds2include
self.num_folds = num_folds
self.samples_per_epoch = samples_per_epoch
self.roi_size = roi_size
self.scale_int = scale_int
self.norm_mean = norm_mean
self.norm_sd = norm_sd
self.zoom_range = zoom_range
self.prob_unseeded_patch = prob_unseeded_patch
self.int_aug_offset = int_aug_offset
self.int_aug_expansion = int_aug_expansion
self.valid_labels = valid_labels
self.is_preloaded = is_preloaded
self.max_input_size = max_input_size
self._input_names = list(
set(dir(self)) - _dum
) #i want the name of this fields so i can access them if necessary
rotation_pad_size = math.ceil(self.roi_size * (math.sqrt(2) - 1) / 2)
padded_roi_size = roi_size + 2 * rotation_pad_size
transforms_random = [
RandomCropWithSeeds(padded_roi_size, rotation_pad_size,
prob_unseeded_patch),
AffineTransform(zoom_range),
RemovePadding(rotation_pad_size),
RandomVerticalFlip(),
RandomHorizontalFlip(),
NormalizeIntensity(scale_int, norm_mean, norm_sd),
RandomIntensityOffset(int_aug_offset),
RandomIntensityExpansion(int_aug_expansion),
OutContours2Segmask(),
FixDTypes()
#I cannot really pass the ToTensor to the dataloader since it crashes when the batchsize is large (>256)
]
self.transforms_random = Compose(transforms_random)
transforms_full = [
NormalizeIntensity(scale_int),
OutContours2Segmask(),
FixDTypes(),
ToTensor()
]
self.transforms_full = Compose(transforms_full)
self.hard_neg_data = None
if self.data_src.is_dir():
assert self.folds2include is None
self.data = self.load_data_from_dir(self.data_src, padded_roi_size,
self.is_preloaded)
else:
assert self.is_preloaded
self.data = self.load_data_from_file(self.data_src)
self.type_ids = sorted(list(self.data.keys()))
self.types2label = {k: (ii + 1) for ii, k in enumerate(self.type_ids)}
self.num_clases = len(self.type_ids)
#flatten data so i can access the whole list by index
self.data_indexes = [(_type, _fname, ii)
for _type, type_data in self.data.items()
for _fname, file_data in type_data.items()
for ii in range(len(file_data))]
assert len(self.data_indexes) > 0 #makes sure there are valid files
def init(batch_size,
state,
input_sizes,
dataset,
mean,
std,
base,
workers=10,
method='baseline'):
# Return data_loaders
# depending on whether the state is
# 0: training
# 1: fast validation by mean IoU (validation set)
# 2: just testing (test set)
# 3: just testing (validation set)
# Transformations
# ! Can't use torchvision.Transforms.Compose
transforms_test = Compose([
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
ToTensor(),
Normalize(mean=mean, std=std)
])
transforms_train = Compose([
Resize(size_image=input_sizes[0], size_label=input_sizes[0]),
RandomRotation(degrees=3),
ToTensor(),
Normalize(mean=mean,
std=std,
normalize_target=True if method == 'lstr' else False)
])
# Batch builder
if method == 'lstr':
collate_fn = dict_collate_fn
else:
collate_fn = None
if state == 0:
if method == 'lstr':
if dataset == 'tusimple':
data_set = TuSimple(root=base,
image_set='train',
transforms=transforms_train,
padding_mask=True,
process_points=True)
elif dataset == 'culane':
data_set = CULane(root=base,
image_set='train',
transforms=transforms_train,
padding_mask=True,
process_points=True)
else:
raise ValueError
else:
data_set = StandardLaneDetectionDataset(
root=base,
image_set='train',
transforms=transforms_train,
data_set=dataset)
data_loader = torch.utils.data.DataLoader(dataset=data_set,
batch_size=batch_size,
collate_fn=collate_fn,
num_workers=workers,
shuffle=True)
validation_set = StandardLaneDetectionDataset(
root=base,
image_set='val',
transforms=transforms_test,
data_set=dataset)
validation_loader = torch.utils.data.DataLoader(dataset=validation_set,
batch_size=batch_size *
4,
num_workers=workers,
shuffle=False,
collate_fn=collate_fn)
return data_loader, validation_loader
elif state == 1 or state == 2 or state == 3:
image_sets = ['valfast', 'test', 'val']
if method == 'lstr':
if dataset == 'tusimple':
data_set = TuSimple(root=base,
image_set=image_sets[state - 1],
transforms=transforms_test,
padding_mask=False,
process_points=False)
elif dataset == 'culane':
data_set = CULane(root=base,
image_set=image_sets[state - 1],
transforms=transforms_test,
padding_mask=False,
process_points=False)
else:
raise ValueError
else:
data_set = StandardLaneDetectionDataset(
root=base,
image_set=image_sets[state - 1],
transforms=transforms_test,
data_set=dataset)
data_loader = torch.utils.data.DataLoader(dataset=data_set,
batch_size=batch_size,
collate_fn=collate_fn,
num_workers=workers,
shuffle=False)
return data_loader
else:
raise ValueError
