def test_rotation_origin(self): # Rotation around far away point, image should be empty transform = RandomAffine( degrees=(90, 90), default_pad_value=0, center='origin', ) transformed = transform(self.sample_subject) total = transformed.t1.data.sum() self.assertEqual(total, 0)
def test_rotation_image(self): # Rotation around image center transform = RandomAffine( degrees=(90, 90), default_pad_value=0, center='image', ) transformed = transform(self.sample_subject) total = transformed.t1.data.sum() self.assertNotEqual(total, 0)
def test_no_rotation(self): transform = RandomAffine( scales=(1, 1), degrees=(0, 0), default_pad_value=0, center='image', ) transformed = transform(self.sample_subject) self.assertTensorAlmostEqual(self.sample_subject.t1.data, transformed.t1.data) transform = RandomAffine( scales=(1, 1), degrees=(180, 180), default_pad_value=0, center='image', ) transformed = transform(self.sample_subject) transformed = transform(transformed) self.assertTensorAlmostEqual(self.sample_subject.t1.data, transformed.t1.data)
def get_tranformation_list(choice=1): if isinstance(choice,int): choice = [choice] transfo_list, transfo_name = [], [] if 1 in choice: transfo_list += [ RandomAffineFFT(scales=(1, 1), degrees=(10, 10)), RandomAffineFFT(scales=(1.2, 1.2), degrees=(0, 0)), RandomAffineFFT(scales=(0.8, 0.8), degrees=(0, 0)), ] transfo_name += ['tAfft_R10', 'tAfft_S1.2', 'tAfft_S08'] if 2 in choice: transfo_list += [ RandomAffine(scales=(1, 1), degrees=(10, 10), image_interpolation='nearest'), RandomAffine(scales=(1.2, 1.2), degrees=(0, 0), image_interpolation='nearest'), RandomAffine(scales=(0.8, 0.8), degrees=(0, 0), image_interpolation='nearest'), ] transfo_name += ['tAffN_R10', 'tAffN_S1.2', 'tAffN_S08'] return transfo_list, transfo_name
def _get_default_transforms(self): io_transforms = Compose([ RandomMotion(), RandomFlip(axes=(1, )), RandomAffine(scales=(0.9, 1.2), degrees=(10), isotropic=False, default_pad_value='otsu', image_interpolation='bspline'), RescaleIntensity((0, 1)) ]) return io_transforms
def test_translation(self): transform = RandomAffine(scales=(1, 1), degrees=0, translation=(5, 5)) transformed = transform(self.sample) # I think the right test should be the following one: # self.assertTensorAlmostEqual( # self.sample.t1.data[:, :-5, :-5, :-5], # transformed.t1.data[:, 5:, 5:, 5:] # ) # However the passing test is this one: self.assertTensorAlmostEqual(self.sample.t1.data[:, :-5, :-5, 5:], transformed.t1.data[:, 5:, 5:, :-5])
def get_torchio_transformer(mask=False): if mask: interpolation = 'linear' else: interpolation = image_interpolation return RandomAffine(scales=scales, degrees=degrees, translation=translation, isotropic=isotropic, center=center, default_pad_value=default_pad_value, image_interpolation=interpolation, p=p, seed=seed)
def transform(self): if hp.mode == '3d': training_transform = Compose([ # ToCanonical(), CropOrPad((hp.crop_or_pad_size, hp.crop_or_pad_size, hp.crop_or_pad_size), padding_mode='reflect'), RandomMotion(), RandomBiasField(), ZNormalization(), RandomNoise(), RandomFlip(axes=(0, )), OneOf({ RandomAffine(): 0.8, RandomElasticDeformation(): 0.2, }), ]) elif hp.mode == '2d': training_transform = Compose([ CropOrPad((hp.crop_or_pad_size, hp.crop_or_pad_size, 1), padding_mode='reflect'), RandomMotion(), RandomBiasField(), ZNormalization(), RandomNoise(), RandomFlip(axes=(0, )), OneOf({ RandomAffine(): 0.8, RandomElasticDeformation(): 0.2, }), ]) else: raise Exception('no such kind of mode!') return training_transform
def get_brats( data_root='/scratch/weina/dld_data/brats2019/MICCAI_BraTS_2019_Data_Training/', fold=1, seed=torch.distributed.get_rank() if torch.distributed.is_initialized() else 0, **kwargs): """ data iter for brats """ logging.debug("BratsIter:: fold = {}, seed = {}".format(fold, seed)) # args for transforms d_size, h_size, w_size = 155, 240, 240 input_size = [7, 223, 223] spacing = (d_size / input_size[0], h_size / input_size[1], w_size / input_size[2]) Mean, Std, Max = read_brats_mean(fold, data_root) normalize = transforms.Normalize(mean=Mean, std=Std) training_transform = Compose([ # RescaleIntensity((0, 1)), # so that there are no negative values for RandomMotion # RandomMotion(), # HistogramStandardization({MRI: landmarks}), RandomBiasField(), # ZNormalization(masking_method=ZNormalization.mean), RandomNoise(), ToCanonical(), Resample(spacing), # CropOrPad((48, 60, 48)), RandomFlip(axes=(0, )), OneOf({ RandomAffine(): 0.8, RandomElasticDeformation(): 0.2, }), normalize ]) val_transform = Compose([Resample(spacing), normalize]) train = BratsIter(csv_file=os.path.join(data_root, 'IDH_label', 'train_fold_{}.csv'.format(fold)), brats_path=os.path.join(data_root, 'all'), brats_transform=training_transform, shuffle=True) val = BratsIter(csv_file=os.path.join(data_root, 'IDH_label', 'val_fold_{}.csv'.format(fold)), brats_path=os.path.join(data_root, 'all'), brats_transform=val_transform, shuffle=False) return train, val
def random_augment(x): '''Randomly augment input data. Returns: Randomly augmented input ''' # Data augmentations to be used transforms_dict = { RandomFlip(): 1, RandomElasticDeformation(): 1, RandomAffine(): 1, RandomNoise(): 1, RandomBlur(): 1 } # Create random transform, with a p chance to apply augmentation transform = OneOf(transforms_dict, p=0.95) return augment(x, transform)
def predict_majority(model, x, y): '''Augments all samples of the original data, and chooses majority predictions predicted by the model. Usage: predict_majority(model, x_original, y_original) ''' # Reshape arrays x = np.reshape(x, (len(x), 40, 40, 4, 1)) y = [x - 1 for x in y] y = to_categorical(y, 5) # Predict majority x_flip = augment(x.copy(), RandomFlip()) x_ed = augment(x.copy(), RandomElasticDeformation()) x_affine = augment(x.copy(), RandomAffine()) x_noise = augment(x.copy(), RandomNoise()) x_blur = augment(x.copy(), RandomBlur()) y_true = pred_list(y) y_pred = pred_list(model.predict(x.copy())) y_flip = pred_list(model.predict(x_flip.copy())) y_ed = pred_list(model.predict(x_ed.copy())) y_affine = pred_list(model.predict(x_affine.copy())) y_noise = pred_list(model.predict(x_noise.copy())) y_blur = pred_list(model.predict(x_blur.copy())) y_most = [] correct = 0 print( '\nEntry Number | Prediction (None, Flip, Elastic Deformation, Affine, Noise, Blur) | Actual' ) for i in range(len(y_true)): preds = [ y_pred[i], y_flip[i], y_ed[i], y_affine[i], y_noise[i], y_blur[i] ] most = max(set(preds), key=preds.count) y_most.append(most) print('Entry', i, '| Predictions:', preds, '| Most Occuring:', most, '| Correct:', y_true[i]) if most == y_true[i]: correct += 1 print('\nTest Accuracy: ', correct / len(y_true)) print('Quadratic Weighted Kappa: ', cohen_kappa_score(y_true, y_most, weights='quadratic'))
def training_network(landmarks, dataset, subjects): training_transform = Compose([ ToCanonical(), Resample(4), CropOrPad((48, 60, 48), padding_mode='reflect'), RandomMotion(), HistogramStandardization({'mri': landmarks}), RandomBiasField(), ZNormalization(masking_method=ZNormalization.mean), RandomNoise(), RandomFlip(axes=(0, )), OneOf({ RandomAffine(): 0.8, RandomElasticDeformation(): 0.2, }), ]) validation_transform = Compose([ ToCanonical(), Resample(4), CropOrPad((48, 60, 48), padding_mode='reflect'), HistogramStandardization({'mri': landmarks}), ZNormalization(masking_method=ZNormalization.mean), ]) training_split_ratio = 0.9 num_subjects = len(dataset) num_training_subjects = int(training_split_ratio * num_subjects) training_subjects = subjects[:num_training_subjects] validation_subjects = subjects[num_training_subjects:] training_set = tio.SubjectsDataset(training_subjects, transform=training_transform) validation_set = tio.SubjectsDataset(validation_subjects, transform=validation_transform) print('Training set:', len(training_set), 'subjects') print('Validation set:', len(validation_set), 'subjects') return training_set, validation_set
def test_scale_too_large(self): with self.assertRaises(ValueError): RandomAffine(scales=1.5)
def test_negative_scales(self): with self.assertRaises(ValueError): RandomAffine(scales=(-1, 1))
def test_incompatible_args_isotropic(self): with self.assertRaises(ValueError): RandomAffine(scales=(0.8, 0.5, 0.1), isotropic=True)
def test_wrong_image_interpolation_value(self): with self.assertRaises(ValueError): RandomAffine(image_interpolation='wrong')
def test_wrong_image_interpolation_type(self): with self.assertRaises(TypeError): RandomAffine(image_interpolation=0)
def test_wrong_default_pad_value(self): with self.assertRaises(ValueError): RandomAffine(default_pad_value='wrong')
def test_wrong_center(self): with self.assertRaises(ValueError): RandomAffine(center=0)
def get_torchio_transformer(mask=False): if mask: interpolation = Interpolation.LINEAR else: interpolation = image_interpolation return RandomAffine(scales, degrees, isotropic, default_pad_value, interpolation, p, seed, is_tensor)
) # Mock PyTorch model model = lambda x: x # Define training and patches sampling parameters num_epochs = 4 patch_size = 128 queue_length = 100 samples_per_volume = 1 batch_size = 2 # Define transforms for data normalization and augmentation transforms = ( ZNormalization(), RandomAffine(scales=(0.9, 1.1), degrees=10), RandomNoise(std_range=(0, 0.25)), RandomFlip(axes=(0, )), ) transform = Compose(transforms) # Populate a list with dictionaries of paths one_subject_dict = { 'T1': dict(path='../BRATS2018_crop_renamed/LGG75_T1.nii.gz', type=torchio.INTENSITY), 'T2': dict(path='../BRATS2018_crop_renamed/LGG75_T2.nii.gz', type=torchio.INTENSITY), 'label': dict(path='../BRATS2018_crop_renamed/LGG75_Label.nii.gz',
def affine(p=1): return RandomAffine(p=p)
def test_too_many_translation_values(self): with self.assertRaises(ValueError): RandomAffine(translation=(-10, 4, 42))
def test_scales_range_with_negative_min(self): with self.assertRaises(ValueError): RandomAffine(scales=(-1, 4))
def test_zero_probabilities(self): with self.assertRaises(ValueError): OneOf({RandomAffine(): 0, RandomElasticDeformation(): 0})
def test_negative_probabilities(self): with self.assertRaises(ValueError): OneOf({RandomAffine(): -1, RandomElasticDeformation(): 1})
def test_wrong_degrees_type(self): with self.assertRaises(ValueError): RandomAffine(degrees='wrong')
def test_too_many_scales_values(self): with self.assertRaises(ValueError): RandomAffine(scales=(1., 4., 12.))
def test_wrong_translation_type(self): with self.assertRaises(ValueError): RandomAffine(translation='wrong')
def test_too_many_degrees_values(self): with self.assertRaises(ValueError): RandomAffine(degrees=(-10., 4., 42.))