Esempio n. 1
0
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)
Esempio n. 2
0
    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)),
        ])
Esempio n. 3
0
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!")
Esempio n. 4
0
def main():

    # get test set and test set loader
    test_set = CRC_Dataset(root_dir=os.path.join(os.getcwd(), "data\\test"),
                           transforms=[
                               MirrorPad(((6, ), (6, ), (0, ))),
                               ToTensor(),
                               Normalize(means=(0.7942, 0.6693, 0.7722),
                                         stds=(0.1998, 0.3008, 0.2037))
                           ])

    test_loader = torch.utils.data.DataLoader(
        test_set,
        batch_size=args.batch_size if args.batch_size else 8,
        num_workers=args.workers if args.workers else 1,
        pin_memory=use_cuda,
    )

    model = UNet((512, 512), (500, 500),
                 32,
                 64,
                 128,
                 256,
                 512,
                 droprate=0.5,
                 Norm=torch.nn.BatchNorm2d)
    #model = UNet((512, 512), (500, 500), 32, 64, 128, 256, Norm=torch.nn.BatchNorm2d)
    model.load_state_dict(torch.load(chkpt))
    model.to(device)

    dice, acc = compute_metrics_on_test_set(model, test_loader)
    print(dice, acc)
Esempio n. 5
0
def valid_dataset(root_dir,
                  normalization=None,
                  grayscale=False,
                  square=False,
                  csv_file='B/validation_data.csv',
                  scale=1.0):
    """This function loads the training dataset with the desired transformations."""

    scaled_width = int(round(scale * constants.default_width))

    transformations = []
    if scale != 1.0:
        transformations.append(Resize(scaled_width))

    if square:
        transformations.append(Square())

    if grayscale:
        transformations.append(BlackAndWhite())

    transformations.append(ToTensor())

    if normalization is not None:
        transformations.append(normalization)

    transform = transforms.Compose(transformations)

    valid_dataset = PostureLandmarksDataset(csv_file=csv_file,
                                            root_dir=root_dir,
                                            transform=transform)
    return valid_dataset
Esempio n. 6
0
def get_transforms():
    data_transform = torchvision.transforms.Compose([
        ToTensor(),
        Normalize(mean=constants.DATA_MEAN, std=constants.DATA_STD),
        Resize(constants.TRANSFORMED_IMAGE_SIZE)
    ])
    return data_transform
Esempio n. 7
0
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
Esempio n. 9
0
def transform_preset(mode='random_crop'):
    transformer = None
    if mode == 'random_crop':
        transformer = Compose([
            ToWoldCoordinateSystem(),
            ToTensor()])

    return transformer
Esempio n. 10
0
def load_data(datadir):
    # Data loading code
    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)

    return dataset, dataset_test
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
Esempio n. 12
0
 def __init__(self,
              files,
              channels,
              patch_size,
              transform=None,
              noise_transform=None):
     self.channels = channels
     self.patch_size = patch_size
     self.transform = transform
     self.noise_transforms = noise_transform
     self.to_tensor = ToTensor()
     self.dataset = {'image': [], 'noisy': []}
     self.load_dataset(files)
Esempio n. 13
0
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
Esempio n. 14
0
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()
Esempio n. 15
0
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()
Esempio n. 16
0
    def __init__(self, root_dir, transforms=[ToTensor()]):
        '''
        Args:\n
            :root_dir: string containing the root directory of the dataset. 
            :transforms: list of transformations to apply to the samples.
        '''

        self.root_dir = root_dir
        self.transforms = transforms
        self.composed_trsfm = Compose(transforms)

        # save name of files in lists
        self.images = glob.glob(os.path.join(root_dir, 'frames\\*.npz'))
        self.labels = glob.glob(os.path.join(root_dir, 'masks\\*.npz'))
