def plot_sine_figures(project_dir, time_tag, model_name): # make the save folder save_folder = project_dir / f'figures/{model_name}' try: os.makedirs(save_folder) except FileExistsError: pass # load previously trained model device = torch.device('cpu') conf = OmegaConf.load(project_dir / f'runs/sine/{model_name}/conf.yaml') h_sizes = OmegaConf.to_container(conf.hidden_sizes) model = MLPModel(dim_y=1, dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_encoder=h_sizes, hidden_sizes_ode_net=h_sizes, hidden_sizes_decoder=h_sizes, t0=-0.1, device=device) model_weights = torch.load(project_dir / f'runs/sine/{model_name}/seed_0/model.pth', map_location=device) model.load_state_dict(model_weights) # create a sine dataset dataset = SineData() dataloader = DataLoader(dataset, batch_size=conf.batch_size, drop_last=True) t, y = next(iter(dataloader)) t_context, y_context, t_extra, y_extra, _, _ = get_split(t, y, test_context_size=conf.test_context_size) with torch.no_grad(): plot_sine_img(model, 0, t, y, t_context, y_context, t_extra, save_folder, time_tag) plot_sine_img(model, 1, t, y, t_context, y_context, t_extra, save_folder, time_tag) plot_sine_img(model, 2, t, y, t_context, y_context, t_extra, save_folder, time_tag) plot_sine_img(model, 3, t, y, t_context, y_context, t_extra, save_folder, time_tag) plot_sine_img(model, 4, t, y, t_context, y_context, t_extra, save_folder, time_tag)
def main(): parser = build_parser() options = parser.parse_args() batch_size=options.batch_size #train_names=utils.train_names # train_set = utils.get_train() # val_set = utils.val_n model = Resnet() model.cuda() model = torch.nn.DataParallel(model) ########################### #train_set,val_set = train_test_split(train_names, test_size=0.2, random_state=2050) train_set,val_set=utils.get_split() train_set = utils.get_train(train_set) train_datasest=ProteinDataset(dirpath=utils.TRAIN,fnames=train_set) train_loader = DataLoader(train_datasest, batch_size=batch_size, shuffle=True,num_workers=4) val_dataset = ProteinDataset(dirpath=utils.TRAIN,fnames=val_set) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4) train(model, options.epochs, train_loader,val_loader,'sgdr_rgb.pkl')
def get_train_val_generators(fold): tr_keys, te_keys = get_split(fold, split_seed) train_data = {i: dataset[i] for i in tr_keys} val_data = {i: dataset[i] for i in te_keys} data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, INPUT_PATCH_SIZE, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 350.), sigma=(14., 17.), do_rotation=True, a_x=(0, 2. * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.7, 1.3), seeds=workers_seeds) # new se has no brain mask data_gen_validation = BatchGenerator(val_data, BATCH_SIZE, num_batches=None, seed=False, PATCH_SIZE=INPUT_PATCH_SIZE) val_transforms = [] val_transforms.append( ConvertSegToOnehotTransform(range(4), 0, 'seg_onehot')) data_gen_validation = MultiThreadedAugmenter(data_gen_validation, Compose(val_transforms), 1, 2, [0]) return data_gen_train, data_gen_validation
def run(config_file, fold=0): cf = imp.load_source('cf', config_file) print fold dataset_root = cf.dataset_root # this is seeded, will be identical each time train_keys, test_keys = get_split(fold) val_data = load_dataset(test_keys, root_dir=dataset_root) use_patients = val_data experiment_name = cf.EXPERIMENT_NAME results_folder = os.path.join(cf.results_dir, "fold%d/" % fold) mode = 'val' BATCH_SIZE = cf.BATCH_SIZE n_repeats = cf.val_num_repeats x_sym = T.tensor4() nt, net, seg_layer = cf.nt, cf.net, cf.seg_layer output_layer = seg_layer best_epoch = 299 results_out_folder = results_folder + "ep%03.0d_MA" % (best_epoch) if not os.path.isdir(results_out_folder): os.mkdir(results_out_folder) results_out_folder += "/%s_mirror" % mode if not os.path.isdir(results_out_folder): os.mkdir(results_out_folder) with open( os.path.join(results_folder, "%s_Params.pkl" % (experiment_name)), 'r') as f: params = cPickle.load(f) lasagne.layers.set_all_param_values(output_layer, params) print "compiling theano functions" output = softmax_helper( lasagne.layers.get_output(output_layer, x_sym, deterministic=not cf.val_bayesian_prediction, batch_norm_update_averages=False, batch_norm_use_averages=False)) pred_fn = theano.function([x_sym], output) _ = pred_fn(np.random.random((BATCH_SIZE, 1, 384, 352)).astype(np.float32)) run_validation( pred_fn, results_out_folder, use_patients, BATCH_SIZE=BATCH_SIZE, n_repeats=n_repeats, save_segmentation=cf.val_save_segmentation, plot_segmentation=cf.val_plot_segmentation, min_size=cf.val_min_size, do_mirroring=cf.val_do_mirroring, input_img_must_be_divisible_by=cf.val_input_img_must_be_divisible_by, preprocess_fn=cf.val_preprocess_fn)
def get_data(cfgs, is_training=True, return_infos=False, split_name='train', use_multitask_loss=False): data_loader = utils.get_split(cfgs.tf_records_folder, is_training=is_training, task=cfgs.task, split_name=split_name, feature_names=cfgs.use_data, batch_size=cfgs.batch_size, return_infos=return_infos, targets=cfgs.targets, use_multitask_loss=use_multitask_loss) return data_loader
def plot_rotnist_figures(project_dir, time_tag, model_name): # make the save folder save_folder = project_dir / f'figures/{model_name}' try: os.makedirs(save_folder) except FileExistsError: pass # load previously trained model device = torch.device('cpu') epoch = 140 conf = OmegaConf.load(project_dir / f'runs/rotnist/{model_name}/conf.yaml') h_sizes = OmegaConf.to_container(conf.hidden_sizes) model = ConvNetModel(dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_ode_net=h_sizes, t0=-0.1, device=device) model_weights = torch.load(project_dir / f'runs/rotnist/{model_name}/seed_0/model_ep{epoch}.pth', map_location=device) model.load_state_dict(model_weights) # load RotNIST dataset, and get the test samples dataset_mnist = RotNISTDataset(data_dir=str(project_dir / 'data')) len_test = 10 dataset_test = dataset_mnist[len(dataset_mnist) - len_test:] dataloader_test = DataLoader(dataset_test, batch_size=10, shuffle=False, drop_last=True) t_all, y_all = next(iter(dataloader_test)) t_context, y_context, _, _, t_target_initial, y_target = get_split(t_all, y_all, context_range=(7, 8), extra_target_range=(9, 10)) # Create a set of target points corresponding to entire [x_min, x_max] range extrapolation = 5 t_min, t_max = 0., 1.5 # for the rotnist dataset t_target = torch.linspace(t_min, t_max + extrapolation / 10, 16 + extrapolation) t_target = t_target.view(1, -1, 1).repeat(t_context.shape[0], 1, 1) t_target_rounded = torch.round(t_target * 10 ** 3) / (10 ** 3) # get prediction on test samples, and plot the images for 2 examples p_y_pred, _, _ = model(t_context, y_context, t_target) mu = p_y_pred.loc.detach() _, T, _ = t_target.shape plot_rotnist_img(0, mu, T, t_target_rounded, t_target_initial, y_target, t_context, y_context, save_folder, time_tag) plot_rotnist_img(9, mu, T, t_target_rounded, t_target_initial, y_target, t_context, y_context, save_folder, time_tag)
def run(config_file, fold=0): cf = imp.load_source('cf', config_file) print ('fold:',fold) # this is seeded, will be identical each time train_keys, test_keys = get_split(0) print('test keys: {}'.format(test_keys)) experiment_name = cf.EXPERIMENT_NAME results_folder = os.path.join(cf.results_dir, "fold%d/"%fold) dataset_root_raw = paths.path_mms_vendorB_2d BATCH_SIZE = cf.BATCH_SIZE n_repeats = cf.val_num_repeats x_sym = cf.x_sym nt, net, seg_layer = cf.nt_bn, cf.net_bn, cf.seg_layer_bn output_layer = seg_layer test_out_folder = cf.test_out_folder if not os.path.isdir(test_out_folder): os.mkdir(test_out_folder) test_out_folder = os.path.join(test_out_folder, "fold%d"%fold) if not os.path.isdir(test_out_folder): os.mkdir(test_out_folder) with open(os.path.join("../",results_folder, "%s_Params.pkl" % (experiment_name)), 'rb') as f: params = cPickle.load(f) lasagne.layers.set_all_param_values(output_layer, params) # load net's params print ("compiling theano functions") output = softmax_helper(lasagne.layers.get_output(output_layer, x_sym, deterministic=not cf.val_bayesian_prediction, batch_norm_update_averages=False, batch_norm_use_averages=False)) pred_fn = theano.function([x_sym], output) _ = pred_fn(np.random.random((BATCH_SIZE, 1, 16, 16)).astype(np.float32)) # print(_.shape) predict_test(pred_fn, test_out_folder, test_keys, dataset_root_raw, BATCH_SIZE=BATCH_SIZE, n_repeats=n_repeats, min_size=cf.min_size, input_img_must_be_divisible_by=cf.val_input_img_must_be_divisible_by, do_mirroring=cf.val_do_mirroring, target_spacing=list(cf.target_spacing), preprocess_fn=preprocess)
def run(config_file, fold=0): cf = imp.load_source('cf', config_file) print('fold:', fold) dataset_root = cf.dataset_root_mmsB print('train path: {}'.format(dataset_root)) # ================================================================================================================== BATCH_SIZE = cf.BATCH_SIZE INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE num_classes = cf.num_classes EXPERIMENT_NAME = cf.EXPERIMENT_NAME results_dir = os.path.join(cf.results_dir, "fold%d/" % fold) if not os.path.isdir(results_dir): os.mkdir(results_dir) n_epochs = cf.n_epochs lr_decay = cf.lr_decay base_lr = cf.base_lr n_batches_per_epoch = cf.n_batches_per_epoch # 100 n_test_batches = cf.n_test_batches # 10 n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch # 10 num_workers = cf.num_workers workers_seeds = cf.workers_seeds print('basiclr: {},lr-decay: {}'.format(cf.base_lr, cf.lr_decay)) # ================================================================================================================== # this is seeded, will be identical each time train_keys, test_keys = get_split(fold) print('train_keys:', train_keys) print('val_keys:', test_keys) train_data = load_dataset(train_keys, root_dir=dataset_root) val_data = load_dataset(test_keys, root_dir=dataset_root) x_sym = cf.x_sym seg_sym = cf.seg_sym nt, net, seg_layer = cf.nt_bn, cf.net_bn, cf.seg_layer_bn output_layer_for_loss = net # draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png')) data_gen_validation = BatchGenerator_2D(val_data, BATCH_SIZE, num_batches=None, seed=False, PATCH_SIZE=INPUT_PATCH_SIZE) # No data augmentation in valuation data_gen_validation = MultiThreadedAugmenter( data_gen_validation, ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"), 1, 2, [0]) # add some weight decay l2_loss = lasagne.regularization.regularize_network_params( output_layer_for_loss, lasagne.regularization.l2) * cf.weight_decay # the distinction between prediction_train and test is important only if we enable dropout prediction_train = lasagne.layers.get_output( output_layer_for_loss, x_sym, deterministic=False, batch_norm_update_averages=False, batch_norm_use_averages=False) loss_vec = -weight_soft_dice(prediction_train, seg_sym) loss = loss_vec.mean() loss += l2_loss acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) prediction_test = lasagne.layers.get_output( output_layer_for_loss, x_sym, deterministic=True, batch_norm_update_averages=False, batch_norm_use_averages=False) loss_val = -soft_dice(prediction_test, seg_sym) loss_val = loss_val.mean() loss_val += l2_loss acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) # learning rate has to be a shared variable because we decrease it with every epoch params = lasagne.layers.get_all_params(output_layer_for_loss, trainable=True) learning_rate = theano.shared(base_lr) updates = lasagne.updates.adam(T.grad(loss, params), params, learning_rate=learning_rate, beta1=0.9, beta2=0.999) dc = hard_dice(prediction_test, seg_sym.argmax(1), num_classes) train_fn = theano.function([x_sym, seg_sym], [loss, acc_train, loss_vec], updates=updates) val_fn = theano.function([x_sym, seg_sym], [loss_val, acc, dc]) dice_scores = None data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(100., 350.), sigma=(14., 17.), do_rotation=True, a_x=(0, 2. * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.7, 1.3), seeds=workers_seeds) # new se has no brain mask all_training_losses = [] all_validation_losses = [] all_validation_accuracies = [] all_training_accuracies = [] all_val_dice_scores = [] epoch = 0 val_min = 0 while epoch < n_epochs: if epoch == 100: data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 250.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.75, 1.25), seeds=workers_seeds) # new se has no brain mask if epoch == 125: data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 150.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.8, 1.2), seeds=workers_seeds) # new se has no brain mask epoch_start_time = time.time() learning_rate.set_value(np.float32(base_lr * lr_decay**epoch)) print("epoch: ", epoch, " learning rate: ", learning_rate.get_value()) train_loss = 0 train_acc_tmp = 0 train_loss_tmp = 0 batch_ctr = 0 for data_dict in data_gen_train: # first call "__iter__(self)" in class BatchGenerator_2D for iter # And then call "__next__()" in class BatchGenerator_2D for looping # As a result, it will generate a random batch data every time, much probably different data = data_dict["data"].astype(np.float32) # print(data.shape) (2,1,352,352) where batchsize = 2 seg = data_dict["seg_onehot"].astype(np.float32).transpose( 0, 2, 3, 1).reshape((-1, num_classes)) if batch_ctr != 0 and batch_ctr % int( np.floor( n_batches_per_epoch / n_feedbacks_per_epoch)) == 0: print("number of batches: ", batch_ctr, "/", n_batches_per_epoch) print("training_loss since last update: ", \ train_loss_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch)), " train accuracy: ", \ train_acc_tmp / np.floor(n_batches_per_epoch / n_feedbacks_per_epoch)) """ n_batches_per_epoch: How many batches in an epoch, 100 here. n_feedbacks_per_epoch: How many feedbacks are given in an epoch, 10 here,it means in an epoch we will calculate loss 10 times. """ all_training_losses.append( train_loss_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch)) ) # for showing and saving result .png all_training_accuracies.append( train_acc_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch))) train_loss_tmp = 0 train_acc_tmp = 0 if len(all_val_dice_scores) > 0: dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape( (-1, num_classes)) plotProgress(all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME), n_feedbacks_per_epoch, val_dice_scores=dice_scores, dice_labels=["0", "1", "2", "3"]) if batch_ctr > (n_batches_per_epoch - 1): break loss_vec, acc, l = train_fn(data, seg) # type: Array loss = loss_vec.mean() train_loss += loss train_loss_tmp += loss train_acc_tmp += acc batch_ctr += 1 # if batch_ctr > (n_batches_per_epoch-1): # break train_loss /= n_batches_per_epoch print("training loss average on epoch: ", train_loss) val_loss = 0 accuracies = [] valid_batch_ctr = 0 all_dice = [] for data_dict in data_gen_validation: data = data_dict["data"].astype( np.float32 ) # print(data.shape) (2,1,352,352) where batchsize = 2 seg = data_dict["seg_onehot"].astype(np.float32).transpose( 0, 2, 3, 1).reshape( (-1, num_classes )) # (2,4,352,352) --> (2,353,353,4)-->(2*352*352,4) w = np.zeros(num_classes, dtype=np.float32) # [0, 0, 0, 0] w[np.unique(seg.argmax(-1))] = 1 loss, acc, dice = val_fn(data, seg) dice[w == 0] = 2 # if there are some class was not be classified, abandon it when calculate mean of dice all_dice.append(dice) val_loss += loss accuracies.append(acc) valid_batch_ctr += 1 if valid_batch_ctr > (n_test_batches - 1): break # Making a valuation every epoch # n_test_batches(here is 10) batches in a valuation all_dice = np.vstack(all_dice) dice_means = np.zeros(num_classes) for i in range(num_classes): dice_means[i] = all_dice[all_dice[:, i] != 2, i].mean() val_loss /= n_test_batches print("val loss: ", val_loss) print("val acc: ", np.mean(accuracies), "\n") print("val dice: ", dice_means) print("This epoch took %f sec" % (time.time() - epoch_start_time)) all_val_dice_scores.append(dice_means) all_validation_losses.append(val_loss) all_validation_accuracies.append(np.mean(accuracies)) dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape( (-1, num_classes)) plotProgress(all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME), n_feedbacks_per_epoch, val_dice_scores=dice_scores, dice_labels=["0", "1", "2", "3"]) mul_except_background = np.array([[0], [1], [1], [1]]) mean_123 = (np.dot(dice_means, mul_except_background)) / 3 if mean_123 > val_min: print( '=========================================================================' ) print( 'epoch {} val123mean_min change to {:.3f} ,updating saved net params......' .format(epoch, mean_123.item())) print( '=========================================================================' ) val_min = (np.dot(dice_means, mul_except_background)) / 3 with open( os.path.join(results_dir, "%s_Params.pkl" % (EXPERIMENT_NAME)), 'wb') as f: cPickle.dump( lasagne.layers.get_all_param_values(output_layer_for_loss), f) with open( os.path.join(results_dir, "%s_allLossesNAccur.pkl" % (EXPERIMENT_NAME)), 'wb') as f: cPickle.dump([ all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, all_val_dice_scores ], f) epoch += 1
import pickle import os import re from utils import get_longest_shot, pic_norm, get_split if __name__ == "__main__": splits_dir = "./data/HMDB_splits" pics_dir = "./data/HMDB_main_frame" train_split = get_split(splits_dir, r"1") dev_split = get_split(splits_dir, r"2") search_split = get_split(splits_dir, r"2") corpus_split = get_split(splits_dir, r"[02]") train_set = {} train_set["xs"] = [] train_set["ys"] = [] train_set["path"] = [] for label, type, name in train_split: base_dir = pics_dir + "/" + type + "/" + name pics = get_longest_shot(base_dir) for pic in pics: train_set["path"].append(pic) train_set["xs"].append(pic_norm(pic, (96, 72))) train_set["ys"].append(label) dev_set = {} dev_set["xs"] = [] dev_set["ys"] = [] dev_set["path"] = [] for label, type, name in dev_split:
def run(config_file, fold=0): cf = imp.load_source('cf', config_file) print fold dataset_root = cf.dataset_root # ================================================================================================================== BATCH_SIZE = cf.BATCH_SIZE INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE num_classes = cf.num_classes EXPERIMENT_NAME = cf.EXPERIMENT_NAME results_dir = os.path.join(cf.results_dir, "fold%d/" % fold) if not os.path.isdir(results_dir): os.mkdir(results_dir) n_epochs = cf.n_epochs lr_decay = cf.lr_decay base_lr = cf.base_lr n_batches_per_epoch = cf.n_batches_per_epoch n_test_batches = cf.n_test_batches n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch num_workers = cf.num_workers workers_seeds = cf.workers_seeds # ================================================================================================================== # this is seeded, will be identical each time train_keys, test_keys = get_split(fold) train_data = load_dataset(train_keys, root_dir=dataset_root) val_data = load_dataset(test_keys, root_dir=dataset_root) x_sym = cf.x_sym seg_sym = cf.seg_sym nt, net, seg_layer = cf.nt, cf.net, cf.seg_layer output_layer_for_loss = net #draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png')) data_gen_validation = BatchGenerator_2D(val_data, BATCH_SIZE, num_batches=None, seed=False, PATCH_SIZE=INPUT_PATCH_SIZE) data_gen_validation = MultiThreadedAugmenter( data_gen_validation, ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"), 1, 2, [0]) # add some weight decay l2_loss = lasagne.regularization.regularize_network_params( output_layer_for_loss, lasagne.regularization.l2) * cf.weight_decay # the distinction between prediction_train and test is important only if we enable dropout prediction_train = lasagne.layers.get_output( output_layer_for_loss, x_sym, deterministic=False, batch_norm_update_averages=False, batch_norm_use_averages=False) loss_vec = -soft_dice(prediction_train, seg_sym) loss = loss_vec.mean() loss += l2_loss acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) prediction_test = lasagne.layers.get_output( output_layer_for_loss, x_sym, deterministic=True, batch_norm_update_averages=False, batch_norm_use_averages=False) loss_val = -soft_dice(prediction_test, seg_sym) loss_val = loss_val.mean() loss_val += l2_loss acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) # learning rate has to be a shared variable because we decrease it with every epoch params = lasagne.layers.get_all_params(output_layer_for_loss, trainable=True) learning_rate = theano.shared(base_lr) updates = lasagne.updates.adam(T.grad(loss, params), params, learning_rate=learning_rate, beta1=0.9, beta2=0.999) dc = hard_dice(prediction_test, seg_sym.argmax(1), num_classes) train_fn = theano.function([x_sym, seg_sym], [loss, acc_train, loss_vec], updates=updates) val_fn = theano.function([x_sym, seg_sym], [loss_val, acc, dc]) dice_scores = None data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(100., 350.), sigma=(14., 17.), do_rotation=True, a_x=(0, 2. * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.7, 1.3), seeds=workers_seeds) # new se has no brain mask all_training_losses = [] all_validation_losses = [] all_validation_accuracies = [] all_training_accuracies = [] all_val_dice_scores = [] epoch = 0 while epoch < n_epochs: if epoch == 100: data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 250.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.75, 1.25), seeds=workers_seeds) # new se has no brain mask if epoch == 125: data_gen_train = create_data_gen_train( train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 150.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.8, 1.2), seeds=workers_seeds) # new se has no brain mask epoch_start_time = time.time() learning_rate.set_value(np.float32(base_lr * lr_decay**epoch)) print "epoch: ", epoch, " learning rate: ", learning_rate.get_value() train_loss = 0 train_acc_tmp = 0 train_loss_tmp = 0 batch_ctr = 0 for data_dict in data_gen_train: data = data_dict["data"].astype(np.float32) seg = data_dict["seg_onehot"].astype(np.float32).transpose( 0, 2, 3, 1).reshape((-1, num_classes)) if batch_ctr != 0 and batch_ctr % int( np.floor( n_batches_per_epoch / n_feedbacks_per_epoch)) == 0: print "number of batches: ", batch_ctr, "/", n_batches_per_epoch print "training_loss since last update: ", \ train_loss_tmp/np.floor(n_batches_per_epoch/(n_feedbacks_per_epoch-1)), " train accuracy: ", \ train_acc_tmp/np.floor(n_batches_per_epoch/n_feedbacks_per_epoch) all_training_losses.append( train_loss_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch - 1))) all_training_accuracies.append( train_acc_tmp / np.floor(n_batches_per_epoch / (n_feedbacks_per_epoch - 1))) train_loss_tmp = 0 train_acc_tmp = 0 if len(all_val_dice_scores) > 0: dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape( (-1, num_classes)) plotProgress(all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME), n_feedbacks_per_epoch, val_dice_scores=dice_scores, dice_labels=["brain", "1", "2", "3", "4", "5"]) loss_vec, acc, l = train_fn(data, seg) loss = loss_vec.mean() train_loss += loss train_loss_tmp += loss train_acc_tmp += acc batch_ctr += 1 if batch_ctr > (n_batches_per_epoch - 1): break train_loss /= n_batches_per_epoch print "training loss average on epoch: ", train_loss val_loss = 0 accuracies = [] valid_batch_ctr = 0 all_dice = [] for data_dict in data_gen_validation: data = data_dict["data"].astype(np.float32) seg = data_dict["seg_onehot"].astype(np.float32).transpose( 0, 2, 3, 1).reshape((-1, num_classes)) w = np.zeros(num_classes, dtype=np.float32) w[np.unique(seg.argmax(-1))] = 1 loss, acc, dice = val_fn(data, seg) dice[w == 0] = 2 all_dice.append(dice) val_loss += loss accuracies.append(acc) valid_batch_ctr += 1 if valid_batch_ctr > (n_test_batches - 1): break all_dice = np.vstack(all_dice) dice_means = np.zeros(num_classes) for i in range(num_classes): dice_means[i] = all_dice[all_dice[:, i] != 2, i].mean() val_loss /= n_test_batches print "val loss: ", val_loss print "val acc: ", np.mean(accuracies), "\n" print "val dice: ", dice_means print "This epoch took %f sec" % (time.time() - epoch_start_time) all_val_dice_scores.append(dice_means) all_validation_losses.append(val_loss) all_validation_accuracies.append(np.mean(accuracies)) dice_scores = np.concatenate(all_val_dice_scores, axis=0).reshape( (-1, num_classes)) plotProgress(all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, os.path.join(results_dir, "%s.png" % EXPERIMENT_NAME), n_feedbacks_per_epoch, val_dice_scores=dice_scores, dice_labels=["brain", "1", "2", "3", "4", "5"]) with open( os.path.join(results_dir, "%s_Params.pkl" % (EXPERIMENT_NAME)), 'w') as f: cPickle.dump( lasagne.layers.get_all_param_values(output_layer_for_loss), f) with open( os.path.join(results_dir, "%s_allLossesNAccur.pkl" % (EXPERIMENT_NAME)), 'w') as f: cPickle.dump([ all_training_losses, all_training_accuracies, all_validation_losses, all_validation_accuracies, all_val_dice_scores ], f) epoch += 1
def main(dataset: str, experiment_name: str = typer.Argument("test"), sample: int = typer.Option(0), epochs: int = typer.Option(5000), max_steps_per_episode: int = typer.Option(1), num_counterfactuals: int = typer.Option(10), fp_length: int = typer.Option(1024), fp_radius: int = typer.Option(2), lr: float = typer.Option(1e-4), polyak: float = typer.Option(0.995), gamma: float = typer.Option(0.95), discount: float = typer.Option(0.9), replay_buffer_size: int = typer.Option(10000), batch_size: int = typer.Option(1), update_interval: int = typer.Option(1), allow_no_modification: bool = typer.Option(False), allow_removal: bool = typer.Option(True), allow_node_addition: bool = typer.Option(True), allow_edge_addition: bool = typer.Option(True), allow_bonds_between_rings: bool = typer.Option(True), seed: int = typer.Option(random.randint(0, 2**12)) ): general_params = { # General-purpose params 'discount_factor': discount, 'allow_removal': allow_removal, 'allow_no_modification': allow_no_modification, 'allow_bonds_between_rings': allow_bonds_between_rings, 'allow_node_addition': allow_node_addition, 'allow_edge_addition': allow_edge_addition, 'allowed_ring_sizes': set([5, 6]), 'max_steps': max_steps_per_episode, 'fp_len': fp_length, 'fp_rad': fp_radius } dataset = dataset.lower() if dataset == 'tox21': meg = tox21 elif dataset == 'esol': meg = esol torch.manual_seed(seed) base_path = f'./runs/{dataset.lower()}/{experiment_name}' meg(general_params, base_path, SummaryWriter(f'{base_path}/plots'), num_counterfactuals, get_split(dataset.lower(), 'test', experiment_name)[sample], model_to_explain=get_dgn(dataset.lower(), experiment_name), experiment_name=experiment_name, sample=sample, epochs=epochs, max_steps_per_episode=max_steps_per_episode, fp_length=fp_length, fp_radius=fp_radius, lr=lr, polyak=polyak, gamma=gamma, discount=discount, replay_buffer_size=replay_buffer_size, batch_size=batch_size, update_interval=update_interval, seed=seed)
def run(): if not os.path.exists(log_eval): os.mkdir(log_eval) #Just construct the graph from scratch again with tf.Graph().as_default() as graph: tf.logging.set_verbosity(tf.logging.INFO) #Get the dataset first and load one batch of validation images and labels tensors. Set is_training as False so as to use the evaluation preprocessing dataset = get_split('validation', dataset_dir) images, raw_images, labels = load_batch(dataset, batch_size=batch_size, is_training=False) #Create some information about the training steps num_batches_per_epoch = dataset.num_samples / batch_size num_steps_per_epoch = num_batches_per_epoch #Now create the inference model but set is_training=False with slim.arg_scope(inception_resnet_v2_arg_scope()): logits, end_points = inception_resnet_v2( images, num_classes=dataset.num_classes, is_training=False) # #get all the variables to restore from the checkpoint file and create the saver function to restore variables_to_restore = slim.get_variables_to_restore() saver = tf.train.Saver(variables_to_restore) def restore_fn(sess): return saver.restore(sess, checkpoint_file) #Just define the metrics to track without the loss or whatsoever predictions = tf.argmax(end_points['Predictions'], 1) accuracy, accuracy_update = tf.contrib.metrics.streaming_accuracy( predictions, labels) metrics_op = tf.group(accuracy_update) #Create the global step and an increment op for monitoring global_step = get_or_create_global_step() global_step_op = tf.assign( global_step, global_step + 1 ) #no apply_gradient method so manually increasing the global_step #Create a evaluation step function def eval_step(sess, metrics_op, global_step): ''' Simply takes in a session, runs the metrics op and some logging information. ''' start_time = time.time() _, global_step_count, accuracy_value = sess.run( [metrics_op, global_step_op, accuracy]) time_elapsed = time.time() - start_time #Log some information logging.info( 'Global Step %s: Streaming Accuracy: %.4f (%.2f sec/step)', global_step_count, accuracy_value, time_elapsed) return accuracy_value #Define some scalar quantities to monitor tf.summary.scalar('Validation_Accuracy', accuracy) my_summary_op = tf.summary.merge_all() #Get your supervisor sv = tf.train.Supervisor(logdir=log_eval, summary_op=None, saver=None, init_fn=restore_fn) #Now we are ready to run in one session with sv.managed_session() as sess: for step in range(int(num_steps_per_epoch * num_epochs)): sess.run(sv.global_step) #print vital information every start of the epoch as always if step % num_batches_per_epoch == 0: logging.info('Epoch: %s/%s', step / num_batches_per_epoch + 1, num_epochs) logging.info('Current Streaming Accuracy: %.4f', sess.run(accuracy)) #Compute summaries every 10 steps and continue evaluating if step % 10 == 0: eval_step(sess, metrics_op=metrics_op, global_step=sv.global_step) summaries = sess.run(my_summary_op) sv.summary_computed(sess, summaries) #Otherwise just run as per normal else: eval_step(sess, metrics_op=metrics_op, global_step=sv.global_step) #At the end of all the evaluation, show the final accuracy logging.info('Final Streaming Accuracy: %.4f', sess.run(accuracy)) #Now we want to visualize the last batch's images just to see what our model has predicted raw_images, labels, predictions = sess.run( [raw_images, labels, predictions]) for i in range(10): image, label, prediction = raw_images[i], labels[ i], predictions[i] prediction_name, label_name = dataset.labels_to_name[ prediction], dataset.labels_to_name[label] text = 'Prediction: %s \n Ground Truth: %s' % (prediction_name, label_name) img_plot = plt.imshow(image) #Set up the plot and hide axes plt.title(text) img_plot.axes.get_yaxis().set_ticks([]) img_plot.axes.get_xaxis().set_ticks([]) plt.show() logging.info( 'Model evaluation has completed! Visit TensorBoard for more information regarding your evaluation.' )
def gnn_explainer( dataset_name: str, experiment_name: str, epochs: int, data_path: Path, output_dir: Path, node_feats: bool = typer.Option(False), edge_size: float = typer.Option(0.005), node_feat_size: float = typer.Option(1.0), edge_ent: float = typer.Option(1.0), node_feat_ent: float = typer.Option(0.1), ): create_path(output_dir) dataset_name = dataset_name.lower() def loss_for_classification(p1, p2): p1 = F.softmax(p1, dim=-1).detach().squeeze() return p1[1 - p2] def loss_for_regression(p1, p2): return F.l1_loss(p1.squeeze(), torch.as_tensor([p2]).squeeze()) cfs = [] with open(data_path, 'r') as f: cfs = json.load(f) cfs = list(filter(lambda mol: mol['marker'] in ['og', 'cf'], cfs)) if dataset_name in ['tox21', 'cycliq', 'cycliq-multi']: loss = loss_for_classification transform = mol_to_tox21_pyg if dataset_name == 'tox21' else None elif dataset_name in ['esol']: loss = loss_for_regression transform = mol_to_esol_pyg GCNN = get_dgn(dataset_name, experiment_name) explainer = GNNExplainer_(model=GCNN, prediction_loss=loss, epochs=epochs) explainer.coeffs['node_feat_ent'] = node_feat_ent explainer.coeffs['node_feat_size'] = node_feat_size explainer.coeffs['edge_size'] = edge_size explainer.coeffs['edge_ent'] = edge_ent dataset = get_split(dataset_name, 'test', experiment_name) for i, mol in enumerate(cfs): data = transform(mol['id']) node_feat_mask, edge_mask = explainer.explain_undirected_graph( data.x, data.edge_index, prediction=mol['prediction']['for_explanation'], node_feats=node_feats) if dataset_name == 'tox21': labels = { i: x_map_tox21(e).name for i, e in enumerate( [x.tolist().index(1) for x in data.x.numpy()]) } elif dataset_name == 'esol': rdkit_mol = Chem.MolFromSmiles(mol['id']) labels = { i: s for i, s in enumerate( [x.GetSymbol() for x in rdkit_mol.GetAtoms()]) } explainer.visualize_subgraph(data.edge_index, edge_mask, len(data.x), threshold=0.5, labels=labels) plt.axis('off') plt.savefig(f"{output_dir}/{i}", bbox_inches='tight') plt.clf() if node_feats: plt.imshow(node_feat_mask.numpy(), cmap='hot', interpolation='nearest') plt.colorbar() plt.savefig(f"{output_dir}/{i}.map.png", bbox_inches='tight', transparent=True) plt.close()
def run(config_file, fold=0): cf = imp.load_source('cf', config_file) print('fold:', fold) dataset_root = cf.dataset_root_mmsB print('train path: {}'.format(dataset_root)) # ================================================================================================================== BATCH_SIZE = cf.BATCH_SIZE INPUT_PATCH_SIZE = cf.INPUT_PATCH_SIZE num_classes = cf.num_classes EXPERIMENT_NAME = cf.EXPERIMENT_NAME results_dir = os.path.join(cf.results_dir, "fold%d/" % fold) if not os.path.isdir(results_dir): os.mkdir(results_dir) n_epochs = cf.n_epochs lr_decay = cf.lr_decay base_lr = cf.base_lr n_batches_per_epoch = cf.n_batches_per_epoch # 100 n_test_batches = cf.n_test_batches # 10 n_feedbacks_per_epoch = cf.n_feedbacks_per_epoch # 10 num_workers = cf.num_workers workers_seeds = cf.workers_seeds print('basiclr: {},lr-decay: {}'.format(cf.base_lr, cf.lr_decay)) # ================================================================================================================== # this is seeded, will be identical each time train_keys, test_keys = get_split(fold) print('train_keys:', train_keys) print('val_keys:', test_keys) train_data = load_dataset(train_keys, root_dir=dataset_root) val_data = load_dataset(test_keys, root_dir=dataset_root) x_sym = cf.x_sym seg_sym = T.tensor4() R_mask = VAE(1, x_sym, BATCH_SIZE, 'same', (None, None), 1, lasagne.nonlinearities.leaky_rectify) output_layer_for_loss = R_mask # draw_to_file(lasagne.layers.get_all_layers(net), os.path.join(results_dir, 'network.png')) data_gen_validation = BatchGenerator_2D(val_data, BATCH_SIZE, num_batches=None, seed=False, PATCH_SIZE=INPUT_PATCH_SIZE) # No data augmentation in valuation data_gen_validation = MultiThreadedAugmenter(data_gen_validation, ConvertSegToOnehotTransform(range(num_classes), 0, "seg_onehot"), 1, 2, [0]) # add some weight decay # l2_loss = lasagne.regularization.regularize_network_params(output_layer_for_loss, # lasagne.regularization.l2) * cf.weight_decay # the distinction between prediction_train and test is important only if we enable dropout prediction_train = lasagne.layers.get_output(output_layer_for_loss, x_sym, deterministic=False, batch_norm_update_averages=False, batch_norm_use_averages=False) loss_vec = F_loss(prediction_train, seg_sym) loss = loss_vec.mean() # acc_train = T.mean(T.eq(T.argmax(prediction_train, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) prediction_test = lasagne.layers.get_output(output_layer_for_loss, x_sym, deterministic=True, batch_norm_update_averages=False, batch_norm_use_averages=False) prediction_test = T.round(prediction_test, mode='half_to_even') loss_val = F_loss(prediction_test, seg_sym) loss_val = loss_val.mean() # acc = T.mean(T.eq(T.argmax(prediction_test, axis=1), seg_sym.argmax(-1)), dtype=theano.config.floatX) # learning rate has to be a shared variable because we decrease it with every epoch params = lasagne.layers.get_all_params(output_layer_for_loss, trainable=True) learning_rate = theano.shared(base_lr) updates = lasagne.updates.adam(T.grad(loss, params), params, learning_rate=learning_rate, beta1=0.9, beta2=0.999) train_fn = theano.function([x_sym, seg_sym], [loss], updates=updates) val_fn = theano.function([x_sym, seg_sym], [loss_val]) dice_scores = None data_gen_train = create_data_gen_train(train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(100., 350.), sigma=(14., 17.), do_rotation=True, a_x=(0, 2. * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.7, 1.3), seeds=workers_seeds) # new se has no brain mask all_training_losses = [] all_validation_losses = [] all_validation_accuracies = [] all_training_accuracies = [] all_val_dice_scores = [] epoch = 0 val_min = 0 while epoch < n_epochs: if epoch == 100: data_gen_train = create_data_gen_train(train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 250.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.75, 1.25), seeds=workers_seeds) # new se has no brain mask if epoch == 125: data_gen_train = create_data_gen_train(train_data, BATCH_SIZE, num_classes, num_workers=num_workers, do_elastic_transform=True, alpha=(0., 150.), sigma=(14., 17.), do_rotation=True, a_x=(-2 * np.pi, 2 * np.pi), a_y=(-0.000001, 0.00001), a_z=(-0.000001, 0.00001), do_scale=True, scale_range=(0.8, 1.2), seeds=workers_seeds) # new se has no brain mask # learning_rate.set_value(np.float32(base_lr * lr_decay ** epoch)) print("epoch: ", epoch, " learning rate: ", learning_rate.get_value()) train_loss = 0 batch_ctr = 0 for data_dict in data_gen_train: # first call "__iter__(self)" in class BatchGenerator_2D for iter # And then call "__next__()" in class BatchGenerator_2D for looping # As a result, it will generate a random batch data every time, much probably different seg = data_dict["seg_onehot"].astype(np.float32) seg = np.argmax(seg,1) seg = seg[:,np.newaxis,...].astype(np.float32) if batch_ctr > (n_batches_per_epoch - 1): break loss = train_fn(seg, seg) # type:numpy.narray # print('batch loss:',loss[0]) train_loss += loss[0].item() batch_ctr += 1 train_loss /= n_batches_per_epoch print("training loss average on epoch: ", train_loss) val_loss = 0 valid_batch_ctr = 0 for data_dict in data_gen_validation: seg = data_dict["seg_onehot"].astype(np.float32) seg = np.argmax(seg, 1) seg = seg[:, np.newaxis, ...].astype(np.float32) loss = val_fn(seg, seg) val_loss += loss[0].item() valid_batch_ctr += 1 if valid_batch_ctr > (n_test_batches - 1): break val_loss /= n_test_batches print('val_loss:',val_loss) with open(os.path.join(results_dir, "%s_Params.pkl" % (EXPERIMENT_NAME)), 'wb') as f: cPickle.dump(lasagne.layers.get_all_param_values(output_layer_for_loss), f) # Making a valuation every epoch # n_test_batches(here is 10) batches in a valuation epoch += 1
# force the number of filters to be square n = int(np.ceil(np.sqrt(data.shape[0]))) padding = (((0, n**2 - data.shape[0]), (0, 1), (0, 1)) + # add some space between filters ((0, 0), ) * (data.ndim - 3)) # don't pad the last dimension (if there is one) # pad with ones (white) data = np.pad(data, padding, mode='constant', constant_values=1) # tile the filters into an image data = data.reshape((n, n) + data.shape[1:]).transpose( (0, 2, 1, 3) + tuple(range(4, data.ndim + 1))) data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:]) plt.imshow(data) plt.axis('off') fn = miniplaces_net(get_split('train'), train=True).name log_dir = None proto_fn = fn param_fn = os.path.join(log_dir, 'place_net_iter_50000.caffemodel') net = caffe.Net(proto_fn, param_fn, caffe.TEST) filters = net.params['conv1'][0].data vis_square(filters.transpose(0, 2, 3, 1))
def train(conf, project_dir: Path, run_dir: Path) -> torch.nn.Module: writer = SummaryWriter(str(run_dir)) save_hparams(conf, writer) device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') if conf.dataset == 'sine': # dataset of time-series dataset_train = SineData() dataloader_train = DataLoader(dataset_train, batch_size=conf.batch_size, drop_last=True) dataset_test = SineData() dataloader_test = DataLoader(dataset_test, batch_size=conf.batch_size, shuffle=False, drop_last=True) h_sizes = OmegaConf.to_container( conf.hidden_sizes) # OmegaConf object to list model = MLPModel(dim_y=1, dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_encoder=h_sizes, hidden_sizes_ode_net=h_sizes, hidden_sizes_decoder=h_sizes, t0=dataset_train.t0, device=device) elif conf.dataset == 'sinefreq': # dataset of frequency varying sinus time-series dataset_train = FreqSineData(amplitude_range=(0.5, 1.), shift_range=(-.5, .5), freq_range=(1.0, 2.0), num_samples=5000) dataloader_train = DataLoader(dataset_train, batch_size=conf.batch_size, drop_last=True) dataset_test = FreqSineData(amplitude_range=(0.5, 1.), shift_range=(-.5, .5), freq_range=(1.0, 2.0), num_samples=1000) dataloader_test = DataLoader(dataset_test, batch_size=conf.batch_size, shuffle=False, drop_last=True) h_sizes = OmegaConf.to_container( conf.hidden_sizes) # OmegaConf object to list model = MLPModel(dim_y=1, dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_encoder=h_sizes, hidden_sizes_ode_net=h_sizes, hidden_sizes_decoder=h_sizes, t0=dataset_train.t0, device=device) elif conf.dataset == 'noisysine': sigma = conf.sigma # dataset of noisy sinus time-series dataset_train = NoisySineData(sigma, shift_range=(-0.1, .1), freq_range=(1.9, 2.0), num_samples=1000) dataloader_train = DataLoader(dataset_train, batch_size=conf.batch_size, drop_last=True) dataset_test = NoisySineData(sigma, shift_range=(-0.1, .1), freq_range=(1.9, 2.0), num_samples=1000) dataloader_test = DataLoader(dataset_test, batch_size=conf.batch_size, shuffle=False, drop_last=True) h_sizes = OmegaConf.to_container( conf.hidden_sizes) # OmegaConf object to list model = MLPModel(dim_y=1, dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_encoder=h_sizes, hidden_sizes_ode_net=h_sizes, hidden_sizes_decoder=h_sizes, t0=dataset_train.t0, device=device) elif conf.dataset == 'rotnist': # dataset of Rotating MNIST (in the literature) dataset_mnist = RotNISTDataset(data_dir=str(project_dir / 'data')) len_test = 10 dataset_train = dataset_mnist[:len(dataset_mnist) - len_test] dataset_test = dataset_mnist[len(dataset_mnist) - len_test:] dataloader_train = DataLoader(dataset_train, batch_size=conf.batch_size, drop_last=True) dataloader_test = DataLoader(dataset_test, batch_size=conf.batch_size, shuffle=False, drop_last=True) h_sizes = OmegaConf.to_container(conf.hidden_sizes) model = ConvNetModel(dim_r=conf.dim_r, dim_z_prime=conf.dim_z_prime, dim_l=conf.dim_l, hidden_sizes_ode_net=h_sizes, t0=dataset_mnist.t0, device=device) else: raise ValueError(f'Dataset {conf.dataset} not recognized') model = model.to(device) optimizer = torch.optim.RMSprop(model.parameters(), lr=conf.lr) context_range = OmegaConf.to_container(conf.context_range) extra_target_range = OmegaConf.to_container(conf.extra_target_range) global_train_step = 0 global_test_step = 0 for epoch in tqdm(range(conf.epochs)): mse_train_list = [] mse_test_list = [] with torch.no_grad(): for step, (t, y) in enumerate(dataloader_test): t, y = t.to(device), y.to(device) t_context, y_context, t_extra, y_extra, _, _ = get_split( t, y, test_context_size=conf.test_context_size) p_y, _, _ = model( t_context, y_context, t_extra ) # for testing, we only need predictions at t_extra output = p_y.loc mse_test = F.mse_loss(output, y_extra) # log test results writer.add_scalar('mse_test', mse_test.item(), global_test_step) mse_test_list.append(mse_test.item()) if step == 0 and epoch % 2 == 0: if conf.dataset in ['sine', 'sinefreq', 'noisysine']: log_sine_plot(writer, model, t, y, t_context, y_context, t_extra, epoch) elif conf.dataset == 'rotnist': log_rotnist_plot2(writer, model, t, y, epoch, 'test') global_test_step += 1 for (t, y) in dataloader_train: t, y = t.to(device), y.to(device) (t_context, y_context, t_extra, y_extra, t_target, y_target) = get_split(t, y, context_range=context_range, extra_target_range=extra_target_range) p_y, q_z_T, q_z_C = model(t_context, y_context, t_target, y_target=y_target) log_p = p_y.log_prob(y_target).sum(dim=(1, 2)).mean( dim=0) # mean on batch dim, sum on time dim/y dim output = p_y.loc mse_train = F.mse_loss(output, y_target) # mean on batch dim, sum on z dim (equivalent to kl_div of the multivariate normal) kl_div = kl_divergence(q_z_C, q_z_T).sum(dim=1).mean(dim=0) loss = -log_p + kl_div optimizer.zero_grad() loss.backward() optimizer.step() # log training metrics writer.add_scalar('kl_div', kl_div.item(), global_train_step) writer.add_scalar('log_p', log_p.item(), global_train_step) writer.add_scalar('train_loss', loss.item(), global_train_step) writer.add_scalar('mse_train', mse_train.item(), global_train_step) mse_train_list.append(mse_train.item()) global_train_step += 1 # log test/train mse epoch-wise to match the paper's figures writer.add_scalar('mse_train_epoch', np.mean(mse_train_list), epoch) writer.add_scalar('mse_test_epoch', np.mean(mse_test_list), epoch) if epoch % conf.checkpoint_freq == 0 and epoch > 0: torch.save(model.state_dict(), run_dir / f'model_ep{epoch}.pth') torch.save(model.state_dict(), run_dir / f'model.pth') return model
this operation aims to recover the res_2d[tpe] to original shape(raw.shape) """ # all_softmax += [softmax_3d[None], softmax_2d[None]] # predicted_seg = postprocess_prediction(np.vstack(all_softmax).mean(0).argmax(0)) predicted_seg = postprocess_prediction(softmax_2d.argmax(0)) itk_seg = sitk.GetImageFromArray(predicted_seg.astype(np.uint8)) # itk_seg.CopyInformation(raw_itk) sitk.WriteImage( itk_seg, os.path.join( output_folder, "patient%03.0d_%s.nii.gz" % (patient, tpe.upper()))) if __name__ == "__main__": # import argparse # parser = argparse.ArgumentParser() # parser.add_argument("-c2d", help="config file for 2d network", type=str, default=CONFIG_FILE_2D) # # parser.add_argument("-c3d", help="config file for 3d network", type=str) # parser.add_argument("-o", help="output folder", type=str, default='./submit_MMS_file') # args = parser.parse_args() # run(args.c2d, args.o) pred_path = '/home/laisong/github/submit_MMS_file' label_path = '/home/laisong/MMs2020/MMS_ED_ES/label' train_keys, test_keys = get_split(0) vendor_path = paths.path_mms_vendorAandB_2d dice = test_dice(pred_path, label_path, test_keys, vendor_path) print(dice)
def run(config_file_2d, output_folder): cf_2d = imp.load_source("cf_2d", config_file_2d) # cf_3d = imp.load_source("cf_3d", config_file_3d) dataset_base_dir = cf_2d.dataset_root_test # results_folder_3D = os.path.join(cf_3d.results_dir, "test_predictions/") results_folder_2D = cf_2d.test_out_folder f = open('/home/laisong/ACDC2017/mms_vendorB_2d_train/patient_info.pkl', 'rb') patient_info = cPickle.load(f) # 读出文件的数据个数 if not os.path.isdir(output_folder): # if folder not exist, create it os.mkdir(output_folder) def resize_softmax_pred(softmax_output, new_shape, order=3): reshaped = np.zeros([len(softmax_output)] + list(new_shape), dtype=float) for i in range(len(softmax_output)): reshaped[i] = resize(softmax_output[i].astype(float), new_shape, order, mode="constant", cval=0, clip=True) return reshaped train_keys, test_keys = get_split(0) print(test_keys) for patient in test_keys: ed = 0 es = 2 for tpe in ['ed', 'es']: raw_itk = sitk.ReadImage( os.path.join(MMSCONFIG.MMs_TOTAL_DATA, 'Img', patient_info[patient]['code'] + '_sa.nii.gz')) raw = sitk.GetArrayFromImage(raw_itk) print('raw.shape:', raw.shape[1:]) for f in range(1): # should be 5 folder totally # res_3d = np.load(os.path.join(results_folder_3D, "fold%d" % f, "patient%03.0d_3D_net.npz" % patient)) res_2d = np.load( os.path.join(results_folder_2D, 'fold0', 'patient%03d_2D_net.npz' % patient)) print(res_2d[tpe].shape) # resize softmax to original image size # softmax_3d = resize_softmax_pred(res_3d[tpe], raw.shape, 3) softmax_2d = resize_softmax_pred( res_2d[tpe], raw.shape[1:], 3) # softmax_2d shape(4,10,256,232) print(softmax_2d.shape) """ res_2d[tpe].shape may be changed because of the transfering of spacing, this operation aims to recover the res_2d[tpe] to original shape(raw.shape) """ # all_softmax += [softmax_3d[None], softmax_2d[None]] # predicted_seg = postprocess_prediction(np.vstack(all_softmax).mean(0).argmax(0)) predicted_seg = postprocess_prediction(softmax_2d.argmax(0)) itk_seg = sitk.GetImageFromArray(predicted_seg.astype(np.uint8)) # itk_seg.CopyInformation(raw_itk) sitk.WriteImage( itk_seg, os.path.join( output_folder, "patient%03.0d_%s.nii.gz" % (patient, tpe.upper())))
print("======= Generating Data Tuples =======") def chunks(iterable, size): it = iter(iterable) chunk = list(itertools.islice(it, size)) while chunk: yield chunk chunk = list(itertools.islice(it, size)) data_tuples = [] for i, c in enumerate(CANDIDATES): seqs = tokenizer.texts_to_sequences(t for t, p in texts_by_candidate[c]) for j, seq in enumerate(seqs): split = get_split(texts_by_candidate[c][j][1]) for chunk in chunks(seq, MAX_SEQUENCE_LEN): if len(chunk) >= MIN_SEQUENCE_LEN: data_tuples.append((chunk, i, split)) print(len(data_tuples), 'data tuples.') counts = [0] * len(CANDIDATES) for _, label, _ in data_tuples: counts[label] += 1 for candidate, count in zip(CANDIDATES, counts): print(candidate, "has", count, "labelled examples.") random.shuffle(data_tuples)