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