Esempio n. 17
0
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
Esempio n. 18
0
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
Esempio n. 19
0
    def __init__(self, options):
        self.options = options
        self.device = torch.device(
            'cuda:0' if torch.cuda.is_available() else 'cpu')

        test_transform_list = []
        if self.options.max_scale > 1:
            test_transform_list.append(
                RandomRescaleBB(1.0, self.options.max_scale))
        test_transform_list.append(
            CropAndResize(out_size=(self.options.crop_size,
                                    self.options.crop_size)))
        test_transform_list.append(
            LocsToHeatmaps(out_size=(self.options.heatmap_size,
                                     self.options.heatmap_size)))
        test_transform_list.append(ToTensor())
        test_transform_list.append(Normalize())

        self.test_ds = RctaDataset(
            root_dir=self.options.dataset_dir,
            is_train=False,
            transform=transforms.Compose(test_transform_list))

        self.model = StackedHourglass(self.options.num_keypoints).to(
            self.device)
        # Only create optimizer because it is required to restore from checkpoint
        self.optimizer = torch.optim.RMSprop(params=self.model.parameters(),
                                             lr=0,
                                             momentum=0,
                                             weight_decay=0)
        self.models_dict = {'stacked_hg': self.model}
        self.optimizers_dict = {'optimizer': self.optimizer}
        print("log dir:", options.log_dir)
        print("checkpoint dir:", options.checkpoint_dir)
        self.saver = CheckpointSaver(save_dir=options.checkpoint_dir)
        print("checkpoint:", self.options.checkpoint)
        self.checkpoint = self.saver.load_checkpoint(
            self.models_dict,
            self.optimizers_dict,
            checkpoint_file=self.options.checkpoint)

        self.criterion = nn.MSELoss().to(self.device)
        self.pose = Pose2DEval(detection_thresh=self.options.detection_thresh,
                               dist_thresh=self.options.dist_thresh)
Esempio n. 20
0
 def get_testing_loader(img_root, label_root, file_list, batch_size,
                        img_size, num_class):
     transformed_dataset = VOCDataset(
         img_root,
         label_root,
         file_list,
         transform=transforms.Compose([
             Resize(img_size),
             ToTensor(),
             Normalize(imagenet_stats['mean'], imagenet_stats['std']),
             # GenOneHotLabel(num_class),
         ]))
     loader = DataLoader(
         transformed_dataset,
         batch_size,
         shuffle=False,
         num_workers=0,
         pin_memory=False,
     )
     return loader
Esempio n. 21
0
 def get_training_loader(img_root, label_root, file_list, batch_size,
                         img_height, img_width, num_class):
     transformed_dataset = VOCTestDataset(
         img_root,
         label_root,
         file_list,
         transform=transforms.Compose([
             RandomHorizontalFlip(),
             Resize((img_height + 5, img_width + 5)),
             RandomCrop((img_height, img_width)),
             ToTensor(),
             Normalize(imagenet_stats['mean'], imagenet_stats['std']),
             # GenOneHotLabel(num_class),
         ]))
     loader = DataLoader(
         transformed_dataset,
         batch_size,
         shuffle=True,
         num_workers=0,
         pin_memory=False,
     )
     return loader
Esempio n. 22
0
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
Esempio n. 23
0
                                               title='info_loss',
                                               ytickmin=0,
                                               ytinkmax=10)),
                    acc=Scalar(vis,
                               'Accuracy',
                               opts=dict(showlegend=True,
                                         title='Accuracy',
                                         ytickmin=0,
                                         ytinkmax=2.0)),
                    inputs=Image3D(vis, 'inputs'),
                    outputs=Image3D(vis, 'outputs'))

    # create train set,  x = image, y=target
    x, y, train_idx, test_idx, ratio = fold_split(FG)
    #transform=Compose([ToWoldCoordinateSystem(), Normalize((0.5, 0.9)), ToTensor()])
    transform = Compose([ToWoldCoordinateSystem(), ToTensor()])

    trainset = ADNIDataset(FG, x[train_idx], y[train_idx], transform=transform)
    testset = ADNIDataset(FG, x[test_idx], y[test_idx], transform=transform)

    trainloader = DataLoader(trainset,
                             batch_size=FG.batch_size,
                             shuffle=True,
                             pin_memory=True,
                             num_workers=4)
    testloader = DataLoader(testset,
                            batch_size=FG.batch_size,
                            shuffle=True,
                            num_workers=4,
                            pin_memory=True)
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
Esempio n. 25
0
    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
