def _get_blurred_dataset(self): if FLAGS.blur != 0: current_sigma = self._get_blur_sigma() if current_sigma != self._last_blur: self._last_blur = current_sigma self._blurred_dataset = inp.apply_gaussian(self.dataset, sigma=current_sigma) return self._blurred_dataset if self._blurred_dataset is not None else self.dataset
def _get_blurred_dataset(self): if FLAGS.blur_sigma != 0: current_sigma = self._get_blur_sigma() if current_sigma != self._last_blur_sigma: print('sigmas current:%f last:%f' % (current_sigma, self._last_blur_sigma)) self._last_blur_sigma = current_sigma self._blurred_dataset = inp.apply_gaussian(self.dataset, sigma=current_sigma) return self._blurred_dataset if self._blurred_dataset is not None else self.dataset
def _get_blurred_dataset(self): if FLAGS.blur != 0: current_sigma = self._get_blur_sigma() if current_sigma != self._last_blur: # print(self._last_blur, current_sigma) self._last_blur = current_sigma self._blurred_dataset = inp.apply_gaussian(self.train_set, sigma=current_sigma) ut.print_info('blur s:%.1f[%.1f>%.1f]' % (current_sigma, self.train_set[2, 10, 10, 0], self._blurred_dataset[2, 10, 10, 0])) return self._blurred_dataset if self._blurred_dataset is not None else self.train_set return self.train_set
def evaluate(self, sess, take): encoded, reconstructed = None, None blurred = inp.apply_gaussian(self.test_set, self._get_blur_sigma()) for i in range(int(len(self.test_set)/FLAGS.batch_size)): batch = blurred[i*FLAGS.batch_size: (i+1)*FLAGS.batch_size] encoding, reconstruction = sess.run( [self._encode, self._decode], feed_dict={self._input: batch}) encoded = self._concatenate(encoded, encoding) reconstructed = self._concatenate(reconstructed, reconstruction, take=take) # reconstructed = self._restore_distribution(reconstructed) # blurred = self._restore_distribution(blurred[:take]) return encoded, reconstructed, blurred
def evaluate(self, sess, take): digest = Bunch(encoded=None, reconstructed=None, source=None, loss=.0, eval_loss=.0, dumb_loss=.0) blurred = inp.apply_gaussian(self.test_set, self._get_blur_sigma()) # Encode for i, batch in enumerate(self._batch_generator(blurred, shuffle=False)): encoding = self.encode.eval(feed_dict={self.input: batch[0]}) digest.encoded = ut.concatenate(digest.encoded, encoding) # Save encoding for visualization encoded_no_nan = np.nan_to_num(digest.encoded) self.embedding_assign.eval( feed_dict={self.embedding_test_ph: encoded_no_nan}) try: self.embedding_saver.save(sess, self.get_checkpoint_path() + EMB_SUFFIX) except: ut.print_info("Unexpected error: %s" % str(sys.exc_info()[0]), color=33) # Calculate expected evaluation expected = digest.encoded[1:-1] * 2 - digest.encoded[:-2] average = 0.5 * (digest.encoded[1:-1] + digest.encoded[:-2]) digest.size = len(expected) # evaluation summaries self.summary_writer.add_summary(self.eval_summs.eval( feed_dict={self.blur_ph: self._get_blur_sigma()}), global_step=self.get_past_epochs()) # evaluation losses for p in self._batch_permutation_generator(digest.size, shuffle=False): digest.loss += self.eval_loss.eval( feed_dict={ self.encoding: digest.encoded[p + 2], self.target: blurred[p + 2] }) digest.eval_loss += self.eval_loss.eval(feed_dict={ self.encoding: expected[p], self.target: blurred[p + 2] }) digest.dumb_loss += self.loss_ae.eval(feed_dict={ self.input: blurred[p], self.target: blurred[p + 2] }) # for batch in self._batch_generator(blurred, batches=1): # digest.source = batch[1][:take] # digest.reconstructed = self.decode.eval(feed_dict={self.input: batch[0]})[:take] # Reconstruction visualizations for p in self._batch_permutation_generator(digest.size, shuffle=True, batches=1): self.visualization_batch_perm = self.visualization_batch_perm if self.visualization_batch_perm is not None else p p = self.visualization_batch_perm digest.source = self.eval_decode.eval( feed_dict={self.encoding: expected[p]})[:take] digest.source = blurred[(p + 2)[:take]] digest.reconstructed = self.eval_decode.eval( feed_dict={self.encoding: average[p]})[:take] self._eval_image_summaries(blurred[p], digest.encoded[p], average[p], expected[p]) digest.dumb_loss = guard_nan(digest.dumb_loss) digest.eval_loss = guard_nan(digest.eval_loss) digest.loss = guard_nan(digest.loss) return digest
def train(self): self.fetch_datasets() if FLAGS.model == AUTOENCODER: self.build_ae_model() elif FLAGS.model == PREDICTIVE: self.build_predictive_model() else: self.build_denoising_model() self._init_optimizer() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) self._on_training_start(sess) try: for current_epoch in range(FLAGS.max_epochs): start = time.time() full_set_blur = len(self.train_set) < 50000 ds = self._get_blurred_dataset( ) if full_set_blur else self.train_set if FLAGS.model == AUTOENCODER: # Autoencoder Training for batch in self._batch_generator(): summs, encoding, reconstruction, loss, _, step = sess.run( [ self.summs_train, self.encode, self.decode, self.loss_ae, self.train_ae, self.step ], feed_dict={ self.input: batch[0], self.target: batch[1] }) self._on_batch_finish(summs, loss, batch, encoding, reconstruction) else: # Predictive and Denoising training for batch_indexes in self._batch_permutation_generator( len(ds) - 2): batch = np.stack( (ds[batch_indexes], ds[batch_indexes + 1], ds[batch_indexes + 2])) if not full_set_blur: batch = np.stack( (inp.apply_gaussian( ds[batch_indexes], sigma=self._get_blur_sigma()), inp.apply_gaussian( ds[batch_indexes + 1], sigma=self._get_blur_sigma()), inp.apply_gaussian( ds[batch_indexes + 2], sigma=self._get_blur_sigma()))) summs, loss, _ = sess.run([ self.summs_train, self.loss_total, self._train ], feed_dict={ self.inputs: batch, self.targets: batch }) self._on_batch_finish(summs, loss) self._on_epoch_finish(current_epoch, start, sess) self._on_training_finish(sess) except KeyboardInterrupt: self._on_training_abort(sess)