def train(path_weights, src_images_train, tar_images_train): # dataset = [src_images_train, tar_images_train] # createing pix2pix model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss, metrics=['accuracy', dice]) # Normalization of the train set #1 and #2 mean = np.mean(src_images_train) # mean for data centering std = np.std(src_images_train) # std for data normalization src_images_train -= mean src_images_train /= std # train model checkpoint = ModelCheckpoint(path_weights + 'gan_lungseg_exp3_100epc_best.hdf5', monitor='dice', verbose=1, save_best_only=True, save_weights_only=True, mode='max') #checkpoint2 = ModelCheckpoint(path_weights+'best_weights_val_gan_512_masked_lung_blur_500epc.hdf5', monitor='val_dice', verbose=1, save_best_only=True,save_weights_only=True, mode='max') history = model.fit(src_images_train, tar_images_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpoint]) #history=model.fit(src_images_train, tar_images_train, batch_size=BATCH_SIZE, epochs=EPOCHS,callbacks=[checkpoint,checkpoint2],validation_data=(src_images_val, tar_images_val)) model.save(path_weights + 'gan_lungseg_exp3_100epc_last.hdf5') # convert the history.history dict to a pandas DataFrame: hist_df = pd.DataFrame(history.history) # save to json: print("Saving history") hist_json_file = path_json + 'gan_lungseg_exp3_100epc_history.json' with open(hist_json_file, mode='w') as f: hist_df.to_json(f) print("History saved") plt.plot(history.history['dice']) plt.plot(history.history['val_dice']) plt.plot(history.history['g_l1']) plt.title('Model dice coeff') plt.ylabel('Dice coeff') plt.xlabel('Epoch') plt.legend(['Train', 'Val', 'Loss'], loc='upper left') # save plot to file plt.savefig(path_plot + 'gan_lungseg_exp3_100epc_plot.png')
def main(): args = parser.parse_args() filelist_test = args.test result_dir = args.out_dir + '/result' ckpt_dir = args.ckpt_dir back_dir = args.out_dir + '/back' if not os.path.exists(result_dir): os.makedirs(result_dir) batch_size = args.visnum database = db.DBreader(filelist_test, batch_size=batch_size, labeled=False, resize=[256, 256], shuffle=False) # databaseo = db.DBreader(filelist_toriginal, batch_size=batch_size, labeled=False, resize=[256, 256], suffle=False) sess = tf.Session() model = Pix2Pix(sess, batch_size) saver = tf.train.Saver(tf.global_variables()) ckpt = tf.train.get_checkpoint_state(ckpt_dir) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): saver.restore(sess, ckpt.model_checkpoint_path) else: sys.exit("There is no trained model") total_batch = database.total_batch print('Generating...') for step in range(total_batch): #img_input, img_target = split_images(database.next_batch(), direction) #img_target = normalize(databaseo.next_batch()) img_input = normalize(database.next_batch()) generated_samples = denormalize( model.sample_generator(img_input, batch_size=batch_size)) #img_target = denormalize(img_target) img_input = denormalize(img_input) img_for_vis = np.concatenate([img_input, generated_samples], axis=2) savepath = result_dir + '/output_' + "_Batch" + str(step).zfill( 6) + '.png' savepath2 = back_dir + '/output_' + "_Batch" + str(step).zfill( 6) + '(back).png' save_visualization(img_for_vis, (batch_size, 1), save_path=savepath) save_visualization2(generated_samples, (batch_size, 1), save_path=savepath2) print('finished!!')
def train(path_weights, src_images_train, tar_images_train): # dataset = [src_images_train, tar_images_train] # createing pix2pix model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss, metrics=['accuracy', dice]) # train model checkpoint = ModelCheckpoint( path_weights + 'originalGen_gan_ds1_150epc_best_k' + str(K) + '.hdf5', monitor='dice', verbose=1, save_best_only=True, save_weights_only=True, mode='max') history = model.fit(src_images_train, tar_images_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpoint]) model.save(path_weights + 'originalGen_gan_ds1_150epc_last_k' + str(K) + '.hdf5') # convert the history.history dict to a pandas DataFrame: hist_df = pd.DataFrame(history.history) # save to json: print("Saving history") hist_json_file = path_json + 'originalGen_gan_ds1_150epc_k' + str( K) + '.json' with open(hist_json_file, mode='w') as f: hist_df.to_json(f) print("History saved") plt.plot(history.history['dice']) plt.plot(history.history['val_dice']) plt.plot(history.history['g_l1']) plt.title('Model dice coeff') plt.ylabel('Dice coeff') plt.xlabel('Epoch') plt.legend(['Train', 'Val', 'Loss'], loc='upper left') # save plot to file plt.savefig(path_plot + 'originalGen_gan_ds1_150epc_k' + str(K) + '.png')
def train(src_images_train, tar_images_train, src_images_val, tar_images_val): dataset = [src_images_train, tar_images_train] # createing pix2pix model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss) # train model checkpoint = ModelCheckpoint(path_weights + 'best_weights_train_gan_aumentation.hdf5', monitor='dice', verbose=1, save_best_only=True, save_weights_only=True, mode='max') checkpoint2 = ModelCheckpoint(path_weights + 'best_weights_val_gan_aumentation.hdf5', monitor='val_dice', verbose=1, save_best_only=True, save_weights_only=True, mode='max') history = model.fit(src_images_train, tar_images_train, batch_size=BATCH_SIZE, epochs=EPOCHS, callbacks=[checkpoint, checkpoint2], validation_data=(src_images_val, tar_images_val)) # convert the history.history dict to a pandas DataFrame: hist_df = pd.DataFrame(history.history) # save to json: print("anatiel/tf_pix2pix/saving history") hist_json_file = 'anatiel/tf_pix2pix/history.json' with open(hist_json_file, mode='w') as f: hist_df.to_json(f) print("history saved") plt.plot(history.history['dice']) plt.title('Model dice coeff') plt.ylabel('Dice coeff') plt.xlabel('Epoch') plt.legend(['Train'], loc='upper left') # save plot to file plt.savefig('anatiel/tf_pix2pix/plot_dice.png') plt.show()
def main(): ext = '.nii.gz' search_pattern = '*' dataset = 'dataset2' # local main_dir = f'/home/anatielsantos/mestrado/datasets/dissertacao/final_tests_dis/teste2_dataset2/Test' main_mask_dir = f'/home/anatielsantos/mestrado/datasets/dissertacao/final_tests_dis/teste2_dataset2/Test_mask' model_path = '/home/anatielsantos/mestrado/datasets/dissertacao/final_tests_dis/gan_test2_exp2_2_150epc_last.hdf5' # remote # main_dir = f'/data/flavio/anatiel/datasets/dissertacao/{dataset}/image' # main_mask_dir = f'/data/flavio/anatiel/datasets/dissertacao/{dataset}/mask' # model_path = '/data/flavio/anatiel/models/dissertacao/unet_500epc_last.h5' src_dir = '{}'.format(main_dir) mask_dir = '{}'.format(main_mask_dir) dst_dir = '{}/GANExp2Tests2Preds'.format(main_dir) nproc = mp.cpu_count() print('Num Processadores = ' + str(nproc)) model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss) model.load_weights(model_path) execExecPredictByUnet(src_dir, mask_dir, dst_dir, ext, search_pattern, model, reverse=False, desc='Predicting (GAN)', parallel=False)
def eval(input_path, output_path, checkpoint_path, model, gpu): input = Image.open(input_path) input = input.convert("RGB") w, h = input.size w_, h_ = 128 * (w // 128), 128 * (h // 128) fa = FaceAlignment(LandmarksType._2D, device="cuda:" + str(gpu)) landmarks = fa.get_landmarks_from_image(input_path)[0] landmark_img = plot_landmarks(np.array(input), landmarks) transform_forward = transforms.Compose([ transforms.Resize((w_, h_)), transforms.CenterCrop((w_, h_)), transforms.ToTensor() ]) transform_backward = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((w, h)), transforms.CenterCrop((w, h)), ]) input = transform_forward(input) landmark_img = transform_forward(landmark_img) if model == "Pix2Pix": NFNet = Pix2Pix() else: NFNet = ResResNet() checkpoint = torch.load(checkpoint_path) NFNet.load_state_dict(checkpoint['my_classifier']) NFNet.to(gpu) x = torch.cat((input, landmark_img), 0) x = x.unsqueeze(0) x = x.to(gpu) output = NFNet(x) output = output.to("cpu") output = transform_backward(output[0]) output.save(output_path)
def main(): ext = '.nii.gz' search_pattern = '*' dataset = 'dataset1' # remote main_dir = f'/data/flavio/anatiel/datasets/dissertacao/final_tests/kfold/{dataset}/images_fold_2.npz' main_mask_dir = f'/data/flavio/anatiel/datasets/dissertacao/final_tests/kfold/{dataset}/masks_fold_2.npz' model_path = '/data/flavio/anatiel/models/dissertacao/unet_150epc_last_k2.h5' # main_dir = f'/home/anatielsantos/mestrado/datasets/dissertacao/bbox/dataset1/images/k0' # main_mask_dir = f'/home/anatielsantos/mestrado/datasets/dissertacao/bbox/dataset1/masks/k0' # model_path = '/home/anatielsantos/Downloads/models_dissertacao/gan_ds1_150epc_best_k0.hdf5' src_dir = '{}'.format(main_dir) mask_dir = '{}'.format(main_mask_dir) dst_dir = '{}/gan_ds1_preds'.format(main_dir) nproc = mp.cpu_count() print('Num Processadores = ' + str(nproc)) model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss) model.load_weights(model_path) execExecPredictByUnet(src_dir, mask_dir, dst_dir, ext, search_pattern, model, reverse=False, desc='Predicting (GAN)', parallel=False)
def main(): ext = '.nii.gz' search_pattern = '*' dataset = 'test' # local # main_dir = f'/home/anatielsantos/mestrado/datasets/dissertacao/{dataset}/image' # model_path = '/home/anatielsantos/mestrado/models/dissertacao/gan/gan_500epc_best.hdf5' # remote main_dir = f'/data/flavio/anatiel/datasets/dissertacao/{dataset}/image' model_path = '/data/flavio/anatiel/models/dissertacao/gan_500epc_last.hdf5' src_dir = '{}'.format(main_dir) dst_dir = '{}/GanPredsLast'.format(main_dir) nproc = mp.cpu_count() print('Num Processadores = ' + str(nproc)) model = Pix2Pix(img_rows, img_cols, img_depth, img_depth) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss) model.load_weights(model_path) execExecPredictByGan(src_dir, dst_dir, ext, search_pattern, model, reverse=False, desc='Predicting (Pix2pix)', parallel=False)
def main(): args = parser.parse_args() result_dir = args.out_dir + '/result' ckpt_dir = args.out_dir + '/checkpoint' if not os.path.exists(result_dir): os.makedirs(result_dir) if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) batch_size = args.batch_size sess = tf.Session() model = Pix2Pix(sess, batch_size) saver = tf.train.Saver(tf.global_variables()) ckpt = tf.train.get_checkpoint_state(ckpt_dir) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) input_img = tf.placeholder(tf.float32, [batch_size] + [472, 472, 3]) target_img = tf.placeholder(tf.float32, [batch_size] + [WIDTH, HEIGHT, 3]) real_dataset = ImageCollector("../../../new_env_dataset", 1, 64, batch_size) # Real data simul_dataset = ImageCollector("../../../simul_dataset__", 1, 64, batch_size) ######################### # tensorboard summary # ######################### dstep_loss = tf.placeholder(tf.float32) gstep_loss = tf.placeholder(tf.float32) image_shaped_input = tf.reshape( tf.image.resize_images(input_img, [WIDTH, HEIGHT]), [-1, WIDTH, HEIGHT, 3]) image_shaped_output = tf.reshape(target_img, [-1, WIDTH, HEIGHT, 3]) tf.summary.scalar('d_step_loss', dstep_loss) tf.summary.scalar('g_step_loss', gstep_loss) tf.summary.image( 'input / output', tf.concat([image_shaped_input, image_shaped_output], axis=2), 3) summary_merged = tf.summary.merge_all() writer = tf.summary.FileWriter(args.out_dir, sess.graph) real_dataset.StartLoadData() simul_dataset.StartLoadData() iter = 100000 for i in range(iter): real_data = real_dataset.getLoadedData() simul_data = simul_dataset.getLoadedData() rgb_img = real_data[1] simul_img = simul_data[1] loss_D = model.train_discrim( simul_img, rgb_img) # Train Discriminator and get the loss value loss_GAN = model.train_gen( simul_img, rgb_img) # Train Generator and get the loss value if i % 100 == 0: print('Step: [', i, '/', iter, '], D_loss: ', loss_D, ', G_loss_GAN: ', loss_GAN) if i % 500 == 0: generated_samples = model.sample_generator(simul_img, batch_size=batch_size) summary = sess.run(summary_merged, feed_dict={ dstep_loss: loss_D, gstep_loss: loss_GAN, input_img: simul_img, target_img: generated_samples }) writer.add_summary(summary, i) if i % 5000 == 0: saver.save(sess, ckpt_dir + '/model_iter' + str(i))
def main(): global_epoch = tf.Variable(0, trainable=False, name='global_step') global_epoch_increase = tf.assign(global_epoch, tf.add(global_epoch, 1)) args = parser.parse_args() direction = args.direction filelist_train = args.train result_dir = args.out_dir + '/result' ckpt_dir = args.out_dir + '/checkpoint' if not os.path.exists(result_dir): os.makedirs(result_dir) if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) total_epoch = args.epochs batch_size = args.batch_size database = db.DBreader(filelist_train, batch_size=batch_size, labeled=False, resize=[256, 512]) sess = tf.Session() model = Pix2Pix(sess, batch_size) saver = tf.train.Saver(tf.global_variables()) ckpt = tf.train.get_checkpoint_state(ckpt_dir) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) total_batch = database.total_batch epoch = sess.run(global_epoch) while True: if epoch == total_epoch: break for step in range(total_batch): img_input, img_target = split_images(database.next_batch(), direction) img_target = normalize(img_target) img_input = normalize(img_input) loss_D = model.train_discrim( img_input, img_target) # Train Discriminator and get the loss value loss_GAN, loss_L1 = model.train_gen( img_input, img_target) # Train Generator and get the loss value if step % 100 == 0: print('Epoch: [', epoch, '/', total_epoch, '], ', 'Step: [', step, '/', total_batch, '], D_loss: ', loss_D, ', G_loss_GAN: ', loss_GAN, ', G_loss_L1: ', loss_L1) if step % 500 == 0: generated_samples = denormalize( model.sample_generator(img_input, batch_size=batch_size)) img_target = denormalize(img_target) img_input = denormalize(img_input) img_for_vis = np.concatenate( [img_input, generated_samples, img_target], axis=2) savepath = result_dir + '/output_' + 'EP' + str(epoch).zfill( 3) + "_Batch" + str(step).zfill(6) + '.jpg' save_visualization(img_for_vis, (batch_size, 1), save_path=savepath) epoch = sess.run(global_epoch_increase) saver.save(sess, ckpt_dir + '/model_epoch' + str(epoch).zfill(3))
# (nothing gets printed in Jupyter, only if you run it standalone) sess = tf.Session(config=config) set_session( sess) # set this TensorFlow session as the default session for Keras # params batch_size = 2 timesteps = 2 im_width = im_height = 256 # end params train_files, test_files = get_train_test_files() train_gen = get_data_gen(files=train_files, timesteps=timesteps, batch_size=batch_size, im_size=(im_width, im_height)) gan = Pix2Pix(im_height=im_height, im_width=im_width, lookback=timesteps - 1) print("Generator Summary") gan.generator.summary() print() print("Discriminator Summary") gan.discriminator.summary() print() print("Combined Summary") gan.combined.summary() gan.train(train_gen, epochs=600, batch_size=batch_size, save_interval=200, save_file_name="r_p2p_gen_t2.model")
def main(): global_epoch = tf.Variable(0, trainable=False, name='global_step') global_epoch_increase = tf.assign(global_epoch, tf.add(global_epoch, 1)) args = parser.parse_args() filelist_train = args.train filelist_original = args.original result_dir = args.out_dir + '/result' back_dir = args.out_dir + '/back' ckpt_dir = args.out_dir + '/checkpoint' if not os.path.exists(result_dir): os.makedirs(result_dir) if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) total_epoch = args.epochs batch_size = args.batch_size database = db.DBreader(filelist_train, batch_size=batch_size, labeled=False, resize=[256, 256]) databaseo = db.DBreader(filelist_original, batch_size=batch_size, labeled=False, resize=[256, 256]) sess = tf.Session() model = Pix2Pix(sess, batch_size) saver = tf.train.Saver(tf.global_variables()) ckpt = tf.train.get_checkpoint_state(ckpt_dir) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) total_batch = database.total_batch epoch = sess.run(global_epoch) print(total_batch) lossd = [] lossgan = [] lossl1 = [] while True: templossd = [] templossgan = [] templossl1 = [] if epoch == total_epoch: flg.plot(range(1, len(lossd) + 1), lossd, 'r', label='loss_Dis') flg.plot(range(1, len(lossgan) + 1), lossgan, 'g', label='loss_Gan') flg.plot(range(1, len(lossl1) + 1), lossl1, 'b', label='loss_L1') flg.legend(loc='upper right') flg.ylabel('loss') flg.xlabel('Number of epoch') flg.savefig('graph99(50%).png') break for step in range(total_batch): img_target = normalize(databaseo.next_batch()) img_input = normalize(database.next_batch()) loss_D = model.train_discrim( img_input, img_target) # Train Discriminator and get the loss value loss_GAN, loss_L1 = model.train_gen( img_input, img_target) # Train Generator and get the loss value templossd.append(loss_D) templossgan.append(loss_GAN) templossl1.append(loss_L1) print('Epoch: [', epoch, '/', total_epoch, '], ', 'Step: [', step, '/', total_batch, '], D_loss: ', loss_D, ', G_loss_GAN: ', loss_GAN, ', G_loss_L1: ', loss_L1) # if epoch % 5 == 0: # generated_samples = denormalize(model.sample_generator(img_input, batch_size=batch_size)) # img_target = denormalize(img_target) # img_input = denormalize(img_input) # img_for_vis = np.concatenate([img_input, generated_samples, img_target], axis=2) # savepath = result_dir + '/output_' + 'EP' + str(epoch).zfill(3) + "_Batch" + str(step).zfill(6) + '.png' # savepath2 = back_dir + '/output_' + 'EP' + str(epoch).zfill(3) + "_Batch" + str(step).zfill(6) + '(back).png' # save_visualization(img_for_vis, (batch_size, 1), save_path=savepath) # save_visualization2(generated_samples, (batch_size, 1), save_path=savepath2) lossd.append(np.mean(templossd)) lossgan.append(np.mean(templossgan)) lossl1.append(np.mean(templossl1)) epoch = sess.run(global_epoch_increase) saver.save(sess, ckpt_dir + '/model_epoch' + str(epoch).zfill(3))
image_B = scipy.misc.imresize(image_B, (pix2pix.nW, pix2pix.nH)) images_B = [] images_B.append(image_B) images_B = np.array(images_B) / 127.5 - 1. generates_A = pix2pix.generator.predict(images_B) generate_A = generates_A[0] generate_A = np.uint8((np.array(generate_A) * 0.5 + 0.5) * 255) generate_A = Image.fromarray(generate_A) generated_image = Image.new('RGB', (pix2pix.nW, pix2pix.nH)) generated_image.paste(generate_A, (0, 0, pix2pix.nW, pix2pix.nH)) generated_image.save(save_path, quality=95) pass def convert_to_gray_single_image(image_path, save_path, resize_height=256, resize_weidth=256): img = Image.open(image_path) img_color = img.resize((resize_weidth, resize_height), Image.ANTIALIAS) img_gray = img_color.convert('L') img_gray = img_gray.convert('RGB') img_gray.save(save_path, quality=95) gan = Pix2Pix() #gan.train(epochs=1200, batch_size=4, sample_interval=10, load_pretrained=True) predict_single_image(gan, './images/test_1.jpg', './images/generate_test_1.jpg')
def test(src_images_test, path_mask_test, weights_path): # load model model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss) imgs_test, imgs_maskt = load_images(src_images_test, path_mask_test) # # #Normalization of the test set # imgs_test = imgs_test.astype('float32') # mean = np.mean(imgs_test) # mean for data centering # std = np.std(imgs_test) # std for data normalization # #to float # imgs_test = imgs_test.astype('float32') # imgs_test -= mean # imgs_test /= std # imgs_maskt = imgs_maskt.astype('float32') # predict print('-' * 30) print('Loading saved weights...') model.load_weights(weights_path) print('-' * 30) print('Predicting data...') output = None for i in range(imgs_test.shape[0]): pred = model.generator(imgs_test[i:i + 1], training=False).numpy() if output is None: output = pred else: output = np.concatenate([output, pred], axis=0) # calculate metrics print('-' * 30) print('Calculating metrics...') #print("DICE Test: ", dice(tar_images_test, output).numpy()) print(np.amin(imgs_maskt)) print(np.amax(imgs_maskt)) print(imgs_maskt.dtype) print(np.amin(output)) print(np.amax(output)) print(output.dtype) dice, jaccard, sensitivity, specificity, accuracy, auc, prec, fscore = calc_metric( output.astype(int), imgs_maskt.astype(int)) print("DICE: ", dice) print("IoU:", jaccard) print("Sensitivity: ", sensitivity) print("Specificity", specificity) print("ACC: ", accuracy) print("AUC: ", auc) print("Prec: ", prec) print("FScore: ", fscore) print('-' * 30) print('Saving predicted masks to files...') # remote # np.savez_compressed('/data/flavio/anatiel/datasets/dissertacao/test/image/teste/gan_mask_test_last_teste.npz', output) np.save('/data/flavio/anatiel/datasets/dissertacao/gan_preds_last.npy', output) # local # np.savez_compressed('/home/anatielsantos/mestrado/datasets/dissertacao/test/image/GanPredsLast/exam_test.npz', output) # np.save('/home/anatielsantos/mestrado/datasets/dissertacao/test/image/GanPredsLast/gan_preds_best.npy', output) print('-' * 30)
# test_set = MyDataset(root_dir='night2day/test/', transform=my_transforms_val) ### dataloaders train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True) val_loader = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=1, pin_memory=True) test_loader = DataLoader(test_set, batch_size=1, shuffle=False, num_workers=1, pin_memory=True) ### model creatng model = Pix2Pix() model = model.to(device) print(count_parameters(model)) ### init weights of model: conv, linear layers to N(0, 0.02), biases to 0 for m in model.parameters(): classname = m.__class__.__name__ if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1): init.normal_(m.weight.data, 0.0, 0.02) if hasattr(m, 'bias') and m.bias is not None: init.constant_(m.bias.data, 0.0) ### WANDB #wandb.init(project='') #wandb.watch(model)
def train(path_weights, src_images_train, tar_images_train): # dataset = [src_images_train, tar_images_train] # createing pix2pix model = Pix2Pix(IMG_HEIGHT, IMG_WIDTH, INPUT_CHANNELS, OUTPUT_CHANNELS) model.compile(discriminator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), generator_optimizer=tf.keras.optimizers.Adam(2e-4, beta_1=0.5), discriminator_loss=discriminator_loss, generator_loss=generator_loss, metrics=['accuracy', dice]) # Normalization of the train set #1 and #2 mean = np.mean(src_images_train) # mean for data centering std = np.std(src_images_train) # std for data normalization src_images_train -= mean src_images_train /= std print('Train test split') X_train, X_test, y_train, y_test = train_test_split(src_images_train, tar_images_train, test_size=0.1) print('-' * 30) print('Data Augmentation Start') data_gen_args = dict(shear_range=0.1, rotation_range=20, width_shift_range=0.1, height_shift_range=0.1, zoom_range=0.3, fill_mode='constant', horizontal_flip=True, vertical_flip=True, cval=0) image_datagen = ImageDataGenerator(**data_gen_args) mask_datagen = ImageDataGenerator(**data_gen_args) seed = 1 image_datagen.fit(X_train, augment=True, seed=seed) mask_datagen.fit(y_train, augment=True, seed=seed) image_generator = image_datagen.flow(X_train, batch_size=BATCH_SIZE) mask_generator = mask_datagen.flow(y_train, batch_size=BATCH_SIZE) train = zip(image_generator, mask_generator) # val = zip(X_test, y_test) print('-' * 30) print('Data Augmentation End') print('-' * 30) print('Creating and compiling model...') print('-' * 30) # train model checkpoint = ModelCheckpoint(path_weights + 'gan_lungseg_exp2_100epc_augment_best.hdf5', monitor='dice', verbose=1, save_best_only=True, save_weights_only=True, mode='max') #checkpoint2 = ModelCheckpoint(path_weights+'best_weights_val_gan_512_masked_lung_blur_500epc.hdf5', monitor='val_dice', verbose=1, save_best_only=True,save_weights_only=True, mode='max') # history = model.fit(src_images_train, tar_images_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpoint]) history = model.fit(train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, shuffle=True, validation_data=(X_test, y_test), callbacks=[checkpoint]) model.save(path_weights + 'gan_lungseg_exp2_100epc_augment_last.hdf5') # convert the history.history dict to a pandas DataFrame: hist_df = pd.DataFrame(history.history) # save to json: print("Saving history") hist_json_file = path_json + 'gan_lungseg_exp2_100epc_augment_history.json' with open(hist_json_file, mode='w') as f: hist_df.to_json(f) print("History saved") plt.plot(history.history['dice']) plt.plot(history.history['val_dice']) plt.plot(history.history['g_l1']) plt.title('Model dice coeff') plt.ylabel('Dice coeff') plt.xlabel('Epoch') plt.legend(['Train', 'Val', 'Loss'], loc='upper left') # save plot to file plt.savefig(path_plot + 'gan_lungseg_exp2_100epc_augment_plot.png')
def main(_): """ :return: """ print("=" * 100) print("FLAGS") pp = pprint.PrettyPrinter() pp.pprint(flags.FLAGS.__flags) # make sub-directories if not os.path.isdir(FLAGS.checkpoint_dir): os.mkdir(FLAGS.checkpoint_dir) if not os.path.isdir(FLAGS.sample_dir): os.mkdir(FLAGS.sample_dir) if not os.path.isdir(FLAGS.test_dir): os.mkdir(FLAGS.test_dir) # Launch Graph sess = tf.Session() model = Pix2Pix(sess=sess, gan_name=FLAGS.gan_name, dataset_name=FLAGS.dataset_name, input_size=FLAGS.input_size, input_dim=FLAGS.input_dim, output_size=FLAGS.output_size, output_dim=FLAGS.output_dim, batch_size=FLAGS.batch_size, gen_num_filter=FLAGS.gen_num_filter, disc_num_filter=FLAGS.disc_num_filter, learning_rate=FLAGS.learning_rate, beta1=FLAGS.beta1, l1_lambda=FLAGS.l1_lambda, checkpoint_dir=FLAGS.checkpoint_dir, sample_dir=FLAGS.sample_dir, test_dir=FLAGS.test_dir) sess.run(tf.global_variables_initializer()) # show all variables model_vars = tf.trainable_variables() slim.model_analyzer.analyze_vars(model_vars, print_info=True) # load trained model flag_checkpoint, counter = load_checkpoint(model) dataset_dir = os.path.join("datasets", FLAGS.dataset_name) if FLAGS.train: # training dataset dir trainset_dir = os.path.join(dataset_dir, "train") valset_dir = os.path.join(dataset_dir, "val") run_train(model=model, trainset_dir=trainset_dir, valset_dir=valset_dir, sample_size=FLAGS.batch_size, scale_size=FLAGS.scale_size, crop_size=FLAGS.crop_size, flip=FLAGS.flip, training_epochs=FLAGS.epoch, flag_checkpoint=flag_checkpoint, checkpoint_counter=counter) else: # test dir testset_dir = os.path.join(dataset_dir, "test") if not os.path.isdir(testset_dir): testset_dir = os.path.join(dataset_dir, "val") run_test(model=model, testset_dir=testset_dir)