def __init__( self, data_path, problem=PROBLEM_CLASSIFICATION, preproc_trn_X=None, preproc_trn_Y=None, preproc_val_X=None, preproc_val_Y=None, ): self.problem = problem self.val_X, self.val_Y, self.trn_X, self.trn_Y = get_dataset( data_path, problem) self.set_preprocessings( preproc_trn_X, preproc_trn_Y, preproc_val_X, preproc_val_Y, )
import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable import os from options.train_options import TrainOptions from data.get_dataset import get_dataset from models.get_model import get_model if __name__ == '__main__': opt = TrainOptions().parse() # get training options dataset = get_dataset(opt) dataloader = torch.utils.data.DataLoader( dataset, batch_size=opt.batch_size, shuffle=True, collate_fn=dataset.collate_fn ) model = get_model(opt) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) num_batches = int(len(dataloader) / opt.batch_size) for epoch in range(opt.start_epochs, opt.start_epochs+opt.epochs): for i, (img_path, imgs, targets) in enumerate(dataloader): if len(opt.gpu_ids) > 0: model = model.to(opt.device) imgs = Variable(imgs.to(opt.device))
def val(epoch, np_save_name, dataroot, dataset_mode, opt_name): opt = Options().parse() opt.dataroot = dataroot opt.dataset_mode = dataset_mode opt.name = opt_name opt.load_model = os.path.join(opt.checkpoint_dir, opt.name, opt.name + '_' + str(epoch) + '.pth') print(opt.load_model) dataset = get_dataset(opt) valLoader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False) print(len(valLoader)) model = create_model(opt) if len(opt.gpu_ids) > 1: model = model.module model.load(opt.load_model) start_time = time.time() dicts = {} for i, (imgs, labels, img_paths) in enumerate(valLoader): st = time.time() inputs = {'img': imgs} if opt.dataset_mode == 'abide': # abide name = img_paths[0].split('/')[-2] elif opt.dataset_mode == 'Ours': # ours name = img_paths[0].split('/')[-1][:-7] # print(name) model.set_input(inputs, mode='test') output = model.inference().cpu() if output.data == 1: dicts[name] = 'yes' else: dicts[name] = 'no' conv1, conv2, conv5 = model.show_middle_results() conv5 = conv5.cpu().detach() input_d, input_h, input_w = 182, 218, 182 bs, channels, d, h, w = conv5.size() cam5 = torch.zeros((1, 1, d, h, w), dtype=torch.float32) weights = model.get_weights('module.fc.weight') if output.data == 1: weights = weights[1, ...] else: weights = weights[0, ...] for c in range(channels): cam5[0, 0, ...] += conv5[0, c, ...] #* weights[c] res5 = (cam5 - torch.min(cam5)) / (torch.max(cam5) - torch.min(cam5)) res5 = F.interpolate(res5, size=(input_d, input_h, input_w), mode='trilinear') res5 = res5.squeeze(0) res5 = res5.squeeze(0) # standardize res5_np = res5.numpy() if not os.path.exists(os.path.join(np_save_name)): os.makedirs(os.path.join(np_save_name)) np.save(os.path.join(np_save_name, name + '.npy'), res5_np) return dicts
def val(epoch): logger = open('preschooler_log.txt', 'w') opt = Options().parse() #opt.dataroot = 'dataset/abide/labels/ours_test_reori.txt' opt.dataset_mode = 'Ours' opt.name = 'preschooler' opt.load_model = os.path.join(opt.checkpoint_dir, opt.name, opt.name + '_' + str(epoch) + '.pth') print(opt.load_model) dataset = get_dataset(opt) valLoader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False) print(len(valLoader)) model = create_model(opt) if len(opt.gpu_ids) > 1: model = model.module model.load(opt.load_model) TP, FP, FN, total = 0, 0, 0, 0 TN = 0 label_tp, label_tn = 0, 0 start_time = time.time() for i, (imgs, labels, img_paths) in enumerate(valLoader): inputs = {'img': imgs} name = img_paths[0].split('/')[-1] model.set_input(inputs, mode='test') output = model.inference().detach().cpu() #print(output, labels, name) logger.write("%d\t%d\t%s\n" % (int(output), int(labels), name)) if labels.data == 1: label_tp += 1 if labels.data == 0: label_tn += 1 if output.data == 1 and labels.data == 1: TP += 1 elif output.data == 0 and labels.data == 0: TN += 1 elif output.data == 1 and labels.data == 0: FP += 1 elif output.data == 0 and labels.data == 1: FN += 1 if TP + FP == 0: P = 0 else: P = float(TP) / (TP + FP) if TP + FN == 0: R = 0 else: R = float(TP) / (TP + FN) if P + R == 0: F1 = 0 else: F1 = (2 * P * R) / (P + R) sen = float(TP) / (TP + FN) spe = float(TN) / (TN + FP) acc = (float(TP) + float(TN)) / len(valLoader) * 100.0 end_time = time.time() #print(TP + TN + FP + FN) #print(len(valLoader)) message = '\n------------------------results----------------------\n' # message += '{:>10}\t{:>10}\t{:>10}\n'.format('TP:', TP, label_tp) # message += '{:>10}\t{:>10}\t{:>10}\n'.format('TN:', TN, label_tn) message += '{:>10}\t{:>10.4f}\n'.format('acc:', acc) message += '{:>10}\t{:>10.4f}\n'.format('precision:', P) message += '{:>10}\t{:>10.4f}\n'.format('recall:', R) message += '{:>10}\t{:>10.4f}\n'.format('Specificity:', spe) message += '{:>10}\t{:>10.4f}\n'.format('Sensitivity:', sen) message += '{:>10}\t{:>10.4f}\n'.format('F1-measure:', F1) message += '{:>10}\t{:>10.4f}\n'.format( 'avg_time:', (end_time - start_time) / len(valLoader)) message += '------------------------------------------------------\n' print(message) logger.write(message + '\n') return acc
def save_mid_report(start, end, train_t, val_t, test_t): # write to txt file val_txt = open(val_t, 'w') test_txt = open(test_t, 'w') train_opt = Options().parse() val_opt = Options().parse() test_opt = Options().parse() # dataroot val_opt.dataroot = 'dataset/abide/labels/test7.txt' # test_opt.dataroot = 'dataset/abide/labels/ours_all.txt' train_opt.dataroot = 'dataset/abide/labels/ours_train.txt' #val_opt.dataroot = 'dataset/abide/labels/ours_test.txt' test_opt.dataroot = 'dataset/abide/labels/less9.txt' # dataset mode # train_opt.dataset_mode = 'abide' # val_opt.dataset_mode = 'abide' # test_opt.dataset_mode = 'Ours' train_opt.dataset_mode = 'Ours' val_opt.dataset_mode = 'abide' test_opt.dataset_mode = 'abide' # model name #train_opt.name = 'abide_all' train_opt.name = 'ours_split' # load models for epoch in range(start, end): train_opt.load_model = os.path.join(train_opt.checkpoint_dir, train_opt.name, train_opt.name+'_'+str(epoch)+'.pth') test_opt.load_model = train_opt.load_model val_opt.load_model = train_opt.load_model print(train_opt.load_model) # train_dataset = get_dataset(train_opt) val_dataset = get_dataset(val_opt) test_dataset = get_dataset(test_opt) # trainLoader = torch.utils.data.DataLoader( # train_dataset, # batch_size=8, # shuffle=False # ) valLoader = torch.utils.data.DataLoader( val_dataset, batch_size=4, shuffle=False ) testLoader = torch.utils.data.DataLoader( test_dataset, batch_size=4, shuffle=False ) #print(len(train_dataset), len(val_dataset), len(test_dataset)) #train_model = create_model(train_opt) model = create_model(test_opt) if len(train_opt.gpu_ids) > 1: model = model.module model.load(test_opt.load_model) #get_model_res(trainLoader, model, train_txt) get_model_res(valLoader, model, val_txt) get_model_res(testLoader, model, test_txt) #train_txt.close() val_txt.close() test_txt.close()
def __init__(self, z_size, post_model, prior_model, obs_model, mix_components, free_bits, h_size, depth, ds_list, sdn_max_scale, sdn_min_scale, sdn_nfeat_0, sdn_nfeat_diff, sdn_num_dirs, lrate, lrate_decay, root, dataset, num_workers, batch, batch_val, ema_coef, random_seed, downsample_first, sampling_temperature, distributed_backend, amp, gpus, nbits, figsize, evaluation_mode, accumulate_grad_batches, beta_rate, beta_final, **kw): super().__init__() self.save_hyperparameters() # create model signature self.signature_string = \ '_amp-{}_gpus-{}_lr-{}_lrd-{}_seed-{}_z-{}_max-{}_min-{}_nf0-{}_nfdif-{}_d-{}_b-{}_fb-{}_h-{}_depth-{}_' \ 'ds-{}-dsf-{}_ema-{}_tmp-{}_nw-{}-{}-{}-{}_mx-{}_bits-{}_ab-{}_bv-{}' \ .format(amp, gpus, lrate, lrate_decay, random_seed, z_size, sdn_max_scale, sdn_min_scale, sdn_nfeat_0, sdn_nfeat_diff, sdn_num_dirs, batch, free_bits, h_size, depth, list2string(ds_list), downsample_first, ema_coef, sampling_temperature, num_workers, obs_model, post_model, distributed_backend, mix_components, nbits, accumulate_grad_batches, batch_val) # initialize variables self.lrate = lrate self.random_seed = random_seed self.sdn_max_scale = sdn_max_scale self.sdn_min_scale = sdn_min_scale self.sdn_nfeat_0 = sdn_nfeat_0 self.sdn_nfeat_diff = sdn_nfeat_diff self.sdn_num_dirs = sdn_num_dirs self.z_size = z_size self.h_size = h_size self.beta_rate = beta_rate self.beta_final = beta_final self.beta_current = 0 # => KL annealing self.obs_model_name = obs_model self.post_model_name = post_model self.mix_components = mix_components self.num_workers = num_workers self.batch = batch self.dataset = dataset self.figsize = figsize # dataset specifications channels, image_size = get_dataset_specifications(dataset) self.bpd_factor = (image_size * image_size * channels * np.log(2.)) # make sure image size is a power of 2 assert image_size in [1024, 512, 256, 128, 64, 32], "Unaccepted image format." # construct prior and observation models self.obs_model = eval(obs_model)(channels=channels, image_size=image_size, nbits=nbits, mix_components=mix_components) self.prior_model = eval(prior_model)() self.post_model = eval(post_model)() # load data self.trainset, self.valset = get_dataset( root=root, dataset=dataset, transform=self.obs_model.get_transform()) # keeping track of SDNLayer directions and state sizes, and also of current scale self.cur_dir = 0 encoder_list, decoder_list = self.create_enc_dec_networks( channels, sdn_nfeat_0) self.encoder = EncWrapper(encoder_list) self.decoder = nn.Sequential(*decoder_list) print(self.encoder) print(self.decoder) # beta vae loss by default self.vae_loss = self.beta_vae_loss # initialize weights self.apply(weights_init) # Evaluate disentanglement metrics and related vars self.num_channels = channels self.image_size = image_size self.evaluation_metric = ['factor_vae_metric', 'beta_vae_sklearn']
def __init__(self, z_size, post_model, prior_model, obs_model, mix_components, free_bits, h_size, depth, ds_list, sdn_max_scale, sdn_min_scale, sdn_nfeat_0, sdn_nfeat_diff, sdn_num_dirs, lrate, lrate_decay, root, dataset, num_workers, batch, batch_val, ema_coef, random_seed, downsample_first, sampling_temperature, distributed_backend, amp, gpus, nbits, figsize, evaluation_mode, accumulate_grad_batches, **kw): super().__init__() # save HPs to checkpoints self.save_hyperparameters() # create model signature self.signature_string = \ '_amp-{}_gpus-{}_lr-{}_lrd-{}_seed-{}_z-{}_max-{}_min-{}_nf0-{}_nfdif-{}_d-{}_b-{}_fb-{}_h-{}_depth-{}_' \ 'ds-{}-dsf-{}_ema-{}_tmp-{}_nw-{}-{}-{}-{}_mx-{}_bits-{}_ab-{}_bv-{}' \ .format(amp, gpus, lrate, lrate_decay, random_seed, z_size, sdn_max_scale, sdn_min_scale, sdn_nfeat_0, sdn_nfeat_diff, sdn_num_dirs, batch, free_bits, h_size, depth, list2string(ds_list), downsample_first, ema_coef, sampling_temperature, num_workers, obs_model, post_model, distributed_backend, mix_components, nbits, accumulate_grad_batches, batch_val) # dataset specifications channels, image_size = get_dataset_specifications(dataset=dataset) self.bpd_factor = image_size * image_size * channels * np.log(2.) self.channels = channels self.image_size = image_size # initialize variables self.lrate = lrate self.lrate_decay = lrate_decay self.sampling_temperature = sampling_temperature self.amp = amp self.num_workers = num_workers self.batch = batch self.batch_val = batch_val if batch_val > 0 else batch self.figsize = figsize self.ema_coef = ema_coef # construct observation model self.obs_model = eval(obs_model)(channels=channels, image_size=image_size, nbits=nbits, mix_components=mix_components) # load data self.trainset, self.valset = get_dataset( root=root, dataset=dataset, transform=self.obs_model.get_transform(), load_trainset=(not evaluation_mode)) # gradient scaler for amp self.scaler = GradScaler(enabled=self.amp) # padding for 28x28 images extra_padding = 0 if image_size != 28 else 2 # keeping track of SDNLayer directions and number of channels, and also of current scale self.cur_dir = 0 cur_num_feat = sdn_nfeat_0 top_input_dim = (image_size + 2 * extra_padding) if downsample_first: top_input_dim = top_input_dim // 2 # parameters for bottom layers bot_kernel_size, bot_stride, bot_padding = ( 4, 2, 1) if downsample_first else (3, 1, 1) # construct bottom layer of encoder i.e. first layer self.first_layer = nn.Sequential( nn.Conv2d(channels, h_size, bot_kernel_size, bot_stride, bot_padding), nn.ZeroPad2d(extra_padding)) # construct ladder network self.ladder_layers = nn.ModuleList() for i in range(depth): # set up the flags downsample = (i in ds_list and top_input_dim > 1) # use sdn or not use_sdn = (sdn_max_scale >= top_input_dim >= sdn_min_scale) if use_sdn: sdn_dirs_a = self._get_dirs(sdn_num_dirs) sdn_dirs_b = self._get_dirs(sdn_num_dirs) else: sdn_dirs_a = None sdn_dirs_b = None # add layer self.ladder_layers.append( LadderLayer(post_model=eval(post_model)(z_size=z_size), prior_model=eval(prior_model)(z_size=z_size), z_size=z_size, h_size=h_size, free_bits=free_bits, downsample=downsample, sdn_num_features=cur_num_feat, sdn_dirs_a=sdn_dirs_a, sdn_dirs_b=sdn_dirs_b, use_sdn=use_sdn, sampling_temperature=sampling_temperature)) # correct input dimensionality for top layer if downsample: top_input_dim = max(1, top_input_dim // 2) if use_sdn: cur_num_feat = max(50, cur_num_feat - sdn_nfeat_diff) # learnable constant which is fed to the top-most layer top-down pass self.register_parameter('h', torch.nn.Parameter(torch.zeros(h_size))) self.h_shape = torch.Size([h_size, top_input_dim, top_input_dim]) # construct bottom layer of decoder i.e. last layer if sdn_max_scale >= image_size: self.last_layer = nn.Sequential( Crop2d(extra_padding), nn.ELU(True), ResSDNLayer(in_ch=h_size, out_ch=self.obs_model.params_per_dim(), num_features=sdn_nfeat_0, dirs=self._get_dirs(4), kernel_size=bot_kernel_size, stride=bot_stride, padding=bot_padding, upsample=downsample_first)) else: cnn_module = nn.ConvTranspose2d if downsample_first else nn.Conv2d self.last_layer = nn.Sequential( Crop2d(extra_padding), nn.ELU(True), cnn_module(h_size, self.obs_model.params_per_dim(), bot_kernel_size, bot_stride, bot_padding)) # initialize NN weights self.apply(weights_init)