def __init__(self, rotMatrix, transVect, cameraMatrix, distCoeffs, anchor_points=None): """ Extrinsic parameters : rotMatrix, transVect. Intrinsic parameters : cameraMatrix, distCoeffs. """ self.rotMatrix = check_shape(rotMatrix, (3, 3), "rotation matrix") self.transVect = column_vector(transVect, 3, "translation vector") self.cameraMatrix = check_shape(cameraMatrix, (3, 3), "camera matrix") self.distCoeffs = column_vector(distCoeffs, 4, "distort coefficients") self.anchor_points = anchor_points
def is_file(args, path): if not os.path.isfile(path): return False for mod in (overlay, auto_resize, auto_resize_crop, auto_rescale): if args.get(mod.__name__): return True if not args['ignore_size']: check_shape(path) else: Conf.log.warn('Image Size Requirements Unchecked.') return True
def select_phases(): """ Select the transformation phases to use following args parameters :return: <ImageTransform[]> list of image transformation """ def shift_step(shift_starting=0, shift_ending=0): if not conf.args['steps']: conf.args['steps'] = (0, 5) conf.args['steps'] = (conf.args['steps'][0] + shift_starting, conf.args['steps'][1] + shift_ending) def add_tail(phases, phase): phases = [phase] + phases if conf.args['steps'] and conf.args['steps'][0] != 0: shift_step(shift_starting=1) if conf.args['steps'] and conf.args['steps'][1] == len(phases) - 1: shift_step(shift_ending=1) return phases def add_head(phases, phase): phases = phases + [phase] if conf.args['steps'] and conf.args['steps'][1] == len(phases) - 1: shift_step(shift_ending=1) return phases phases = [ DressToCorrect, CorrectToMask, MaskToMaskref, MaskrefToMaskdet, MaskdetToMaskfin, MaskfinToNude ] if conf.args['overlay']: phases = add_tail(phases, ImageToResized) phases = add_tail(phases, ImageToCrop) phases = add_head(phases, ImageToOverlay) elif conf.args['auto_resize']: phases = add_tail(phases, ImageToResized) elif conf.args['auto_resize_crop']: phases = add_tail(phases, ImageToResizedCrop) elif conf.args['auto_rescale']: phases = add_tail(phases, ImageToRescale) elif os.path.isfile(conf.args['input']): if not conf.args['ignore_size']: check_shape(conf.args['input']) else: conf.log.warn('Image Size Requirements Unchecked.') if conf.args['color_transfer']: phases = add_head(phases, ColorTransfer) return phases
def chromosome(self,chrom): '''Outputs the feature dataframe for chromosome=chrom The dataframe should include the info columns ''' print('Getting features for chromosome {}'.format(chrom)) if chrom not in [x for x in range(1,23)]: raise Exception('{} is not a valid chromosome number'.format(chrom)) else: ref_df = self.ref_annot_df(chrom) cts_df = self.cts_annot_df(chrom) if not u.check_shape(ref_df,cts_df,'row'): raise Exception('Shape of reference annotations doesn not match cell type specific annotations.\n Reference annotation shape {},\n cell type specific annotation shape {}'.format(ref_df.shape,cts_df.shape)) else: if u.containList(self.info_colnames,cts_df.columns.tolist()): cts_df.drop(self.info_colnames,axis=1,inplace=True) return pd.concat([ref_df,cts_df],axis=1) elif u.nonInList(self.info_colnames,cts_df.columns.tolist()): return pd.concat([ref_df,cts_df],axis=1) else: raise Exception('Cell type specific annotations dataframe contains some but not all info column names')
num_workers=16) eval_samples = iter(eval_loader) num_points = 400 file_dir = 'ours_fix_alpha_' + str(num_points) os.makedirs(file_dir, exist_ok=True) feature_list = np.random.randn(num_points * opt.batch_size * 2, opt.vector_dim) label = [] for total_step in tqdm(range(num_points)): batch = next(train_samples) to_device(batch, device) # feature = encoder(batch['img']) feature = encoder(batch['img'], batch['v_0']) check_shape(feature, 'feature') set_mute(True) feature_list[total_step * opt.batch_size:(total_step + 1) * opt.batch_size] = feature.data.cpu().numpy() label = [0] * num_points * opt.batch_size for total_step in tqdm(range(num_points, 2 * num_points)): batch = next(eval_samples) to_device(batch, device) feature = encoder(batch['img'], batch['v_0']) check_shape(feature, 'feature') set_mute(True) feature_list[total_step * opt.batch_size:(total_step + 1) * opt.batch_size] = feature.data.cpu().numpy() label.extend([1] * num_points * opt.batch_size)
dpi=400) plt.close('all') cluster.train_models() """ logger_avg = SummaryWriter(log_dir=log_path+'avg_model') logger_min = SummaryWriter(log_dir=log_path+'min_uncty') for total_steps in range(1000000): eval_new_error(total_steps, logger_avg, logger_min) eval_error(total_steps) """ for total_steps in range(1000000): for model_index in range(opt.model_num): check_shape(model_index, 'model_index') batch = next(train_loader_cluster[model_index]) batch['t'] = batch['t'].view(-1, 1) batch['t'].requires_grad = True batch['v0_array'] = batch['v0_array'].view(-1, 1) check_shape(batch) to_device(batch, device) feature = cluster.get_encoder(batch['img'], model_index) feature_dim = feature.shape[-1] feature = feature.unsqueeze(1) feature = feature.expand(opt.batch_size, opt.points_num, feature_dim) feature = feature.reshape(opt.batch_size * opt.points_num, feature_dim) check_shape(feature, 'feature')
plt.close('all') model.train_models() # def train_adversarial(): # pass # def train_supervised(): # pass for total_steps in range(1000000): model_index = random.randint(0, opt.model_num - 1) batch = next(train_samples) check_shape(batch) to_device(batch, device) batch['t'] = batch['t'].view(-1, 1) batch['t'].requires_grad = True batch['v0_array'] = batch['v0_array'].view(-1, 1) check_shape(batch) to_device(batch, device) feature = model.get_encoder(batch['img'], batch['v_0']) feature_dim = feature.shape[-1] feature = feature.unsqueeze(1) feature = feature.expand(opt.batch_size, opt.points_num, feature_dim) feature = feature.reshape(opt.batch_size * opt.points_num, feature_dim)
def is_file(args): if not args['ignore_size']: check_shape(args['input']) else: Conf.log.warn('Image Size Requirements Unchecked.')
def eval_decision(logger, total_steps, algorithm='WCM'): batch = next(eval_samples) to_device(batch, device) check_shape(batch) set_mute(True) x = model_cluster[0]._decoder._base_dist.mean.clone().detach().view(-1, opt.points_num, 2) x.requires_grad = True zs = [model._params( velocity=batch['v_0'].view(-1,1), visual_features=batch['img'], ) for model in model_cluster] optimizer = torch.optim.Adam(params=[x], lr=1e-1) x_best = x.clone() loss_best = torch.ones(()).to(x.device) * 1000.0 for _ in range(50): optimizer.zero_grad() y, _ = model_cluster[0]._decoder._forward(x=x, z=zs[0]) imitation_posteriors = list() for model, z in zip(model_cluster, zs): _, log_prob, logabsdet = model._decoder._inverse(y=y, z=z) imitation_prior = torch.mean(log_prob - logabsdet) imitation_posteriors.append(imitation_prior) imitation_posteriors = torch.stack(imitation_posteriors, dim=0) if algorithm == "WCM": loss, _ = torch.min(-imitation_posteriors, dim=0) elif algorithm == "BCM": loss, _ = torch.max(-imitation_posteriors, dim=0) else: loss = torch.mean(-imitation_posteriors, dim=0) loss.backward(retain_graph=True) optimizer.step() if loss < loss_best: x_best = x.clone() loss_best = loss.clone() plan, _ = model_cluster[0]._decoder._forward(x=x_best, z=zs[0]) xy = plan.detach().cpu().numpy()[0]*opt.max_dist real_xy = batch['xy'].view(-1, 2).data.cpu().numpy()*opt.max_dist fake_x = xy[:,0] fake_y = xy[:,1] real_x = real_xy[:,0] real_y = real_xy[:,1] time = batch['t'].data.cpu().numpy()[0]*opt.max_t # time_list = [0.0, 0.75, 1.5, 2.25] #oxford training time time_list = [0.0000, 0.1875, 0.3750, 0.5625, 0.7500, 0.9375, 1.1250, 1.3125, 1.5001,1.6875, 1.8750, 2.0625, 2.2501, 2.4376, 2.6250, 2.8126] xs = [] ys = [] for t in time: x, y = interpolation(time_list, fake_x, fake_y, t) xs.append(x) ys.append(y) fake_x = np.array(xs) fake_y = np.array(ys) # max_x = 30. # max_y = 30. # fig = plt.figure(figsize=(7, 7)) # ax1 = fig.add_subplot(111) # ax1.plot(real_x, real_y, label='real-trajectory', color = 'b', linewidth=3, linestyle='--') # ax1.plot(fake_x, fake_y, label='fake-trajectory', color = 'r', linewidth=3) # ax1.set_xlabel('Forward/(m)') # ax1.set_ylabel('Sideways/(m)') # ax1.set_xlim([0., max_x]) # ax1.set_ylim([-max_y/2, max_y/2]) # plt.legend(loc='lower right') # plt.legend(loc='lower left') # plt.savefig('result/output/%s/' % opt.dataset_name+'/'+str(total_steps)+'.png') # plt.close('all') ex = np.mean(np.abs(fake_x-real_x)) ey = np.mean(np.abs(fake_y-real_y)) fde = np.hypot(fake_x - real_x, fake_y - real_y)[-1] ade = np.mean(np.hypot(fake_x - real_x, fake_y - real_y)) logger.add_scalar('eval/ex', ex.item(), total_steps) logger.add_scalar('eval/ey', ey.item(), total_steps) logger.add_scalar('eval/fde', fde.item(), total_steps) logger.add_scalar('eval/ade', ade.item(), total_steps)
logger.add_scalar('eval/ex', ex.item(), total_steps) logger.add_scalar('eval/ey', ey.item(), total_steps) logger.add_scalar('eval/fde', fde.item(), total_steps) logger.add_scalar('eval/ade', ade.item(), total_steps) for total_steps in range(1000000): for model_index in range(opt.model_num): model = model_cluster[model_index] train_loader = train_loader_cluster[model_index] optimizer = optimizer_cluster[model_index] logger = logger_cluster[model_index] batch = next(train_loader) check_shape(batch) to_device(batch, device) print(batch['t'] * opt.max_t) y = batch['xy'] #*opt.max_dist z = model._params( velocity=batch['v_0'].view(-1, 1), visual_features=batch['img'], ) _, log_prob, logabsdet = model._decoder._inverse(y=y, z=z) check_shape(log_prob, 'log_prob') check_shape(logabsdet, 'logabsdet') loss = -torch.mean(log_prob - logabsdet, dim=0) optimizer.zero_grad() loss.backward() logger.add_scalar('train/loss', loss.item(), total_steps)
real_traj = batch['xy'].view(-1, opt.points_num * 2) # y = batch['xy'].view(-1, opt.points_num, 2)[..., 1].view(-1, opt.points_num) # check_shape(batch['xy'].view(-1, opt.points_num, 2)[..., 1], '1') # check_shape(y, 'y') # set_mute(True) condition = batch['v0_array'] single_latent = encoder(batch['img']) ###################################################################### # traj_sim = cos_similarity(real_traj[:opt.batch_size//2], real_traj[opt.batch_size//2:]) input_sim_net = torch.cat( (real_traj[:opt.batch_size // 2], real_traj[opt.batch_size // 2:]), 1) check_shape(input_sim_net) input_sim_net2 = torch.cat((batch['v_0'][:opt.batch_size // 2], batch['v_0'][opt.batch_size // 2:]), 1) check_shape(input_sim_net2) input_sim_net = torch.cat((input_sim_net, input_sim_net2), 1) real_dist = similarity_net(input_sim_net) latent_dist = torch.norm(single_latent[:opt.batch_size // 2] - single_latent[opt.batch_size // 2:], dim=1) # latent_sim = cos_similarity(single_latent[:opt.batch_size//2], single_latent[opt.batch_size//2:]) sim_loss = latent_criterion(real_dist, latent_dist.unsqueeze(1)) # if speed == 0: sim_loss = 0 ###################################################################### latent = single_latent.unsqueeze(1)
def eval_model(total_steps): global model batch = next(eval_samples) to_device(batch, device) check_shape(batch) x = model._decoder._base_dist.mean.clone().detach().view( -1, opt.points_num, 2) x.requires_grad = True z = model._params( velocity=batch['v_0'].view(-1, 1), visual_features=batch['img'], ) optimizer = torch.optim.Adam(params=[x], lr=1e-1) x_best = x.clone() loss_best = torch.ones(()).to(x.device) * 1000.0 for _ in range(10): optimizer.zero_grad() y, _ = model._decoder._forward(x=x, z=z) _, log_prob, logabsdet = model._decoder._inverse(y=y, z=z) imitation_prior = torch.mean(log_prob - logabsdet) loss = -imitation_prior loss.backward(retain_graph=True) optimizer.step() if loss < loss_best: x_best = x.clone() loss_best = loss.clone() plan, _ = model._decoder._forward(x=x_best, z=z) xy = plan.detach().cpu().numpy()[0] * opt.max_dist real_xy = batch['xy'].view(-1, 2).data.cpu().numpy() * opt.max_dist fake_x = xy[:, 0] fake_y = xy[:, 1] time_list = [0.0, 0.75, 1.5, 2.25] real_x = real_xy[:, 0] real_y = real_xy[:, 1] time = batch['t'].data.cpu().numpy()[0] * opt.max_t xs = [] ys = [] for t in time: x, y = interpolation(time_list, fake_x, fake_y, t) xs.append(x) ys.append(y) fake_x = np.array(xs) fake_y = np.array(ys) if total_steps % (4 * opt.test_interval) == 0: max_x = 30. max_y = 30. fig = plt.figure(figsize=(7, 7)) ax1 = fig.add_subplot(111) ax1.plot(real_x, real_y, label='real-trajectory', color='b', linewidth=3, linestyle='--') ax1.plot(fake_x, fake_y, label='fake-trajectory', color='r', linewidth=3) ax1.set_xlabel('Forward/(m)') ax1.set_ylabel('Sideways/(m)') ax1.set_xlim([0., max_x]) ax1.set_ylim([-max_y / 2, max_y / 2]) plt.legend(loc='lower right') plt.legend(loc='lower left') plt.savefig('result/output/%s/' % opt.dataset_name + '/' + str(total_steps) + '.png') plt.close('all') ex = np.mean(np.abs(fake_x - real_x)) ey = np.mean(np.abs(fake_y - real_y)) fde = np.hypot(fake_x - real_x, fake_y - real_y)[-1] ade = np.mean(np.hypot(fake_x - real_x, fake_y - real_y)) logger.add_scalar('eval/ex', ex.item(), total_steps) logger.add_scalar('eval/ey', ey.item(), total_steps) logger.add_scalar('eval/fde', fde.item(), total_steps) logger.add_scalar('eval/ade', ade.item(), total_steps)
real_y = real_traj[:, 1] ex = np.mean(np.abs(fake_x - real_x)) ey = np.mean(np.abs(fake_y - real_y)) fde = np.hypot(fake_x - real_x, fake_y - real_y)[-1] ade = np.mean(np.hypot(fake_x - real_x, fake_y - real_y)) logger.add_scalar('eval/ex', ex.item(), total_steps) logger.add_scalar('eval/ey', ey.item(), total_steps) logger.add_scalar('eval/fde', fde.item(), total_steps) logger.add_scalar('eval/ade', ade.item(), total_steps) for total_steps in range(1000000): batch = next(train_samples) check_shape(batch) to_device(batch, device) x = batch['img'] d = batch['domian'] y = batch['xy'].view(opt.batch_size, 2 * opt.points_num) v0 = batch['v0_array'] t = batch['t'] optimizer.zero_grad() vae_loss, regression_loss = model.loss_function(d, x, y, v0, t) loss = regression_loss loss.backward() optimizer.step() logger.add_scalar('train/vae_loss', vae_loss.item(), total_steps) logger.add_scalar('train/regression_loss', regression_loss.item(),
dpi=400) plt.close('all') cluster.train_models() # def train_adversarial(): # pass # def train_supervised(): # pass for total_steps in range(1000000): model_index = random.randint(0, opt.model_num - 1) logger = logger_cluster[0] check_shape(model_index, 'model_index') batch = next(train_samples) check_shape(batch) to_device(batch, device) mask1 = torch.arange(0, opt.batch_size - 1, 2) mask2 = torch.arange(1, opt.batch_size, 2) labels = 1 - 0.5 * torch.sum( torch.abs(batch['domian'][mask1] - batch['domian'][mask2]), dim=1) # import pdb; pdb.set_trace() batch['t'] = batch['t'].view(-1, 1) batch['t'].requires_grad = True batch['v0_array'] = batch['v0_array'].view(-1, 1)
for total_step in tqdm(range(num_points)): train_loader = train_loader_cluster[total_step % opt.model_num] batch = next(train_loader) batch['t'] = batch['t'].view(-1,1) batch['v0_array'] = batch['v0_array'].view(-1,1) batch['xy'] = batch['xy'].view(-1,2) to_device(batch, device) real_traj = batch['xy'].data.cpu().numpy()*opt.max_dist real_x = real_traj[:,0] real_y = real_traj[:,1] model_index = 0 feature = cluster.get_encoder(batch['img'], index=model_index) check_shape(feature, 'feature') check_shape(batch['xy'], 'xy') set_mute(True) feature = feature.data.cpu().numpy()[0] feature_list[total_step] = feature label.append(total_step % opt.model_num) # num_points = 5000 # traj_list = np.random.randn(num_points*opt.model_num, opt.points_num*2) # label = [] # for model_index in range(opt.model_num): # for total_step in tqdm(range(num_points)): # batch = next(train_loader_cluster[model_index]) # traj_list[total_step+num_points*model_index] = batch['xy'].flatten().data.cpu().numpy()