def __init__(self, square_model): """Setup the square, including position.""" pygame.sprite.Sprite.__init__(self) self.square_model = square_model self.image = load_image('normal_square.png') self.rect = self.image.get_rect() (x, y, z) = square_model.xyz # I'm inverting the y to match model.Game.__repr__. self.rect.bottom = (SCREEN_HEIGHT - (BOARD_OFFSET_BOTTOM + z * Z_OFFSET_BOTTOM + invert(y) * Y_OFFSET_BOTTOM)) self.rect.left = (BOARD_OFFSET_LEFT + invert(y) * Y_OFFSET_LEFT + x * X_OFFSET_LEFT) dispatcher.connect(self.handle_board_changed, 'BOARD CHANGED')
def error_per_sample(identifier, epoch, samples, n_rep=3, n_iter=None, g_tolerance=0.025, use_min=True, C_samples=None): """ Get (average over a few runs) of the reconstruction error per sample """ n_samples = samples.shape[0] heuristic_sigma = np.float32(mmd.median_pairwise_distance(samples)) errors = np.zeros(shape=(n_samples, n_rep)) for rep in range(n_rep): Z, rep_errors, sigma = model.invert(identifier, epoch, samples, n_iter=n_iter, heuristic_sigma=heuristic_sigma, g_tolerance=g_tolerance, C_samples=C_samples) errors[:, rep] = rep_errors # return min, or average? if use_min: errors = np.min(errors, axis=1) else: # use mean errors = np.mean(errors, axis=1) return errors
def view_interpolation(identifier, epoch, n_steps=6, input_samples=None, e_tolerance=0.01, sigma=3.29286853021): """ If samples: generate interpolation between real points Else: Sample two points in the latent space, view a linear interpolation between them. """ settings = json.load(open('./experiments/settings/' + identifier + '.txt', 'r')) if input_samples is None: # grab two trainng examples data = np.load('./experiments/data/' + identifier + '.data.npy').item() train = data['samples']['train'] input_samples = np.random.permutation(train)[:2] # Z_sampleA, Z_sampleB = model.sample_Z(2, settings['seq_length'], settings['latent_dim'], # settings['use_time']) if sigma is None: ## gotta get a sigma somehow sigma = mmd.median_pairwise_distance(train) print('Calcualted heuristic sigma from training data:', sigma) Zs, error, _ = model.invert(settings, epoch, input_samples, e_tolerance=e_tolerance) Z_sampleA, Z_sampleB = Zs Z_samples = plotting.interpolate(Z_sampleA, Z_sampleB, n_steps=n_steps) samples = model.sample_trained_model(settings, epoch, Z_samples.shape[0], Z_samples) # get distances from generated samples to target samples d_A, d_B = [], [] for sample in samples: d_A.append(sample_distance(sample, samples[0], sigma)) d_B.append(sample_distance(sample, samples[-1], sigma)) distances = pd.DataFrame({'dA': d_A, 'dB': d_B}) plotting.save_plot_interpolate(input_samples, samples, epoch, settings['identifier'] + '_epoch' + str(epoch), distances=distances, sigma=sigma) return True
def view_reconstruction(identifier, epoch, real_samples, tolerance=1): """ Given a set of real samples, find the "closest" latent space points corresponding to them, generate samples from these, visualise! """ settings = json.load(open('./experiments/settings/' + identifier + '.txt', 'r')) Zs, error, sigma = model.invert(settings, epoch, real_samples, tolerance=tolerance) plotting.visualise_latent(Zs[0], identifier+'_' + str(epoch) + '_0') plotting.visualise_latent(Zs[1], identifier+'_' + str(epoch) + '_1') model_samples = model.sample_trained_model(settings, epoch, Zs.shape[0], Zs) plotting.save_plot_reconstruct(real_samples, model_samples, settings['identifier']) return True