def run_dae(): ######################################## # Initialization things with arguments # ######################################## config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = { "outdir": 'outputs/dae/mnist/', "input_size": 28 * 28, "tied_weights": True } dae = DenoisingAutoencoder(**config) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(dae, mnist) optimizer.train() # Save some reconstruction output images import opendeep.data.dataset as datasets n_examples = 100 test_xs, _ = mnist.getSubset(subset=datasets.TEST) test_xs = test_xs[:n_examples].eval() dae.create_reconstruction_image(test_xs)
def run_mlp(): # # define the model layers # layer1 = BasicLayer(input_size=784, output_size=1000, activation='rectifier') # layer2 = BasicLayer(inputs_hook=(1000, layer1.get_outputs()), output_size=1000, activation='rectifier') # classlayer3 = SoftmaxLayer(inputs_hook=(1000, layer2.get_outputs()), output_size=10, out_as_probs=False) # # add the layers to the prototype # mlp = Prototype(layers=[layer1, layer2, classlayer3]) # test the new way to automatically fill in inputs_hook for models mlp = Prototype() mlp.add(BasicLayer(input_size=784, output_size=1000, activation="rectifier", noise="dropout")) mlp.add(BasicLayer(output_size=1500, activation="tanh", noise="dropout")) mlp.add(SoftmaxLayer(output_size=10)) mnist = MNIST() optimizer = AdaDelta(model=mlp, dataset=mnist, n_epoch=10) optimizer.train() test_data, test_labels = mnist.getSubset(subset=TEST) test_data = test_data[:25].eval() test_labels = test_labels[:25].eval() # use the run function! yhat = mlp.run(test_data) print("-------") print("Prediction: %s" % str(yhat)) print("Actual: %s" % str(test_labels.astype("int32")))
def run_mlp(): # # define the model layers # layer1 = Dense(input_size=784, output_size=1000, activation='rectifier') # layer2 = Dense(inputs_hook=(1000, layer1.get_outputs()), output_size=1000, activation='rectifier') # classlayer3 = SoftmaxLayer(inputs_hook=(1000, layer2.get_outputs()), output_size=10, out_as_probs=False) # # add the layers to the prototype # mlp = Prototype(layers=[layer1, layer2, classlayer3]) # test the new way to automatically fill in inputs_hook for models mlp = Prototype() mlp.add(Dense(input_size=784, output_size=1000, activation='rectifier', noise='dropout')) mlp.add(Dense(output_size=1500, activation='tanh', noise='dropout')) mlp.add(SoftmaxLayer(output_size=10)) mnist = MNIST() optimizer = AdaDelta(model=mlp, dataset=mnist, epochs=10) optimizer.train() test_data, test_labels = mnist.test_inputs, mnist.test_targets test_data = test_data[:25] test_labels = test_labels[:25] # use the run function! yhat = mlp.run(test_data) print('-------') print('Prediction: %s' % str(yhat)) print('Actual: %s' % str(test_labels.astype('int32')))
def run_dae(): ######################################## # Initialization things with arguments # ######################################## config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = { "outdir": 'outputs/dae/mnist/', "input_size": 28 * 28, "tied_weights": True } dae = DenoisingAutoencoder(**config) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(model=dae, dataset=mnist, epochs=100) optimizer.train() # Save some reconstruction output images n_examples = 100 test_xs = mnist.test_inputs[:n_examples] dae.create_reconstruction_image(test_xs) del dae, mnist
def run_dae(): ######################################## # Initialization things with arguments # ######################################## config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = { "outdir": 'outputs/dae/mnist/', "input_size": 28*28, "tied_weights": True } dae = DenoisingAutoencoder(**config) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(dae, mnist) optimizer.train() # Save some reconstruction output images import opendeep.data.dataset as datasets n_examples = 100 test_xs, _ = mnist.getSubset(subset=datasets.TEST) test_xs = test_xs[:n_examples].eval() dae.create_reconstruction_image(test_xs)
def run_dae(): ######################################## # Initialization things with arguments # ######################################## config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = { "outdir": 'outputs/dae/mnist/', "input_size": 28*28, "tied_weights": True } dae = DenoisingAutoencoder(**config) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(model=dae, dataset=mnist, epochs=100) optimizer.train() # Save some reconstruction output images n_examples = 100 test_xs = mnist.test_inputs[:n_examples] dae.create_reconstruction_image(test_xs) del dae, mnist
def create_mlp(): # define the model layers relu_layer1 = BasicLayer(input_size=784, output_size=1000, activation='rectifier') relu_layer2 = BasicLayer(inputs_hook=(1000, relu_layer1.get_outputs()), output_size=1000, activation='rectifier') class_layer3 = SoftmaxLayer(inputs_hook=(1000, relu_layer2.get_outputs()), output_size=10, out_as_probs=False) # add the layers as a Prototype mlp = Prototype(layers=[relu_layer1, relu_layer2, class_layer3]) mnist = MNIST() optimizer = AdaDelta(model=mlp, dataset=mnist, n_epoch=20) optimizer.train() test_data, test_labels = mnist.getSubset(TEST) test_data = test_data[:25].eval() test_labels = test_labels[:25].eval() # use the run function! preds = mlp.run(test_data) log.info('-------') log.info("predicted: %s",str(preds)) log.info("actual: %s",str(test_labels.astype('int32')))
def run_dae(): ######################################## # Initialization things with arguments # ######################################## config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = {"output_path": '../../../../outputs/dae/mnist/'} dae = DenoisingAutoencoder(config=config, dataset=mnist) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(dae, mnist) optimizer.train() # Save some reconstruction output images import opendeep.data.dataset as datasets n_examples = 100 test_xs = mnist.getDataByIndices(indices=range(n_examples), subset=datasets.TEST) dae.create_reconstruction_image(test_xs)
def main(): ######################################## # Initialization things with arguments # ######################################## logger.config_root_logger() log.info("Creating a new DAE") mnist = MNIST() config = {"output_path": '../../../outputs/dae/mnist/'} dae = DenoisingAutoencoder(config=config, dataset=mnist) # # Load initial weights and biases from file # params_to_load = 'dae_params.pkl' # dae.load_params(params_to_load) optimizer = AdaDelta(dae, mnist) optimizer.train() # Save some reconstruction output images import opendeep.data.dataset as datasets n_examples = 100 test_xs = mnist.getDataByIndices(indices=range(n_examples), subset=datasets.TEST) dae.create_reconstruction_image(test_xs)
# set up the logging environment to display outputs (optional) # although this is recommended over print statements everywhere import logging import opendeep.log.logger as logger logger.config_root_logger() log = logging.getLogger(__name__) log.info("Creating softmax!") # grab the MNIST dataset mnist = MNIST() # create the softmax classifier s = SoftmaxLayer(input_size=28 * 28, output_size=10, out_as_probs=False) # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=s, dataset=mnist, n_epoch=20) # perform training! optimizer.train() # test it on some images! test_data = mnist.getDataByIndices(indices=range(25), subset=TEST) # use the predict function! preds = s.predict(test_data) print '-------' print preds print mnist.getLabelsByIndices(indices=range(25), subset=TEST) print print del mnist del s del optimizer log.info("Creating softmax with categorical cross-entropy!")
# import the dataset and optimizer to use from opendeep.data.dataset import TEST from opendeep.data.standard_datasets.image.mnist import MNIST from opendeep.optimization.adadelta import AdaDelta # grab the MNIST dataset mnist = MNIST() # create your shiny new DAE dae = DenoisingAutoencoder() # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=dae, dataset=mnist) # perform training! optimizer.train() # test it on some images! test_data, _ = mnist.getSubset(TEST) test_data = test_data[:25].eval() corrupted_test = salt_and_pepper(test_data, 0.4).eval() # use the run function! reconstructed_images = dae.run(corrupted_test) # create an image from this reconstruction! # imports for working with tiling outputs into one image from opendeep.utils.image import tile_raster_images import numpy import PIL # stack the image matrices together in three 5x5 grids next to each other using numpy stacked = numpy.vstack([
def run_sequence(sequence=0): log.info("Creating RNN-GSN for sequence %d!" % sequence) # grab the MNIST dataset mnist = MNIST(sequence_number=sequence, concat_train_valid=True) outdir = "outputs/rnngsn/mnist_%d/" % sequence rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2**30)) rnngsn = RNN_GSN(layers=2, walkbacks=4, input_size=28 * 28, hidden_size=1000, tied_weights=True, rnn_hidden_size=100, weights_init='uniform', weights_interval='montreal', rnn_weights_init='identity', mrg=mrg, outdir=outdir) # load pretrained rbm on mnist # rnngsn.load_gsn_params('outputs/trained_gsn_epoch_1000.pkl') # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=rnngsn, dataset=mnist, n_epoch=200, batch_size=100, minimum_batch_size=2, learning_rate=1e-6, save_frequency=1, early_stop_length=200) # optimizer = SGD(model=rnngsn, # dataset=mnist, # n_epoch=300, # batch_size=100, # minimum_batch_size=2, # learning_rate=.25, # lr_decay='exponential', # lr_factor=.995, # momentum=0.5, # nesterov_momentum=True, # momentum_decay=False, # save_frequency=20, # early_stop_length=100) crossentropy = Monitor('crossentropy', rnngsn.get_monitors()['noisy_recon_cost'], test=True) error = Monitor('error', rnngsn.get_monitors()['mse'], test=True) # perform training! optimizer.train(monitor_channels=[crossentropy, error]) # use the generate function! log.debug("generating images...") generated, ut = rnngsn.generate(initial=None, n_steps=400) # Construct image image = Image.fromarray( tile_raster_images(X=generated, img_shape=(28, 28), tile_shape=(20, 20), tile_spacing=(1, 1))) image.save(outdir + "rnngsn_mnist_generated.png") log.debug('saved generated.png') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images(X=rnngsn.weights_list[0].get_value(borrow=True).T, img_shape=(28, 28), tile_shape=closest_to_square_factors( rnngsn.hidden_size), tile_spacing=(1, 1))) image.save(outdir + "rnngsn_mnist_weights.png") log.debug("done!") del mnist del rnngsn del optimizer
def run_audio(dataset): log.info("Creating RNN-GSN for dataset %s!", dataset) outdir = "outputs/rnngsn/%s/" % dataset # grab the dataset if dataset == 'tedlium': dataset = tedlium.TEDLIUMDataset(max_speeches=3) extra_args = { } elif dataset == 'codegolf': dataset = codegolf.CodeGolfDataset() extra_args = { } else: raise ValueError("dataset %s not recognized." % dataset) rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2 ** 30)) assert dataset.window_size == 256, dataset.window_size rnngsn = RNN_GSN(layers=2, walkbacks=4, input_size=dataset.window_size, image_height = 1, image_width = 256, hidden_size=128, rnn_hidden_size=128, weights_init='gaussian', weights_std=0.01, rnn_weights_init='identity', rnn_hidden_activation='relu', rnn_weights_std=0.0001, mrg=mrg, outdir=outdir, **extra_args) # make an optimizer to train it optimizer = AdaDelta(model=rnngsn, dataset=dataset, epochs=200, batch_size=128, min_batch_size=2, learning_rate=1e-6, save_freq=1, stop_patience=100) ll = Monitor('crossentropy', rnngsn.get_monitors()['noisy_recon_cost'],test=True) mse = Monitor('frame-error', rnngsn.get_monitors()['mse'],train=True,test=True,valid=True) plot = Plot( bokeh_doc_name='rnngsn_tedlium_%s'%dataset, monitor_channels=[ll,mse],open_browser=True ) # perform training! optimizer.train(plot=plot) # use the generate function! generated, _ = rnngsn.generate(initial=None, n_steps=200) # Construct image from the weight matrix image = Image.fromarray( tile_raster_images( X=rnngsn.weights_list[0].get_value(borrow=True).T, img_shape=closest_to_square_factors(rnngsn.input_size), tile_shape=closest_to_square_factors(rnngsn.hidden_size), tile_spacing=(1, 1) ) ) image.save(outdir + 'rnngsn_%s_weights.png'%(dataset,)) log.debug("done!") del rnngsn del optimizer if has_pylab: pylab.show()
def run_midi(dataset): log.info("Creating RNN-GSN for dataset %s!", dataset) outdir = "outputs/rnngsn/%s/" % dataset # grab the MIDI dataset if dataset == 'nottingham': midi = Nottingham() elif dataset == 'jsb': midi = JSBChorales() elif dataset == 'muse': midi = MuseData() elif dataset == 'piano_de': midi = PianoMidiDe() else: raise AssertionError("dataset %s not recognized." % dataset) # rng = numpy.random # rng.seed(0xbeef) # mrg = RandomStreams(seed=rng.randint(1 << 30)) rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2 ** 30)) rnngsn = RNN_GSN(layers=2, walkbacks=4, input_size=88, hidden_size=150, rnn_hidden_size=100, weights_init='gaussian', weights_std=0.01, rnn_weights_init='identity', rnn_hidden_activation='relu', rnn_weights_std=0.0001, mrg=mrg, outdir=outdir) # make an optimizer to train it optimizer = AdaDelta(model=rnngsn, dataset=midi, epochs=200, batch_size=100, min_batch_size=2, # learning_rate=1e-4, learning_rate=1e-6, save_freq=1, stop_patience=100) ll = Monitor('crossentropy', rnngsn.get_monitors()['noisy_recon_cost'],test=True) mse = Monitor('frame-error', rnngsn.get_monitors()['mse'],train=True,test=True,valid=True) plot = Plot(bokeh_doc_name='rnngsn_midi_%s'%dataset, monitor_channels=[ll,mse],open_browser=True) # perform training! optimizer.train(plot=plot) # use the generate function! generated, _ = rnngsn.generate(initial=None, n_steps=200) dt = 0.3 r = (21, 109) midiwrite(outdir + 'rnngsn_generated_midi.mid', generated, r=r, dt=dt) if has_pylab: extent = (0, dt * len(generated)) + r pylab.figure() pylab.imshow(generated.T, origin='lower', aspect='auto', interpolation='nearest', cmap=pylab.cm.gray_r, extent=extent) pylab.xlabel('time (s)') pylab.ylabel('MIDI note number') pylab.title('generated piano-roll') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images( X=rnngsn.weights_list[0].get_value(borrow=True).T, img_shape=closest_to_square_factors(rnngsn.input_size), tile_shape=closest_to_square_factors(rnngsn.hidden_size), tile_spacing=(1, 1) ) ) image.save(outdir + 'rnngsn_midi_weights.png') log.debug("done!") del midi del rnngsn del optimizer if has_pylab: pylab.show()
def run_sequence(sequence=0): log.info("Creating RNN-RBM for sequence %d!" % sequence) # grab the MNIST dataset mnist = MNIST(sequence_number=sequence, concat_train_valid=True) outdir = "outputs/rnnrbm/mnist_%d/" % sequence # create the RNN-RBM rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2 ** 30)) rnnrbm = RNN_RBM(input_size=28 * 28, hidden_size=1000, rnn_hidden_size=100, k=15, weights_init='uniform', weights_interval=4 * numpy.sqrt(6. / (28 * 28 + 500)), rnn_weights_init='identity', rnn_hidden_activation='relu', rnn_weights_std=1e-4, mrg=mrg, outdir=outdir) # load pretrained rbm on mnist # rnnrbm.load_params(outdir + 'trained_epoch_200.pkl') # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=rnnrbm, dataset=mnist, n_epoch=200, batch_size=100, minimum_batch_size=2, learning_rate=1e-8, save_frequency=10, early_stop_length=200) crossentropy = Monitor('crossentropy', rnnrbm.get_monitors()['crossentropy'], test=True) error = Monitor('error', rnnrbm.get_monitors()['mse'], test=True) plot = Plot(bokeh_doc_name='rnnrbm_mnist_%d' % sequence, monitor_channels=[crossentropy, error], open_browser=True) # perform training! optimizer.train(plot=plot) # use the generate function! log.debug("generating images...") generated, ut = rnnrbm.generate(initial=None, n_steps=400) # Construct image image = Image.fromarray( tile_raster_images( X=generated, img_shape=(28, 28), tile_shape=(20, 20), tile_spacing=(1, 1) ) ) image.save(outdir + "rnnrbm_mnist_generated.png") log.debug('saved generated.png') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images( X=rnnrbm.W.get_value(borrow=True).T, img_shape=(28, 28), tile_shape=closest_to_square_factors(rnnrbm.hidden_size), tile_spacing=(1, 1) ) ) image.save(outdir + "rnnrbm_mnist_weights.png") log.debug("done!") del mnist del rnnrbm del optimizer
def run_midi(dataset): log.info("Creating RNN-GSN for dataset %s!", dataset) outdir = "outputs/rnngsn/%s/" % dataset # grab the MIDI dataset if dataset == 'nottingham': midi = Nottingham() elif dataset == 'jsb': midi = JSBChorales() elif dataset == 'muse': midi = MuseData() elif dataset == 'piano_de': midi = PianoMidiDe() else: raise AssertionError("dataset %s not recognized." % dataset) # rng = numpy.random # rng.seed(0xbeef) # mrg = RandomStreams(seed=rng.randint(1 << 30)) rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2 ** 30)) rnngsn = RNN_GSN(layers=2, walkbacks=4, input_size=88, hidden_size=150, rnn_hidden_size=100, weights_init='gaussian', weights_std=0.01, rnn_weights_init='identity', rnn_hidden_activation='relu', rnn_weights_std=0.0001, mrg=mrg, outdir=outdir) # make an optimizer to train it optimizer = AdaDelta(model=rnngsn, dataset=midi, n_epoch=200, batch_size=100, minimum_batch_size=2, # learning_rate=1e-4, learning_rate=1e-6, save_frequency=1, early_stop_length=100) ll = Monitor('crossentropy', rnngsn.get_monitors()['noisy_recon_cost'],test=True) mse = Monitor('frame-error', rnngsn.get_monitors()['mse'],train=True,test=True,valid=True) plot = Plot(bokeh_doc_name='rnngsn_midi_%s'%dataset, monitor_channels=[ll,mse],open_browser=True) # perform training! optimizer.train(plot=plot) # use the generate function! generated, _ = rnngsn.generate(initial=None, n_steps=200) dt = 0.3 r = (21, 109) midiwrite(outdir + 'rnngsn_generated_midi.mid', generated, r=r, dt=dt) if has_pylab: extent = (0, dt * len(generated)) + r pylab.figure() pylab.imshow(generated.T, origin='lower', aspect='auto', interpolation='nearest', cmap=pylab.cm.gray_r, extent=extent) pylab.xlabel('time (s)') pylab.ylabel('MIDI note number') pylab.title('generated piano-roll') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images( X=rnngsn.weights_list[0].get_value(borrow=True).T, img_shape=closest_to_square_factors(rnngsn.input_size), tile_shape=closest_to_square_factors(rnngsn.hidden_size), tile_spacing=(1, 1) ) ) image.save(outdir + 'rnngsn_midi_weights.png') log.debug("done!") del midi del rnngsn del optimizer if has_pylab: pylab.show()
def run_sequence(sequence=0): log.info("Creating RNN-GSN for sequence %d!" % sequence) # grab the MNIST dataset mnist = MNIST(sequence_number=sequence, concat_train_valid=True) outdir = "outputs/rnngsn/mnist_%d/" % sequence rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2 ** 30)) rnngsn = RNN_GSN(layers=2, walkbacks=4, input_size=28 * 28, hidden_size=1000, tied_weights=True, rnn_hidden_size=100, weights_init='uniform', weights_interval='montreal', rnn_weights_init='identity', mrg=mrg, outdir=outdir) # load pretrained rbm on mnist # rnngsn.load_gsn_params('outputs/trained_gsn_epoch_1000.pkl') # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=rnngsn, dataset=mnist, n_epoch=200, batch_size=100, minimum_batch_size=2, learning_rate=1e-6, save_frequency=1, early_stop_length=200) # optimizer = SGD(model=rnngsn, # dataset=mnist, # n_epoch=300, # batch_size=100, # minimum_batch_size=2, # learning_rate=.25, # lr_decay='exponential', # lr_factor=.995, # momentum=0.5, # nesterov_momentum=True, # momentum_decay=False, # save_frequency=20, # early_stop_length=100) crossentropy = Monitor('crossentropy', rnngsn.get_monitors()['noisy_recon_cost'], test=True) error = Monitor('error', rnngsn.get_monitors()['mse'], test=True) # perform training! optimizer.train(monitor_channels=[crossentropy, error]) # use the generate function! log.debug("generating images...") generated, ut = rnngsn.generate(initial=None, n_steps=400) # Construct image image = Image.fromarray( tile_raster_images( X=generated, img_shape=(28, 28), tile_shape=(20, 20), tile_spacing=(1, 1) ) ) image.save(outdir + "rnngsn_mnist_generated.png") log.debug('saved generated.png') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images( X=rnngsn.weights_list[0].get_value(borrow=True).T, img_shape=(28, 28), tile_shape=closest_to_square_factors(rnngsn.hidden_size), tile_spacing=(1, 1) ) ) image.save(outdir + "rnngsn_mnist_weights.png") log.debug("done!") del mnist del rnngsn del optimizer
def run_sequence(sequence=0): log.info("Creating RNN-RBM for sequence %d!" % sequence) # grab the MNIST dataset mnist = MNIST(sequence_number=sequence, concat_train_valid=True) outdir = "outputs/rnnrbm/mnist_%d/" % sequence # create the RNN-RBM rng = numpy.random.RandomState(1234) mrg = RandomStreams(rng.randint(2**30)) rnnrbm = RNN_RBM(input_size=28 * 28, hidden_size=1000, rnn_hidden_size=100, k=15, weights_init='uniform', weights_interval=4 * numpy.sqrt(6. / (28 * 28 + 500)), rnn_weights_init='identity', rnn_hidden_activation='relu', rnn_weights_std=1e-4, mrg=mrg, outdir=outdir) # load pretrained rbm on mnist # rnnrbm.load_params(outdir + 'trained_epoch_200.pkl') # make an optimizer to train it (AdaDelta is a good default) optimizer = AdaDelta(model=rnnrbm, dataset=mnist, n_epoch=200, batch_size=100, minimum_batch_size=2, learning_rate=1e-8, save_frequency=10, early_stop_length=200) crossentropy = Monitor('crossentropy', rnnrbm.get_monitors()['crossentropy'], test=True) error = Monitor('error', rnnrbm.get_monitors()['mse'], test=True) plot = Plot(bokeh_doc_name='rnnrbm_mnist_%d' % sequence, monitor_channels=[crossentropy, error], open_browser=True) # perform training! optimizer.train(plot=plot) # use the generate function! log.debug("generating images...") generated, ut = rnnrbm.generate(initial=None, n_steps=400) # Construct image image = Image.fromarray( tile_raster_images(X=generated, img_shape=(28, 28), tile_shape=(20, 20), tile_spacing=(1, 1))) image.save(outdir + "rnnrbm_mnist_generated.png") log.debug('saved generated.png') # Construct image from the weight matrix image = Image.fromarray( tile_raster_images(X=rnnrbm.W.get_value(borrow=True).T, img_shape=(28, 28), tile_shape=closest_to_square_factors( rnnrbm.hidden_size), tile_spacing=(1, 1))) image.save(outdir + "rnnrbm_mnist_weights.png") log.debug("done!") del mnist del rnnrbm del optimizer