def train(model, output_dir, train_feed, test_feed, lr_start=0.01, lr_stop=0.00001, lr_gamma=0.75, n_epochs=150, gan_margin=0.35): n_hidden = model.latent_encoder.n_out # For plotting original_x = np.array(test_feed.batches().next()[0]) samples_z = np.random.normal(size=(len(original_x), n_hidden)) samples_z = (samples_z).astype(dp.float_) recon_video = Video(os.path.join(output_dir, 'convergence_recon.mp4')) sample_video = Video(os.path.join(output_dir, 'convergence_samples.mp4')) original_x_ = original_x original_x_ = img_inverse_transform(original_x) sp.misc.imsave(os.path.join(output_dir, 'examples.png'), dp.misc.img_tile(original_x_)) # Train network learn_rule = dp.RMSProp() annealer = dp.GammaAnnealer(lr_start, lr_stop, n_epochs, gamma=lr_gamma) trainer = aegan.GradientDescent(model, train_feed, learn_rule, margin=gan_margin) try: for e in range(n_epochs): model.phase = 'train' model.setup(*train_feed.shapes) learn_rule.learn_rate = annealer.value(e) / train_feed.batch_size trainer.train_epoch() model.phase = 'test' original_z = model.encode(original_x) recon_x = model.decode(original_z) samples_x = model.decode(samples_z) recon_x = img_inverse_transform(recon_x) samples_x = img_inverse_transform(samples_x) recon_video.append(dp.misc.img_tile(recon_x)) sample_video.append(dp.misc.img_tile(samples_x)) except KeyboardInterrupt: pass model.phase = 'test' n_examples = 100 test_feed.reset() original_x = np.array(test_feed.batches().next()[0])[:n_examples] samples_z = np.random.normal(size=(n_examples, n_hidden)) output.samples(model, samples_z, output_dir, img_inverse_transform) output.reconstructions(model, original_x, output_dir, img_inverse_transform) original_z = model.encode(original_x) output.walk(model, original_z, output_dir, img_inverse_transform) return model
def run(self, epochs, training_frames, testing_frames): for epoch in range(1, epochs + 1): print "Epoch %d:" % epoch learn_rate = 0.0001 * 1 / float(epoch) self.trainer = dp.StochasticGradientDescent( max_epochs=1, learn_rule=dp.RMSProp(learn_rate=learn_rate, decay=0.9, max_scaling=1e3), ) if training_frames > 0: # play number of frames with training and epsilon annealing print " Training for %d frames" % training_frames training_scores = self.play_games(training_frames, epoch, train=True) if testing_frames > 0: # play number of frames without training and without epsilon annealing print " Testing for %d frames" % testing_frames self.test_game_scores.append( self.play_games(testing_frames, epoch, train=False, epsilon=self.test_epsilon)) # Pick random states to calculate Q-values for if self.random_states is None and self.memory.count > self.nr_random_states: print " Picking %d random states for Q-values" % self.nr_random_states self.random_states = self.memory.get_minibatch( self.nr_random_states)[0] # Do not calculate Q-values when memory is empty if self.random_states is not None: # calculate Q-values qvalues = self.nnet.predict(self.random_states) assert qvalues.shape[0] == self.nr_random_states assert qvalues.shape[1] == self.number_of_actions max_qvalues = np.max(qvalues, axis=1) assert max_qvalues.shape[0] == self.nr_random_states assert len(max_qvalues.shape) == 1 avg_qvalue = np.mean(max_qvalues) else: avg_qvalue = 0
def train_network(model, x_train, n_epochs=1000, learn_rate=0.2, batch_size=64, seq_size=50, epoch_size=100): recurrent_nodes, fc_out = model n_classes = fc_out.n_out recurrent_graph = RecurrentGraph( recurrent_nodes=recurrent_nodes, seq_size=seq_size, batch_size=batch_size, cyclic=True, dropout=0.5 ) net = dp.NeuralNetwork( layers=[ OneHot(n_classes=n_classes), Reshape((seq_size, batch_size, -1)), recurrent_graph, Reshape((seq_size*batch_size, -1)), fc_out, ], loss=dp.SoftmaxCrossEntropy(), ) net.phase = 'train' # Prepare network inputs train_input = SupervisedSequenceInput( x_train, seq_size=seq_size, batch_size=batch_size, epoch_size=epoch_size ) # Train network try: trainer = dp.StochasticGradientDescent( max_epochs=n_epochs, min_epochs=n_epochs, learn_rule=dp.RMSProp(learn_rate=learn_rate), ) test_error = None trainer.train(net, train_input, test_error) except KeyboardInterrupt: pass return recurrent_nodes, fc_out
dp.Affine( n_out=1024, weights=dp.Parameter(dp.AutoFiller(w_gain), weight_decay=w_decay), ), dp.ReLU(), dp.Affine( n_out=2, weights=dp.Parameter(dp.AutoFiller(w_gain)), ), ], loss=dp.ContrastiveLoss(margin=1.0), ) # Train network learn_rate = 0.01 / batch_size learn_rule = dp.RMSProp(learn_rate) trainer = dp.GradientDescent(net, train_feed, learn_rule) trainer.train_epochs(n_epochs=15) # Plot 2D embedding test_feed = dp.Feed(x_test) x_test = np.reshape(x_test, (-1, ) + dataset.img_shape) embedding = net.embed(test_feed) embedding -= np.min(embedding, 0) embedding /= np.max(embedding, 0) plt.figure() ax = plt.subplot(111) shown_images = np.array([[1., 1.]]) for i in range(embedding.shape[0]): dist = np.sum((embedding[i] - shown_images)**2, 1)
n_out=1024, weights=dp.Parameter(dp.AutoFiller(w_gain), weight_decay=w_decay), ), dp.ReLU(), dp.Affine( n_out=2, weights=dp.Parameter(dp.AutoFiller(w_gain)), ), ], loss=dp.ContrastiveLoss(margin=1.0), ) # Train network trainer = dp.GradientDescent( max_epochs=15, learn_rule=dp.RMSProp(learn_rate=0.01), ) trainer.train(net, train_input) # Plot 2D embedding test_input = dp.Input(x_test) x_test = np.reshape(x_test, (-1, ) + dataset.img_shape) embedding = net.embed(test_input) embedding -= np.min(embedding, 0) embedding /= np.max(embedding, 0) plt.figure() ax = plt.subplot(111) shown_images = np.array([[1., 1.]]) for i in range(embedding.shape[0]): dist = np.sum((embedding[i] - shown_images)**2, 1)
def run(): # Prepare MNIST data dataset = dp.datasets.MNIST() x, y = dataset.data(flat=True) x = x.astype(dp.float_) y = y.astype(dp.int_) train_idx, test_idx = dataset.split() x_train = x[train_idx] y_train = y[train_idx] x_test = x[test_idx] y_test = y[test_idx] scaler = dp.UniformScaler(high=255.) x_train = scaler.fit_transform(x_train) x_test = scaler.transform(x_test) # Generate image pairs n_pairs = 100000 x1 = np.empty((n_pairs, 28 * 28), dtype=dp.float_) x2 = np.empty_like(x1, dtype=dp.float_) y = np.empty(n_pairs, dtype=dp.int_) n_imgs = x_train.shape[0] n = 0 while n < n_pairs: i = random.randint(0, n_imgs - 1) j = random.randint(0, n_imgs - 1) if i == j: continue x1[n, ...] = x_train[i] x2[n, ...] = x_train[j] if y_train[i] == y_train[j]: y[n] = 1 else: y[n] = 0 n += 1 # Input to network train_input = dp.SupervisedSiameseInput(x1, x2, y, batch_size=128) test_input = dp.SupervisedInput(x_test, y_test) # Setup network net = dp.SiameseNetwork( siamese_layers=[ dp.Dropout(), dp.FullyConnected( n_output=800, weights=dp.Parameter(dp.AutoFiller(), weight_decay=0.00001), ), dp.Activation('relu'), dp.FullyConnected( n_output=800, weights=dp.Parameter(dp.AutoFiller(), weight_decay=0.00001), ), dp.Activation('relu'), dp.FullyConnected( n_output=2, weights=dp.Parameter(dp.AutoFiller(), weight_decay=0.00001), ), ], loss_layer=dp.ContrastiveLoss(margin=0.5), ) # Train network trainer = dp.StochasticGradientDescent( max_epochs=10, learn_rule=dp.RMSProp(learn_rate=0.001), ) trainer.train(net, train_input) # Visualize feature space feat = net.features(test_input) colors = [ 'tomato', 'lawngreen', 'royalblue', 'gold', 'saddlebrown', 'violet', 'turquoise', 'mediumpurple', 'darkorange', 'darkgray' ] plt.figure() for i in range(10): plt.scatter(feat[y_test == i, 0], feat[y_test == i, 1], s=3, c=colors[i], linewidths=0) plt.legend([str(i) for i in range(10)], scatterpoints=1, markerscale=4) if not os.path.exists('mnist'): os.mkdirs('mnist') plt.savefig(os.path.join('mnist', 'siamese_dists.png'), dpi=200)
expr.nnet.ReLU(), affine(n_in, gain), expr.nnet.Sigmoid(), ]) net = dp.model.VariationalAutoencoder( encoder=encoder, decoder=decoder, n_hidden=n_hidden, ) # Train network n_epochs = 25 trainer = dp.GradientDescent( min_epochs=n_epochs, max_epochs=n_epochs, learn_rule=dp.RMSProp(learn_rate=0.25), ) trainer.train(net, train_input) def plot_tile(imgs, title): imgs = np.reshape(imgs, (-1, 28, 28)) tile_img = dp.misc.img_tile(dp.misc.img_stretch(imgs)) plt.figure() plt.imshow(tile_img, cmap='gray', interpolation='nearest') plt.axis('off') plt.title(title) plt.tight_layout() n_examples = 100
# Prepare network feeds batch_size = 64 train_feed = dp.Feed(x_train, batch_size=batch_size) # Samples to be plotted during training n_examples = 100 samples = np.random.normal(size=(n_examples, model.n_hidden)).astype(dp.float_) plot_epochs = [0, 4, 14] plot_imgs = [(x_train[:n_examples], 'Dataset examples')] # Train network n_epochs = 15 margin = 0.25 equilibrium = 0.6931 learn_rate = 0.075 learn_rule_g = dp.RMSProp(learn_rate=learn_rate) learn_rule_d = dp.RMSProp(learn_rate=learn_rate) model.setup(*train_feed.shapes) g_params, d_params = model.params learn_rule_g.learn_rate /= batch_size learn_rule_d.learn_rate /= batch_size*2 g_states = [learn_rule_g.init_state(p) for p in g_params] d_states = [learn_rule_d.init_state(p) for p in d_params] for epoch in range(n_epochs): batch_costs = [] for x, in train_feed.batches(): real_cost, gen_cost = model.update(x) batch_costs.append((real_cost, gen_cost)) update_g = True update_d = True if real_cost < equilibrium - margin or gen_cost < equilibrium - margin:
def run(): n_hidden = 128 real_vs_gen_weight = 0.75 gan_margin = 0.3 lr_start = 0.04 lr_stop = 0.0001 lr_gamma = 0.75 n_epochs = 150 epoch_size = 250 batch_size = 64 experiment_name = 'mnist_gan' experiment_name += '_nhidden%i' % n_hidden out_dir = os.path.join('out', experiment_name) arch_path = os.path.join(out_dir, 'arch.pickle') start_arch_path = arch_path start_arch_path = None print('experiment_name', experiment_name) print('start_arch_path', start_arch_path) print('arch_path', arch_path) # Setup network if start_arch_path is None: print('Creating new model') _, decoder, discriminator = architectures.mnist() else: print('Starting from %s' % start_arch_path) with open(start_arch_path, 'rb') as f: decoder, discriminator = pickle.load(f) model = gan.GAN( n_hidden=n_hidden, generator=decoder, discriminator=discriminator, real_vs_gen_weight=real_vs_gen_weight, ) # Fetch dataset dataset = dp.dataset.MNIST() x_train, y_train, x_test, y_test = dataset.arrays() x_train = mnist_transform(x_train) x_test = mnist_transform(x_test) # Prepare network feeds train_feed = dp.Feed(x_train, batch_size, epoch_size) test_feed = dp.Feed(x_test, batch_size) # Plotting n_examples = 64 original_x, = test_feed.batches().next() original_x = np.array(original_x)[:n_examples] samples_z = np.random.normal(size=(n_examples, n_hidden)) samples_z = (samples_z).astype(dp.float_) # Train network learn_rule = dp.RMSProp() trainer = gan.GradientDescent(model, train_feed, learn_rule, margin=gan_margin) annealer = dp.GammaAnnealer(lr_start, lr_stop, n_epochs, gamma=lr_gamma) try: sample_video = Video(os.path.join(out_dir, 'convergence_samples.mp4')) sp.misc.imsave(os.path.join(out_dir, 'examples.png'), dp.misc.img_tile(mnist_inverse_transform(original_x))) for e in range(n_epochs): model.phase = 'train' model.setup(*train_feed.shapes) learn_rule.learn_rate = annealer.value(e) / batch_size trainer.train_epoch() model.phase = 'test' samples_x = model.decode(samples_z) samples_x = mnist_inverse_transform(model.decode(samples_z)) sample_video.append(dp.misc.img_tile(samples_x)) except KeyboardInterrupt: pass print('Saving model to disk') with open(arch_path, 'wb') as f: pickle.dump((decoder, discriminator), f) model.phase = 'test' n_examples = 100 samples_z = np.random.normal(size=(n_examples, n_hidden)).astype(dp.float_) output.samples(model, samples_z, out_dir, mnist_inverse_transform) output.walk(model, samples_z, out_dir, mnist_inverse_transform)
def run(): experiment_name = 'celeba-ae' img_size = 64 epoch_size = 250 batch_size = 64 n_hidden = 128 n_augment = int(6e5) train_feed, test_feed = dataset.celeba.feeds( img_size, split='test', batch_size=batch_size, epoch_size=epoch_size, n_augment=n_augment, ) experiment_name += '_nhidden%i' % n_hidden out_dir = os.path.join('out', experiment_name) arch_path = os.path.join(out_dir, 'arch.pickle') start_arch_path = arch_path start_arch_path = None print('experiment_name', experiment_name) print('start_arch_path', start_arch_path) print('arch_path', arch_path) ae_kind = 'variational' # Setup network if start_arch_path is None: print('Creating new model') encoder, decoder, _ = architectures.img64x64() if ae_kind == 'variational': latent_encoder = architectures.vae_latent_encoder(n_hidden) elif ae_kind == 'adversarial': latent_encoder = architectures.aae_latent_encoder(n_hidden) else: print('Starting from %s' % start_arch_path) with open(start_arch_path, 'rb') as f: encoder, latent_encoder, decoder = pickle.load(f) model = ae.Autoencoder( encoder=encoder, latent_encoder=latent_encoder, decoder=decoder, ) model.recon_error = ae.NLLNormal() # Plotting n_examples = 64 original_x, = test_feed.batches().next() original_x = np.array(original_x)[:n_examples] samples_z = np.random.normal(size=(n_examples, n_hidden)) samples_z = (samples_z).astype(dp.float_) n_epochs = 250 lr_start = 0.025 lr_stop = 0.00001 lr_gamma = 0.75 # Train network learn_rule = dp.RMSProp() trainer = dp.GradientDescent(model, train_feed, learn_rule) annealer = dp.GammaAnnealer(lr_start, lr_stop, n_epochs, gamma=lr_gamma) try: recon_video = Video(os.path.join(out_dir, 'convergence_recon.mp4')) sample_video = Video(os.path.join(out_dir, 'convergence_samples.mp4')) sp.misc.imsave(os.path.join(out_dir, 'examples.png'), dp.misc.img_tile(img_inverse_transform(original_x))) for e in range(n_epochs): model.phase = 'train' model.setup(*train_feed.shapes) learn_rule.learn_rate = annealer.value(e) / batch_size loss = trainer.train_epoch() model.phase = 'test' original_z = model.encode(original_x) recon_x = model.decode(original_z) samples_x = model.decode(samples_z) recon_x = img_inverse_transform(recon_x) samples_x = img_inverse_transform(model.decode(samples_z)) recon_video.append(dp.misc.img_tile(recon_x)) sample_video.append(dp.misc.img_tile(samples_x)) likelihood = model.likelihood(test_feed) print( 'epoch %i Train loss:%.4f Test likelihood:%.4f Learn Rate:%.4f' % (e, np.mean(loss), np.mean(likelihood), learn_rule.learn_rate)) except KeyboardInterrupt: pass print('Saving model to disk') with open(arch_path, 'wb') as f: pickle.dump((encoder, latent_encoder, decoder), f) model.phase = 'test' n_examples = 100 test_feed.reset() original_x = np.array(test_feed.batches().next()[0])[:n_examples] samples_z = np.random.normal(size=(n_examples, n_hidden)) output.samples(model, samples_z, out_dir, img_inverse_transform) output.reconstructions(model, original_x, out_dir, img_inverse_transform) original_z = model.encode(original_x) output.walk(model, original_z, out_dir, img_inverse_transform)
def run(): n_hidden = 64 ae_kind = 'variational' lr_start = 0.01 lr_stop = 0.0001 lr_gamma = 0.75 n_epochs = 150 epoch_size = 250 batch_size = 64 experiment_name = 'mnist_ae' experiment_name += '_nhidden%i' % n_hidden out_dir = os.path.join('out', experiment_name) arch_path = os.path.join(out_dir, 'arch.pickle') start_arch_path = arch_path start_arch_path = None print('experiment_name', experiment_name) print('start_arch_path', start_arch_path) print('arch_path', arch_path) # Setup network if start_arch_path is None: print('Creating new model') encoder, decoder, _ = architectures.mnist() if ae_kind == 'variational': latent_encoder = architectures.vae_latent_encoder(n_hidden) elif ae_kind == 'adversarial': latent_encoder = architectures.aae_latent_encoder(n_hidden) else: print('Starting from %s' % start_arch_path) with open(start_arch_path, 'rb') as f: decoder, discriminator = pickle.load(f) model = ae.Autoencoder( encoder=encoder, latent_encoder=latent_encoder, decoder=decoder, ) model.recon_error = ae.NLLNormal() # Fetch dataset dataset = dp.dataset.MNIST() x_train, y_train, x_test, y_test = dataset.arrays() x_train = mnist_transform(x_train) x_test = mnist_transform(x_test) # Prepare network feeds train_feed = dp.Feed(x_train, batch_size, epoch_size) test_feed = dp.Feed(x_test, batch_size) # Plotting n_examples = 64 original_x, = test_feed.batches().next() original_x = np.array(original_x)[:n_examples] samples_z = np.random.normal(size=(n_examples, n_hidden)) samples_z = (samples_z).astype(dp.float_) # Train network learn_rule = dp.RMSProp() trainer = dp.GradientDescent(model, train_feed, learn_rule) annealer = dp.GammaAnnealer(lr_start, lr_stop, n_epochs, gamma=lr_gamma) try: recon_video = Video(os.path.join(out_dir, 'convergence_recon.mp4')) sample_video = Video(os.path.join(out_dir, 'convergence_samples.mp4')) sp.misc.imsave(os.path.join(out_dir, 'examples.png'), dp.misc.img_tile(mnist_inverse_transform(original_x))) for e in range(n_epochs): model.phase = 'train' model.setup(*train_feed.shapes) learn_rule.learn_rate = annealer.value(e) / batch_size loss = trainer.train_epoch() model.phase = 'test' original_z = model.encode(original_x) recon_x = model.decode(original_z) samples_x = model.decode(samples_z) recon_x = mnist_inverse_transform(recon_x) samples_x = mnist_inverse_transform(model.decode(samples_z)) recon_video.append(dp.misc.img_tile(recon_x)) sample_video.append(dp.misc.img_tile(samples_x)) likelihood = model.likelihood(test_feed) print('epoch %i Train loss:%.4f Test likelihood:%.4f' % (e, np.mean(loss), np.mean(likelihood))) except KeyboardInterrupt: pass print('Saving model to disk') with open(arch_path, 'wb') as f: pickle.dump((decoder, discriminator), f) model.phase = 'test' n_examples = 100 samples_z = np.random.normal(size=(n_examples, n_hidden)).astype(dp.float_) output.samples(model, samples_z, out_dir, mnist_inverse_transform) output.walk(model, samples_z, out_dir, mnist_inverse_transform)