Esempio n. 26
0
def main(args=None):
    global thres
    global rel_thresh
    global attr_thresh

    parser = argparse.ArgumentParser(description='Simple training script for training a RetinaNet network.')

    parser.add_argument('--dataset', help='Dataset type, must be one of csv or coco.')
    parser.add_argument('--data_path', help='Path to COCO directory')
    parser.add_argument('--csv_classes', help='Path to file containing class list (see readme)')
    parser.add_argument('--csv_val', help='Path to file containing validation annotations (optional, see readme)')
    parser.add_argument('--net', help='Network to use', default='fasterrcnn')
    parser.add_argument('--set', help='Set on which evaluation will be performed', default='validation')
    parser.add_argument('--store_detections', action='store_true', default=False,
                        help='Cache all detections with very low threshold in order to enable filtering after extraction')
    parser.add_argument('--load_detections', action='store_true', default=False,
                        help='Load cached detections')

    parser.add_argument('--model_rel', help='Path to model (.pt) file for relationships.', default=None)
    parser.add_argument('--model_attr', help='Path to model (.pt) file for attributes.', default=None)
    parser.add_argument('--model_detector', help='Path to model (.pt) file for the detector.')
    parser.add_argument('--depth', help='Resnet depth, must be one of 18, 34, 50, 101, 152', type=int, default=50)

    parser = parser.parse_args(args)

    assert parser.model_rel is not None and parser.model_attr is not None and parser.model_detector is not None, \
           'Models snapshots have to be specified!'
    assert not (parser.load_detections and parser.store_detections)

    det_output_path = os.path.split(parser.model_rel)[0]

    if parser.dataset == 'openimages':
        dataset_val = OidDatasetVRD(parser.data_path, subset=parser.set,
                                    transform=Compose([ToTensor()]))
    else:
        raise ValueError('Dataset type not understood (must be csv or coco), exiting.')

    #sampler_val = AspectRatioBasedSampler(dataset_val, batch_size=1, drop_last=False)
    dataloader_val = DataLoader(dataset_val, num_workers=1, collate_fn=collate_fn, batch_size=1)

    # Create the model
    detector = create_detection_model(dataset_val.num_classes(), parser, box_score_thresh=thres)
    model = VRD(detector, dataset=dataset_val, train_relationships=parser.model_rel is not None,
                train_attributes=parser.model_attr is not None, max_objects=max_objects)

    # Load the detector
    checkpoint = torch.load(parser.model_detector, map_location=lambda storage, loc: storage)
    weights = checkpoint['model']
    weights = {k.replace('module.', ''): v for k, v in weights.items()}
    model.detector.load_state_dict(weights)
    print('Detector correctly loaded!')

    # Load the attributes, if needed
    if parser.model_rel:
        checkpoint = torch.load(parser.model_rel, map_location=lambda storage, loc: storage)
        weights = checkpoint['model_rel']
        weights = {k.replace('module.', ''): v for k, v in weights.items()}
        model.relationships_net.load_state_dict(weights)
        print('Relationships correctly loaded!')

    if parser.model_attr:
        checkpoint = torch.load(parser.model_attr, map_location=lambda storage, loc: storage)
        weights = checkpoint['model_attr']
        weights = {k.replace('module.', ''): v for k, v in weights.items()}
        model.attributes_net.load_state_dict(weights)
        print('Attributes correctly loaded!')

    if use_gpu:
        model = model.cuda()

    model.eval()

    all_detections = []
    if parser.load_detections or parser.store_detections:
        print('Opening detections database file...')
        flag = 'r' if parser.load_detections else 'c'
        loaded_detections = shelve.open(os.path.join(det_output_path, 'cached_detections_detthr{}.db'.format(thres)), flag=flag)

    for idx, data in enumerate(tqdm.tqdm(dataloader_val)):
        if parser.load_detections:
            loaded_det = loaded_detections[str(idx)]
            scores = loaded_det[0]
            classification = loaded_det[1]
            boxes = loaded_det[2]
            relationships = loaded_det[3]
            rel_scores = loaded_det[4]
            attributes = loaded_det[5]
            attr_scores = loaded_det[6]
        else:
            with torch.no_grad():
                st = time.time()

                images, targets = data

                # targets = [{k: v.cuda() for k, v in t.items()} for t in targets]
                if use_gpu:
                    input_images = list(image.cuda().float() for image in images)
                else:
                    input_images = list(image.float() for image in images)
                # TODO: adapt retinanet output to the one by torchvision 0.3
                # scores, classification, transformed_anchors = model(data_img.float())
                outputs = model(input_images)
                outputs = [{k: v.cpu() for k, v in t.items()} for t in outputs]

            output = outputs[0]  # take the only batch
            scores = output['scores']
            classification = output['labels']
            boxes = output['boxes']
            relationships = output['relationships']
            rel_scores = output['relationships_scores']
            attributes = output['attributes']
            attr_scores = output['attributes_scores']

        if parser.store_detections:
            loaded_detections[str(idx)] = [scores, classification, boxes, relationships, rel_scores, attributes, attr_scores]
        else:
            '''if parser.load_detections:
                pdb.set_trace()
                # filter objects, relationships and attributes
                filtered_idxs = np.where(scores > thres)[0]
                scores = scores[filtered_idxs]
                classification = classification[filtered_idxs]
                boxes = boxes[filtered_idxs]
                relationships = relationships[np.ix_(filtered_idxs, filtered_idxs)]
                rel_scores = rel_scores[np.ix_(filtered_idxs, filtered_idxs)]
                attributes = attributes[filtered_idxs]
                attr_scores = attr_scores[filtered_idxs]
            '''
            subj_boxes_out = []
            subj_labels_out = []
            obj_boxes_out = []
            obj_labels_out = []
            rel_labels_out = []
            rel_scores_out = []

            if len(boxes) != 0:
                # num_objects = min(boxes.shape[0], max_objects)

                # Collect objects and attributes
                for j in range(attributes.shape[0]):
                    bbox = boxes[j, :4]
                    attr = attributes[j, 0].item() if parser.model_attr is not None and attr_scores[j, 0] > attr_thresh else 0      # TODO: only the top rank attribute is considered, generalize better!
                    # We add an 'is' relation. 'is' relation is mapped to relation index of -1.
                    if attr != 0:
                        subj_boxes_out.append(bbox)
                        obj_boxes_out.append(bbox)
                        rel_labels_out.append(-1)
                        rel_scores_out.append(attr_scores[j, 0])
                        subj_labels_out.append(int(classification[j]))
                        obj_labels_out.append(attr)
                # Collect relationships
                for s_ind in range(relationships.shape[0]):
                    for o_ind in range(relationships.shape[1]):
                        subj = boxes[s_ind, :4]
                        obj = boxes[o_ind, :4]
                        rel = relationships[s_ind, o_ind].item() if rel_scores[s_ind, o_ind] > rel_thresh else 0
                        if rel != 0:
                            subj_boxes_out.append(subj)
                            obj_boxes_out.append(obj)
                            rel_labels_out.append(rel)
                            rel_scores_out.append(rel_scores[s_ind, o_ind])
                            subj_labels_out.append(int(classification[s_ind]))
                            obj_labels_out.append(int(classification[o_ind]))

            all_detections.append([idx, subj_boxes_out, subj_labels_out, obj_boxes_out, obj_labels_out, rel_labels_out, rel_scores_out])
            # if idx == 400:
            #    break

    if not parser.store_detections:
        print('Evaluating...')
        # TODO: add identification parameter to evaluate so that detections from different checkpoints are not overwritten
        dataset_val.evaluate(all_detections, det_output_path, file_identifier='{}_relthr{}_attrthr{}_detthr{}'.format(parser.set, rel_thresh, attr_thresh, thres))
        print('DONE!')
