def initLossAggregators(self):
if self.train_losses is not None and self.val_losses is not None:
assert set(self.train_losses.keys()) == set(self.val_losses.keys()), 'train and val loss keys are not equal, ' + ', '.join(map(str, self.train_losses.keys())) + ' and ' + ', '.join(map(str, self.val_losses.keys()))
if self.train_losses is None:
return
summaries_placeholders = OrderedDict([(loss_name, create_summary_placeholder(loss_name)) for loss_name in self.train_losses.keys()])
# mean values used for summaries
self.train_loss_aggregator = SummaryHandler(self.sess,
self.train_losses,
summaries_placeholders,
'train',
os.path.join(self.output_folder, 'train'),
os.path.join(self.output_folder, 'train.csv', ))
if self.val_losses is None:
return
summaries_placeholders_val = summaries_placeholders.copy()
if self.additional_summaries_placeholders_val is not None:
summaries_placeholders_val.update(self.additional_summaries_placeholders_val)
self.val_loss_aggregator = SummaryHandler(self.sess,
self.val_losses,
summaries_placeholders_val,
'test',
os.path.join(self.output_folder, 'test'),
os.path.join(self.output_folder, 'test.csv'))
def __init__(self, modality, cv):
super().__init__()
self.modality = modality
self.cv = cv
self.batch_size = 1
self.learning_rates = [0.00001, 0.000001]
self.learning_rate_boundaries = [20000]
self.max_iter = 40000
self.test_iter = 5000
self.disp_iter = 100
self.snapshot_iter = self.test_iter
self.test_initialization = False
self.current_iter = 0
self.reg_constant = 0.0001
self.num_labels = 8
self.data_format = 'channels_first'
self.channel_axis = 1
self.save_debug_images = False
self.has_validation_groundtruth = cv != 0
self.base_folder = 'mmwhs_dataset'
self.image_size = [64, 64, 64]
if modality == 'ct':
self.image_spacing = [3, 3, 3]
else:
self.image_spacing = [4, 4, 4]
self.input_gaussian_sigma = 1.0
self.label_gaussian_sigma = 1.0
self.use_landmarks = True
self.output_folder = './output/scn_' + modality + '_' + str(
cv) + '/' + self.output_folder_timestamp()
dataset_parameters = dict(
image_size=self.image_size,
image_spacing=self.image_spacing,
base_folder=self.base_folder,
cv=self.cv,
modality=self.modality,
input_gaussian_sigma=self.input_gaussian_sigma,
label_gaussian_sigma=self.label_gaussian_sigma,
use_landmarks=self.use_landmarks,
num_labels=self.num_labels,
data_format=self.data_format,
save_debug_images=self.save_debug_images)
self.dataset = Dataset(**dataset_parameters)
self.dataset_train = self.dataset.dataset_train()
self.dataset_val = self.dataset.dataset_val()
self.dataset_val = self.dataset.dataset_val()
self.files_to_copy = ['main.py', 'network.py', 'dataset.py']
self.dice_names = list(
map(lambda x: 'dice_{}'.format(x), range(self.num_labels)))
self.additional_summaries_placeholders_val = dict([
(name, create_summary_placeholder(name))
for name in self.dice_names
])
self.loss_function = softmax_cross_entropy_with_logits
self.network = network_scn
def __init__(self, param):
super().__init__()
#polyaxon
data_dir = os.path.join(
list(get_data_paths().values())[0], "lung/JSRT/preprocessed/")
logging.info('DATA DIR = ' + data_dir)
output_path = get_outputs_path()
self.loss_function = param[0]
self.network = param[1]
self.routing_type = param[2]
self.batch_size = 1
self.learning_rates = [1, 1]
self.max_iter = 300000
self.test_iter = 10000
self.disp_iter = 100
self.snapshot_iter = self.test_iter
self.test_initialization = False
self.current_iter = 0
self.num_labels = 6
self.data_format = 'channels_first' #WARNING: Capsule might not work with channel last !
self.channel_axis = 1
self.save_debug_images = False
self.base_folder = data_dir ##input folder
self.image_size = [128, 128]
self.image_spacing = [1, 1]
self.output_folder = output_path + self.network.__name__ + '_' + self.output_folder_timestamp(
) ##output save
self.dataset = Dataset(image_size=self.image_size,
image_spacing=self.image_spacing,
num_labels=self.num_labels,
base_folder=self.base_folder,
data_format=self.data_format,
save_debug_images=self.save_debug_images)
self.dataset_train = self.dataset.dataset_train()
self.dataset_train.get_next()
self.dataset_val = self.dataset.dataset_val()
self.dice_names = list(
map(lambda x: 'dice_{}'.format(x), range(self.num_labels)))
self.additional_summaries_placeholders_val = dict([
(name, create_summary_placeholder(name))
for name in self.dice_names
])
if self.network.__name__ is 'network_ud':
self.net_file = './Lung_Segmentation/LungSeg/cnn_network.py'
elif self.network.__name__ is 'SegCaps_multilabels':
self.net_file = './Lung_Segmentation/LungSeg/SegCaps/SegCaps.py'
else:
self.net_file = './Lung_Segmentation/LungSeg/capsule_network.py'
self.files_to_copy = ['main_train_and_test.py', self.net_file]
def __init__(self,
cv,
network,
unet,
network_parameters,
learning_rate,
output_folder_name=''):
"""
Initializer.
:param cv: The cv fold. 0, 1, 2 for CV; 'train_all' for training on whole dataset.
:param network: The used network. Usually network_u.
:param unet: The specific instance of the U-Net. Usually UnetClassicAvgLinear3d.
:param network_parameters: The network parameters passed to unet.
:param learning_rate: The initial learning rate.
:param output_folder_name: The output folder name that is used for distinguishing experiments.
"""
super().__init__()
self.batch_size = 1
self.learning_rates = [
learning_rate, learning_rate * 0.5, learning_rate * 0.1
]
self.learning_rate_boundaries = [20000, 30000]
self.max_iter = 50000
self.test_iter = 5000
self.disp_iter = 100
self.snapshot_iter = 5000
self.test_initialization = False
self.current_iter = 0
self.reg_constant = 0.000001
self.num_labels = 1
self.num_labels_all = 26
self.data_format = 'channels_first'
self.channel_axis = 1
self.network = network
self.unet = unet
self.network_parameters = network_parameters
self.padding = 'same'
self.clip_gradient_global_norm = 1.0
self.use_pyro_dataset = False
self.save_output_images = True
self.save_output_images_as_uint = True # set to False, if you want to see the direct network output
self.save_debug_images = False
self.has_validation_groundtruth = cv in [0, 1, 2]
self.local_base_folder = '../verse2019_dataset'
self.image_size = [128, 128, 96]
self.image_spacing = [1] * 3
self.output_folder = os.path.join('./output/vertebrae_segmentation/',
network.__name__, unet.__name__,
output_folder_name, str(cv),
self.output_folder_timestamp())
dataset_parameters = {
'base_folder': self.local_base_folder,
'image_size': self.image_size,
'image_spacing': self.image_spacing,
'cv': cv,
'input_gaussian_sigma': 0.75,
'label_gaussian_sigma': 1.0,
'heatmap_sigma': 3.0,
'generate_single_vertebrae_heatmap': True,
'generate_single_vertebrae': True,
'save_debug_images': self.save_debug_images
}
dataset = Dataset(**dataset_parameters)
if self.use_pyro_dataset:
server_name = '@localhost:51232'
uri = 'PYRO:verse_dataset' + server_name
print('using pyro uri', uri)
self.dataset_train = PyroClientDataset(uri, **dataset_parameters)
else:
self.dataset_train = dataset.dataset_train()
self.dataset_val = dataset.dataset_val()
self.dice_names = ['mean_dice'] + list(
map(lambda x: 'dice_{}'.format(x), range(self.num_labels_all)))
self.hausdorff_names = ['mean_h'] + list(
map(lambda x: 'h_{}'.format(x), range(self.num_labels)))
self.additional_summaries_placeholders_val = dict([
(name, create_summary_placeholder(name))
for name in (self.dice_names + self.hausdorff_names)
])
self.loss_function = sigmoid_cross_entropy_with_logits
self.setup_base_folder = os.path.join(self.local_base_folder, 'setup')
if cv in [0, 1, 2]:
self.cv_folder = os.path.join(self.setup_base_folder,
os.path.join('cv', str(cv)))
self.test_file = os.path.join(self.cv_folder, 'val.txt')
else:
self.test_file = os.path.join(self.setup_base_folder,
'train_all.txt')
self.valid_landmarks_file = os.path.join(self.setup_base_folder,
'valid_landmarks.csv')
self.test_id_list = utils.io.text.load_list(self.test_file)
self.valid_landmarks = utils.io.text.load_dict_csv(
self.valid_landmarks_file)
def __init__(self,
cv,
network,
unet,
network_parameters,
learning_rate,
output_folder_name=''):
"""
Initializer.
:param cv: The cv fold. 0, 1, 2 for CV; 'train_all' for training on whole dataset.
:param network: The used network. Usually network_u.
:param unet: The specific instance of the U-Net. Usually UnetClassicAvgLinear3d.
:param network_parameters: The network parameters passed to unet.
:param learning_rate: The initial learning rate.
:param output_folder_name: The output folder name that is used for distinguishing experiments.
"""
super().__init__()
self.batch_size = 1
self.learning_rates = [
learning_rate, learning_rate * 0.5, learning_rate * 0.1
]
self.learning_rate_boundaries = [50000, 75000]
self.max_iter = 100000
self.test_iter = 10000
self.disp_iter = 100
self.snapshot_iter = 5000
self.test_initialization = False
self.current_iter = 0
self.reg_constant = 0.0005
self.use_background = True
self.num_landmarks = 25
self.heatmap_sigma = 4.0
self.learnable_sigma = True
self.data_format = 'channels_first'
self.network = network
self.unet = unet
self.network_parameters = network_parameters
self.padding = 'same'
self.clip_gradient_global_norm = 100000.0
self.use_pyro_dataset = False
self.use_spine_postprocessing = True
self.save_output_images = True
self.save_output_images_as_uint = True # set to False, if you want to see the direct network output
self.save_debug_images = False
self.has_validation_groundtruth = cv in [0, 1, 2]
self.local_base_folder = '../verse2019_dataset'
self.image_size = [96, 96, 128]
self.image_spacing = [2] * 3
self.cropped_inc = [0, 96, 0, 0]
self.heatmap_size = self.image_size
self.sigma_regularization = 100
self.sigma_scale = 1000.0
self.cropped_training = True
self.output_folder = os.path.join('./output/vertebrae_localization/',
network.__name__, unet.__name__,
output_folder_name, str(cv),
self.output_folder_timestamp())
dataset_parameters = {
'base_folder': self.local_base_folder,
'image_size': self.image_size,
'image_spacing': self.image_spacing,
'cv': cv,
'input_gaussian_sigma': 0.75,
'generate_landmarks': True,
'generate_landmark_mask': True,
'translate_to_center_landmarks': True,
'translate_by_random_factor': True,
'save_debug_images': self.save_debug_images
}
dataset = Dataset(**dataset_parameters)
if self.use_pyro_dataset:
server_name = '@localhost:51232'
uri = 'PYRO:verse_dataset' + server_name
print('using pyro uri', uri)
self.dataset_train = PyroClientDataset(uri, **dataset_parameters)
else:
self.dataset_train = dataset.dataset_train()
self.dataset_val = dataset.dataset_val()
self.point_statistics_names = [
'pe_mean', 'pe_stdev', 'pe_median', 'num_correct'
]
self.additional_summaries_placeholders_val = dict([
(name, create_summary_placeholder(name))
for name in self.point_statistics_names
])
def __init__(self, cv, network_id):
super().__init__()
self.cv = cv
self.network_id = network_id
self.output_folder = network_id
if cv != -1:
self.output_folder += '_cv{}'.format(cv)
self.output_folder += '/' + self.output_folder_timestamp()
self.batch_size = 1
learning_rates = {'scn': 0.00000005, 'unet': 0.000000005}
max_iters = {'scn': 40000, 'unet': 80000}
self.learning_rate = learning_rates[self.network_id]
self.max_iter = max_iters[self.network_id]
self.test_iter = 2500
self.disp_iter = 100
self.snapshot_iter = self.test_iter
self.test_initialization = False
self.current_iter = 0
self.reg_constant = 0.0005
self.sigma_regularization = 100
self.sigma_scale = 1000
self.invert_transformation = False
self.num_landmarks = 26
self.image_size = [96, 96, 192]
self.image_spacing = [2, 2, 2]
self.heatmap_size = self.image_size
self.image_channels = 1
self.heatmap_sigma = 4
self.data_format = 'channels_first'
self.save_debug_images = False
self.base_folder = 'spine_localization_dataset'
self.generate_landmarks = True
self.cropped_training = True
self.cropped_inc = [0, 64, 0, 0]
if self.cropped_training:
dataset = Dataset(self.image_size,
self.image_spacing,
self.heatmap_sigma,
self.num_landmarks,
self.base_folder,
self.cv,
self.data_format,
self.save_debug_images,
generate_heatmaps=not self.generate_landmarks,
generate_landmarks=self.generate_landmarks)
self.dataset_train = dataset.dataset_train()
dataset = Dataset(self.image_size,
self.image_spacing,
self.heatmap_sigma,
self.num_landmarks,
self.base_folder,
self.cv,
self.data_format,
self.save_debug_images,
generate_heatmaps=not self.generate_landmarks,
generate_landmarks=self.generate_landmarks)
self.dataset_val = dataset.dataset_val()
else:
dataset = Dataset(self.image_size,
self.image_spacing,
self.heatmap_sigma,
self.num_landmarks,
self.base_folder,
self.cv,
self.data_format,
self.save_debug_images,
generate_heatmaps=not self.generate_landmarks,
generate_landmarks=self.generate_landmarks,
translate_by_random_factor=False)
self.dataset_train = dataset.dataset_train()
self.dataset_val = dataset.dataset_val()
networks = {'scn': network_scn, 'unet': network_unet}
self.network = networks[self.network_id]
self.point_statistics_names = [
'pe_mean', 'pe_stdev', 'pe_median', 'num_correct'
]
self.additional_summaries_placeholders_val = dict([
(name, create_summary_placeholder(name))
for name in self.point_statistics_names
])
def __init__(self, network_id, cv, landmark_source, sigma_regularization, output_folder_name=''):
super().__init__()
self.network_id = network_id
self.output_folder = os.path.join('output', network_id, landmark_source, cv if cv >= 0 else 'all', output_folder_name, self.output_folder_timestamp())
self.batch_size = 1
self.max_iter = 30000
self.learning_rate = 0.000001
self.test_iter = 5000
self.disp_iter = 100
self.snapshot_iter = self.test_iter
self.test_initialization = False
self.current_iter = 0
self.reg_constant = 0.001
self.cv = cv
self.landmark_source = landmark_source
original_image_extend = [193.5, 240.0]
image_sizes = {'unet': [512, 512],
'scn_mia': [512, 512]}
heatmap_sizes = {'unet': [512, 512],
'scn_mia': [512, 512]}
sigmas = {'unet': 2.5,
'scn_mia': 2.5}
self.image_size = image_sizes[self.network_id]
self.heatmap_size = heatmap_sizes[self.network_id]
self.image_spacing = [float(np.max([e / s for e, s in zip(original_image_extend, self.image_size)]))] * 2
self.sigma = sigmas[self.network_id]
self.image_channels = 1
self.num_landmarks = 19
self.heatmap_sigma = self.sigma
self.sigma_regularization = sigma_regularization
self.sigma_scale = 100.0
self.data_format = 'channels_first'
self.save_debug_images = False
self.base_folder = './'
dataset_parameters = {'image_size': self.image_size,
'heatmap_size': self.heatmap_size,
'image_spacing': self.image_spacing,
'num_landmarks': self.num_landmarks,
'base_folder': self.base_folder,
'data_format': self.data_format,
'save_debug_images': self.save_debug_images,
'cv': self.cv,
'landmark_source': self.landmark_source}
dataset = Dataset(**dataset_parameters)
self.dataset_train = dataset.dataset_train()
self.dataset_val = dataset.dataset_val()
networks = {'unet': network_unet,
'scn_mia': network_scn_mia}
self.network = networks[self.network_id]
self.landmark_metrics = ['pe_mean', 'pe_std', 'pe_median', 'or2', 'or25', 'or3', 'or4', 'or10']
self.landmark_metric_prefixes = ['challenge', 'senior', 'junior', 'mean']
self.additional_summaries_placeholders_val = OrderedDict([(prefix + '_' + name, create_summary_placeholder(prefix + '_' + name)) for name in self.landmark_metrics for prefix in self.landmark_metric_prefixes])