def test_MODEL_loading(self):
nn = Neural_Network(preprocessor=self.pp3D)
model_path = os.path.join(self.tmp_dir3D.name, "my_model.hdf5")
nn.dump(model_path)
nn_new = Neural_Network(preprocessor=self.pp3D)
nn_new.load(model_path)
def test_MODEL_resetWeights(self):
nn = Neural_Network(preprocessor=self.pp3D)
nn.reset_weights()
def test_MODEL_validation3D(self):
nn = Neural_Network(preprocessor=self.pp3D)
history = nn.evaluate(self.sample_list3D[0:4], self.sample_list3D[4:6],
epochs=3)
self.assertIsNotNone(history)
def test_MODEL_storage(self):
nn = Neural_Network(preprocessor=self.pp3D)
model_path = os.path.join(self.tmp_dir3D.name, "my_model.hdf5")
nn.dump(model_path)
self.assertTrue(os.path.exists(model_path))
def test_MODEL_training3D(self):
nn = Neural_Network(preprocessor=self.pp3D)
nn.train(self.sample_list3D, epochs=3)
def test_MODEL_prediction_returnOutput(self):
nn = Neural_Network(preprocessor=self.pp2D)
pred_list = nn.predict(self.sample_list2D, return_output=True)
for pred in pred_list:
self.assertIsNotNone(pred)
self.assertEqual(pred.shape, (16,16))
def test_MODEL_multiGPU(self):
nn = Neural_Network(preprocessor=self.pp2D,
multi_gpu=True)
nn.train(self.sample_list2D, epochs=3)
## want a specific shape (e.g. DenseNet for classification)
sf = [Resize(new_shape=(224, 224))]
# 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"], 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,
sf = [sf_clipping, sf_normalize, sf_resample, sf_zscore]
# Create and configure the Preprocessor class
pp = Preprocessor(data_io, data_aug=data_aug, 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=3, learninig_rate=0.001)
# Define Callbacks
cb_lr = ReduceLROnPlateau(monitor='loss', factor=0.1, patience=15,
verbose=1, mode='min', min_delta=0.0001, cooldown=1,
min_lr=0.00001)
cb_es = EarlyStopping(monitor="loss", patience=100)
cb_tb = TensorBoard(log_dir=os.path.join(fold_subdir, "tensorboard"),
histogram_freq=0, write_graph=True, write_images=True)
cb_cl = CSVLogger(os.path.join(fold_subdir, "logs.csv"), separator=',',
append=True)
cb_mc = ModelCheckpoint(os.path.join(fold_subdir, "model.best.hdf5"),
monitor="loss", verbose=1,
save_best_only=True, mode="min")
class metricTEST(unittest.TestCase):
# Create random imaging and segmentation data
@classmethod
def setUpClass(self):
np.random.seed(1234)
# Create 2D imgaging and segmentation data set
self.dataset = dict()
for i in range(0, 2):
img = np.random.rand(16, 16) * 255
self.img = img.astype(int)
seg = np.random.rand(16, 16) * 2
self.seg = seg.astype(int)
self.dataset["TEST.sample_" + str(i)] = (self.img, self.seg)
# Initialize Dictionary IO Interface
io_interface = Dictionary_interface(self.dataset, classes=3,
three_dim=False)
# Initialize temporary directory
self.tmp_dir = tempfile.TemporaryDirectory(prefix="tmp.miscnn.")
tmp_batches = os.path.join(self.tmp_dir.name, "batches")
# Initialize Data IO
self.data_io = Data_IO(io_interface,
input_path=os.path.join(self.tmp_dir.name),
output_path=os.path.join(self.tmp_dir.name),
batch_path=tmp_batches, delete_batchDir=False)
# Initialize Preprocessor
self.pp = Preprocessor(self.data_io, batch_size=1,
data_aug=None, analysis="fullimage")
# Initialize Neural Network
self.model = Neural_Network(self.pp)
# Get sample list
self.sample_list = self.data_io.get_indiceslist()
# Delete all temporary files
@classmethod
def tearDownClass(self):
self.tmp_dir.cleanup()
#-------------------------------------------------#
# Standard DSC Metric #
#-------------------------------------------------#
def test_METRICS_DSC_standard(self):
self.model.loss = dice_coefficient
self.model.metrics = [dice_coefficient]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Standard DSC Loss #
#-------------------------------------------------#
def test_METRICS_DSC_standardLOSS(self):
self.model.loss = dice_coefficient_loss
self.model.metrics = [dice_coefficient_loss]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Soft DSC Metric #
#-------------------------------------------------#
def test_METRICS_DSC_soft(self):
self.model.loss = dice_soft
self.model.metrics = [dice_soft]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Soft DSC Loss #
#-------------------------------------------------#
def test_METRICS_DSC_softLOSS(self):
self.model.loss = dice_soft_loss
self.model.metrics = [dice_soft_loss]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Weighted DSC #
#-------------------------------------------------#
def test_METRICS_DSC_weighted(self):
self.model.loss = dice_weighted([1,1,4])
self.model.metrics = [dice_weighted([1,1,4])]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Dice & Crossentropy loss #
#-------------------------------------------------#
def test_METRICS_DSC_CrossEntropy(self):
self.model.loss = dice_crossentropy
self.model.metrics = [dice_crossentropy]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Tversky loss #
#-------------------------------------------------#
def test_METRICS_Tversky(self):
self.model.loss = tversky_loss
self.model.metrics = [tversky_loss]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Tversky & Crossentropy loss #
#-------------------------------------------------#
def test_METRICS_Tversky_CrossEntropy(self):
self.model.loss = tversky_crossentropy
self.model.metrics = [tversky_crossentropy]
self.model.train(self.sample_list, epochs=1)
#-------------------------------------------------#
# Focal Loss - Categorical #
#-------------------------------------------------#
def test_METRICS_FocalCategorical(self):
self.model.loss = categorical_focal_loss([0.9, 0.1])
self.model.metrics = [categorical_focal_loss([0.1, 0.9])]
self.model.train(self.sample_list, epochs=1)
# 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)