Esempio n. 27
0
            showlegend=True, title='DG_z2', ytickmin=0, ytinkmax=2.0)),
        D_x = Scalar(vis, 'D_x', opts=dict(
            showlegend=True, title='D_x', ytickmin=0, ytinkmax=2.0)),
        inputs0 = Image3D(vis, 'inputs0'),
        inputs1 = Image3D(vis, 'inputs1'),
        fake0 = Image3D(vis, 'fake0'),
        fake1 = Image3D(vis, 'fake1'),
        outputs0 = Image3D(vis, 'outputs0'),
        outputs1 = Image3D(vis, 'outputs1'))

    # dataset setting
    x, y = Trainset(FG)
    # x, y, train_idx, test_idx, ratio = fold_split(FG)
    # transform = Compose([ToFloatTensor(), Normalize(0.5,0.5)])
    # trainset = ADNIDataset2D(FG, x, y, transform=transform)
    transform=Compose([ToWoldCoordinateSystem(), ToTensor(), Pad(1,0,1,0,1,0), Normalize(0.5,0.5)])
    trainset = ADNIDataset(FG, x, y, transform=transform)
    trainloader = DataLoader(trainset, batch_size=FG.batch_size,
                             shuffle=True, pin_memory=True)
    # trainset = ADNIDataset2D(FG, x[train_idx], y[train_idx], transform=transform)
    # testset = ADNIDataset2D(FG, x[test_idx], y[test_idx], transform=transform)
    # trainloader = DataLoader(trainset, batch_size=FG.batch_size, shuffle=True,
    #                          pin_memory=True, num_workers=4)
    # testloader = DataLoader(testset, batch_size=FG.batch_size, shuffle=True,
    #                         num_workers=4, pin_memory=True)

    # models
    D = infoDiscriminator3D(FG.c_code).to('cuda:{}'.format(FG.devices[0]))
    G = infoGenerator3D(FG.z_dim, FG.c_code).to('cuda:{}'.format(FG.devices[0]))

    if len(FG.devices) != 1:
