def forward(self, x, args): if len(x.shape) not in [2, 4]: raise ValueError('input shape of FC layer should be 2D or 4D') if len(x.shape) == 4: self.inbound_shape = x.shape x = x.reshape(x.shape[0], -1) else: self.inbound_shape = x.shape self.tensor_in = x tensor_out = self.tensor_in @ self.weight self.l2_loss = utils.get_l2_loss(args['weight_decay'], self.weight) if self.bias is not None: self.value = tensor_out + self.bias self.l2_loss += utils.get_l2_loss(args['weight_decay'], self.bias) self.value = tensor_out
def forward(self, x, args): batch, h, w, c = x.shape self.h_range = utils.get_out_length(h, self.weight_size, self.stride) self.w_range = utils.get_out_length(w, self.weight_size, self.stride) self.tensor_in = x tensor_out = np.zeros((batch, self.h_range, self.w_range, self.out_depth)).astype(np.float32) for window, i, j, _, _, _, _ in utils.get_window( x, self.h_range, self.w_range, self.weight_size, self.stride): tensor_out[:, i, j, :] = np.tensordot(window, self.weight, axes=([1, 2, 3], [0, 1, 2])) self.l2_loss = utils.get_l2_loss(args['weight_decay'], self.weight) if self.bias is not None: self.value = tensor_out + self.bias self.l2_loss += utils.get_l2_loss(args['weight_decay'], self.bias) self.value = tensor_out
def main(hparams): # Set up some stuff accoring to hparams hparams.n_input = np.prod(hparams.image_shape) utils.set_num_measurements(hparams) utils.print_hparams(hparams) # get inputs data_dict = model_input(hparams) estimator = utils.get_estimator(hparams, 'vae') utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) h_hats_dict = {model_type: {} for model_type in hparams.model_types} for key, x in data_dict.iteritems(): if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([ os.path.isfile(save_path) for save_path in save_paths.values() ]) if is_saved: continue # Get Rx data Rx = data_dict[key]['Rx_data'] Tx = data_dict[key]['Rx_data'] H = data_dict[key]['H_data'] # Construct estimates using each estimator h_hat = estimator(Tx, Rx, hparams) # Save the estimate h_hats_dict['vae'][key] = h_hat # Compute and store measurement and l2 loss measurement_losses['vae'][key] = utils.get_measurement_loss( h_hat, Tx, Rx) l2_losses['vae'][key] = utils.get_l2_loss(h_hat, H) print 'Processed upto image {0} / {1}'.format(key + 1, len(data_dict)) # Checkpointing if (hparams.save_images) and ((key + 1) % hparams.checkpoint_iter == 0): utils.checkpoint(key, h_hat, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved first ', key + 1, 'channels\n'
def main(hparams): # set up perceptual loss device = 'cuda:0' percept = PerceptualLoss( model="net-lin", net="vgg", use_gpu=device.startswith("cuda") ) utils.print_hparams(hparams) # get inputs xs_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses, lpips_scores, z_hats = utils.load_checkpoints(hparams) x_hats_dict = {model_type : {} for model_type in hparams.model_types} x_batch_dict = {} A = utils.get_A(hparams) noise_batch = hparams.noise_std * np.random.standard_t(2, size=(hparams.batch_size, hparams.num_measurements)) for key, x in xs_dict.items(): if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([os.path.isfile(save_path) for save_path in save_paths.values()]) if is_saved: continue x_batch_dict[key] = x if len(x_batch_dict) < hparams.batch_size: continue # Reshape input x_batch_list = [x.reshape(1, hparams.n_input) for _, x in x_batch_dict.items()] x_batch = np.concatenate(x_batch_list) # Construct noise and measurements y_batch = utils.get_measurements(x_batch, A, noise_batch, hparams) # Construct estimates using each estimator for model_type in hparams.model_types: estimator = estimators[model_type] x_hat_batch, z_hat_batch, m_loss_batch = estimator(A, y_batch, hparams) for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y_train = y_batch[i] x_hat = x_hat_batch[i] # Save the estimate x_hats_dict[model_type][key] = x_hat # Compute and store measurement and l2 loss measurement_losses[model_type][key] = m_loss_batch[key] l2_losses[model_type][key] = utils.get_l2_loss(x_hat, x) lpips_scores[model_type][key] = utils.get_lpips_score(percept, x_hat, x, hparams.image_shape) z_hats[model_type][key] = z_hat_batch[i] print('Processed upto image {0} / {1}'.format(key+1, len(xs_dict))) # Checkpointing if (hparams.save_images) and ((key+1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, lpips_scores, z_hats, save_image, hparams) x_hats_dict = {model_type : {} for model_type in hparams.model_types} print('\nProcessed and saved first ', key+1, 'images\n') x_batch_dict = {} # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, lpips_scores, z_hats, save_image, hparams) print('\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict))) if hparams.print_stats: for model_type in hparams.model_types: print(model_type) measurement_loss_list = list(measurement_losses[model_type].values()) l2_loss_list = list(l2_losses[model_type].values()) mean_m_loss = np.mean(measurement_loss_list) mean_l2_loss = np.mean(l2_loss_list) print('mean measurement loss = {0}'.format(mean_m_loss)) print('mean l2 loss = {0}'.format(mean_l2_loss)) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print('\nDid NOT process last {} images because they did not fill up the last batch.'.format(len(x_batch_dict))) print('Consider rerunning lazily with a smaller batch size.')
def main(hparams): hparams.n_input = np.prod(hparams.image_shape) hparams.model_type = 'vae' maxiter = hparams.max_outer_iter utils.print_hparams(hparams) xs_dict = model_input(hparams) # returns the images estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) x_hats_dict = {'vae': {}} x_batch_dict = {} for key, x in xs_dict.iteritems(): print key x_batch_dict[key] = x #placing images in dictionary if len(x_batch_dict) < hparams.batch_size: continue x_coll = [ x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems() ] #Generates the columns of input x x_batch = np.concatenate(x_coll) # Generates entire X A_outer = utils.get_outer_A(hparams) # Created the random matric A noise_batch = hparams.noise_std * np.random.randn( hparams.batch_size, 100) y_batch_outer = np.sign( np.matmul(x_batch, A_outer) ) # Multiplication of A and X followed by quantization on 4 levels #y_batch_outer = np.matmul(x_batch, A_outer) x_main_batch = 0.0 * x_batch z_opt_batch = np.random.randn(hparams.batch_size, 20) #Input to the generator of the GAN for k in range(maxiter): x_est_batch = x_main_batch + hparams.outer_learning_rate * ( np.matmul( (y_batch_outer - np.sign(np.matmul(x_main_batch, A_outer))), A_outer.T)) #x_est_batch = x_main_batch + hparams.outer_learning_rate * (np.matmul((y_batch_outer - np.matmul(x_main_batch, A_outer)), A_outer.T)) # Gradient decent in x is done estimator = estimators['vae'] x_hat_batch, z_opt_batch = estimator( x_est_batch, z_opt_batch, hparams) # Projectin on the GAN x_main_batch = x_hat_batch dist = np.linalg.norm(x_batch - x_main_batch) / 784 print 'cool' print dist for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y = y_batch_outer[i] x_hat = x_hat_batch[i] # Save the estimate x_hats_dict['vae'][key] = x_hat # Compute and store measurement and l2 loss measurement_losses['vae'][key] = utils.get_measurement_loss( x_hat, A_outer, y) l2_losses['vae'][key] = utils.get_l2_loss(x_hat, x) print 'Processed upto image {0} / {1}'.format(key + 1, len(xs_dict)) # Checkpointing if (hparams.save_images) and ((key + 1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) #x_hats_dict = {'dcgan' : {}} print '\nProcessed and saved first ', key + 1, 'images\n' x_batch_dict = {} # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict)) if hparams.print_stats: for model_type in hparams.model_types: print model_type mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print 'mean measurement loss = {0}'.format(mean_m_loss) print 'mean l2 loss = {0}'.format(mean_l2_loss) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print '\nDid NOT process last {} images because they did not fill up the last batch.'.format( len(x_batch_dict)) print 'Consider rerunning lazily with a smaller batch size.'
def main(hparams): # Set up some stuff according to hparams hparams.n_input = np.prod(hparams.image_shape) maxiter = hparams.max_outer_iter utils.print_hparams(hparams) # get inputs xs_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) x_hats_dict = {'dcgan' : {}} x_batch_dict = {} for key, x in xs_dict.iteritems(): if hparams.lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([os.path.isfile(save_path) for save_path in save_paths.values()]) if is_saved: continue x_batch_dict[key] = x if len(x_batch_dict) < hparams.batch_size: continue # Reshape input x_batch_list = [x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems()] x_batch = np.concatenate(x_batch_list) # Construct measurements A_outer = utils.get_outer_A(hparams) y_batch_outer=np.matmul(x_batch, A_outer) x_main_batch = 0.0 * x_batch z_opt_batch = np.random.randn(hparams.batch_size, 100) for k in range(maxiter): x_est_batch=x_main_batch + hparams.outer_learning_rate*(np.matmul((y_batch_outer-np.matmul(x_main_batch,A_outer)),A_outer.T)) estimator = estimators['dcgan'] x_hat_batch,z_opt_batch = estimator(x_est_batch,z_opt_batch, hparams) x_main_batch=x_hat_batch for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y = y_batch_outer[i] x_hat = x_hat_batch[i] # Save the estimate x_hats_dict['dcgan'][key] = x_hat # Compute and store measurement and l2 loss measurement_losses['dcgan'][key] = utils.get_measurement_loss(x_hat, A_outer, y) l2_losses['dcgan'][key] = utils.get_l2_loss(x_hat, x) print 'Processed upto image {0} / {1}'.format(key+1, len(xs_dict)) # Checkpointing if (hparams.save_images) and ((key+1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) #x_hats_dict = {'dcgan' : {}} print '\nProcessed and saved first ', key+1, 'images\n' x_batch_dict = {} # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict)) if hparams.print_stats: for model_type in hparams.model_types: print model_type mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print 'mean measurement loss = {0}'.format(mean_m_loss) print 'mean l2 loss = {0}'.format(mean_l2_loss) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print '\nDid NOT process last {} images because they did not fill up the last batch.'.format(len(x_batch_dict)) print 'Consider rerunning lazily with a smaller batch size.'
def main(hparams): # Set up some stuff accoring to hparams hparams.n_input = np.prod(hparams.image_shape) utils.set_num_measurements(hparams) utils.print_hparams(hparams) # get inputs xs_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) x_hats_dict = {model_type: {} for model_type in hparams.model_types} x_batch_dict = {} for key, x in xs_dict.iteritems(): if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([ os.path.isfile(save_path) for save_path in save_paths.values() ]) if is_saved: continue x_batch_dict[key] = x if len(x_batch_dict) < hparams.batch_size: continue # Reshape input x_batch_list = [ x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems() ] x_batch = np.concatenate(x_batch_list) # Construct noise and measurements A = utils.get_A(hparams) noise_batch = hparams.noise_std * np.random.randn( hparams.batch_size, hparams.num_measurements) if hparams.measurement_type == 'project': y_batch = x_batch + noise_batch else: y_batch = np.matmul(x_batch, A) + noise_batch # Construct estimates using each estimator for model_type in hparams.model_types: estimator = estimators[model_type] x_hat_batch = estimator(A, y_batch, hparams) for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y = y_batch[i] x_hat = x_hat_batch[i] # Save the estimate x_hats_dict[model_type][key] = x_hat # Compute and store measurement and l2 loss measurement_losses[model_type][ key] = utils.get_measurement_loss(x_hat, A, y) l2_losses[model_type][key] = utils.get_l2_loss(x_hat, x) print('Processed upto image {0} / {1}'.format(key + 1, len(xs_dict))) # Checkpointing if (hparams.save_images) and ((key + 1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) x_hats_dict = { model_type: {} for model_type in hparams.model_types } print('\nProcessed and saved first ', key + 1, 'images\n') x_batch_dict = {} # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print('\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict))) if hparams.print_stats: for model_type in hparams.model_types: print(model_type) mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print('mean measurement loss = {0}'.format(mean_m_loss)) print('mean l2 loss = {0}'.format(mean_l2_loss)) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print( '\nDid NOT process last {} images because they did not fill up the last batch.' .format(len(x_batch_dict))) print('Consider rerunning lazily with a smaller batch size.')
def estimator(A_val, y_batch_val, hparams): if A_val is None: A = np.eye(y_batch_val.shape[1]) #TODO remove idle else: A = A_val.T mode = hparams.tv_or_lasso_mode y = utils_lasso.get_y(mode,y_batch_val,A) W = utils_lasso.load_W(hparams, A, y) x_hat_batch = [] if W is None: AW = A else: if W is None or 'tv-norm' in hparams.model_types: AW = None else: AW = A.dot(W) if 'fista' in mode: clf1 = FistaRegressor(penalty='l1') gs = GridSearchCV(clf1, {'alpha': np.logspace(-3, 3, 10)}) gs.fit(AW, y) x_hat_batch = gs.best_estimator_.coef_.dot(W)#.T elif 'cvxpy' in mode: maxit = utils_lasso.get_key('reweight',mode,int) weight = np.array([]) errors = [] for it in range(maxit): if maxit >1: print('Computing reweighting iteration: {}'.format(it+1)) x_hat_batch,weight = utils_lasso.cvxpy_problem(mode,W,A,AW,y,weight) current_error = np.mean(utils.get_l2_loss(np.array(hparams.x),utils_lasso.get_x(mode,x_hat_batch)))#np.mean(np.mean((np.array(hparams.x)-x_hat_batch)**2,axis=1)) errors.append(current_error) print('Current error: {}'.format(current_error)) if maxit>1: errors = np.array(errors) np.save(utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'error_course',errors) elif 'cvxopt' in mode: for i in range(hparams.batch_size): y_val = y_batch_val[i] x_hat = utils_lasso.tv_cvxopt_partial(A_val, y_val,hparams) x_hat_batch.append(x_hat) print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100)) x_hat_batch = np.asarray(x_hat_batch) elif 'sklearn' in mode: for i in range(hparams.batch_size): y_val = y_batch_val[i] x_hat = utils.solve_lasso(A_val, y_val, hparams) x_hat = np.maximum(np.minimum(x_hat, 1), 0) x_hat_batch.append(x_hat) print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100)) x_hat_batch = np.asarray(x_hat_batch) elif 'bestkTermApprox' in mode: for i in range(hparams.batch_size): y_val = y_batch_val[i] x_hat = utils_lasso.check_bestkTermApprox(mode, W, y_val) x_hat = np.maximum(np.minimum(x_hat, 1), 0) x_hat_batch.append(x_hat) print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100)) x_hat_batch = np.asarray(x_hat_batch) elif 'bruteForce' in mode: #slithly redundant to above for i in range(hparams.batch_size): y_val = y_batch_val[i] x_hat = utils_lasso.brute_force(mode, A_val,W,y_val) x_hat = np.maximum(np.minimum(x_hat, 1), 0) x_hat_batch.append(x_hat) print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100)) x_hat_batch = np.asarray(x_hat_batch) else: raise NotImplementedError('Mode {} does not exist!'.format(mode)) return utils_lasso.get_x(mode,x_hat_batch)
def main(hparams): hparams.n_input = np.prod(hparams.image_shape) maxiter = hparams.max_outer_iter utils.print_hparams(hparams) xs_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) x_hats_dict = {'dcgan': {}} x_batch_dict = {} for key, x in xs_dict.iteritems(): x_batch_dict[key] = x if len(x_batch_dict) < hparams.batch_size: continue x_coll = [ x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems() ] x_batch = np.concatenate(x_coll) A_outer = utils.get_outer_A(hparams) # 1bitify y_batch_outer = np.sign(np.matmul(x_batch, A_outer)) x_main_batch = 0.0 * x_batch z_opt_batch = np.random.randn(hparams.batch_size, 100) for k in range(maxiter): x_est_batch = x_main_batch + hparams.outer_learning_rate * ( np.matmul( (y_batch_outer - np.sign(np.matmul(x_main_batch, A_outer))), A_outer.T)) estimator = estimators['dcgan'] x_hat_batch, z_opt_batch = estimator(x_est_batch, z_opt_batch, hparams) x_main_batch = x_hat_batch for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y = y_batch_outer[i] x_hat = x_hat_batch[i] x_hats_dict['dcgan'][key] = x_hat measurement_losses['dcgan'][key] = utils.get_measurement_loss( x_hat, A_outer, y) l2_losses['dcgan'][key] = utils.get_l2_loss(x_hat, x) print 'Processed upto image {0} / {1}'.format(key + 1, len(xs_dict)) if (hparams.save_images) and ((key + 1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved first ', key + 1, 'images\n' x_batch_dict = {} if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict)) if hparams.print_stats: for model_type in hparams.model_types: print model_type mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print 'mean measurement loss = {0}'.format(mean_m_loss) print 'mean l2 loss = {0}'.format(mean_l2_loss) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print '\nDid NOT process last {} images because they did not fill up the last batch.'.format( len(x_batch_dict)) print 'Consider rerunning lazily with a smaller batch size.'
def main(hparams): # if not hparams.use_gpu: # os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # Set up some stuff accoring to hparams hparams.n_input = np.prod(hparams.image_shape) #hparams.stdv = 10 #adjust to HPARAM in model_def.py #hparams.mean = 0 #adjust to HPARAM in model_def.py utils.set_num_measurements(hparams) utils.print_hparams(hparams) hparams.bol = False # hparams.dict_flag = False # get inputs if hparams.input_type == 'dict-input':# or hparams.dict_flag: hparams_load_key = copy.copy(hparams) hparams_load_key.input_type = 'full-input' hparams_load_key.measurement_type = 'project' hparams_load_key.zprior_weight = 0.0 hparams.key_field = np.load(utils.get_checkpoint_dir(hparams_load_key, hparams.model_types[0])+'candidates.npy').item() print(hparams.measurement_type) xs_dict, label_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) sh = utils.SaveHandler() sh.load_or_init_all(hparams.save_images,hparams.model_types,sh.get_pkl_filepaths(hparams,use_all=True)) if label_dict is None: print('No labels exist.') del sh.class_loss # measurement_losses, l2_losses, emd_losses, x_orig, x_rec, noise_batch = utils.load_checkpoints(hparams) if hparams.input_type == 'gen-span': np.save(utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'z.npy',hparams.z_from_gen) np.save(utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'images.npy',hparams.images_mat) x_hats_dict = {model_type : {} for model_type in hparams.model_types} x_batch_dict = {} x_batch=[] x_hat_batch=[] # l2_losses2=np.zeros((len(xs_dict),1)) # distances_arr=[] image_distance =np.zeros((len(xs_dict),1)) hparams.x = [] # TO REMOVE for key, x in xs_dict.iteritems(): #//each batch once (x_batch_dict emptied at end) if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([os.path.isfile(save_path) for save_path in save_paths.values()]) if is_saved: continue x_batch_dict[key] = x hparams.x.append(x)#To REMOVE if len(x_batch_dict) < hparams.batch_size: continue # Reshape input x_batch_list = [x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems()] x_batch = np.concatenate(x_batch_list) # x_batch, known_distortion, distances = get_random_distortion(x_batch) # distances_arr[(key-1)*hparams.batch_size:key*hparams.batch_size] = distances # xs_dict[(key-1)*hparams.batch_size:key*hparams.batch_size] =x_batch # Construct noise and measurements recovered, optim = utils.load_if_optimized(hparams) if recovered and np.linalg.norm(optim.x_orig-x_batch) < 1e-10: hparams.optim = optim hparams.recovered = True else: hparams.recovered=False optim.x_orig = x_batch hparams.optim = optim A, noise_batch, y_batch, c_val = utils.load_meas(hparams,sh,x_batch,xs_dict) hparams.optim.noise_batch = noise_batch if c_val: continue if hparams.measurement_type == 'sample_distribution': plot_distribution(hparams,x_batch) # for i in range(z.shape[1]):#range(1): # plt.hist(z[i,:], facecolor='blue', alpha=0.5) # directory_distr = # pl.savefig("abc.png") elif hparams.measurement_type == 'autoencoder': plot_reconstruction(hparams,x_batch) else: # Construct estimates using each estimator for model_type in hparams.model_types: estimator = estimators[model_type] start = time.time() tmp = estimator(A, y_batch, hparams) if isinstance(tmp,tuple): x_hat_batch = tmp[0] sh.z_rec = tmp[1] else: x_hat_batch = tmp del sh.z_rec end = time.time() duration = end-start print('The calculation needed {} time'.format(datetime.timedelta(seconds=duration))) np.save(utils.get_checkpoint_dir(hparams, model_type)+'elapsed_time',duration) # DEBUGGING = [] for i, key in enumerate(x_batch_dict.keys()): # x = xs_dict[key]+known_distortion[i] x = xs_dict[key] y = y_batch[i] x_hat = x_hat_batch[i] # plt.figure() # plt.imshow(np.reshape(x_hat, [64, 64, 3])*255)#, interpolation="nearest", cmap=plt.cm.gray) # plt.show() # Save the estimate x_hats_dict[model_type][key] = x_hat # Compute and store measurement and l2 loss sh.measurement_losses[model_type][key] = utils.get_measurement_loss(x_hat, A, y) # DEBUGGING.append(np.sum((x_hat.dot(A)-y)**2)/A.shape[1]) sh.l2_losses[model_type][key] = utils.get_l2_loss(x_hat, x) if hparams.class_bol and label_dict is not None: try: sh.class_losses[model_type][key] = utils.get_classifier_loss(hparams,x_hat,label_dict[key]) except: sh.class_losses[model_type][key] = NaN warnings.warn('Class loss unsuccessfull, most likely due to corrupted memory. Simply retry.') if hparams.emd_bol: try: _,sh.emd_losses[model_type][key] = utils.get_emd_loss(x_hat, x) if 'nonneg' not in hparams.tv_or_lasso_mode and 'pca' in model_type: warnings.warn('EMD requires nonnegative images, for safety insert nonneg into tv_or_lasso_mode') except ValueError: warnings.warn('EMD calculation unsuccesfull (most likely due to negative images)') pass # if l2_losses[model_type][key]-measurement_losses[model_type][key]!=0: # print('NO') # print(y) # print(x) # print(np.mean((x-y)**2)) image_distance[i] = np.linalg.norm(x_hat-x) # l2_losses2[key] = np.mean((x_hat-x)**2) # print('holla') # print(l2_losses2[key]) # print(np.linalg.norm(x_hat-x)**2/len(xs_dict[0])) # print(np.linalg.norm(x_hat-x)/len(xs_dict[0])) # print(np.linalg.norm(x_hat-x)) print('Processed upto image {0} / {1}'.format(key+1, len(xs_dict))) sh.x_orig = x_batch sh.x_rec = x_hat_batch sh.noise = noise_batch #ACTIVATE ON DEMAND #plot_bad_reconstruction(measurement_losses,x_batch) # Checkpointing if (hparams.save_images) and ((key+1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, save_image, sh, hparams) x_hats_dict = {model_type : {} for model_type in hparams.model_types} print('\nProcessed and saved first ', key+1, 'images\n') x_batch_dict = {} if 'wavelet' in hparams.model_types[0]: print np.abs(sh.x_rec) print('The average sparsity is {}'.format(np.sum(np.abs(sh.x_rec)>=0.0001)/float(hparams.batch_size))) # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, save_image, sh, hparams) print('\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict))) if hparams.dataset in ['mnist', 'fashion-mnist']: if np.array(x_batch).size: utilsM.save_images(np.reshape(x_batch, [-1, 28, 28]), [8, 8],utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'original.png') if np.array(x_hat_batch).size: utilsM.save_images(np.reshape(x_hat_batch, [-1, 28, 28]), [8, 8],utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'reconstruction.png') for model_type in hparams.model_types: # print(model_type) mean_m_loss = np.mean(sh.measurement_losses[model_type].values()) mean_l2_loss = np.mean(sh.l2_losses[model_type].values()) #\|XHUT-X\|**2/784/64 if hparams.emd_bol: mean_emd_loss = np.mean(sh.emd_losses[model_type].values()) if label_dict is not None: mean_class_loss = np.mean(sh.class_losses[model_type].values()) print('mean class loss = {0}'.format(mean_class_loss)) # print(image_distance) mean_norm_loss = np.mean(image_distance)#sum_i(\|xhut_i-x_i\|)/64 # mean_rep_error = np.mean(distances_arr) # mean_opt_meas_error_pixel = np.mean(np.array(l2_losses[model_type].values())-np.array(distances_arr)/xs_dict[0].shape) # mean_opt_meas_error = np.mean(image_distance-distances_arr) print('mean measurement loss = {0}'.format(mean_m_loss)) # print np.sum(np.asarray(DEBUGGING))/64 print('mean l2 loss = {0}'.format(mean_l2_loss)) if hparams.emd_bol: print('mean emd loss = {0}'.format(mean_emd_loss)) print('mean distance = {0}'.format(mean_norm_loss)) print('mean distance pixelwise = {0}'.format(mean_norm_loss/len(xs_dict[xs_dict.keys()[0]]))) # print('mean representation error = {0}'.format(mean_rep_error)) # print('mean optimization plus measurement error = {0}'.format(mean_opt_meas_error)) # print('mean optimization plus measurement error per pixel = {0}'.format(mean_opt_meas_error_pixel)) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print('\nDid NOT process last {} images because they did not fill up the last batch.'.format(len(x_batch_dict))) print('Consider rerunning lazily with a smaller batch size.')
def main(hparams): hparams.n_input = np.prod(hparams.image_shape) images = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) est_images = {model_type: {} for model_type in hparams.model_types} for i, image in images.iteritems(): if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, i) if all([ os.path.isfile(save_path) for save_path in save_paths.values() ]): continue # Reshape input x_val = image.reshape(1, hparams.n_input) # Construct noise and measurements noise_val = hparams.noise_std * np.random.randn( 1, hparams.num_measurements) A_val = np.random.randn(hparams.n_input, hparams.num_measurements) y_val = np.matmul(x_val, A_val) + noise_val # Construct estimates using each estimator print 'Processing image {0}'.format(i) for model_type in hparams.model_types: estimator = estimators[model_type] est_image = estimator(A_val, y_val, hparams) est_images[model_type][i] = est_image # Compute and store measurement and l2 loss measurement_losses[model_type][i] = utils.get_measurement_loss( est_image, A_val, y_val) l2_losses[model_type][i] = utils.get_l2_loss(est_image, image) # Checkpointing if (hparams.save_images) and ((i + 1) % 100 == 0): utils.checkpoint(est_images, measurement_losses, l2_losses, save_image, hparams) est_images = {model_type: {} for model_type in hparams.model_types} print '\nProcessed and saved first ', i + 1, 'images\n' # Final checkpoint if hparams.save_images: utils.checkpoint(est_images, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved all {0} images\n'.format(len(images)) if hparams.print_stats: for model_type in hparams.model_types: print model_type mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print 'mean measurement loss = {0}'.format(mean_m_loss) print 'mean l2 loss = {0}'.format(mean_l2_loss) if hparams.image_matrix > 0: utils.image_matrix(images, est_images, view_image, hparams)
def main(hparams): # Set up some stuff accoring to hparams hparams.n_input = np.prod(hparams.image_shape) utils.set_num_measurements(hparams) utils.print_hparams(hparams) if hparams.dataset == 'mnist': hparams.n_z = latent_dim elif hparams.dataset == 'celebA': hparams.z_dim = latent_dim # get inputs xs_dict = model_input(hparams) estimators = utils.get_estimators(hparams) utils.setup_checkpointing(hparams) measurement_losses, l2_losses = utils.load_checkpoints(hparams) image_loss_mnist = [] meas_loss_mnist = [] x_hat_mnist = [] x_hats_dict = {model_type : {} for model_type in hparams.model_types} x_batch_dict = {} for key, x in xs_dict.iteritems(): if not hparams.not_lazy: # If lazy, first check if the image has already been # saved before by *all* estimators. If yes, then skip this image. save_paths = utils.get_save_paths(hparams, key) is_saved = all([os.path.isfile(save_path) for save_path in save_paths.values()]) if is_saved: continue x_batch_dict[key] = x if len(x_batch_dict) < hparams.batch_size: continue # Reshape input x_batch_list = [x.reshape(1, hparams.n_input) for _, x in x_batch_dict.iteritems()] x_batch = np.concatenate(x_batch_list) # Construct noise and measurements A = utils.get_A(hparams) noise_batch = hparams.noise_std * np.random.randn(hparams.batch_size, hparams.num_measurements) if hparams.measurement_type == 'project': y_batch = x_batch + noise_batch else: measure = np.matmul(x_batch, A) y_batch = np.absolute(measure) + noise_batch # Construct estimates using each estimator for model_type in hparams.model_types: x_main_batch = 10000*np.ones_like(x_batch) for k in range(num_restarts): print "Restart #", str(k+1) # Solve deep pr problem with random initial iterate init_iter = np.random.randn(hparams.batch_size, latent_dim) # First gradient descent z_opt_batch = init_iter estimator = estimators[model_type] items = estimator(A, y_batch, z_opt_batch, hparams) x_hat_batch1 = items[0] z_opt_batch1 = items[1] losses_val1 = items[2] x_hat_batch = x_hat_batch1 x_hat_batch = utils.resolve_ambiguity(x_hat_batch, x_batch, hparams.batch_size) # Use reflection of initial iterate z_opt_batch2 = -1*init_iter items = estimator(A, y_batch, z_opt_batch2, hparams) x_hat_batch2 = items[0] z_opt_batch2 = items[1] losses_val2 = items[2] x_hat_batch2 = utils.resolve_ambiguity(x_hat_batch2, x_batch, hparams.batch_size) x_hat_batchnew = utils.get_optimal_x_batch(x_hat_batch, x_hat_batch2, x_batch, hparams.batch_size) x_main_batch = utils.get_optimal_x_batch(x_hat_batchnew, x_main_batch, x_batch, hparams.batch_size) x_hat_batch = x_main_batch if hparams.dataset == 'mnist': utils.print_stats(x_hat_batch, x_batch, hparams.batch_size) for i, key in enumerate(x_batch_dict.keys()): x = xs_dict[key] y = y_batch[i] x_hat = x_hat_batch[i] # Save the estimate x_hats_dict[model_type][key] = x_hat # Compute and store measurement and l2 loss measurement_losses[model_type][key] = utils.get_measurement_loss(x_hat, A, y) meas_loss_mnist.append(utils.get_measurement_loss(x_hat, A, y)) l2_losses[model_type][key] = utils.get_l2_loss(x_hat, x) image_loss_mnist.append(utils.get_l2_loss(x_hat,x)) print 'Processed upto image {0} / {1}'.format(key+1, len(xs_dict)) # Checkpointing if (hparams.save_images) and ((key+1) % hparams.checkpoint_iter == 0): utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) x_hats_dict = {model_type : {} for model_type in hparams.model_types} print '\nProcessed and saved first ', key+1, 'images\n' x_batch_dict = {} # Final checkpoint if hparams.save_images: utils.checkpoint(x_hats_dict, measurement_losses, l2_losses, save_image, hparams) print '\nProcessed and saved all {0} image(s)\n'.format(len(xs_dict)) if hparams.print_stats: for model_type in hparams.model_types: mean_m_loss = np.mean(measurement_losses[model_type].values()) mean_l2_loss = np.mean(l2_losses[model_type].values()) print 'mean measurement loss = {0}'.format(mean_m_loss) print 'mean l2 loss = {0}'.format(mean_l2_loss) if hparams.image_matrix > 0: utils.image_matrix(xs_dict, x_hats_dict, view_image, hparams) # Warn the user that some things were not processsed if len(x_batch_dict) > 0: print '\nDid NOT process last {} images because they did not fill up the last batch.'.format(len(x_batch_dict)) print 'Consider rerunning lazily with a smaller batch size.'