def sa_data_generator(data): # n_slice, n_pixel, n_pixel, slice_x slice_x = gbl_get_value("slice_x") n_pixel = gbl_get_value("img_shape")[0] n_slice = gbl_get_value("img_shape")[2] X = np.zeros((n_slice, n_pixel, n_pixel, slice_x)) Y = np.zeros((n_slice, n_pixel, n_pixel, 1)) # write X if slice_x == 1: for idx in range(n_slice): X[idx, :, :, 0] = data[:, :, idx] Y[idx, :, :, 0] = data[:, :, idx] if slice_x == 3: for idx in range(n_slice): idx_0 = idx - 1 if idx > 0 else 0 idx_1 = idx idx_2 = idx + 1 if idx < n_slice - 1 else n_slice - 1 X[idx, :, :, 0] = data[:, :, idx_0] X[idx, :, :, 1] = data[:, :, idx_1] X[idx, :, :, 2] = data[:, :, idx_2] Y[idx, :, :, 0] = data[:, :, idx] X = X / np.amax(X) Y = Y / np.amax(Y) return X, Y
def write_XY(temp_x, data): # n_slice, n_pixel, n_pixel, slice_x slice_x = gbl_get_value("slice_x") n_pixel = gbl_get_value("img_shape")[0] n_slice = gbl_get_value("img_shape")[2] X = np.zeros((n_slice, n_pixel, n_pixel, slice_x)) Y = np.zeros((n_slice, n_pixel, n_pixel, 1)) # write X if slice_x == 1: for idx in range(n_slice): X[idx, :, :, 0] = temp_x[:, :, idx] Y[idx, :, :, 0] = data[:, :, idx] if slice_x == 3: for idx in range(n_slice): idx_0 = idx - 1 if idx > 0 else 0 idx_1 = idx idx_2 = idx + 1 if idx < n_slice - 1 else n_slice - 1 X[idx, :, :, 0] = temp_x[:, :, idx_0] X[idx, :, :, 1] = temp_x[:, :, idx_1] X[idx, :, :, 2] = temp_x[:, :, idx_2] Y[idx, :, :, 0] = data[:, :, idx] return X, Y
def content_loss(y_true, y_pred): content_weight = gbl_get_value('content_weight') discriminator_path = gbl_get_value('discriminator_path') input_size = gbl_get_value('input_size') y_true = K.reshape(y_true, (-1, input_size, input_size, 3)) print('+++++++++++++++++++++++++++++++++++++') print('content_loss') print(y_true.shape) print(y_pred.shape) print('+++++++++++++++++++++++++++++++++++++') # load the model model_path = discriminator_path model = load_model(model_path, compile=False) for layer in model.layers: layer.trainable = False selected_layers = [ 'block1_conv2', 'block2_conv2', 'block3_conv3', 'block4_conv3', 'final_pred' ] selected_output = [ model.get_layer(name).output for name in selected_layers ] layer_model = Model(inputs=model.input, outputs=selected_output) feature_pred = layer_model(y_pred) feature_true = layer_model(y_true) content_loss = mean_squared_error_123(feature_true[2], feature_pred[2]) content_loss = content_weight * content_loss return content_loss
def style_loss(y_pred, y_true): style_weight = gbl_get_value('style_weight') batch_size = gbl_get_value("batch_size") discriminator_path = gbl_get_value('discriminator_path') input_size = gbl_get_value('input_size') print(style_weight) y_true = K.reshape(y_true, (-1, input_size, input_size, 3)) y_pred = K.reshape(y_pred, (-1, input_size, input_size, 3)) print('+++++++++++++++++++++++++++++++++++++') print('style_loss') print(y_true.shape) print(y_pred.shape) print('+++++++++++++++++++++++++++++++++++++') # load the model model_path = discriminator_path model = load_model(model_path, compile=False) for layer in model.layers: layer.trainable = False selected_layers = [ 'block1_conv2', 'block2_conv2', 'block3_conv3', 'block4_conv3', 'final_pred' ] selected_output = [ model.get_layer(name).output for name in selected_layers ] layer_model = Model(inputs=model.input, outputs=selected_output) feature_pred = layer_model(y_pred) feature_true = layer_model(y_true) # feature_gram gram_pred = [] gram_true = [] for i in range(len(feature_pred) - 1): gram_pred.append(gram_matrix(feature_pred[i])) gram_true.append(gram_matrix(feature_true[i])) style_loss = 0 for i in range(len(selected_layers) - 1): temp = mean_squared_error_12(gram_true[i], gram_pred[i][:batch_size]) style_loss += temp style_loss = style_weight * style_loss return style_loss
def data_generator(data, blur_method, blur_para): temp_x = None # kernel convolution if blur_method == 'kernel_conv': ksize = int(blur_para) kernel = gaussian_kernel(ksize) temp_x = np.zeros(data.shape) for idx in range(data.shape[2]): temp_x[:, :, idx] = ndimage.convolve(data[:, :, idx], kernel, mode='constant') # skimage gaussian if blur_method == 'skimage_gaus': sigma = float(blur_para) temp_x = gaussian(data, sigma=sigma, multichannel=True) # nibabel smooth if blur_method == 'nib_smooth': fwhm = float(blur_para) dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X, Y = write_XY(temp_x, data) X = X / np.amax(X) Y = Y / np.amax(Y) return X, Y
def tv_loss(y_true, y_pred): tv_weight = gbl_get_value('tv_weight') diff_i = K.sum(K.abs(y_pred[:, :, :, 1:] - y_pred[:, :, :, :-1])) diff_j = K.sum(K.abs(y_pred[:, :, 1:, :] - y_pred[:, :, :-1, :])) tv_loss = tv_weight * (diff_i + diff_j) return tv_loss
def predict(model, data): dir_pet = gbl_get_value("dir_pet") n_pixel = gbl_get_value("img_shape")[0] n_slice = gbl_get_value("img_shape")[2] slice_x = gbl_get_value("slice_x") model_id = gbl_get_value("model_id") # dir_syn = gbl_get_value('dir_syn') dir_syn = './' run_aim = gbl_get_value("run_aim") flag_save = True if run_aim == 'see_aug': flag_save = False file_pet = nib.load(dir_pet) factor = np.sum(data) data = data / np.amax(data) y_hat = np.zeros(data.shape) X = np.zeros((1, n_pixel, n_pixel, slice_x)) if slice_x == 1: for idx in range(n_slice): X[0, :, :, 0] = data[:, :, idx] y_hat[:, :, idx] = np.squeeze(model.predict(X)) if slice_x == 3: for idx in range(n_slice): idx_0 = idx-1 if idx > 0 else 0 idx_1 = idx idx_2 = idx+1 if idx < n_slice-1 else n_slice - 1 X[0, :, :, 0] = data[:, :, idx_0] X[0, :, :, 1] = data[:, :, idx_1] X[0, :, :, 2] = data[:, :, idx_2] y_hat[:, :, idx] = np.squeeze(model.predict(X)) dif = y_hat - data y_hat = y_hat / np.sum(y_hat) * factor if flag_save: # save nifty file affine = file_pet.affine header = file_pet.header nii_file = nib.Nifti1Image(y_hat, affine, header) nib.save(nii_file, dir_syn + 'syn_'+model_id+'.nii') # save difference dif_file = nib.Nifti1Image(dif, affine, header) nib.save(dif_file, dir_syn + 'dif_' + model_id + '.nii')
def deeprad_backend_norm(): ui = gbl_get_value("ui") # QtWidgets.QMessageBox.information(ui.button_start, "test", "I am in the glue!") value_folder = ui.norm_folder.toPlainText().split('\n') value_vn = ui.norm_radio_vn.isChecked() value_gn = ui.norm_radio_gn.isChecked() value_vz = ui.norm_radio_vz.isChecked() value_gz = ui.norm_radio_gz.isChecked() value_cn = ui.norm_radio_cn.isChecked() value_nn = ui.norm_radio_nn.isChecked() if ui.norm_radio_cn.isChecked(): value_shift = float(ui.norm_text_shift.text()) value_scale = float(ui.norm_text_scale.text()) value_cropa = float(ui.norm_text_cropa.text()) value_cropb = float(ui.norm_text_cropb.text()) else: value_shift = 0.0 value_scale = 1.0 value_cropa = 100.0 value_cropb = 0.0 args = SimpleNamespace(folder=value_folder, volumenorm=value_vn, globalnorm=value_gn, volumezscore=value_vz, globalzscore=value_gz, customnorm=value_cn, nonorm=value_nn, shift=value_shift, scale=value_scale, cropabove=value_cropa, cropbelow=value_cropb, log_output=ui.norm_log_text) dr_norm.process_norm(args)
def enhance_data_generator(data): # # kernel convolution # ksize = 7 # kernel = gaussian_kernel(ksize) # temp_x = np.zeros(data.shape) # for idx in range(data.shape[2]): # temp_x[:, :, idx] = ndimage.convolve(data[:, :, idx], kernel, mode='constant') # X1, Y1 = write_XY(temp_x, data) # # # skimage gaussian # sigma = 3 # temp_x = gaussian(data, sigma=sigma, multichannel=True) # X2, Y2 = write_XY(temp_x, data) # nibabel smooth fwhm = 4 dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X1, Y1 = write_XY(temp_x, data) # nibabel smooth fwhm = 5 dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X2, Y2 = write_XY(temp_x, data) # nibabel smooth fwhm = 6 dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X3, Y3 = write_XY(temp_x, data) # nibabel smooth fwhm = 7 dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X4, Y4 = write_XY(temp_x, data) # nibabel smooth fwhm = 8 dir_mri = gbl_get_value("dir_mri") file_X = nib.processing.smooth_image(nib.load(dir_mri), fwhm=fwhm, mode='nearest') temp_x = file_X.get_fdata() X5, Y5 = write_XY(temp_x, data) X = np.vstack((X1, X2, X3, X4, X5)) Y = np.vstack((Y1, Y2, Y3, Y4, Y5)) X = X / np.amax(X) Y = Y / np.amax(Y) return X, Y
def train_a_unet(train_path, val_path): slice_x = gbl_get_value("slice_x") n_pixel = gbl_get_value("n_pixel") n_slice = gbl_get_value("n_slice") model_id = gbl_get_value("model_id") dir_model = gbl_get_value('dir_model') epochs = gbl_get_value("n_epoch") batch_size = gbl_get_value("batch_size") flag_save = True # ----------------------------------------------Configurations----------------------------------------------# # save the log log_path = dir_model.split('model')[0] + 'log/' if not os.path.exists(log_path): os.makedirs(log_path) tensorboard = TensorBoard(log_dir=log_path, batch_size=batch_size, write_graph=True, write_grads=True, write_images=True) # set traininig configurations conf = {"image_shape": (n_pixel, n_pixel, slice_x), "out_channel": 1, "shuffle": True, "augmentation": True, "learning_rate": 1e-4, "validation_split": 0.3, "batch_size": batch_size, "epochs": epochs, "model_id": model_id} np.save(log_path + model_id + '_info.npy', conf) # set augmentation configurations conf_a = {"rotation_range": 15, "shear_range": 10, "width_shift_range": 0.33, "height_shift_range": 0.33, "zoom_range": 0.33, "horizontal_flip": True, "vertical_flip": True, "fill_mode": 'nearest', "seed": 314, "batch_size": conf["batch_size"]} np.save(log_path + model_id + '__aug.npy', conf_a) # save the models which has the minimum validation loss or highest accuracy if flag_save: check_path1 = dir_model+'loss_model_'+model_id+'.hdf5' checkpoint1 = ModelCheckpoint(check_path1, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='min') check_path2 = dir_model+'acc_model_'+model_id+'.hdf5' checkpoint2 = ModelCheckpoint(check_path2, monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='max') callbacks_list = [checkpoint1, checkpoint2, tensorboard] else: callbacks_list = [tensorboard] # ----------------------------------------------Create Model----------------------------------------------# # build up the model if gbl_get_value("pretrained_flag") == 0: model = vgg16_model() # model = multi_gpu_model(model, 2) else: model_path = gbl_get_value("pretrained_path") model = load_model(model_path) opt = RAdam(learning_rate=conf['learning_rate'], total_steps=10000, warmup_proportion=0.1, min_lr=1e-6) # ----------------------------------------------Data Generator----------------------------------------------# # train data_generator data_generator1 = ImageDataGenerator(rescale=1./255, rotation_range=conf_a["rotation_range"], shear_range=conf_a["shear_range"], width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) # validation data_generator data_generator3 = ImageDataGenerator(rescale=1./255, width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) aug_dir = '' # ----------------------------------------------Train Model----------------------------------------------# # compile model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['binary_crossentropy', 'acc']) train_path = train_path val_path = val_path # train model.fit_generator(generator=data_generator1.flow_from_directory(directory=train_path, target_size=(512, 512), color_mode='rgb', classes=None, class_mode="binary", batch_size=conf_a["batch_size"], seed=conf_a["seed"], shuffle=True, save_to_dir=aug_dir, save_prefix='train'), steps_per_epoch=int(int(n_slice * (1-conf["validation_split"])) / conf_a["batch_size"]), epochs=conf["epochs"], callbacks=callbacks_list, validation_data=data_generator3.flow_from_directory(directory=val_path, target_size=(512, 512), color_mode='rgb', classes=None, class_mode="binary", batch_size=conf_a["batch_size"], seed=conf_a["seed"], shuffle=True, save_to_dir=aug_dir, save_prefix='val'), validation_steps=int(int(n_slice * conf["validation_split"]) / conf_a["batch_size"])) return model
def train_a_unet(X, Y): slice_x = gbl_get_value("slice_x") n_pixel = X.shape[2] n_slice = X.shape[0] model_id = gbl_get_value("model_id") # dir_model = gbl_get_value('dir_model') dir_model = './' epochs = gbl_get_value("n_epoch") n_fliter = gbl_get_value("n_filter") depth = gbl_get_value("depth") batch_size = gbl_get_value("batch_size") optimizer = 'Adam' run_aim = gbl_get_value("run_aim") flag_save = True if run_aim == 'see_aug': flag_save = False # ----------------------------------------------Configurations----------------------------------------------# # logs log_path = './logs/' + model_id + "/" if not os.path.exists(log_path): os.makedirs(log_path) tensorboard = TensorBoard(log_dir=log_path, batch_size=batch_size, write_graph=True, write_grads=True, write_images=True) # set traininig configurations conf = { "image_shape": (n_pixel, n_pixel, slice_x), "out_channel": 1, "filter": n_fliter, "depth": depth, "inc_rate": 2, "activation": 'relu', "dropout": True, "batchnorm": True, "maxpool": True, "upconv": True, "residual": True, "shuffle": True, "augmentation": True, "learning_rate": 1e-5, "decay": 0.0, "epsilon": 1e-8, "beta_1": 0.9, "beta_2": 0.999, "validation_split": 0.2632, "batch_size": batch_size, "epochs": epochs, "loss": "mse1e6", "metric": "mse", "optimizer": optimizer, "model_id": model_id } np.save(log_path + model_id + '_info.npy', conf) # set augmentation configurations conf_a = { "rotation_range": 15, "shear_range": 10, "width_shift_range": 0.33, "height_shift_range": 0.33, "zoom_range": 0.33, "horizontal_flip": True, "vertical_flip": True, "fill_mode": 'nearest', "seed": 314, "batch_size": conf["batch_size"] } np.save(log_path + model_id + '__aug.npy', conf_a) # checkpoint # check_path= './training_models/' + model_type + '_' + str(LOOCV) + '/' # if not os.path.exists(check_path): # os.makedirs(check_path) if flag_save: check_path = dir_model + 'model_' + model_id + '.hdf5' # _{epoch:03d}_{val_loss:.4f} checkpoint1 = ModelCheckpoint(check_path, monitor='val_psnr', verbose=1, save_best_only=True, mode='max') # checkpoint2 = ModelCheckpoint(check_path, period=100) callbacks_list = [checkpoint1, tensorboard] else: callbacks_list = [tensorboard] # ----------------------------------------------Create Model----------------------------------------------# # build up the model model = unet(img_shape=conf["image_shape"], out_ch=conf["out_channel"], start_ch=conf["filter"], depth=conf["depth"], inc_rate=conf["inc_rate"], activation=conf["activation"], dropout=conf["dropout"], batchnorm=conf["batchnorm"], maxpool=conf["maxpool"], upconv=conf["upconv"], residual=conf["residual"]) # Adam optimizer # if conf["optimizer"] == 'Adam': # opt = Adam(lr=conf["learning_rate"], decay=conf["decay"], # epsilon=conf["epsilon"], beta_1=conf["beta_1"], beta_2=conf["beta_2"]) # if conf["loss"] == 'mse1e6': # loss = mean_squared_error_1e6 loss = mean_squared_error_1e6 opt = Adam(lr=conf["learning_rate"], decay=conf["decay"], epsilon=conf["epsilon"], beta_1=conf["beta_1"], beta_2=conf["beta_2"]) # load dataset [80, n_pixel, n_pixel, 1] # x_val = np.zeros((int(n_slice * 0.3), n_pixel, n_pixel, 1), dtype=np.float32) # y_val = np.zeros((int(n_slice * 0.3), n_pixel, n_pixel, 1), dtype=np.float32) # x_train = np.zeros((int(n_slice * 0.7) + 1, n_pixel, n_pixel, 1), dtype=np.float32) # y_train = np.zeros((int(n_slice * 0.7) + 1, n_pixel, n_pixel, 1), dtype=np.float32) # # temp_x = X # temp_y = Y # list_cand = [] # # idx_x = 0 # while idx_x < int(n_slice * 0.3): # idx_slice = int(np.random.rand() * n_slice) # if not (idx_slice in list_cand): # list_cand.append(idx_slice) # x_val[idx_x, :, :, :] = temp_x[:, :, idx_slice].reshape((1, n_pixel, n_pixel, 1)) # y_val[idx_x, :, :, :] = temp_x[:, :, idx_slice].reshape((1, n_pixel, n_pixel, 1)) # idx_x += 1 # # idx_x = 0 # for i in range(n_slice): # if not (i in list_cand): # x_train[idx_x, :, :, :] = temp_x[:, :, i].reshape((1, n_pixel, n_pixel, 1)) # y_train[idx_x, :, :, :] = temp_y[:, :, i].reshape((1, n_pixel, n_pixel, 1)) # idx_x = idx_x + 1 X = X.reshape((n_slice, n_pixel, n_pixel, slice_x)) Y = Y.reshape((n_slice, n_pixel, n_pixel, 1)) x_train, x_val, y_train, y_val = train_test_split(X, Y, test_size=0.33, random_state=42) x_train = x_train / np.amax(x_train) y_train = y_train / np.amax(y_train) x_val = x_val / np.amax(x_val) y_val = y_val / np.amax(y_val) # ----------------------------------------------Data Generator----------------------------------------------# # train data_generator data_generator1 = ImageDataGenerator( rotation_range=conf_a["rotation_range"], shear_range=conf_a["shear_range"], width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"], preprocessing_function=aug_noise) data_generator2 = ImageDataGenerator( rotation_range=conf_a["rotation_range"], shear_range=conf_a["shear_range"], width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"], preprocessing_function=aug_noise) # validation data_generator data_generator3 = ImageDataGenerator( width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"], preprocessing_function=aug_noise) data_generator4 = ImageDataGenerator( width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"], preprocessing_function=aug_noise) # set generator # data_generator1.fit(x_train, seed=conf_a["seed"]) # data_generator2.fit(y_train, seed=conf_a["seed"]) # data_generator3.fit(x_val, seed=conf_a["seed"]) # data_generator4.fit(y_val, seed=conf_a["seed"]) if run_aim == "see_aug": # aug dir aug_dir = './aug_files/' + model_id + '/' if not os.path.exists(aug_dir): os.makedirs(aug_dir) else: aug_dir = '' # # save files # data_generator1.flow(x_train, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_x') # data_generator2.flow(y_train, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_y') # data_generator3.flow(x_val, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_x') # data_generator4.flow(y_val, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_y') # zip files data_generator_t = zip( data_generator1.flow(x=x_train, y=None, batch_size=conf_a["batch_size"], seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_x'), data_generator2.flow(x=y_train, y=None, batch_size=conf_a["batch_size"], seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_y')) data_generator_v = zip( data_generator3.flow(x=x_val, y=None, batch_size=conf_a["batch_size"], seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_x'), data_generator4.flow(x=y_val, y=None, batch_size=conf_a["batch_size"], seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_y')) # ----------------------------------------------Train Model----------------------------------------------# # compile model.compile(loss=loss, optimizer=opt, metrics=[mean_squared_error_1e6, psnr]) # train model.fit_generator( generator=data_generator_t, steps_per_epoch=int(int(n_slice * 0.7) / conf_a["batch_size"]), # epochs=conf["epochs"], callbacks=callbacks_list, validation_data=data_generator_v, validation_steps=int(int(n_slice * 0.3) / conf_a["batch_size"])) # return model
def deeprad_backend_n2i(): ui = gbl_get_value("ui") value_outfolder = ui.n2i_folder_output.toPlainText() value_X = [ui.n2i_folder_X.toPlainText()] value_Y = [ui.n2i_folder_Y.toPlainText()] try: value_axes = [int(ui.n2i_text_axes.text())] except ValueError: value_axes = None try: value_imsize_w = int(ui.n2i_text_imsize_w.text()) except ValueError: value_imsize_w = None try: value_imsize_h = int(ui.n2i_text_imsize_h.text()) except ValueError: value_imsize_h = None try: value_testfraction = int(ui.n2i_text_testfraction.text()) except ValueError: value_testfraction = None try: value_valfraction = int(ui.n2i_text_valfraction.text()) except ValueError: value_valfraction = None try: value_Xslices = int(ui.n2i_text_xslices.text()) except ValueError: value_Xslices = None try: value_Yslices = int(ui.n2i_text_yslices.text()) except ValueError: value_Yslices = None value_force = ui.n2i_check_force.isChecked() value_shuffle = ui.n2i_check_shuffle.isChecked() if value_imsize_w is None and value_imsize_h is None: value_imsize = None else: value_imsize = [value_imsize_w, value_imsize_h] # augmentation part if ui.n2i_check_aug.isChecked(): value_augfactor = int(ui.n2i_text_augfactor.text()) value_augseed = int(ui.n2i_text_augseed.text()) value_addnoise = float(ui.n2i_text_addnoise.text()) value_rotations = float(ui.n2i_text_rotations.text()) value_scalings = float(ui.n2i_text_scalings.text()) value_shears = float(ui.n2i_text_shears.text()) value_translations = float(ui.n2i_text_translations.text()) value_hflips = ui.n2i_check_hflips.isChecked() value_vflips = ui.n2i_check_vflips.isChecked() value_augmode = None if ui.n2i_radio_augmode_reflect.isChecked(): value_augmode = 'reflect' if ui.n2i_radio_augmode_nearest.isChecked(): value_augmode = 'nearest' if ui.n2i_radio_augmode_mirror.isChecked(): value_augmode = 'mirror' if ui.n2i_radio_augmode_warp.isChecked(): value_augmode = 'warp' else: value_augfactor = 1 value_augseed = 0 value_addnoise = 0 value_rotations = 0 value_scalings = 0 value_shears = 0 value_translations = 0 value_hflips = False value_vflips = False value_augmode = None args = SimpleNamespace(outfolder=value_outfolder, X=value_X, Y=value_Y, axes=value_axes, imsize=value_imsize, Xslices=value_Xslices, Yslices=value_Yslices, force=value_force, shuffle=value_shuffle, testfraction=value_testfraction, valfraction=value_valfraction, augfactor=value_augfactor, augseed=value_augseed, addnoise=value_addnoise, rotations=value_rotations, scalings=value_scalings, shears=value_shears, translations=value_translations, hflips=value_hflips, vflips=value_vflips, augmode=value_augmode, log_output=ui.n2i_log_text) # np.save('args_n2i.npy', args) dr_n2i.process_n2i(args)
def predict_MRCT(model, test_path, tag=''): path_X = glob.glob(test_path + '*Align*.nii')[-1] file_X = nib.load(path_X) data_X = file_X.get_fdata() path_Y = glob.glob(test_path + '*CT*.nii')[-1] file_Y = nib.load(path_Y) data_Y = file_Y.get_fdata() # MaxMin-norm data_input, X_max, X_min = MaxMinNorm(data_X, keep_para=True) print("data shape", data_input.shape) n_pixel = data_X.shape[0] n_slice = data_X.shape[2] slice_x = gbl_get_value("slice_x") model_id = gbl_get_value("model_id") dir_syn = gbl_get_value('dir_syn') # print("y_hat shape: ", y_hat.shape) X = np.zeros((1, n_pixel, n_pixel, slice_x)) y_hat = np.zeros((n_pixel, n_pixel, n_slice)) if slice_x == 1: for idx in range(n_slice): X[0, :, :, 0] = data_input[:, :, idx] y_hat[:, :, idx] = np.squeeze(model.predict(X)) if slice_x == 3: for idx in range(n_slice): idx_0 = idx - 1 if idx > 0 else 0 idx_1 = idx idx_2 = idx + 1 if idx < n_slice - 1 else n_slice - 1 X[0, :, :, 0] = data_input[:, :, idx_0] X[0, :, :, 1] = data_input[:, :, idx_1] X[0, :, :, 2] = data_input[:, :, idx_2] y_hat[:, :, idx] = np.squeeze(model.predict(X)) print("Output:") print("Mean:", np.mean(y_hat)) print("STD:", np.std(y_hat)) print("Max:", np.amax(y_hat)) print("Min:", np.amax(y_hat)) # norm y_hat y_hat_norm = MaxMinNorm(y_hat) # restore norm y_hat_norm *= (X_max - X_min) y_hat_norm += X_min dif = y_hat_norm - data_Y # save nifty file affine = file_Y.affine header = file_Y.header nii_file = nib.Nifti1Image(y_hat_norm, affine, header) nib.save(nii_file, dir_syn + 'syn_' + model_id + '_' + tag + '.nii') print(dir_syn + 'syn_' + model_id + '.nii') # save difference dif_file = nib.Nifti1Image(dif, affine, header) nib.save(dif_file, dir_syn + 'dif_' + model_id + '_' + tag + '.nii')
def train_a_unet(data_path): slice_x = gbl_get_value("slice_x") n_slice_train = gbl_get_value("n_slice_train") n_slice_val = gbl_get_value("n_slice_val") n_pixel = gbl_get_value('input_size') model_id = gbl_get_value("model_id") dir_model = gbl_get_value('dir_model') epochs = gbl_get_value("n_epoch") n_fliter = gbl_get_value("n_filter") depth = gbl_get_value("depth") batch_size = gbl_get_value("batch_size") optimizer = 'RAdam' flag_save = True # ----------------------------------------------Configurations----------------------------------------------# # save logs log_path = dir_model.split('model')[0] + 'log/' if not os.path.exists(log_path): os.makedirs(log_path) tensorboard = TensorBoard(log_dir=log_path, batch_size=batch_size, write_graph=True, write_grads=True, write_images=True) # set traininig configurations conf = { "image_shape": (n_pixel, n_pixel, slice_x), "out_channel": 1, "filter": n_fliter, "depth": depth, "inc_rate": 2, "activation": 'relu', "dropout": True, "batchnorm": True, "maxpool": True, "upconv": True, "residual": True, "shuffle": True, "augmentation": True, "learning_rate": 1e-4, "decay": 0.0, "epsilon": 1e-8, "beta_1": 0.9, "beta_2": 0.999, "validation_split": 0.3, "batch_size": batch_size, "epochs": epochs, "loss": "mse1e6", "metric": "mse", "optimizer": optimizer, "model_id": model_id } np.save(log_path + model_id + '_info.npy', conf) # set augmentation configurations conf_a = { "rotation_range": 15, "shear_range": 10, "width_shift_range": 0.33, "height_shift_range": 0.33, "zoom_range": 0.33, "horizontal_flip": True, "vertical_flip": True, "fill_mode": 'nearest', "seed": 314, "batch_size": conf["batch_size"] } np.save(log_path + model_id + '__aug.npy', conf_a) if flag_save: check_path_1 = dir_model + 'psnr_model_' + model_id + '.hdf5' # _{epoch:03d}_{val_loss:.4f} checkpoint1 = ModelCheckpoint(check_path_1, monitor='val_psnr', verbose=1, save_best_only=True, mode='max') check_path_2 = dir_model + 'loss_model_' + model_id + '.hdf5' # _{epoch:03d}_{val_loss:.4f} checkpoint2 = ModelCheckpoint(check_path_2, monitor='val_loss', verbose=1, save_best_only=True, mode='min') callbacks_list = [checkpoint1, checkpoint2, tensorboard] else: callbacks_list = [tensorboard] # ----------------------------------------------Create Model----------------------------------------------# # build up the model print(conf) if gbl_get_value("pretrained_flag") == 0: print('-----------------start with new model---------------') model = unet(img_shape=conf["image_shape"], out_ch=conf["out_channel"], start_ch=conf["filter"], depth=conf["depth"], inc_rate=conf["inc_rate"], activation=conf["activation"], dropout=conf["dropout"], batchnorm=conf["batchnorm"], maxpool=conf["maxpool"], upconv=conf["upconv"], residual=conf["residual"]) # model = multi_gpu_model(model, 3) else: # load model print('-----------------fine tune previous models----------------') model_path = gbl_get_value("pretrained_path") model = load_model(model_path, compile=False) # for the perceptual loss model, the loss function is perceptual loss loss = perceptual_loss # for the mse loss model, the loss function is mse loss # loss = mean_squared_error_1e6 opt = RAdam(learning_rate=conf['learning_rate'], total_steps=10000, warmup_proportion=0.1, min_lr=1e-6) # ----------------------------------------------Data Generator----------------------------------------------# # train data_generator data_generator1 = ImageDataGenerator( rescale=1. / 255, rotation_range=conf_a["rotation_range"], shear_range=conf_a["shear_range"], width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) data_generator2 = ImageDataGenerator( rescale=1. / 255, rotation_range=conf_a["rotation_range"], shear_range=conf_a["shear_range"], width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) # validation data_generator data_generator3 = ImageDataGenerator( rescale=1. / 255, width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) data_generator4 = ImageDataGenerator( rescale=1. / 255, width_shift_range=conf_a["width_shift_range"], height_shift_range=conf_a["height_shift_range"], zoom_range=conf_a["zoom_range"], horizontal_flip=conf_a["horizontal_flip"], vertical_flip=conf_a["vertical_flip"], fill_mode=conf_a["fill_mode"]) # preprocessing_function=aug_noise) aug_dir = '' train_x_path = data_path + 'train/train_x/' train_y_path = data_path + 'train/train_y/' val_x_path = data_path + 'val/val_x/' val_y_path = data_path + 'val/val_y' # zip files data_generator_t = zip( data_generator1.flow_from_directory(train_x_path, target_size=(512, 512), color_mode='grayscale', classes=None, class_mode=None, batch_size=conf_a["batch_size"], shuffle=True, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_x'), data_generator2.flow_from_directory(train_y_path, target_size=(512, 512), color_mode='rgb', classes=None, class_mode=None, batch_size=conf_a["batch_size"], shuffle=True, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='train_y')) data_generator_v = zip( data_generator3.flow_from_directory(val_x_path, target_size=(512, 512), color_mode='grayscale', classes=None, class_mode=None, batch_size=conf_a["batch_size"], shuffle=True, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_x'), data_generator4.flow_from_directory(val_y_path, target_size=(512, 512), color_mode='rgb', classes=None, class_mode=None, batch_size=conf_a["batch_size"], shuffle=True, seed=conf_a["seed"], save_to_dir=aug_dir, save_prefix='val_y')) # ----------------------------------------------Train Model----------------------------------------------# # compile model.compile(loss=loss, optimizer=opt, metrics=[ content_loss, style_loss, psnr, mean_squared_error_1e6, mean_absolute_error_1e6 ]) # train model.fit_generator( generator=data_generator_t, steps_per_epoch=int(n_slice_train / conf_a["batch_size"]), epochs=conf["epochs"], callbacks=callbacks_list, validation_data=data_generator_v, validation_steps=int(n_slice_val / conf_a["batch_size"])) # return model
def perceptual_loss(y_true, y_pred): batch_size = gbl_get_value("batch_size") style_weight = gbl_get_value('style_weight') content_weight = gbl_get_value('content_weight') tv_weight = gbl_get_value('tv_weight') binary_weight = gbl_get_value('binary_weight') discriminator_path = gbl_get_value('discriminator_path') input_size = gbl_get_value('input_size') y_true = K.reshape(y_true, (-1, input_size, input_size, 3)) mse_loss = mean_squared_error_1e6(y_true, y_pred) print('+++++++++++++++++++++++++++++++++++++') print('perceptual_loss') print(y_true.shape) print(y_pred.shape) print('+++++++++++++++++++++++++++++++++++++') # load the model model_path = discriminator_path model = load_model(model_path, compile=False) for layer in model.layers: layer.trainable = False selected_layers = [ 'block1_conv2', 'block2_conv2', 'block3_conv3', 'block4_conv3', 'final_pred' ] selected_output = [ model.get_layer(name).output for name in selected_layers ] layer_model = Model(inputs=model.input, outputs=selected_output) feature_pred = layer_model(y_pred) feature_true = layer_model(y_true) # feature_gram gram_pred = [] gram_true = [] for i in range(len(feature_pred) - 1): gram_pred.append(gram_matrix(feature_pred[i])) gram_true.append(gram_matrix(feature_true[i])) one = tf.ones_like(feature_true[-1]) feature_true[-1] = tf.where(feature_true[-1] >= 0, x=one, y=one) style_loss = 0 for i in range(len(selected_layers) - 1): temp = mean_squared_error_12(gram_true[i], gram_pred[i][:batch_size]) style_loss += temp style_loss = style_weight * style_loss content_loss = mean_squared_error_123(feature_true[2], feature_pred[2]) content_loss = content_weight * content_loss diff_i = K.sum(K.abs(y_pred[:, :, :, 1:] - y_pred[:, :, :, :-1])) diff_j = K.sum(K.abs(y_pred[:, :, 1:, :] - y_pred[:, :, :-1, :])) tv_loss = tv_weight * (diff_i + diff_j) final_percep_loss = style_loss + content_loss + tv_loss return final_percep_loss