Esempio n. 28
0
                                           ytinkmax=2.0)),
                    inputs=Image3D(vis, 'inputs'),
                    fake=Image3D(vis, 'fake'),
                    valid=Image3D(vis, 'valid'),
                    outputs=Image3D(vis, 'outputs'),
                    outputs2=Image3D(vis, 'outputs2'))

    # x, y = Trainset(FG)      # x = image, y=target
    x, y, train_idx, test_idx, ratio = fold_split(FG)
    # transform=Compose([ToFloatTensor(), Normalize(0.5,0.5)])
    # trainset = ADNIDataset2D(FG, x[train_idx], y[train_idx], transform=transform)
    # testset = ADNIDataset2D(FG, x[test_idx], y[test_idx], transform=transform)

    transform = Compose([
        ToWoldCoordinateSystem(),
        ToTensor(),
        Pad(1, 0, 1, 0, 1, 0),
        Normalize(0.5, 0.5)
    ])
    trainset = ADNIDataset(FG, x[train_idx], y[train_idx], transform=transform)
    testset = ADNIDataset(FG, x[test_idx], y[test_idx], transform=transform)

    trainloader = DataLoader(trainset,
                             batch_size=FG.batch_size,
                             shuffle=True,
                             pin_memory=True,
                             num_workers=4)
    testloader = DataLoader(testset,
                            batch_size=FG.batch_size,
                            shuffle=True,
                            num_workers=4,
Esempio n. 29
0
def main(args):

    print(args)

    torch.backends.cudnn.benchmark = True

    # Data loading
    normalize = T.Normalize(mean=[0.485, 0.456, 0.406],
                            std=[0.229, 0.224, 0.225])
    base_size = 320
    crop_size = 256
    min_size, max_size = int(0.5 * base_size), int(2.0 * base_size)

    interpolation_mode = InterpolationMode.BILINEAR

    train_loader, val_loader = None, None
    if not args.test_only:
        st = time.time()
        train_set = VOCSegmentation(args.data_path,
                                    image_set='train',
                                    download=True,
                                    transforms=Compose([
                                        RandomResize(min_size, max_size,
                                                     interpolation_mode),
                                        RandomCrop(crop_size),
                                        RandomHorizontalFlip(0.5),
                                        ImageTransform(
                                            T.ColorJitter(brightness=0.3,
                                                          contrast=0.3,
                                                          saturation=0.1,
                                                          hue=0.02)),
                                        ToTensor(),
                                        ImageTransform(normalize)
                                    ]))

        train_loader = torch.utils.data.DataLoader(
            train_set,
            batch_size=args.batch_size,
            drop_last=True,
            sampler=RandomSampler(train_set),
            num_workers=args.workers,
            pin_memory=True,
            worker_init_fn=worker_init_fn)

        print(f"Training set loaded in {time.time() - st:.2f}s "
              f"({len(train_set)} samples in {len(train_loader)} batches)")

    if args.show_samples:
        x, target = next(iter(train_loader))
        plot_samples(x, target, ignore_index=255)
        return

    if not (args.lr_finder or args.check_setup):
        st = time.time()
        val_set = VOCSegmentation(args.data_path,
                                  image_set='val',
                                  download=True,
                                  transforms=Compose([
                                      Resize((crop_size, crop_size),
                                             interpolation_mode),
                                      ToTensor(),
                                      ImageTransform(normalize)
                                  ]))

        val_loader = torch.utils.data.DataLoader(
            val_set,
            batch_size=args.batch_size,
            drop_last=False,
            sampler=SequentialSampler(val_set),
            num_workers=args.workers,
            pin_memory=True,
            worker_init_fn=worker_init_fn)

        print(
            f"Validation set loaded in {time.time() - st:.2f}s ({len(val_set)} samples in {len(val_loader)} batches)"
        )

    if args.source.lower() == 'holocron':
        model = segmentation.__dict__[args.arch](args.pretrained,
                                                 num_classes=len(VOC_CLASSES))
    elif args.source.lower() == 'torchvision':
        model = tv_segmentation.__dict__[args.arch](
            args.pretrained, num_classes=len(VOC_CLASSES))

    # Loss setup
    loss_weight = None
    if isinstance(args.bg_factor, float) and args.bg_factor != 1:
        loss_weight = torch.ones(len(VOC_CLASSES))
        loss_weight[0] = args.bg_factor
    if args.loss == 'crossentropy':
        criterion = nn.CrossEntropyLoss(weight=loss_weight,
                                        ignore_index=255,
                                        label_smoothing=args.label_smoothing)
    elif args.loss == 'focal':
        criterion = holocron.nn.FocalLoss(weight=loss_weight, ignore_index=255)
    elif args.loss == 'mc':
        criterion = holocron.nn.MutualChannelLoss(weight=loss_weight,
                                                  ignore_index=255,
                                                  xi=3)

    # Optimizer setup
    model_params = [p for p in model.parameters() if p.requires_grad]
    if args.opt == 'sgd':
        optimizer = torch.optim.SGD(model_params,
                                    args.lr,
                                    momentum=0.9,
                                    weight_decay=args.weight_decay)
    elif args.opt == 'radam':
        optimizer = holocron.optim.RAdam(model_params,
                                         args.lr,
                                         betas=(0.95, 0.99),
                                         eps=1e-6,
                                         weight_decay=args.weight_decay)
    elif args.opt == 'adamp':
        optimizer = holocron.optim.AdamP(model_params,
                                         args.lr,
                                         betas=(0.95, 0.99),
                                         eps=1e-6,
                                         weight_decay=args.weight_decay)
    elif args.opt == 'adabelief':
        optimizer = holocron.optim.AdaBelief(model_params,
                                             args.lr,
                                             betas=(0.95, 0.99),
                                             eps=1e-6,
                                             weight_decay=args.weight_decay)

    log_wb = lambda metrics: wandb.log(metrics) if args.wb else None
    trainer = SegmentationTrainer(model,
                                  train_loader,
                                  val_loader,
                                  criterion,
                                  optimizer,
                                  args.device,
                                  args.output_file,
                                  num_classes=len(VOC_CLASSES),
                                  amp=args.amp,
                                  on_epoch_end=log_wb)
    if args.resume:
        print(f"Resuming {args.resume}")
        checkpoint = torch.load(args.resume, map_location='cpu')
        trainer.load(checkpoint)

    if args.show_preds:
        x, target = next(iter(train_loader))
        with torch.no_grad():
            if isinstance(args.device, int):
                x = x.cuda()
            trainer.model.eval()
            preds = trainer.model(x)
        plot_predictions(x.cpu(), preds.cpu(), target, ignore_index=255)
        return

    if args.test_only:
        print("Running evaluation")
        eval_metrics = trainer.evaluate()
        print(
            f"Validation loss: {eval_metrics['val_loss']:.4} (Mean IoU: {eval_metrics['mean_iou']:.2%})"
        )
        return

    if args.lr_finder:
        print("Looking for optimal LR")
        trainer.lr_find(args.freeze_until,
                        norm_weight_decay=args.norm_weight_decay,
                        num_it=min(len(train_loader), 100))
        trainer.plot_recorder()
        return

    if args.check_setup:
        print("Checking batch overfitting")
        is_ok = trainer.check_setup(args.freeze_until,
                                    args.lr,
                                    norm_weight_decay=args.norm_weight_decay,
                                    num_it=min(len(train_loader), 100))
        print(is_ok)
        return

    # Training monitoring
    current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    exp_name = f"{args.arch}-{current_time}" if args.name is None else args.name

    # W&B
    if args.wb:

        run = wandb.init(name=exp_name,
                         project="holocron-semantic-segmentation",
                         config={
                             "learning_rate": args.lr,
                             "scheduler": args.sched,
                             "weight_decay": args.weight_decay,
                             "epochs": args.epochs,
                             "batch_size": args.batch_size,
                             "architecture": args.arch,
                             "source": args.source,
                             "input_size": 256,
                             "optimizer": args.opt,
                             "dataset": "Pascal VOC2012 Segmentation",
                             "loss": args.loss,
                         })

    print("Start training")
    start_time = time.time()
    trainer.fit_n_epochs(args.epochs,
                         args.lr,
                         args.freeze_until,
                         args.sched,
                         norm_weight_decay=args.norm_weight_decay)
    total_time_str = str(
        datetime.timedelta(seconds=int(time.time() - start_time)))
    print(f"Training time {total_time_str}")

    if args.wb:
        run.finish()
Esempio n. 30
0
def main():
    gflags.DEFINE_string('id', None, 'ID for Training')
    gflags.DEFINE_string('epoch', 25, 'Number of Epochs')
    gflags.DEFINE_string('pretrained', None, 'Pretrained for Resuming Training')
    gflags.DEFINE_string('threshold', 0.5, 'Threshold probability for predicting class')
    gflags.DEFINE_string('batchsize', 128, 'Batch Size')
    gflags.DEFINE_string('gpu', True, 'Use GPU or Not')
    gflags.DEFINE_string('lr', 0.001, 'Learning Rate')
    gflags.DEFINE_string('class_name', 'None', 'class name')
    gflags.FLAGS(sys.argv)
    
    # Directory Path for saving weights of Trained Model
    save_path = 'Train_id' + str(gflags.FLAGS.id)
    class_name = gflags.FLAGS.class_name
    threshold = gflags.FLAGS.threshold
    class_name = gflags.FLAGS.class_name
    writer = SummaryWriter('./runs/{}'.format(gflags.FLAGS.id))
    
    if not os.path.isdir(save_path):
        os.mkdir(save_path)
        os.mkdir(save_path + '/Checkpoint')

    train_dataset_path = 'data/train'
    val_dataset_path = 'data/valid'
    train_transform = transforms.Compose([
        ImgAugTransform(),
        ToTensor()
    ])
    valid_transform = transforms.Compose([
        ToTensor()
    ])
    
    train_dataset = TrainDataset(path=train_dataset_path, transform=valid_transform, class_name=class_name)
    val_dataset = TrainDataset(path=val_dataset_path, transform=valid_transform, class_name=class_name)
    
    sampler = WeightedRandomSampler(torch.DoubleTensor(train_dataset.weights), len(train_dataset.weights))
    
    train_dataloader = DataLoader(train_dataset, batch_size=4,
                                  pin_memory=True, num_workers=4)
    val_dataloader = DataLoader(val_dataset, batch_size=4, shuffle=False,
                                pin_memory=True, num_workers=4)

    size_train = len(train_dataloader)
    size_val = len(val_dataloader)
    
    print('Number of Training Images: {}'.format(size_train))
    print('Number of Validation Images: {}'.format(size_val))
    
    # Reads class weights from a Json file
    with open('class_weights.json', 'r') as fp:
        class_weights = json.load(fp)
        
    weight = torch.tensor([1/class_weights[class_name]])
    start_epoch = 0
    
    if class_name in ['Roads', 'Railway']:
        model = DinkNet34(num_classes = 1)
    else:   
        model = Unet(n_ch=4, n_classes=1)
    
    if pretrained is not None:
        criterion = FocalLoss()
    else:
        criterion = LogDiceLoss()
    criterion1 = torch.nn.BCEWithLogitsLoss()
    
    optimizer = torch.optim.Adam(model.parameters(), lr=float(gflags.FLAGS.lr))

    if gflags.FLAGS.gpu:
        model = model.cuda()
        criterion = criterion.cuda()
        criterion1 = criterion1.cuda()

    if gflags.FLAGS.pretrained is not None:
        weight_path = sorted(os.listdir('./weights/' + save_path+ '/Checkpoint/'), key=lambda x:float(x[:-8]))[0]
        checkpoint = torch.load('./weights/' + save_path + '/Checkpoint/' + weight_path)
        start_epoch = checkpoint['epoch']
        model.load_state_dict(checkpoint['state_dict'])
        optimizer.load_state_dict(checkpoint['optimizer'])
        print('Loaded Checkpoint of Epoch: {}'.format(gflags.FLAGS.weight))

    for epoch in range(start_epoch, int(gflags.FLAGS.epoch) + start_epoch):
        print("epoch {}".format(epoch))
        train(model, train_dataloader, criterion, criterion1, optimizer, epoch, writer, size_train, threshold)
        print('')
        val_loss = val(model, val_dataloader, criterion, criterion1, epoch, writer, size_val, threshold)
        print('')
        save_checkpoint({
            'epoch': epoch + 1,
            'state_dict': model.state_dict(),
            'optimizer': optimizer.state_dict(),
        }, filename= save_path + '/Checkpoint/' + str(val_loss) + '.pth.tar')
    writer.export_scalars_to_json(save_path + 'log.json')