def initialize(self, opt, **kwargs):
self.gpu_ids = opt.gpu_ids
self.isTrain = opt.isTrain
self.use_cuda = opt.use_cuda
self.ImgTensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
self.LblTensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
self.save_dir = opt.save_dir
mkdir(self.save_dir)
def prepare_config(json_config_path: Path,
scratch_dir: Path,
additional_args: list = None):
mkdir(os.path.expanduser(scratch_dir))
config = json_to_dict(json_config_path)
# copy the json configuration file to the scratch directory
new_config_path = scratch_dir / 'config.json'
verify_config_path(new_config_path)
copyfile(json_config_path, new_config_path)
workflow_uid = uuid.uuid4().hex
parameters = [
('workflow_config.uid', workflow_uid), *additional_args
] if additional_args else [('workflow_config.uid', workflow_uid)]
# write workflow uid and model dice scores to new workflow config
write_to_jsonfile(new_config_path, parameters)
return config, workflow_uid
def __init__(self, opt, save_dir, filename='loss_log.txt'):
self.display_id = opt.display_id
self.use_html = not opt.no_html
self.win_size = opt.display_winsize
self.save_epoch_freq = opt.save_epoch_freq
# if save epoch frequency option is negative, volumes will not be saved
self.save_to_disk = opt.save_epoch_freq >= 0
self.save_dir = save_dir
self.name = os.path.basename(self.save_dir)
self.saved = False
self.display_single_pane_ncols = opt.display_single_pane_ncols
# Error plots
self.error_plots = {}
self.error_wins = {}
if self.display_id > 0:
import visdom
self.vis = visdom.Visdom(port=opt.display_port)
if self.save_volumes:
self.saved_volumes_dir = os.path.join(self.save_dir, 'saved_volumes')
utils.mkdir(self.saved_volumes_dir)
if self.use_html:
self.web_dir = os.path.join(self.save_dir, 'web')
self.img_dir = os.path.join(self.web_dir, 'images')
print('create web directory %s...' % self.web_dir)
utils.mkdirs([self.web_dir, self.img_dir])
self.log_name = os.path.join(self.save_dir, filename)
self.log_table = os.path.join(self.save_dir, filename.split('.')[0] + '.xlsx')
if os.path.exists(self.log_table):
timestamp = str(time.time()).split('.')[0]
self.log_table = os.path.splitext(self.log_table)[0] + '_' + timestamp + '.xlsx'
with open(self.log_name, "a") as log_file:
now = time.strftime("%c")
log_file.write('================ Training Loss (%s) ================\n' % now)
def evaluate(config_path):
json_opts = json_file_to_pyobj(config_path)
template_dir = json_opts.data.template_dir
model = get_model(json_opts.model)
save_path = os.path.join(model.save_dir, 'irsabi_test')
mkdir(save_path)
data_type = json_opts.data.data_type
print(save_path)
# shape of the images on which the classifier was trained:
training_shape = json_opts.augmentation.mlebe.scale_size[:3]
ds_class = get_dataset('mlebe_dataset')
# define preprocessing transformations for model
ds_transform = get_dataset_transformation('mlebe', opts=json_opts.augmentation,
max_output_channels=json_opts.model.output_nc)
test_dataset = ds_class(template_dir, json_opts.data.data_dir, json_opts.data, split='test',
transform=ds_transform['valid'],
train_size=None, training_shape=training_shape)
data_selection = test_dataset.data_selection
transformer = ds_transform['valid']()
temp = load_mask(template_dir)
mask_data = [copy.deepcopy(temp) for _ in range(len(data_selection))]
dice_scores_df = pd.DataFrame(columns=['volume_name', 'slice', 'dice_score', 'idx'])
predictions = []
for volume in tqdm(range(len(data_selection))): # volume is an index
# get volume
volume_name = data_selection.iloc[volume]['uid']
img = nib.load(data_selection.iloc[volume]['path']).get_data()
target = mask_data[volume].get_data()
if json_opts.data.with_arranged_mask:
# set the mask to zero where the image is zero
target = arrange_mask(img, target)
# img = preprocess(img, training_shape[:2], 'coronal')
# target = preprocess(target, training_shape[:2], 'coronal')
#
# # set image shape to x,y,z
# img = np.moveaxis(img, 0, 2)
# target = np.moveaxis(target, 0, 2)
# preprocess data for compatibility with model
network_input = transformer(np.expand_dims(img, -1))
target = np.squeeze(transformer(np.expand_dims(target, -1)).cpu().byte().numpy()).astype(np.int16)
# add dimension for batches
network_input = network_input.unsqueeze(0)
model.set_input(network_input)
model.test()
# predict
mask_pred = np.squeeze(model.pred_seg.cpu().numpy())
img = np.squeeze(network_input.numpy())
# set image shape to z,x,y
mask_pred = np.moveaxis(mask_pred, 2, 0)
img = np.moveaxis(img, 2, 0)
target = np.moveaxis(target, 2, 0)
for slice in range(img.shape[0]):
dice_score = dice(target[slice], mask_pred[slice])
# see if this is a black slice (want to skip those for visualisation)
black_slice = np.max(img[slice]) <= 0
dice_scores_df = dice_scores_df.append(
{'volume_name': volume_name, 'slice': slice, 'dice_score': dice_score, 'idx': volume,
'black_slice': black_slice},
ignore_index=True)
predictions.append(mask_pred)
min_df = dice_scores_df.loc[dice_scores_df['black_slice'] == False].sort_values(by=['dice_score']).head(
sum(IMG_NBRs) // 2)
min_df = pd.concat([min_df,
dice_scores_df.loc[dice_scores_df['black_slice'] == False].sort_values(by=['dice_score']).tail(
sum(IMG_NBRs) - sum(IMG_NBRs) // 2)],
ignore_index=True)
with PdfPages(os.path.join(save_path, 'irsabi_test_{}.pdf'.format(data_type))) as pdf:
df_idx = 0
for IMG_NBR in IMG_NBRs:
plt.figure(figsize=(40, IMG_NBR * 10))
plt.figtext(.5, .9, 'Mean dice score of {}'.format(np.round(dice_scores_df['dice_score'].mean(), 4)),
fontsize=100, ha='center')
i = 1
while i <= IMG_NBR * 2 and df_idx < len(min_df):
volume = min_df.iloc[df_idx]['idx']
slice = min_df.iloc[df_idx]['slice']
dice_score = min_df.iloc[df_idx]['dice_score']
plt.subplot(IMG_NBR, 2, i)
plt.imshow(img[slice], cmap='gray')
plt.imshow(target[slice], cmap='Blues', alpha=0.6)
plt.axis('off')
i += 1
plt.subplot(IMG_NBR, 2, i)
plt.imshow(img[slice], cmap='gray')
plt.imshow(predictions[volume][slice], cmap='Blues', alpha=0.6)
plt.title('Volume: {}, slice {}, dice {}'.format(volume_name, slice, dice_score))
plt.axis('off')
i += 1
df_idx += 1
pdf.savefig()
plt.close()
plt.title('Dice score = {}'.format(dice_scores_df['dice_score'].mean()))
plt.savefig('{}.pdf'.format(save_path), format='pdf')
return dice_scores_df['dice_score'].mean(), dice_scores_df['dice_score'].std()
cv2.normalize(input_arr[..., slice],
None,
alpha=0,
beta=1,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_32F))
y_train.append(label_arr[..., slice])
with open(os.path.join(save_directory, 'x_train.npy'), 'wb') as file1:
np.save(file1, x_train)
with open(os.path.join(save_directory, 'y_train.npy'), 'wb') as file2:
np.save(file2, y_train)
save_dir = os.path.expanduser(os.path.join(scratch_dir, 'classifiers', 'T2'))
mkdir(save_dir)
workflow_json_opts = json_file_to_pyobj(config_path)
model_config_path = Path(workflow_json_opts.masking_config.masking_config_anat.
model_folder_path) / 'trained_mlebe_config_anat.json'
model_json_opts = json_file_to_pyobj(model_config_path)
data_dir = model_json_opts.data.data_dir
template_dir = '/usr/share/mouse-brain-atlases/'
ds_class = get_dataset('mlebe_dataset')
ds_path = model_json_opts.data.data_dir
channels = model_json_opts.data_opts.channels
split_opts = model_json_opts.data_split
train_opts = model_json_opts.training
ds_transform = get_dataset_transformation(
'mlebe',