def test_MODEL_prediction3D(self): nn = Neural_Network(preprocessor=self.pp3D) nn.predict(self.sample_list3D) for index in self.sample_list3D: sample = self.data_io3D.sample_loader(index, load_seg=True, load_pred=True) self.assertIsNotNone(sample.pred_data)
def test_MODEL_prediction_activationOutput(self): nn = Neural_Network(preprocessor=self.pp2D) pred_list = nn.predict(self.sample_list2D, return_output=True, activation_output=True) for pred in pred_list: self.assertIsNotNone(pred) self.assertEqual(pred.shape, (16,16,3))
def test_SUBFUNCTIONS_fullrun(self): ds = dict() for i in range(0, 10): img = np.random.rand(16, 16, 16) * 255 img = img.astype(int) seg = np.random.rand(16, 16, 16) * 3 seg = seg.astype(int) sample = (img, seg) ds["TEST.sample_" + str(i)] = sample io_interface = Dictionary_interface(ds, classes=3, three_dim=True) self.tmp_dir = tempfile.TemporaryDirectory(prefix="tmp.miscnn.") tmp_batches = os.path.join(self.tmp_dir.name, "batches") dataio = Data_IO(io_interface, input_path="", output_path="", batch_path=tmp_batches, delete_batchDir=False) sf = [Resize((16,16,16)), Normalization(), Clipping(min=-1.0, max=0.0)] pp = Preprocessor(dataio, batch_size=1, prepare_subfunctions=True, analysis="fullimage", subfunctions=sf) nn = Neural_Network(preprocessor=pp) sample_list = dataio.get_indiceslist() nn.predict(sample_list, return_output=True)
# Initialize the Preprocessor class pp = Preprocessor(data_io, data_aug=None, batch_size=1, subfunctions=sf, prepare_subfunctions=True, prepare_batches=False, analysis="fullimage") ## We are using fullimage analysis due to a 2D image can easily fit completely ## in our GPU # Initialize the neural network model model = Neural_Network(preprocessor=pp) # Start the fitting on some slices model.train(samples_list[30:50], epochs=3, iterations=10, callbacks=[]) # Predict a generic slice with direct output pred = model.predict(["case_00002:#:42"], return_output=True) print(np.asarray(pred).shape) ## Be aware that the direct prediction output, has a additional batch axis # Predict a generic slice and save it as a NumPy pickle on disk model.predict(["case_00002:#:42"], return_output=False) # Load the slice via sample-loader and output also the new prediction, now sample = data_io.sample_loader("case_00002:#:42", load_seg=True, load_pred=True) print(sample.img_data.shape, sample.seg_data.shape, sample.pred_data.shape) ## Final words # I hope that this usage example / tutorial on the new NIfTI slicer IO # interface, helps on understanding how it works and how you can use it #
def test_ARCHITECTURES_UNET_standard(self): model2D = Neural_Network(self.pp2D, architecture=UNet_standard()) model2D.predict(self.sample_list2D) model3D = Neural_Network(self.pp3D, architecture=UNet_standard()) model3D.predict(self.sample_list3D)
mode="min") #-----------------------------------------------------# # Run Pipeline for provided CV Fold # #-----------------------------------------------------# # Run pipeline for cross-validation fold run_fold(fold, model, epochs=1000, iterations=150, evaluation_path=path_eval, draw_figures=True, callbacks=[cb_lr, cb_es, cb_tb, cb_cl, cb_mc], save_models=False) # Dump latest model to disk model.dump(os.path.join(fold_subdir, "model.latest.hdf5")) #-----------------------------------------------------# # Inference for provided CV Fold # #-----------------------------------------------------# # Load best model weights during fitting model.load(os.path.join(fold_subdir, "model.best.hdf5")) # Obtain training and validation data set training, validation = load_disk2fold( os.path.join(fold_subdir, "sample_list.json")) # Compute predictions model.predict(validation, return_output=False)
def run(self): # Create sample list for miscnn util.create_sample_list(self.input_dir) # Initialize Data IO Interface for NIfTI data interface = NIFTI_interface(channels=1, classes=2) # Create Data IO object to load and write samples in the file structure data_io = Data_IO(interface, input_path=self.input_dir, delete_batchDir=False) # Access all available samples in our file structure sample_list = data_io.get_indiceslist() sample_list.sort() # Create a resampling Subfunction to voxel spacing 1.58 x 1.58 x 2.70 sf_resample = Resampling((1.58, 1.58, 2.70)) # Create a pixel value normalization Subfunction for z-score scaling sf_zscore = Normalization(mode="z-score") # Create a pixel value normalization Subfunction to scale between 0-255 sf_normalize = Normalization(mode="grayscale") # Assemble Subfunction classes into a list sf = [sf_normalize, sf_resample, sf_zscore] # Create and configure the Preprocessor class pp = Preprocessor(data_io, batch_size=2, subfunctions=sf, prepare_subfunctions=True, prepare_batches=False, analysis="patchwise-crop", patch_shape=(160, 160, 80)) # Adjust the patch overlap for predictions pp.patchwise_overlap = (80, 80, 30) # Initialize the Architecture unet_standard = Architecture(depth=4, activation="softmax", batch_normalization=True) # Create the Neural Network model model = Neural_Network( preprocessor=pp, architecture=unet_standard, loss=tversky_crossentropy, metrics=[tversky_loss, dice_soft, dice_crossentropy], batch_queue_size=3, workers=1, learninig_rate=0.001) # Load best model weights during fitting model.load(f'{self.model_dir}{self.model_name}.hdf5') # Obtain training and validation data set ----- CHANGE BASED ON PRED/TRAIN images, _ = load_disk2fold(f'{self.input_dir}sample_list.json') print('\n\nRunning automatic segmentation on samples...\n') print(f'Segmenting images: {images}') # Compute predictions self.predictions = model.predict(images) # Delete folder created by miscnn shutil.rmtree('batches/')
mode="min") #-----------------------------------------------------# # Run Pipeline for provided CV Fold # #-----------------------------------------------------# # Run pipeline for cross-validation fold run_fold(fold, model, epochs=1000, iterations=150, evaluation_path="evaluation", draw_figures=True, callbacks=[cb_lr, cb_es, cb_tb, cb_cl, cb_mc], save_models=False) # Dump latest model to disk model.dump(os.path.join(fold_subdir, "model.latest.hdf5")) #-----------------------------------------------------# # Inference for provided CV Fold # #-----------------------------------------------------# # Load best model weights during fitting model.load(os.path.join(fold_subdir, "model.best.hdf5")) # Obtain training and validation data set training, validation = load_csv2fold( os.path.join(fold_subdir, "sample_list.csv")) # Compute predictions model.predict(validation, direct_output=False)
def test_ARCHITECTURES_UNET_attention_residual(self): model2D = Neural_Network(self.pp2D, architecture=UNet_attention_residual()) model2D.predict(self.sample_list2D) model3D = Neural_Network(self.pp3D, architecture=UNet_attention_residual()) model3D.predict(self.sample_list3D)
batch_size=1, subfunctions=sf, prepare_subfunctions=True, prepare_batches=False, analysis="fullimage") ## We are using fullimage analysis due to a 2D image can easily fit completely ## in our GPU # Initialize the neural network model model = Neural_Network(preprocessor=pp) # Start the fitting on some slices model.train(samples_list[30:50], epochs=3, iterations=10, callbacks=[]) # Predict a generic slice with direct output pred = model.predict(["case_00002:#:42"], direct_output=True) print(np.asarray(pred).shape) ## Be aware that the direct prediction output, has a additional batch axis # Predict a generic slice and save it as a NumPy pickle on disk model.predict(["case_00002:#:42"], direct_output=False) # Load the slice via sample-loader and output also the new prediction, now sample = data_io.sample_loader("case_00000:#:89", load_seg=True, load_pred=True) print(sample.img_data.shape, sample.seg_data.shape, sample.pred_data.shape) ## Final words # I hope that this usage example / tutorial on the new NIfTI slicer IO # interface, helps on understanding how it works and how you can use it
# Create a pixel value normalization Subfunction for z-score scaling sf_zscore = Normalization(mode="z-score") # Assemble Subfunction classes into a list sf = [sf_clipping, sf_normalize, sf_resample, sf_zscore] # Create and configure the Preprocessor class pp = Preprocessor(data_io, data_aug=None, batch_size=2, subfunctions=sf, prepare_subfunctions=True, prepare_batches=False, analysis="patchwise-crop", patch_shape=(160, 160, 80), use_multiprocessing=True) # Adjust the patch overlap for predictions pp.patchwise_overlap = (80, 80, 30) pp.mp_threads = 16 # Initialize the Architecture unet_standard = Architecture(depth=4, activation="softmax", batch_normalization=True) # Create the Neural Network model model = Neural_Network(preprocessor=pp, architecture=unet_standard, loss=tversky_crossentropy, metrics=[tversky_loss, dice_soft, dice_crossentropy], batch_queue_size=3, workers=3, learninig_rate=0.001) # Load best model weights during fitting model.load(path_model) # Compute predictions model.predict(sample_list, return_output=False)