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 = 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_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_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)
if __name__ == '__main__':
# set up the logging environment to display outputs (optional)
# although this is recommended over print statements everywhere
import logging
from opendeep.log import config_root_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, epochs=20)
# perform training!
optimizer.train()
# test it on some images!
test_data, test_labels = mnist.test_inputs[:25], mnist.test_targets[:25]
# use the run function!
preds = s.run(test_data)
print('-------')
print(preds)
print(test_labels.astype('int32'))
print()
print()
del mnist
del s
del optimizer
log = logging.getLogger(__name__)
log.info("Creating a Denoising Autoencoder!")
# 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
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()
if __name__ == '__main__':
# 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
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_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
log = logging.getLogger(__name__)
log.info("Creating a Denoising Autoencoder!")
# 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, n_epoch=100)
# 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
def run_midi(dataset):
log.info("Creating RNN-RBM for dataset %s!", dataset)
outdir = "outputs/rnnrbm/%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)
# create the RNN-RBM
# rng = numpy.random
# rng.seed(0xbeef)
# mrg = RandomStreams(seed=rng.randint(1 << 30))
rng = numpy.random.RandomState(1234)
mrg = RandomStreams(rng.randint(2**30))
# rnnrbm = RNN_RBM(input_size=88,
# hidden_size=150,
# rnn_hidden_size=100,
# k=15,
# weights_init='gaussian',
# weights_std=0.01,
# rnn_weights_init='gaussian',
# rnn_weights_std=0.0001,
# rng=rng,
# outdir=outdir)
rnnrbm = RNN_RBM(
input_size=88,
hidden_size=150,
rnn_hidden_size=100,
k=15,
weights_init='gaussian',
weights_std=0.01,
rnn_weights_init='identity',
rnn_hidden_activation='relu',
# rnn_weights_init='gaussian',
# rnn_hidden_activation='tanh',
rnn_weights_std=0.0001,
mrg=mrg,
outdir=outdir)
# make an optimizer to train it
optimizer = SGD(model=rnnrbm,
dataset=midi,
epochs=200,
batch_size=100,
min_batch_size=2,
learning_rate=.001,
save_freq=10,
stop_patience=200,
momentum=False,
momentum_decay=False,
nesterov_momentum=False)
optimizer = AdaDelta(
model=rnnrbm,
dataset=midi,
epochs=200,
batch_size=100,
min_batch_size=2,
# learning_rate=1e-4,
learning_rate=1e-6,
save_freq=10,
stop_patience=200)
ll = Monitor('pseudo-log', rnnrbm.get_monitors()['pseudo-log'], test=True)
mse = Monitor('frame-error',
rnnrbm.get_monitors()['mse'],
valid=True,
test=True)
plot = Plot(bokeh_doc_name='rnnrbm_midi_%s' % dataset,
monitor_channels=[ll, mse],
open_browser=True)
# perform training!
optimizer.train(plot=plot)
# use the generate function!
generated, _ = rnnrbm.generate(initial=None, n_steps=200)
dt = 0.3
r = (21, 109)
midiwrite(outdir + 'rnnrbm_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=rnnrbm.W.get_value(borrow=True).T,
img_shape=closest_to_square_factors(rnnrbm.input_size),
tile_shape=closest_to_square_factors(rnnrbm.hidden_size),
tile_spacing=(1, 1)))
image.save(outdir + 'rnnrbm_midi_weights.png')
log.debug("done!")
del midi
del rnnrbm
del optimizer
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
layer1_act = Activation(inputs=((None, 1000), layer1.get_outputs()),
activation='relu')
# create the softmax classifier
layer2 = Softmax(inputs=((None, 1000), layer1_act.get_outputs()),
outputs=10,
out_as_probs=True)
# create the mlp from the two layers
mlp = Prototype(layers=[layer1, layer1_act, layer2])
# define the loss function
loss = Neg_LL(inputs=mlp.get_outputs(),
targets=vector("y", dtype="int64"),
one_hot=False)
# make an optimizer to train it (AdaDelta is a good default)
# optimizer = AdaDelta(model=mlp, dataset=mnist, n_epoch=20)
optimizer = AdaDelta(dataset=mnist, loss=loss, epochs=20)
# perform training!
# optimizer.train()
mlp.train(optimizer)
# test it on some images!
test_data, test_labels = mnist.test_inputs, mnist.test_targets
test_data = test_data[:25]
test_labels = test_labels[:25]
# use the run function!
preds = mlp.run(test_data)[0]
print('-------')
print(argmax(preds, axis=1))
print(test_labels.astype('int32'))
print()
print()
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
log.info("Creating MLP!")
# grab the MNIST dataset
mnist = MNIST()
# create the basic layer
layer1 = BasicLayer(input_size=28 * 28,
output_size=1000,
activation='relu')
# create the softmax classifier
layer2 = SoftmaxLayer(inputs_hook=(1000, layer1.get_outputs()),
output_size=10,
out_as_probs=False)
# create the mlp from the two layers
mlp = Prototype(layers=[layer1, layer2])
# make an optimizer to train it (AdaDelta is a good default)
optimizer = AdaDelta(model=mlp, dataset=mnist, n_epoch=20)
# perform training!
optimizer.train()
# test it on some images!
test_data, test_labels = mnist.getSubset(subset=TEST)
test_data = test_data[:25].eval()
test_labels = test_labels[:25].eval()
# use the run function!
preds = mlp.run(test_data)
print('-------')
print(preds)
print(test_labels.astype('int32'))
print()
print()
del mnist
del mlp
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()
