Esempio n. 1
0
 def generate_diversity_samples(self, sess, filename, X_corrupted, X_true, horz_samples=10, vert_samples=10):
     from data.dataset import noise
     print('Generating samples for', filename)
     predictions = [X_true[:vert_samples,:,:,:].reshape(1, vert_samples, self.height, self.width), X_corrupted[:vert_samples,:,:,:].reshape(1, vert_samples, self.height, self.width)]
     X_corrupted = np.repeat(X_corrupted[:vert_samples,:,:,:], horz_samples, axis=0)
     X_true = np.repeat(X_true[:vert_samples,:,:,:], horz_samples, axis=0)
     
     start = time.perf_counter()
     for i in range(self.test_iterations // 2 if filename == 'denoise' else self.test_iterations):
         X_corrupted = self.update_clamp(X_corrupted, sess.run(self.predictions, feed_dict={self.X_in:X_corrupted}), filename)
         if self.markov_type == 'renoise_per_two':
             X_corrupted = self.update_clamp(X_corrupted, sess.run(self.predictions, feed_dict={self.X_in:X_corrupted}), filename)
         if self.markov_type != 'only_denoise':
             if filename == 'denoise':
                 noise_prop = ((self.test_iterations//2 - i - 1) / self.test_iterations)
             else:
                 noise_prop = (self.test_iterations - i - 1) / self.test_iterations
             X_corrupted = self.update_clamp(X_corrupted, np.array([noise(arr, noise_prop, noise_prop)[0] for arr in X_corrupted]), filename)
     print(time.perf_counter() - start)
     
     
     predictions.append(X_corrupted.reshape(vert_samples, horz_samples, self.height, self.width).transpose(1,0,2,3))
     images = np.concatenate(tuple(predictions), axis=0)
     images = images.transpose(1, 2, 0, 3)
     images = images.reshape((self.height * vert_samples, self.width * (horz_samples + 2)))
     
     filename = datetime.now().strftime('samples/%Y_%m_%d_%H_%M_noncausal_diversity_' + filename)+".png"
     Image.fromarray((images*255).astype(np.int32)).convert('RGB').save(filename)
Esempio n. 2
0
 def generate_one_group_of_samples(self, sess, filename, X_corrupted, X_true=None, horz_samples=10):
     from data.dataset import noise
     print('Generating samples for', filename)
     X_corrupted = X_corrupted[:horz_samples,:,:,:]
     predictions = [X_true[:horz_samples,:,:,:]] if X_true is not None else []
     predictions.append(X_corrupted)
     
     start = time.perf_counter()
     for i in range(self.test_iterations // 2 if filename == 'denoise' else self.test_iterations):
         X_corrupted = self.update_clamp(X_corrupted, sess.run(self.predictions, feed_dict={self.X_in:X_corrupted}), filename)
         if self.markov_type == 'renoise_per_two':
             X_corrupted = self.update_clamp(X_corrupted, sess.run(self.predictions, feed_dict={self.X_in:X_corrupted}), filename)
         predictions.append(X_corrupted)
         if self.markov_type != 'only_denoise':
             if filename == 'denoise':
                 noise_prop = ((self.test_iterations//2 - i - 1) / self.test_iterations)
             else:
                 noise_prop = (self.test_iterations - i - 1) / self.test_iterations
             X_corrupted = self.update_clamp(X_corrupted, np.array([noise(arr, noise_prop, noise_prop)[0] for arr in X_corrupted]), filename)
     print(time.perf_counter() - start)
     
     predictions = tuple(p.reshape((horz_samples, 1, self.height, self.width)) for p in predictions)
     images = np.concatenate(predictions, axis=1)
     images = images.transpose(1, 2, 0, 3)
     images = images.reshape((self.height * ((self.test_iterations//2 if filename == 'denoise' else self.test_iterations) + 1 + (1 if X_true is not None else 0)), self.width * horz_samples))
     
     filename = datetime.now().strftime('samples/%Y_%m_%d_%H_%M_noncausal_' + filename)+".png"
     Image.fromarray((images*255).astype(np.int32)).convert('RGB').save(filename)
Esempio n. 3
0
 def generate_ten_thousand_samples(self, sess):
     if self.denoising:
         from data.dataset import noise
         print('Generating 10000 samples for denoising')
         start = time.perf_counter()
         samples = []
         test_data = self.data.get_noise_values()
         for j in range(self.data.total_test_batches):
             print('batch', j)
             X_corrupted = sess.run(test_data)
             for i in range(self.test_iterations):
                 X_corrupted = sess.run(self.predictions,
                                        feed_dict={self.X_in: X_corrupted})
                 if self.markov_type == 'renoise_per_two':
                     X_corrupted = sess.run(
                         self.predictions,
                         feed_dict={self.X_in: X_corrupted})
                 if self.markov_type != 'only_denoise':
                     noise_prop = (self.test_iterations - i -
                                   1) / self.test_iterations
                     X_corrupted = np.array([
                         noise(arr, noise_prop, noise_prop)[0]
                         for arr in X_corrupted
                     ])
             samples.append(X_corrupted)
         samples = np.concatenate(samples)
         print(time.perf_counter() - start)
         return samples
     else:
         print('Generating 10000 samples for pixelcnn')
         start = time.perf_counter()
         sampless = []
         for _ in range(10000 // 100):
             samples = np.zeros(
                 (100, self.height, self.width, self.channels),
                 dtype=np.float32)
             for i in range(self.height):
                 for j in range(self.width):
                     #print(i,j)
                     predictions = sess.run(self.predictions,
                                            feed_dict={self.X_in: samples})
                     samples[:, i, j, :] = predictions[:, i, j, :]
             sampless.append(samples)
         samples = np.concatenate(sampless)
         print(time.perf_counter() - start)
         return samples
Esempio n. 4
0
 def generate_ten_thousand_samples(self, sess):
     from data.dataset import noise
     print('Generating 10000 samples for noncausal')
     start = time.perf_counter()
     samples = []
     test_data = self.data.get_noise_values()
     for j in range(self.data.total_test_batches):
         print('batch', j)
         X_corrupted = sess.run(test_data)
         for i in range(self.test_iterations):
             X_corrupted = sess.run(self.predictions, feed_dict={self.X_in:X_corrupted})
             if self.markov_type == 'renoise_per_two':
                 X_corrupted = sess.run(self.predictions, feed_dict={self.X_in:X_corrupted})
             if self.markov_type != 'only_denoise':
                 noise_prop = (self.test_iterations - i - 1) / self.test_iterations
                 X_corrupted = np.array([noise(arr, noise_prop, noise_prop)[0] for arr in X_corrupted])
         samples.append(X_corrupted)
     samples = np.concatenate(samples)
     print(time.perf_counter() - start)
     return samples
Esempio n. 5
0
    def generate_grid_of_samples(self, sess, X_corrupted):
        from data.dataset import noise
        print('Generating samples for grid')
        horz_samples = 10
        vert_samples = 10
        X_corrupted = X_corrupted[:horz_samples*vert_samples,:,:,:]

        start = time.perf_counter()
        for i in range(self.test_iterations):
            X_corrupted = sess.run(self.predictions, feed_dict={self.X_in:X_corrupted})
            if self.markov_type == 'renoise_per_two':
                X_corrupted = sess.run(self.predictions, feed_dict={self.X_in:X_corrupted})
            if self.markov_type != 'only_denoise':
                noise_prop = (self.test_iterations - i - 1) / self.test_iterations
                X_corrupted = np.array([noise(arr, noise_prop, noise_prop)[0] for arr in X_corrupted])
        print(time.perf_counter() - start)

        images = X_corrupted.reshape((vert_samples, horz_samples, self.height, self.width))
        images = images.transpose(0, 2, 1, 3)
        images = images.reshape((self.height * vert_samples, self.width * horz_samples))

        filename = datetime.now().strftime('samples/%Y_%m_%d_%H_%M_noncausal_grid')+".png"
        Image.fromarray((images*255).astype(np.int32)).convert('RGB').save(filename)