def main(argv):
experiment = Experiment()
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--model', '-m', type=str, required=True)
parser.add_argument('--data',
'-d',
type=str,
default='data/deadleaves_train.mat')
parser.add_argument('--width', '-W', type=int, default=512)
parser.add_argument('--height', '-H', type=int, default=512)
parser.add_argument('--crop', '-C', type=int, default=16)
parser.add_argument('--log', '-L', type=int, default=0)
parser.add_argument('--output',
'-o',
type=str,
default='results/sample.png')
args = parser.parse_args(argv[1:])
images = loadmat(args.data)['data']
vmin = percentile(images, 0.02)
vmax = percentile(images, 98.)
experiment = Experiment(args.model)
img = empty([args.height + args.crop, args.width + 2 * args.crop])
img.ravel()[:] = images.ravel()[random_select(img.size, images.size)]
img = sample_image(img,
experiment['model'],
experiment['input_mask'],
experiment['output_mask'],
experiment['preconditioner'],
min_value=vmin,
max_value=vmax)
if args.log:
# linearize and gamma-correct
img = power(exp(img), .45)
vmin = power(exp(vmin), .45)
vmax = power(exp(vmax), .45)
imwrite(
args.output,
imformat(img[args.crop:, args.crop:-args.crop],
vmin=vmin,
vmax=vmax,
symmetric=False))
savez('sample.npz', sample=img)
return 0
def main(argv):
if len(argv) < 2:
print 'Usage:', argv[0], '<experiment>', '[data_points]'
return 0
experiment = Experiment()
# range of data points evaluated
if len(argv) < 3:
fr, to = 0, 1000
else:
if '-' in argv[2]:
fr, to = argv[2].split('-')
fr, to = int(fr), int(to)
else:
fr, to = 0, int(argv[2])
indices = range(fr, to)
# load experiment with trained model
results = Experiment(argv[1])
# generate test data
data = load('data/vanhateren.{0}.0.npz'.format(results['parameters'][0]))['data']
data = preprocess(data, shuffle=False)
# compute importance weights estimating likelihoods
ais_weights = results['model'].loglikelihood(data[:, indices],
num_samples=NUM_AIS_SAMPLES, sampling_method=('ais', {'num_steps': NUM_AIS_STEPS}), return_all=True)
# average log-likelihood in [bit/pixel]
loglik = mean(logmeanexp(ais_weights, 0)) / log(2.) / data.shape[0]
sem = std(logmeanexp(ais_weights, 0), ddof=1) / log(2.) / data.shape[0] / sqrt(ais_weights.shape[1])
# store save results
experiment['indices'] = indices
experiment['ais_weights'] = ais_weights
experiment['loglik'] = loglik
experiment['sem'] = sem
experiment['fixed'] = True
experiment.save(argv[1][:-4] + '{0}-{1}.xpck'.format(fr, to))
return 0
def main(argv):
experiment = Experiment()
# load and preprocess data
data = load('./data/vanhateren8x8.npz')['data']
data = preprocess(data)
# train a mixture of Gaussian scale mixtures
mixture = MoGSM(data.shape[0], 8, 4)
mixture.train(data[:, :100000], num_epochs=100)
# compute training error
avglogloss = mixture.evaluate(data[:, 100000:])
# store results
experiment.results['mixture'] = mixture
experiment.results['avglogloss'] = avglogloss
experiment.save('results/experiment01/experiment01b.{0}.{1}.xpck')
return 0
def main(argv):
experiment = Experiment()
# load and preprocess data samples
data = load('./data/vanhateren4x4.npz')['data']
data = preprocess(data)
# train mixture of Gaussian scale mixtures
mixture = MoGSM(data.shape[0], 8, 4)
mixture.train(data, num_epochs=100)
# split data
batches = mixture.split(data)
# Gaussianize data
for k in range(len(mixture)):
batches[k] = RadialGaussianization(mixture[k],
symmetric=False)(batches[k])
# store results
experiment.results['mixture'] = mixture
experiment.results['batches'] = batches
experiment.save('results/experiment01/experiment01a.{0}.{1}.xpck')
return 0
def main(argv):
preconditioners = []
models = []
for i in range(63):
files = glob('results/BSDS300/snapshots/mcgsm_{0}_128.*.xpck'.format(i))
files.sort(key=os.path.getmtime)
if len(files) == 0:
print 'Could not find snapshot for model {0}.'.format(i)
files = glob('results/BSDS300/snapshots/mcgsm_{0}_64.*.xpck'.format(i))
filepath = files[-1]
print 'Using {0}.'.format(filepath)
experiment = Experiment(filepath)
preconditioners.append(experiment['preconditioners'][i])
models.append(experiment['models'][i])
experiment = Experiment()
experiment['models'] = models
experiment['preconditioners'] = preconditioners
experiment.save('results/BSDS300/mcgsm_128_merged.xpck', overwrite=True)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data', '-d', type=str, default='data/deadleaves_test.mat')
parser.add_argument('--patch_size', '-p', type=int, default=64,
help='Images are split into patches of this size and evaluated separately.')
parser.add_argument('--fraction', '-f', type=float, default=1.,
help='Only use a fraction of the data for a faster estimate.')
parser.add_argument('--mode', '-q', type=str, default='CPU', choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument('--stride', '-S', type=int, default=1)
args = parser.parse_args(argv[1:])
# select CPU or GPU for caffe
if args.mode.upper() == 'GPU':
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
# load data
data = loadmat(args.data)['data']
# load model
experiment = Experiment(args.model)
model = experiment['model']
if isinstance(model, PatchRIDE):
if args.patch_size != model.num_rows or args.patch_size != model.num_cols:
print 'Model is for {0}x{1} patches but data is {2}x{2}.'.format(
model.num_rows, model.num_cols, args.patch_size)
return 0
# apply model to data
logloss = []
for i in range(0, data.shape[1] - args.patch_size + 1, args.patch_size * args.stride):
for j in range(0, data.shape[2] - args.patch_size + 1, args.patch_size * args.stride):
# select random subset
idx = random_select(int(ceil(args.fraction * data.shape[0]) + .5), data.shape[0])
logloss.append(
model.evaluate(
data[:, i:i + args.patch_size, j:j + args.patch_size][idx]))
loglik_avg = -mean(logloss)
loglik_err = std(logloss, ddof=1) / sqrt(len(logloss)) if len(logloss) > 1 else inf
print 'Avg. log-likelihood: {0:.5f} +- {1:.5f} [bit/px]'.format(loglik_avg, loglik_err)
return 0
def main(argv):
experiment = Experiment()
# load and preprocess data samples
data = load('./data/vanhateren4x4.npz')['data']
data = preprocess(data)
# train mixture of Gaussian scale mixtures
mixture = MoGSM(data.shape[0], 8, 4)
mixture.train(data, num_epochs=100)
# split data
batches = mixture.split(data)
# Gaussianize data
for k in range(len(mixture)):
batches[k] = RadialGaussianization(mixture[k], symmetric=False)(batches[k])
# store results
experiment.results['mixture'] = mixture
experiment.results['batches'] = batches
experiment.save('results/experiment01/experiment01a.{0}.{1}.xpck')
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data', '-d', type=str, default='data/BSDS300_8x8.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
args = parser.parse_args(argv[1:])
data_test = loadmat(args.data)['patches_test']
dim = data_test.shape[1]
# reconstruct patches
patch_size = int(sqrt(data_test.shape[1] + 1) + .5)
data_test = hstack([data_test, -sum(data_test, 1)[:, None]])
data_test = data_test.reshape(-1, patch_size, patch_size)
if args.num_data > 0 and data_test.shape[0] > args.num_data:
data_test = data_test[random_select(args.num_data, data_test.shape[0])]
model = Experiment(args.model)['model']
print '{0:.3f} [nat]'.format(
-model.evaluate(data_test) * dim * log(2.))
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--num_data', '-N', type=int, default=5000000)
parser.add_argument('--data',
'-d',
type=str,
default='data/vanhateren_deq2_test.mat')
parser.add_argument('--verbosity', '-v', type=int, default=1)
args = parser.parse_args(argv[1:])
### LOAD RESULTS
experiment = Experiment(args.model)
### DATA HANDLING
if args.verbosity > 0:
print 'Loading data...'
# load data
images = loadmat(args.data)['data']
# causal neighborhood definition
input_mask = experiment['input_mask']
output_mask = experiment['output_mask']
# extract causal neighborhoods
num_samples = args.num_data // images.shape[0]
data = []
for i in range(images.shape[0]):
data.append(
generate_data_from_image(images[i], input_mask, output_mask,
num_samples))
inputs, outputs = zip(*data)
inputs = hstack(inputs)
outputs = hstack(outputs)
### MODEL EVALUATION
crossentropy = experiment['model'].evaluate(inputs, outputs,
experiment['preconditioner'])
print 'Cross-entropy: {0:.4f} [bit/px]'.format(crossentropy)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data', '-d', type=str, default='data/BSDS300_8x8.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
parser.add_argument('--batch_size', '-B', type=int, default=100000)
args = parser.parse_args(argv[1:])
data_test = loadmat(args.data)['patches_test']
dim = data_test.shape[1]
# reconstruct patches
patch_size = int(sqrt(data_test.shape[1] + 1) + .5)
data_test = hstack([data_test, -sum(data_test, 1)[:, None]])
data_test = data_test.reshape(-1, patch_size, patch_size)
if args.num_data > 0 and data_test.shape[0] > args.num_data:
data_test = data_test[random_select(args.num_data, data_test.shape[0])]
model = Experiment(args.model)['model']
# container for average log-likelihoods of batches
logliks = []
try:
for b in range(0, data_test.shape[0], args.batch_size):
# select batch
batch = data_test[b:b + args.batch_size]
# compute average log-likelihood of different models
loglik = []
loglik.append(model.loglikelihood(batch))
loglik.append(model.loglikelihood(transform(batch, True, False, False)))
loglik.append(model.loglikelihood(transform(batch, False, True, False)))
loglik.append(model.loglikelihood(transform(batch, True, True, False)))
loglik.append(model.loglikelihood(transform(batch, False, False, True)))
loglik.append(model.loglikelihood(transform(batch, True, False, True)))
loglik.append(model.loglikelihood(transform(batch, False, True, True)))
loglik.append(model.loglikelihood(transform(batch, True, True, True)))
# compute average log-likelihood of mixture model
loglik = logsumexp(loglik, 0) - log(len(loglik))
logliks.append(loglik.mean())
print '{0:.3f} [nat]'.format(mean(logliks))
except KeyboardInterrupt:
pass
import pdb
pdb.set_trace()
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS300_8x8.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
args = parser.parse_args(argv[1:])
# load data
data = loadmat(args.data)['patches_test']
# load model
experiment = Experiment(args.model)
models = experiment['models']
preconditioners = experiment['preconditioners']
def preprocess(data, i, N):
if N > 0 and N < data.shape[0]:
# select subset of data
idx = random_select(N, data.shape[0])
return data[idx, :i].T, data[idx, i][None, :]
return data.T[:i], data.T[[i]]
logloss = 0.
for i, model in enumerate(models):
inputs, outputs = preprocess(data, i, args.num_data)
if isinstance(model, MoGSM):
logloss += model.evaluate(outputs)
else:
logloss += model.evaluate(inputs, outputs, preconditioners[i])
print '{0}/{1} {2:.3f} [nat]'.format(
i + 1, data.shape[1],
-logloss * log(2.) / (i + 1.) * data.shape[1])
return 0
def main(argv):
experiment = Experiment()
# load and preprocess data
data = load('./data/vanhateren8x8.npz')['data']
data = preprocess(data)
# train a mixture of Gaussian scale mixtures
mixture = MoGSM(data.shape[0], 8, 4)
mixture.train(data[:, :100000], num_epochs=100)
# compute training error
avglogloss = mixture.evaluate(data[:, 100000:])
# store results
experiment.results['mixture'] = mixture
experiment.results['avglogloss'] = avglogloss
experiment.save('results/experiment01/experiment01b.{0}.{1}.xpck')
return 0
def main(argv):
seterr(over='raise', divide='raise', invalid='raise')
try:
if int(os.environ['OMP_NUM_THREADS']) > 1 or int(os.environ['MKL_NUM_THREADS']) > 1:
print 'It seems that parallelization is turned on. This will skew the results. To turn it off:'
print '\texport OMP_NUM_THREADS=1'
print '\texport MKL_NUM_THREADS=1'
except:
print 'Parallelization of BLAS might be turned on. This could skew results.'
experiment = Experiment(seed=42)
if os.path.exists('results/toyexample/toyexample.xpck'):
results = Experiment('results/toyexample/toyexample.xpck')
ica = results['ica']
else:
# toy model
ica = ISA(1, 3)
ica.initialize(method='exponpow')
ica.A = 1. + randn(1, 3) / 5.
experiment['ica'] = ica
experiment.save('results/toyexample/toyexample.xpck')
Y_ = ica.sample_prior(NUM_AUTOCORR)
X_ = dot(ica.A, Y_)
for method in sampling_methods:
# disable output and parallelization
Distribution.VERBOSITY = 0
mapp.max_processes = 1
Y = ica.sample_prior(NUM_SAMPLES)
X = dot(ica.A, Y)
# measure time required by transition operator
start = time()
# increase number of steps to reduce overhead
ica.sample_posterior(X, method=(method['method'], dict(method['parameters'],
Y=Y, num_steps=method['parameters']['num_steps'] * NUM_STEPS_MULTIPLIER)))
# time required per transition operator application
duration = (time() - start) / NUM_STEPS_MULTIPLIER
# number of mcmc steps to run for this method
num_mcmc_steps = int(NUM_SECONDS_RUN / duration + 1.)
num_autocorr_steps = int(NUM_SECONDS_VIS / duration + 1.)
# enable output and parallelization
Distribution.VERBOSITY = 2
mapp.max_processes = 2
# posterior samples
Y = [Y_]
# Markov chain
for i in range(num_mcmc_steps):
Y.append(ica.sample_posterior(X_,
method=(method['method'], dict(method['parameters'], Y=Y[-1]))))
ac = []
for j in range(NUM_AUTOCORR):
# collect samples belonging to one posterior distribution
S = hstack([Y[k][:, [j]] for k in range(num_mcmc_steps)])
# compute autocorrelation for j-th posterior
ac = [autocorr(S, num_autocorr_steps)]
# average and plot autocorrelation functions
plot(arange(num_autocorr_steps) * duration, mean(ac, 0), '-',
color=method['color'],
line_width=1.2,
comment=str(method['parameters']))
xlabel('time in seconds')
ylabel('autocorrelation')
title('toy example')
gca().width = 7
gca().height = 7
gca().xmin = -1
gca().xmax = NUM_SECONDS_VIS
savefig('results/toyexample/toyexample_autocorr2.tex')
return 0
def main(argv):
experiment = Experiment()
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--data',
'-d',
type=str,
default='data/vanhateren_deq2_train.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
parser.add_argument('--num_valid', '-V', type=int, default=200000)
parser.add_argument('--input_size', '-i', type=int, default=9)
parser.add_argument('--max_iter', '-I', type=int, default=3000)
parser.add_argument('--num_components', '-c', type=int, default=128)
parser.add_argument('--num_features', '-f', type=int, default=48)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--verbosity', '-v', type=int, default=1)
parser.add_argument('--output',
'-o',
type=str,
default='results/vanhateren_deq2/mcgsm.{0}.{1}.xpck')
args = parser.parse_args(argv[1:])
### DATA HANDLING
if args.verbosity > 0:
print 'Loading data...'
# load data
images = loadmat(args.data)['data']
# define causal neighborhood
input_mask, output_mask = generate_masks(input_size=args.input_size,
output_size=1)
# extract causal neighborhoods
num_samples = int((args.num_data + args.num_valid) / images.shape[0] + .9)
def extract(image):
return generate_data_from_image(image, input_mask, output_mask,
num_samples)
inputs, outputs = zip(*mapp(extract, images))
inputs, outputs = hstack(inputs), hstack(outputs)
inputs_train = inputs[:, :args.num_data]
outputs_train = outputs[:, :args.num_data]
inputs_valid = inputs[:, args.num_data:]
outputs_valid = outputs[:, args.num_data:]
if inputs_valid.size < 100:
print 'Not enough data for validation.'
inputs_valid = None
outputs_valid = None
### MODEL TRAINING
if args.verbosity > 0:
print 'Preconditioning...'
preconditioner = WhiteningPreconditioner(inputs_train, outputs_train)
inputs_train, outputs_train = preconditioner(inputs_train, outputs_train)
if inputs_valid is not None:
inputs_valid, outputs_valid = preconditioner(inputs_valid,
outputs_valid)
# free memory
del inputs
del outputs
if args.verbosity > 0:
print 'Training model...'
model = MCGSM(dim_in=inputs_train.shape[0],
dim_out=outputs_train.shape[0],
num_components=args.num_components,
num_features=args.num_features,
num_scales=args.num_scales)
def callback(i, mcgsm):
experiment['args'] = args
experiment['model'] = mcgsm
experiment['preconditioner'] = preconditioner
experiment['input_mask'] = input_mask
experiment['output_mask'] = output_mask
experiment.save(args.output)
model.train(inputs_train,
outputs_train,
inputs_valid,
outputs_valid,
parameters={
'verbosity': args.verbosity,
'cb_iter': 500,
'callback': callback,
'max_iter': args.max_iter
})
### SAVE RESULTS
experiment['args'] = args
experiment['model'] = model
experiment['preconditioner'] = preconditioner
experiment['input_mask'] = input_mask
experiment['output_mask'] = output_mask
experiment.save(args.output)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--patch_size', '-p', type=int, default=[8, 10, 12, 14, 16, 18, 20, 22], nargs='+')
parser.add_argument('--row_multiplier', '-R', type=int, default=[1], nargs='+',
help='Can be used to train on elongated patches.')
parser.add_argument('--col_multiplier', '-C', type=int, default=[1], nargs='+',
help='Can be used to train on elongated patches.')
parser.add_argument('--num_patches', '-P', type=int, default=None,
help='If given, subsample training data.')
parser.add_argument('--num_valid', '-V', type=int, default=0,
help='Number of training images used for validation error based early stopping.')
parser.add_argument('--finetune', '-F', type=int, default=[1], nargs='+',
help='Indicate iterations in which to finetune MCGSM with L-BFGS.')
parser.add_argument('--learning_rate', '-l', type=float, default=[1., .5, .1, .05, .01, 0.005, 0.001, 0.0005], nargs='+')
parser.add_argument('--momentum', '-m', type=float, default=[.9], nargs='+')
parser.add_argument('--batch_size', '-B', type=int, default=[50], nargs='+')
parser.add_argument('--nb_size', '-b', type=int, default=5,
help='Size of the causal neighborhood of pixels.')
parser.add_argument('--num_hiddens', '-n', type=int, default=64)
parser.add_argument('--num_components', '-c', type=int, default=32)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--num_features', '-f', type=int, default=32)
parser.add_argument('--num_epochs', '-e', type=int, default=[1], nargs='+')
parser.add_argument('--precondition', '-Q', type=int, default=1)
parser.add_argument('--method', '-M', type=str, default=['SGD'], nargs='+')
parser.add_argument('--data', '-d', type=str, default='data/deadleaves_train.mat')
parser.add_argument('--noise', '-N', type=float, default=None,
help='Standard deviation of Gaussian noise added to data before training (as fraction of data standard deviation).')
parser.add_argument('--model', '-I', type=str, default='',
help='Start with this model as initialization. Other flags will be ignored.')
parser.add_argument('--add_layer', '-a', type=int, default=[0], nargs='+')
parser.add_argument('--train_top_layer', '-T', type=int, default=[0], nargs='+')
parser.add_argument('--train_means', '-S', type=int, default=[0], nargs='+')
parser.add_argument('--mode', '-q', type=str, default='CPU', choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument('--augment', '-A', type=int, default=1,
help='Increase training set size by transforming data.')
parser.add_argument('--overlap', '-O', type=int, default=[1], nargs='+')
parser.add_argument('--output', '-o', type=str, default='results/deadleaves/')
parser.add_argument('--patch_model', type=int, default=0,
help='Train a patch-based model instead of a stochastic process.')
parser.add_argument('--extended', '-X', type=int, default=0,
help='Use extended version of spatial LSTM.')
parser.add_argument('--multiscale', '-Y', type=int, default=0,
help='Apply recurrent image model to multiscale representation of images.')
parser.add_argument('--color', '-Z', type=int, default=0,
help='Use separate models to model color and grayscale values.')
args = parser.parse_args(argv[1:])
experiment = Experiment()
if args.mode.upper() == 'GPU':
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
# load data
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
data = imread(args.data)[None]
data += rand(*data.shape)
else:
data = loadmat(args.data)['data']
if args.augment > 0:
data = vstack([data, data[:, :, ::-1]])
if args.augment > 1:
data = vstack([data, data[:, ::-1, :]])
if args.noise is not None:
# add noise as a means for regularization
data += randn(*data.shape) * (std(data, ddof=1) / args.noise)
if args.num_valid > 0:
if args.num_valid >= data.shape[0]:
print 'Cannot use {0} for validation, there are only {1} training images.'.format(
args.num_valid, data.shape[0])
return 1
# select subset for validation
idx = random_select(args.num_valid, data.shape[0])
data_valid = data[idx]
data = asarray([image for i, image in enumerate(data) if i not in idx])
print '{0} training images'.format(data.shape[0])
print '{0} validation images'.format(data_valid.shape[0])
patches_valid = []
patch_size = min([64, data.shape[1], data.shape[2]])
for i in range(0, data_valid.shape[1] - patch_size + 1, patch_size):
for j in range(0, data_valid.shape[2] - patch_size + 1, patch_size):
patches_valid.append(data_valid[:, i:i + patch_size, j:j + patch_size])
patches_valid = vstack(patches_valid)
if args.model:
# load pretrained model
results = Experiment(args.model)
model = results['model']
loss = [results['loss']]
if args.patch_model and not isinstance(model, PatchRIDE):
model = PatchRIDE(
model=model,
num_rows=args.patch_size[0],
num_cols=args.patch_size[0])
else:
# create recurrent image model
if args.patch_model:
model = PatchRIDE(
num_rows=args.patch_size[0],
num_cols=args.patch_size[0],
num_channels=data.shape[-1] if data.ndim > 3 else 1,
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
model_class=ColorRIDE if args.color else RIDE)
if args.extended:
print 'Extended patch model not supported.'
return 0
if args.multiscale:
print 'Multiscale patch model not supported.'
return 0
else:
if args.multiscale:
if data.ndim > 3 and data.shape[-1] > 1:
print 'Multiscale color model not supported.'
return 0
model = MultiscaleRIDE(
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
elif args.color:
if data.ndim < 4 or data.shape[-1] != 3:
print 'These images don\'t look like RGB images.'
return 0
model = ColorRIDE(
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
else:
model = RIDE(
num_channels=data.shape[-1] if data.ndim > 3 else 1,
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
loss = []
# compute initial performance
loss_valid = []
if args.num_valid > 0:
print 'Computing validation loss...'
loss_valid.append(model.evaluate(patches_valid))
model_copy = deepcopy(model)
for k, patch_size in enumerate(args.patch_size):
if args.multiscale:
patch_size *= 2
if k < len(args.add_layer):
for _ in range(args.add_layer[k]):
# add spatial LSTM to the network
model.add_layer()
# extract patches of given patch size
patches = []
row_size = patch_size * args.row_multiplier[k % len(args.row_multiplier)]
col_size = patch_size * args.col_multiplier[k % len(args.col_multiplier)]
if isinstance(model, PatchRIDE):
model.num_rows = row_size
model.num_cols = col_size
for i in range(0, data.shape[1] - row_size + 1, row_size / args.overlap[k % len(args.overlap)]):
for j in range(0, data.shape[2] - col_size + 1, col_size / args.overlap[k % len(args.overlap)]):
patches.append(data[:, i:i + row_size, j:j + col_size])
patches = vstack(patches)
# randomize order of patches
if args.num_patches is not None and args.num_patches < len(patches):
patches = patches[random_select(args.num_patches, len(patches))]
else:
patches = patches[permutation(len(patches))]
# determine batch size
if args.method[k % len(args.method)].upper() == 'SFO':
num_batches = int(max([25, sqrt(patches.shape[0]) / 5.]))
batch_size = patches.shape[0] // num_batches
else:
batch_size = args.batch_size[k % len(args.batch_size)]
if batch_size < 1:
raise RuntimeError('Too little data.')
print 'Patch size: {0}x{1}'.format(row_size, col_size)
print 'Number of patches: {0}'.format(patches.shape[0])
print 'Batch size: {0}'.format(batch_size)
# train recurrent image model
print 'Training...'
loss.append(
model.train(patches,
batch_size=batch_size,
method=args.method[k % len(args.method)],
num_epochs=args.num_epochs[k % len(args.num_epochs)],
learning_rate=args.learning_rate[k % len(args.learning_rate)],
momentum=args.momentum[k % len(args.momentum)],
precondition=args.precondition > 0,
train_top_layer=args.train_top_layer[k % len(args.train_top_layer)] > 0,
train_means=args.train_means[k % len(args.train_means)] > 0))
if args.finetune[k % len(args.finetune)]:
print 'Finetuning...'
model.finetune(patches, num_samples_train=1000000, max_iter=500)
if args.num_valid > 0:
print 'Computing validation loss...'
loss_valid.append(model.evaluate(patches_valid))
if loss_valid[-1] > loss_valid[-2]:
print 'Performance got worse. Stopping optimization.'
model = model_copy
break
print 'Copying model...'
model_copy = deepcopy(model)
experiment['batch_size'] = batch_size
experiment['args'] = args
experiment['model'] = model
experiment['loss_valid'] = loss_valid
experiment['loss'] = hstack(loss) if len(loss) > 0 else []
experiment.save(os.path.join(args.output, 'rim.{0}.{1}.xpck'))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--num_rows', '-r', type=int, default=256)
parser.add_argument('--num_cols', '-c', type=int, default=256)
parser.add_argument('--data', '-d', type=str, default=None)
parser.add_argument('--log', '-L', type=int, default=0)
parser.add_argument('--output', '-o', type=str, default='sample.png')
parser.add_argument('--margin', '-M', type=int, default=8)
args = parser.parse_args(argv[1:])
model = Experiment(args.model)['model']
if isinstance(model, PatchRIDE):
img = model.sample()[0]
imwrite(args.output, imformat(img, vmin=0, vmax=255, symmetric=False))
else:
if args.data is None:
# initialize image with white noise
img_init = randn(1,
args.num_rows + args.margin * 2,
args.num_cols + args.margin * 2,
sum(model.num_channels)) / 10.
img = model.sample(img_init)
if args.log:
# linearize and gamma-correct
img = power(exp(img), .45)
if args.margin > 0:
img = img[:, args.margin:-args.margin, args.margin:-args.margin]
if img.shape[-1] == 3:
img[img > 255.] = 255.
img[img < 0.] = 0.
imwrite(args.output, asarray(img[0, :, :, :], dtype='uint8'))
else:
imwrite(args.output, imformat(img[0, :, :, 0], perc=99))
else:
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
data = imread(args.data)[None]
vmin, vmax = 0, 255
else:
data = loadmat(args.data)['data']
vmin = percentile(data, 0.02)
vmax = percentile(data, 98.)
if data.ndim < 4:
data = data[:, :, :, None]
if isinstance(model, MultiscaleRIDE):
num_channels = 1
elif isinstance(model, ColorRIDE):
num_channels = 3
else:
num_channels = model.num_channels
num_pixels = (args.num_rows + args.margin) * (args.num_cols + args.margin * 2)
# initialize image with white noise (but correct marginal distribution)
img_init = []
for c in range(num_channels):
indices = randint(data.size // num_channels, size=num_pixels)
img_init.append(
asarray(data[:, :, :, c].ravel()[indices], dtype=float).reshape(
1,
args.num_rows + args.margin,
args.num_cols + args.margin * 2, 1))
img_init = concatenate(img_init, 3)
img_init[img_init < vmin] = vmin
img_init[img_init > vmax] = vmax
if isinstance(model, MultiscaleRIDE) or isinstance(model, ColorRIDE):
data = model._transform(data)
idx = randint(data.shape[0])
img = model.sample(img_init,
# min_values=data[idx].min(1).min(0),
# max_values=data[idx].max(1).max(0))
min_values=data.min(2).min(1).min(0),
max_values=data.max(2).max(1).max(0))
else:
# img_init[:] = img_init.mean()
img = model.sample(img_init,
min_values=percentile(data, .1),
max_values=percentile(data, 99.8))
# min_values=percentile(data, 1.),
# max_values=percentile(data, 96.))
if args.log:
# linearize and gamma-correct
img = power(exp(img), .45)
vmin = power(exp(vmin), .45)
vmax = power(exp(vmax), .45)
try:
savez(args.output.split('.')[0] + '.npz', sample=img)
except:
pass
if args.margin > 0:
img = img[:, args.margin:, args.margin:-args.margin]
if num_channels == 1:
imwrite(args.output,
imformat(img[0, :, :, 0], vmin=vmin, vmax=vmax, symmetric=False))
else:
imwrite(args.output,
imformat(img[0], vmin=vmin, vmax=vmax, symmetric=False))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS300_8x8.mat')
parser.add_argument('--num_train', '-N', type=int, default=1000000)
parser.add_argument('--num_valid', '-V', type=int, default=200000)
parser.add_argument('--num_components', '-n', type=int, default=128)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--num_features', '-f', type=int, default=48)
parser.add_argument('--train_means', '-M', type=int, default=0)
parser.add_argument('--indices', '-I', type=int, default=[], nargs='+')
parser.add_argument('--initialize', '-i', type=str, default=None)
parser.add_argument('--verbosity', '-v', type=int, default=1)
parser.add_argument('--max_iter', '-m', type=int, default=2000)
args = parser.parse_args(argv[1:])
experiment = Experiment()
data_train = loadmat(args.data)['patches_train']
data_valid = loadmat(args.data)['patches_valid']
if args.initialize:
results = Experiment(args.initialize)
models = results['models']
preconditioners = results['preconditioners']
else:
models = [None] * data_train.shape[1]
preconditioners = [None] * data_train.shape[1]
def preprocess(data, i, N):
if N > 0 and N < data.shape[0]:
# select subset of data
idx = random_select(N, data.shape[0])
return data[idx, :i].T, data[idx, i][None, :]
return data.T[:i], data.T[[i]]
for i in range(data_train.shape[1]):
if args.indices and i not in args.indices:
# skip this one
continue
print 'Training model {0}/{1}...'.format(i + 1, data_train.shape[1])
inputs_train, outputs_train = preprocess(data_train, i, args.num_train)
inputs_valid, outputs_valid = preprocess(data_valid, i, args.num_valid)
if i > 0:
if preconditioners[i] is None:
preconditioners[i] = WhiteningPreconditioner(
inputs_train, outputs_train)
inputs_train, outputs_train = preconditioners[i](inputs_train,
outputs_train)
inputs_valid, outputs_valid = preconditioners[i](inputs_valid,
outputs_valid)
if models[i] is None:
models[i] = MCGSM(dim_in=i,
dim_out=1,
num_components=args.num_components,
num_features=args.num_features,
num_scales=args.num_scales)
models[i].train(inputs_train,
outputs_train,
inputs_valid,
outputs_valid,
parameters={
'verbosity': 1,
'max_iter': args.max_iter,
'train_means': args.train_means > 0
})
else:
preconditioners[i] = None
if models[i] is None:
models[i] = MoGSM(dim=1, num_components=4, num_scales=8)
models[i].train(outputs_train,
outputs_valid,
parameters={
'verbosity': 1,
'threshold': -1.,
'train_means': 1,
'max_iter': 100
})
experiment['args'] = args
experiment['models'] = models
experiment['preconditioners'] = preconditioners
experiment.save(
'results/BSDS300/snapshots/mcgsm_{0}_{1}.{{0}}.{{1}}.xpck'.format(
i, args.num_components))
if not args.indices:
experiment['args'] = args
experiment['models'] = models
experiment['preconditioners'] = preconditioners
experiment.save('results/BSDS300/mcgsm.{0}.{1}.xpck')
return 0
def main(argv):
seterr(over='raise', divide='raise', invalid='raise')
try:
if int(os.environ['OMP_NUM_THREADS']) > 1 or int(
os.environ['MKL_NUM_THREADS']) > 1:
print 'It seems that parallelization is turned on. This will skew the results. To turn it off:'
print '\texport OMP_NUM_THREADS=1'
print '\texport MKL_NUM_THREADS=1'
except:
print 'Parallelization of BLAS might be turned on. This could skew results.'
experiment = Experiment(seed=42)
if os.path.exists('results/toyexample/toyexample.xpck'):
results = Experiment('results/toyexample/toyexample.xpck')
ica = results['ica']
else:
# toy model
ica = ISA(1, 3)
ica.initialize(method='exponpow')
ica.A = 1. + randn(1, 3) / 5.
experiment['ica'] = ica
experiment.save('results/toyexample/toyexample.xpck')
# generate visible and corresponding hidden states
Y = ica.sample_prior(NUM_SAMPLES)
X = dot(ica.A, Y)
# energy of posterior samples should be around this value
energy = mean(ica.prior_energy(Y))
for method in sampling_methods:
# disable output and parallelization
Distribution.VERBOSITY = 0
mapp.max_processes = 1
# measure time required by transition operator
start = time()
# initial hidden states
Y = dot(pinv(ica.A), X)
# increase number of steps to reduce overhead
ica.sample_posterior(
X,
method=(method['method'],
dict(method['parameters'],
Y=Y,
num_steps=method['parameters']['num_steps'] *
NUM_STEPS_MULTIPLIER)))
# time required per transition operator application
duration = (time() - start) / NUM_STEPS_MULTIPLIER
# enable output and parallelization
Distribution.VERBOSITY = 2
mapp.max_processes = 2
energies = [mean(ica.prior_energy(Y))]
# Markov chain
for i in range(int(NUM_SECONDS / duration + 1.)):
Y = ica.sample_posterior(X,
method=(method['method'],
dict(method['parameters'], Y=Y)))
energies.append(mean(ica.prior_energy(Y)))
plot(arange(len(energies)) * duration,
energies,
'-',
color=method['color'],
line_width=1.2,
pgf_options=['forget plot'],
comment=str(method['parameters']))
plot([-2, NUM_SECONDS + 2], energy, 'k--', line_width=1.2)
xlabel('time in seconds')
ylabel('average energy')
title('toy example')
gca().width = 7
gca().height = 7
gca().xmin = -1
gca().xmax = NUM_SECONDS
savefig('results/toyexample/toyexample_trace.tex')
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--num_rows', '-r', type=int, default=256)
parser.add_argument('--num_cols', '-c', type=int, default=256)
parser.add_argument('--data', '-d', type=str, default=None)
parser.add_argument('--log', '-L', type=int, default=0)
parser.add_argument('--output', '-o', type=str, default='sample.png')
parser.add_argument('--margin', '-M', type=int, default=8)
args = parser.parse_args(argv[1:])
model = Experiment(args.model)['model']
if isinstance(model, PatchRIDE):
img = model.sample()[0]
imwrite(args.output, imformat(img, vmin=0, vmax=255, symmetric=False))
else:
if args.data is None:
# initialize image with white noise
img_init = randn(1, args.num_rows + args.margin * 2, args.num_cols
+ args.margin * 2, sum(model.num_channels)) / 10.
img = model.sample(img_init)
if args.log:
# linearize and gamma-correct
img = power(exp(img), .45)
if args.margin > 0:
img = img[:, args.margin:-args.margin,
args.margin:-args.margin]
if img.shape[-1] == 3:
img[img > 255.] = 255.
img[img < 0.] = 0.
imwrite(args.output, asarray(img[0, :, :, :], dtype='uint8'))
else:
imwrite(args.output, imformat(img[0, :, :, 0], perc=99))
else:
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
data = imread(args.data)[None]
vmin, vmax = 0, 255
else:
data = loadmat(args.data)['data']
vmin = percentile(data, 0.02)
vmax = percentile(data, 98.)
if data.ndim < 4:
data = data[:, :, :, None]
if isinstance(model, MultiscaleRIDE):
num_channels = 1
elif isinstance(model, ColorRIDE):
num_channels = 3
else:
num_channels = model.num_channels
num_pixels = (args.num_rows + args.margin) * (args.num_cols +
args.margin * 2)
# initialize image with white noise (but correct marginal distribution)
img_init = []
for c in range(num_channels):
indices = randint(data.size // num_channels, size=num_pixels)
img_init.append(
asarray(data[:, :, :, c].ravel()[indices],
dtype=float).reshape(
1, args.num_rows + args.margin,
args.num_cols + args.margin * 2, 1))
img_init = concatenate(img_init, 3)
img_init[img_init < vmin] = vmin
img_init[img_init > vmax] = vmax
if isinstance(model, MultiscaleRIDE) or isinstance(
model, ColorRIDE):
data = model._transform(data)
idx = randint(data.shape[0])
img = model.sample(
img_init,
# min_values=data[idx].min(1).min(0),
# max_values=data[idx].max(1).max(0))
min_values=data.min(2).min(1).min(0),
max_values=data.max(2).max(1).max(0))
else:
# img_init[:] = img_init.mean()
img = model.sample(img_init,
min_values=percentile(data, .1),
max_values=percentile(data, 99.8))
# min_values=percentile(data, 1.),
# max_values=percentile(data, 96.))
if args.log:
# linearize and gamma-correct
img = power(exp(img), .45)
vmin = power(exp(vmin), .45)
vmax = power(exp(vmax), .45)
try:
savez(args.output.split('.')[0] + '.npz', sample=img)
except:
pass
if args.margin > 0:
img = img[:, args.margin:, args.margin:-args.margin]
if num_channels == 1:
imwrite(
args.output,
imformat(img[0, :, :, 0],
vmin=vmin,
vmax=vmax,
symmetric=False))
else:
imwrite(
args.output,
imformat(img[0], vmin=vmin, vmax=vmax, symmetric=False))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('image', type=str)
parser.add_argument('model', type=str)
parser.add_argument('--init', '-I', type=str, default=None)
parser.add_argument('--index', '-x', type=int, default=0,
help='Determines which image is used when whole dataset is given instead of image.')
parser.add_argument('--fill_region', '-f', type=int, default=71)
parser.add_argument('--outer_patch_size', '-p', type=int, default=19)
parser.add_argument('--inner_patch_size', '-i', type=int, default=5)
parser.add_argument('--stride', '-s', type=int, default=3)
parser.add_argument('--candidates', '-C', type=int, default=5,
help='The best initialization is taken out of this many initializations.')
parser.add_argument('--num_epochs', '-e', type=int, default=1000)
parser.add_argument('--method', '-m', type=str, default='SAMPLE', choices=['SAMPLE', 'MAP'])
parser.add_argument('--step_width', '-l', type=float, default=100.)
parser.add_argument('--output', '-o', type=str, default='results/inpainting/')
parser.add_argument('--flip', '-F', type=int, default=0,
help='If > 0, assume horizontal symmetry. If > 1, assume vertical symmetry.')
args = parser.parse_args(argv[1:])
### DATA
# load image
if args.image.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
image = imread(args.image)[None]
vmin, vmax = 0, 255
else:
image = loadmat(args.image)['data'][[args.index]]
vmin, vmax = image.min(), image.max()
if image.ndim < 4:
image = image[:, :, :, None]
image = asarray(image, dtype=float)
imwrite(os.path.join(args.output, 'original.png'),
imformat(image[0, :, :, 0], vmin=vmin, vmax=vmax, symmetric=False))
# remove center portion
i_start = (image.shape[1] - args.fill_region) // 2
j_start = (image.shape[2] - args.fill_region) // 2
image[0,
i_start:i_start + args.fill_region,
j_start:j_start + args.fill_region, 0] = vmin + rand(args.fill_region, args.fill_region) * (vmax - vmin)
imwrite(os.path.join(args.output, 'start.png'),
imformat(image[0, :, :, 0], vmin=vmin, vmax=vmax, symmetric=False))
### MODEL
# load model
model = Experiment(args.model)['model']
model.verbosity = False
# use different models for sampling and likelihoods because of SLSTM caching
model_copy = deepcopy(model)
# create mask indicating pixels to replace
M = args.outer_patch_size
N = args.inner_patch_size
m = (M - N) // 2
n = M - N - m
patch_mask = zeros([M, M], dtype=bool)
patch_mask[m:-n, m:-n] = True
if args.init is None:
candidates = []
logliks = []
for _ in range(args.candidates):
# replace missing pixels by ancestral sampling
patch = image[:,
i_start - M:i_start + args.fill_region,
j_start - M:j_start + args.fill_region + M]
sample_mask = zeros([patch.shape[1], patch.shape[2]], dtype=bool)
sample_mask[M:, M:-M] = True
image[:,
i_start - M:i_start + args.fill_region,
j_start - M:j_start + args.fill_region + M] = model.sample(patch, mask=sample_mask,
min_values=vmin, max_values=vmax)
candidates.append(image.copy())
logliks.append(model.loglikelihood(image).sum())
image = candidates[argmax(logliks)]
imwrite(os.path.join(args.output, 'fillin.0.png'),
imformat(image[0, :, :, 0], vmin=vmin, vmax=vmax, symmetric=False))
start_epoch = 0
else:
init = load(args.init)
image = init['image']
start_epoch = init['epoch']
### INPAINTING
try:
for epoch in range(start_epoch, args.num_epochs):
print epoch
h_flipped = False
if args.flip > 0 and rand() < .5:
print 'Horizontal flip.'
# flip image horizontally
image = image[:, :, ::-1]
j_start = image.shape[2] - j_start - args.fill_region
h_flipped = True
v_flipped = False
if args.flip > 0 and rand() < .5:
print 'Vertical flip.'
# flip image vertically
image = image[:, ::-1, :]
i_start = image.shape[1] - i_start - args.fill_region
v_flipped = True
for i in range(i_start - m, i_start - m + args.fill_region - N + 1, args.stride):
for j in range(j_start - m, j_start - m + args.fill_region - N + 1, args.stride):
patch = image[:, i:i + M, j:j + M]
if args.method == 'SAMPLE':
# proposal
patch_pr, logq_pr = model.sample(patch.copy(), mask=patch_mask,
min_values=vmin, max_values=vmax, return_loglik=True)
# conditional log-density
logq = model_copy._logq(patch, patch_mask)
# joint log-densities
logp = model_copy.loglikelihood(patch).sum()
logp_pr = model_copy.loglikelihood(patch_pr).sum()
if rand() < exp(logp_pr - logp - logq_pr + logq):
# accept proposal
patch[:] = patch_pr
else:
# gradient step
grad = model.gradient(patch)[1]
patch[:, patch_mask] += grad[:, patch_mask] * args.step_width
# flip back
if h_flipped:
image = image[:, :, ::-1]
j_start = image.shape[2] - j_start - args.fill_region
if v_flipped:
image = image[:, ::-1, :]
i_start = image.shape[1] - i_start - args.fill_region
imwrite(os.path.join(args.output, 'fillin.{0}.png'.format(epoch + 1)),
imformat(image[0, :, :, 0], vmin=vmin, vmax=vmax, symmetric=False))
except KeyboardInterrupt:
pass
savez(os.path.join(args.output, 'final.npz'), image=image, epoch=epoch)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS300_8x8.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
args = parser.parse_args(argv[1:])
# load data
data = loadmat(args.data)['patches_test']
if args.num_data > 0 and args.num_data < data.shape[0]:
# select random subset of data
data = data[random_select(args.num_data, data.shape[0])]
print 'Transforming data...'
# transform data
data_all = [
data,
transform(data, True, False, False),
transform(data, False, True, False),
transform(data, True, True, False),
transform(data, False, False, True),
transform(data, True, False, True),
transform(data, False, True, True),
transform(data, True, True, True)
]
# each entry corresponds to a different model/transformation
loglik = [0.] * len(data_all)
# load model
experiment = Experiment(args.model)
models = experiment['models'] # models for the different pixels
preconditioners = experiment['preconditioners']
if len(models) != data.shape[1]:
print 'Wrong number of models!'
return 0
for i, model in enumerate(models):
for n, data in enumerate(data_all):
inputs, outputs = data.T[:i], data.T[[i]]
# this sums over pixels
if isinstance(model, MoGSM):
loglik[n] = loglik[n] + model.loglikelihood(outputs)
else:
loglik[n] = loglik[n] + model.loglikelihood(*preconditioners[i](inputs, outputs)) \
+ preconditioners[i].logjacobian(inputs, outputs)
print '{0}/{1}'.format(i + 1, data.shape[1])
# each row of loglik is a different model/transformation, each column a different data point
loglik = logsumexp(loglik, 0) - log(len(loglik))
print '{0:.4f} [nat]'.format(mean(loglik))
return 0
def main(argv):
seterr(over='raise', divide='raise', invalid='raise')
try:
if int(os.environ['OMP_NUM_THREADS']) > 1 or int(
os.environ['MKL_NUM_THREADS']) > 1:
print 'It seems that parallelization is turned on. This will skew the results. To turn it off:'
print '\texport OMP_NUM_THREADS=1'
print '\texport MKL_NUM_THREADS=1'
except:
print 'Parallelization of BLAS might be turned on. This could skew results.'
experiment = Experiment(seed=42)
if not os.path.exists(EXPERIMENT_PATH):
print 'Could not find file \'{0}\'.'.format(EXPERIMENT_PATH)
return 0
results = Experiment(EXPERIMENT_PATH)
ica = results['model'].model[1].model
# load test data
data = load('data/vanhateren.{0}.0.npz'.format(
results['parameters'][0]))['data']
data = data[:, :100000]
data = preprocess(data)
data = data[:, permutation(data.shape[1] / 2)[:NUM_SAMPLES]]
# transform data
dct = results['model'].transforms[0]
wt = results['model'].model[1].transforms[0]
data = wt(dct(data)[1:])
X = data
for method in sampling_methods:
# disable output and parallelization
Distribution.VERBOSITY = 0
mapp.max_processes = 1
# measure time required by transition operator
start = time()
# initial hidden states
Y = dot(pinv(ica.A), X)
# increase number of steps to reduce overhead
ica.sample_posterior(
X,
method=(method['method'],
dict(method['parameters'],
Y=Y,
num_steps=method['parameters']['num_steps'] *
NUM_STEPS_MULTIPLIER)))
# time required per transition operator application
duration = (time() - start) / NUM_STEPS_MULTIPLIER
# enable output and parallelization
Distribution.VERBOSITY = 2
mapp.max_processes = 2
energies = [mean(ica.prior_energy(Y))]
# Markov chain
for i in range(int(NUM_SECONDS / duration + 1.)):
Y = ica.sample_posterior(X,
method=(method['method'],
dict(method['parameters'], Y=Y)))
energies.append(mean(ica.prior_energy(Y)))
plot(arange(len(energies)) * duration,
energies,
'-',
color=method['color'],
line_width=1.2,
pgf_options=['forget plot'],
comment=str(method['parameters']))
xlabel('time in seconds')
ylabel('average energy')
title('van Hateren')
gca().width = 7
gca().height = 7
gca().xmin = -1
gca().xmax = NUM_SECONDS
savefig('results/vanhateren/vanhateren_trace_.tex')
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS300_8x8.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
parser.add_argument('--batch_size', '-B', type=int, default=100000)
args = parser.parse_args(argv[1:])
data_test = loadmat(args.data)['patches_test']
dim = data_test.shape[1]
# reconstruct patches
patch_size = int(sqrt(data_test.shape[1] + 1) + .5)
data_test = hstack([data_test, -sum(data_test, 1)[:, None]])
data_test = data_test.reshape(-1, patch_size, patch_size)
if args.num_data > 0 and data_test.shape[0] > args.num_data:
data_test = data_test[random_select(args.num_data, data_test.shape[0])]
model = Experiment(args.model)['model']
# container for average log-likelihoods of batches
logliks = []
try:
for b in range(0, data_test.shape[0], args.batch_size):
# select batch
batch = data_test[b:b + args.batch_size]
# compute average log-likelihood of different models
loglik = []
loglik.append(model.loglikelihood(batch))
loglik.append(
model.loglikelihood(transform(batch, True, False, False)))
loglik.append(
model.loglikelihood(transform(batch, False, True, False)))
loglik.append(
model.loglikelihood(transform(batch, True, True, False)))
loglik.append(
model.loglikelihood(transform(batch, False, False, True)))
loglik.append(
model.loglikelihood(transform(batch, True, False, True)))
loglik.append(
model.loglikelihood(transform(batch, False, True, True)))
loglik.append(
model.loglikelihood(transform(batch, True, True, True)))
# compute average log-likelihood of mixture model
loglik = logsumexp(loglik, 0) - log(len(loglik))
logliks.append(loglik.mean())
print '{0:.3f} [nat]'.format(mean(logliks))
except KeyboardInterrupt:
pass
import pdb
pdb.set_trace()
def main(argv):
### 8x8 PATCHES
subplot(0, 0)
# LINEAR MODELS
# load importance weights for each model
for model in linear_models:
model['indices'] = []
model['loglik'] = []
for path in glob(model['path'][:-4] + '[0-9]*[0-9].xpck'):
results = Experiment(path)
if results['ais_weights'].shape[0] not in [1, 200, 300]:
print path, '(IGNORE)'
continue
model['indices'].append(results['indices'])
model['loglik'].append(
logmeanexp(results['ais_weights'], 0).flatten() / log(2.) /
64.)
if not model['loglik']:
experiment = Experiment(model['path'])
# whitening and DC transform
wt = experiment['model'].model[1].transforms[0]
dct = experiment['model'].transforms[0]
# load test data
data = load('data/vanhateren.{0}.0.npz'.format(
experiment['parameters'][0]))['data']
data = preprocess(data, shuffle=False)
for path in glob(model['path'][:-4] +
'ais_samples.[0-9]*[0-9].xpck'):
results = Experiment(path)
# incorporate log-likelihood of DC component and jacobian of whitening transform
loglik_dc = experiment['model'].model[0].loglikelihood(
dct(data[:, results['indices']])[:1])
loglik = logmeanexp(results['ais_weights'],
0) + wt.logjacobian() + loglik_dc
model['indices'].append(results['indices'])
model['loglik'].append(loglik.flatten() / 64. / log(2.))
# make sure each data point is used only once
model['indices'] = hstack(model['indices']).tolist()
model['indices'], idx = unique(model['indices'], return_index=True)
model['loglik'] = hstack(model['loglik'])[idx]
# find intersection of data points
indices = [model['indices'] for model in linear_models]
indices = list(set(indices[0]).intersection(*indices[1:]))
print 'Using {0} data points for 8x8 patches.'.format(len(indices))
# use importance weights to estimate log-likelihood
for idx, model in enumerate(linear_models):
subset = [i in indices for i in model['indices']]
# one estimate of the log-likelihood for each data point
estimates = model['loglik'][asarray(subset)]
model['loglik_mean'] = mean(estimates)
model['loglik_sem'] = std(estimates, ddof=1) / sqrt(estimates.size)
bar(idx + 2,
model['loglik_mean'],
yerr=model['loglik_sem'],
color=model['color'],
fill=model['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm,font=\\footnotesize}'
])
# PRODUCT OF EXPERTS
for idx, model in enumerate(poe):
results = loadmat(model['path'])
estimates = -results['E'] - results['logZ']
estimates = estimates.flatten() / 64. / log(2.)
estimates = estimates[indices]
model['loglik_mean'] = mean(estimates)
model['loglik_sem'] = std(estimates, ddof=1) / sqrt(estimates.size)
bar(idx + 6,
model['loglik_mean'],
yerr=model['loglik_sem'],
color=model['color'],
fill=model['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm,font=\\footnotesize}'
])
# GAUSSIAN SCALE MIXTURE
results = Experiment(gsm['path'])
gsm['loglik_mean'] = mean(results['logliks'][:, indices])
gsm['loglik_sem'] = std(results['logliks'][:, indices], ddof=1) / sqrt(
len(indices))
bar(1,
gsm['loglik_mean'],
yerr=gsm['loglik_sem'],
color=gsm['color'],
fill=gsm['fill'],
bar_width=BAR_WIDTH,
pattern=gsm['pattern'],
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm, font=\\footnotesize}'
])
# GAUSSIAN
results = Experiment(gaussian['path'])
gaussian['loglik_mean'] = mean(results['logliks'][:, indices])
gaussian['loglik_sem'] = std(results['logliks'][:, indices],
ddof=1) / sqrt(len(indices))
bar(0,
gaussian['loglik_mean'],
yerr=gaussian['loglik_sem'],
color=gaussian['color'],
fill=gaussian['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'nodes near coords',
'every node near coord/.style={yshift=0.05cm, font=\\footnotesize}'
])
xtick(range(len(linear_models) + len(poe) + 2),
[gaussian['label']] + \
[gsm['label']] + \
[model['label'] for model in linear_models] + \
[model['label'] for model in poe])
ytick([0.9, 1.1, 1.3, 1.5])
xlabel(r'\small Overcompleteness')
ylabel(r'\small Log-likelihood $\pm$ SEM [bit/pixel]')
axis(width=6,
height=4,
ytick_align='outside',
axis_x_line='bottom',
axis_y_line='left',
pgf_options=[
'xtick style={color=white}',
r'tick label style={font=\footnotesize}',
'every outer x axis line/.append style={-}'
])
axis([-0.5, 8.5, 0.85, 1.65])
title(r'\small 8 $\times$ 8 image patches')
### 16x16 PATCHES
subplot(0, 1)
# dummy plots
bar(-1,
0,
color=gaussian['color'],
fill=gaussian['fill'],
bar_width=BAR_WIDTH)
bar(-1, 0, color=gsm['color'], fill=gsm['fill'], pattern=gsm['pattern'])
# LINEAR MODELS
# load importance weights for each model
for model in linear_models16:
model['indices'] = []
model['loglik'] = []
for path in glob(model['path'][:-4] + '[0-9]*[0-9].xpck'):
results = Experiment(path)
model['indices'].append(results['indices'])
model['loglik'].append(
logmeanexp(results['ais_weights'], 0).flatten() / 256. /
log(2.))
if not model['loglik']:
experiment = Experiment(model['path'])
# whitening and DC transform
wt = experiment['model'].model[1].transforms[0]
dct = experiment['model'].transforms[0]
# load test data
data = load('data/vanhateren.{0}.0.npz'.format(
experiment['parameters'][0]))['data']
data = preprocess(data, shuffle=False)
for path in glob(model['path'][:-4] +
'ais_samples.[0-9]*[0-9].xpck'):
results = Experiment(path)
# incorporate log-likelihood of DC component and jacobian of whitening transform
loglik_dc = experiment['model'].model[0].loglikelihood(
dct(data[:, results['indices']])[:1])
loglik = logmeanexp(results['ais_weights'],
0) + wt.logjacobian() + loglik_dc
model['indices'].append(results['indices'])
model['loglik'].append(loglik.flatten() / 256. / log(2.))
if not model['loglik']:
print 'NO IMPORTANCE WEIGHTS FOUND FOR', model['path']
return 0
# make sure each data point is used only once
model['indices'] = hstack(model['indices']).tolist()
model['indices'], idx = unique(model['indices'], return_index=True)
model['loglik'] = hstack(model['loglik'])[idx]
# find intersection of data points
indices = [model['indices'] for model in linear_models16]
indices = list(set(indices[0]).intersection(*indices[1:]))
print 'Using {0} data points for 16x16 patches.'.format(len(indices))
# use importance weights to estimate log-likelihood
for idx, model in enumerate(linear_models16):
subset = [i in indices for i in model['indices']]
# exp(ais_weights) represent unbiased estimates of the likelihood
estimates = model['loglik'][:, asarray(subset)]
model['loglik_mean'] = mean(estimates)
model['loglik_sem'] = std(estimates, ddof=1) / sqrt(estimates.size)
bar(idx + 2,
model['loglik_mean'],
yerr=model['loglik_sem'],
color=model['color'],
fill=model['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm,font=\\footnotesize}'
])
# PRODUCT OF EXPERTS
for idx, model in enumerate(poe16):
results = loadmat(model['path'])
estimates = -results['E'] - results['logZ']
estimates = estimates.flatten() / 256. / log(2.)
estimates = estimates[indices]
model['loglik_mean'] = mean(estimates)
model['loglik_sem'] = std(estimates, ddof=1) / sqrt(estimates.size)
bar(idx + 6,
model['loglik_mean'],
yerr=model['loglik_sem'],
color=model['color'],
fill=model['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm,font=\\footnotesize}'
])
# GAUSSIAN SCALE MIXTURE
results = Experiment(gsm16['path'])
gsm['loglik_mean'] = mean(results['logliks'][:, indices])
gsm['loglik_sem'] = std(results['logliks'][:, indices], ddof=1) / sqrt(
len(indices))
bar(1,
gsm['loglik_mean'],
yerr=gsm['loglik_sem'],
color=gsm16['color'],
fill=gsm16['fill'],
bar_width=BAR_WIDTH,
pattern=gsm['pattern'],
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm, font=\\footnotesize}'
])
# GAUSSIAN
results = Experiment(gaussian16['path'])
gaussian['loglik_mean'] = mean(results['logliks'][:, indices])
gaussian['loglik_sem'] = std(results['logliks'][:, indices],
ddof=1) / sqrt(len(indices))
bar(0,
gaussian['loglik_mean'],
yerr=gaussian['loglik_sem'],
color=gaussian['color'],
fill=gaussian['fill'],
bar_width=BAR_WIDTH,
pgf_options=[
'forget plot', 'nodes near coords',
'every node near coord/.style={yshift=0.05cm, font=\\footnotesize}'
])
xtick([0, 1, 2, 3, 4, 5, 6, 7, 8],
['-', '-', '1x', '2x', '3x', '4x', '2x', '3x', '4x'])
ytick([0.9, 1.1, 1.3, 1.5])
xlabel(r'\small Overcompleteness')
axis(width=6,
height=4,
ytick_align='outside',
axis_x_line='bottom',
axis_y_line='left',
pgf_options=[
'xtick style={color=white}',
r'tick label style={font=\footnotesize}',
'every outer x axis line/.append style={-}'
])
axis([-0.5, 8.5, 0.85, 1.65])
title(r'\small 16 $\times$ 16 image patches')
gcf().margin = 4
gcf().save('results/vanhateren/comparison.tex')
# dummy plots
bar(-1, 0, color=linear_models[0]['color'], fill=linear_models[0]['fill'])
bar(-1, 0, color=linear_models[1]['color'], fill=linear_models[1]['fill'])
bar(-1, 0, color=poe[0]['color'], fill=poe[0]['fill'])
legend('Gaussian', 'GSM', 'LM', 'OLM', 'PoT', location='outer north east')
savefig('results/vanhateren/comparison.tex')
draw()
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--model',
'-m',
type=str,
default='models/1_layer_ride/rim.10082016.221222.xpck')
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS_Cropped/img_data.mat')
parser.add_argument('--holes', '-H', type=float, default=0.7)
parser.add_argument('--momentum', '-M', type=float, default=0.9)
parser.add_argument('--lr', '-l', type=float, default=5.0)
parser.add_argument('--niter', '-N', type=int, default=10000)
parser.add_argument('--path',
'-p',
type=str,
default='/home/cplab-ws1/ride/code/map_interpolate/')
parser.add_argument('--mode',
'-q',
type=str,
default='CPU',
choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument('--size', '-s', type=int, default=256)
parser.add_argument('--flip', '-f', type=int, default=1)
parser.add_argument('--ent_max', '-e', type=float, default=3.5)
parser.add_argument('--resume', '-r', type=int, default=0)
parser.add_argument('--index', '-I', type=int, default=0)
args = parser.parse_args(argv[1:])
niter = args.niter
lr = args.lr
N = args.size
path = args.path
if not os.path.exists(path):
os.makedirs(path)
# select CPU or GPU for caffe
if args.mode.upper() == 'GPU':
print "setting the GPU mode"
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
if args.index > -1:
path += str(args.index) + '/'
print path
if not os.path.exists(path):
os.makedirs(path)
sys.stdout = open(path + 'log' + str(args.index) + '.txt', 'w')
print 'in log'
# load data
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
images = plt.imread(args.data)
img = rgb2gray(images[:args.size, :args.size])
print 'img max', img.max()
img = img.astype('float64')
#img = (img/255.0)
#vmin, vmax = 0, 255
else:
images = loadmat(args.data)['data']
img = images[args.index, :args.size, :args.size].squeeze()
if img.max() > 2:
img.astype('float64')
img = img / 255.0
print 'img shape', img.shape
del images
# load model
experiment = Experiment(args.model)
model = experiment['model']
input_mask = model.input_mask
output_mask = model.output_mask
mplimg.imsave(path + 'original_img', img, cmap=cm.gray)
binary_mask = get_mask(img, 0, holes=args.holes)
mplimg.imsave(path + 'noisy_img', binary_mask * img, cmap=cm.gray)
sizer = 130
sizec = 140
images = []
stacked_masks = []
for i in [0, 126]:
for j in [0, 116]:
images.append(img[i:i + sizer, j:j + sizec])
stacked_masks.append(binary_mask[i:i + sizer, j:j + sizec])
images = np.expand_dims(np.array(images), axis=4)
stacked_masks = np.expand_dims(np.array(stacked_masks), axis=4)
print images.shape, stacked_masks.shape
masked_images = images * stacked_masks
if args.resume == 0:
np.random.seed(10)
init_img = masked_images + (1 - stacked_masks) * (np.random.rand(
*images.shape))
else:
init_img = np.load(path + 'cleaned_img/' + str(args.resume) + '.npy')
print init_img.min()
print init_img.max()
prev_update = 0
print 'init shape', init_img.shape
for i in range(args.niter):
# if i%50==0 and i!= 0:
# lr = lr/2.0
j = args.flip * i # To enable flipping directions
f, grad_img, whitened_img = model.gradient(
init_img[:, ::(-1)**j, ::(-1)**(j / 2), :],
path=path,
niter=i,
ent_max=args.ent_max)
f = f.sum()
grad_img = grad_img[:, ::(-1)**j, ::(-1)**(j / 2), :]
whitened_img = whitened_img[:, ::(-1)**j, ::(-1)**(j / 2), :]
df_dh = lr * grad_img
print i, 'loglik', f, 'df_dh', (df_dh).sum()
current_update = lr * grad_img + args.momentum * prev_update
init_img += (1 - stacked_masks) * current_update
init_img = np.clip(init_img, 0.0, 1.0)
prev_update = current_update
#Printing results
if (i % 1 == 0):
for k in range(images.shape[0]):
m = 4
cleaned_img = init_img[k, m:, m:-m, :].squeeze()
img_k = images[k, m:, m:-m, :].squeeze()
if not os.path.exists(path + str(k) + '/'):
os.makedirs(path + str(k) + '/')
mplimg.imsave(path + '' + str(k) + '/cleaned_img' + str(i),
cleaned_img,
cmap=cm.gray,
vmin=0,
vmax=1)
ssim1 = ssim(cleaned_img,
img_k,
dynamic_range=img_k.max() - img_k.min())
psnr1 = psnr(cleaned_img,
img_k,
dynamic_range=img_k.max() - img_k.min())
print k, 'ssim', ssim1, 'psnr', psnr1 #, 'min',cleaned_img.min(),'max',cleaned_img.max()
# if (i%10==0):
# for k in range(images.shape[0]):
# fig2 = plt.figure(2)
# plt.imshow(grad_img[k,:,:,:].squeeze(),vmin = -0.02,vmax=0.02)
# plt.colorbar()
# plt.savefig(path+''+str(k)+'/grad_img'+str(i))
# plt.close(fig2)
# fig3 = plt.figure(3)
# plt.imshow(whitened_img[k,:,:,:].squeeze(),vmin=-5.0,vmax=6.0)
# plt.colorbar()
# plt.savefig(path+''+str(k)+'/whitened_img'+str(i))
# plt.close(fig3)
if (i % 20 == 0):
if not os.path.exists(path + 'cleaned_img/'):
os.makedirs(path + 'cleaned_img/')
np.save(path + 'cleaned_img/' + str(i), init_img)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--data', '-d', type=str, default='data/BSDS300_8x8.mat')
parser.add_argument('--nb_size', '-b', type=int, default=5,
help='Size of the causal neighborhood of pixels.')
parser.add_argument('--num_train', '-N', type=int, default=1000000)
parser.add_argument('--num_valid', '-V', type=int, default=200000)
parser.add_argument('--num_hiddens', '-n', type=int, default=64)
parser.add_argument('--num_components', '-c', type=int, default=32)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--num_features', '-f', type=int, default=32)
parser.add_argument('--add_layer', '-a', type=int, default=[0], nargs='+')
parser.add_argument('--learning_rate', '-l', type=float, nargs='+', default=[.5, .1, .05, .01, .005, .001, 0.0005])
parser.add_argument('--batch_size', '-B', type=int, nargs='+', default=[50])
parser.add_argument('--num_epochs', '-e', type=int, default=[1], nargs='+')
parser.add_argument('--finetune', '-F', type=int, default=[1], nargs='+',
help='Indicate iterations in which to finetune MCGSM with L-BFGS.')
parser.add_argument('--precondition', '-Q', type=int, default=1)
parser.add_argument('--output', '-o', type=str, default='results/BSDS300/')
args = parser.parse_args(argv[1:])
experiment = Experiment()
print 'Loading data...'
data_train = loadmat(args.data)['patches_train']
data_valid = loadmat(args.data)['patches_valid']
# reconstruct patches
data_train = hstack([data_train, -sum(data_train, 1)[:, None]])
data_valid = hstack([data_valid, -sum(data_valid, 1)[:, None]])
patch_size = int(sqrt(data_train.shape[1]) + .5)
data_train = data_train.reshape(-1, patch_size, patch_size)
data_valid = data_valid.reshape(-1, patch_size, patch_size)
print 'Creating model...'
model = PatchRIDE(
num_rows=8,
num_cols=8,
model_class=RIDE_BSDS300, # ensures the bottom-right pixel will be ignored
nb_size=args.nb_size,
num_hiddens=args.num_hiddens,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features)
print 'Evaluating...'
loss = []
loss_valid = []
loss_valid.append(model.evaluate(data_valid))
for i, learning_rate in enumerate(args.learning_rate):
print 'Training...'
if i < len(args.add_layer):
for _ in range(args.add_layer[i]):
# add spatial LSTM to the network
model.add_layer()
# randomize patch order
data_train = data_train[permutation(data_train.shape[0])]
# store current parameters
model_copy = deepcopy(model)
# train
loss.append(
model.train(data_train,
learning_rate=learning_rate,
precondition=args.precondition > 0,
batch_size=args.batch_size[i % len(args.batch_size)],
num_epochs=args.num_epochs[i % len(args.num_epochs)]))
print 'Evaluating...'
# evaluate model
loss_valid.append(model.evaluate(data_valid))
if loss_valid[-1] > loss_valid[-2]:
# restore previous parameters
model = model_copy
print 'Performance got worse... Stopping optimization.'
break
# fine-tune
if args.finetune[i % len(args.finetune)]:
print 'Finetuning...'
# store current parameters
model_copy = deepcopy(model)
model.finetune(data_train, num_samples_train=1000000, max_iter=500)
print 'Evaluating...'
loss_valid.append(model.evaluate(data_valid))
if loss_valid[-1] > loss_valid[-2]:
print 'Performance got worse... Restoring parameters.'
model = model_copy
loss_valid[-1] = loss_valid[-2]
experiment['args'] = args
experiment['loss'] = loss
experiment['loss_valid'] = loss_valid
experiment['model'] = model
experiment.save(os.path.join(args.output, 'patchrim.{0}.{1}.xpck'))
return 0
def main(argv):
seterr(over='raise', divide='raise', invalid='raise')
experiment = Experiment(seed=42)
try:
if int(os.environ['OMP_NUM_THREADS']) > 1 or int(
os.environ['MKL_NUM_THREADS']) > 1:
print 'It seems that parallelization is turned on. This will skew the results. To turn it off:'
print '\texport OMP_NUM_THREADS=1'
print '\texport MKL_NUM_THREADS=1'
except:
print 'Parallelization of BLAS might be turned on. This could skew results.'
if not os.path.exists(EXPERIMENT_PATH):
print 'Could not find file \'{0}\'.'.format(EXPERIMENT_PATH)
return 0
results = Experiment(EXPERIMENT_PATH)
ica = results['model'].model[1].model
# load test data
data = load('data/vanhateren.{0}.0.npz'.format(
results['parameters'][0]))['data']
data = data[:, :100000]
data = preprocess(data)
data = data[:, permutation(data.shape[1] / 2)[:NUM_SAMPLES]]
# transform data
dct = results['model'].transforms[0]
wt = results['model'].model[1].transforms[0]
data = wt(dct(data)[1:])
# burn-in using Gibbs sampler
X_ = data[:, :NUM_AUTOCORR]
Y_ = ica.sample_posterior(X_,
method=('gibbs', {
'num_steps': NUM_BURN_IN_STEPS
}))
for method in sampling_methods:
# disable output and parallelization for measuring time
Distribution.VERBOSITY = 0
mapp.max_processes = 1
Y = ica.sample_prior(NUM_SAMPLES)
X = dot(ica.A, Y)
# measure time required by transition operator
start = time()
# increase number of steps to reduce overhead
ica.sample_posterior(
X,
method=(method['method'],
dict(method['parameters'],
Y=Y,
num_steps=method['parameters']['num_steps'] *
NUM_STEPS_MULTIPLIER)))
# time required per transition operator application
duration = (time() - start) / NUM_STEPS_MULTIPLIER
# number of mcmc steps to run for this method
num_mcmc_steps = int(NUM_SECONDS_RUN / duration + 1.)
num_autocorr_steps = int(NUM_SECONDS_VIS / duration + 1.)
# enable output and parallelization
Distribution.VERBOSITY = 2
mapp.max_processes = 12
# posterior samples
Y = [Y_]
# Markov chain
for i in range(num_mcmc_steps):
Y.append(
ica.sample_posterior(X_,
method=(method['method'],
dict(method['parameters'],
Y=Y[-1]))))
ac = []
for j in range(NUM_AUTOCORR):
# collect samples belonging to one posterior distribution
S = hstack([Y[k][:, [j]] for k in range(num_mcmc_steps)])
# compute autocorrelation for j-th posterior
ac = [autocorr(S, num_autocorr_steps)]
# average and plot autocorrelation functions
plot(arange(num_autocorr_steps) * duration,
mean(ac, 0),
'-',
color=method['color'],
line_width=1.2,
comment=str(method['parameters']))
xlabel('time in seconds')
ylabel('autocorrelation')
title('van Hateren')
gca().width = 7
gca().height = 7
gca().xmin = -1
gca().xmax = NUM_SECONDS_VIS
savefig('results/vanhateren/vanhateren_autocorr2.tex')
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--num_components', '-c', type=int, default=20)
parser.add_argument('--max_epochs', '-E', type=int, default=4)
parser.add_argument('--max_iter_tr', '-m', type=int, default=5,
help='Number of steps in the inner loop of the trust-region method.')
parser.add_argument('--output', '-o', type=str, default='results/mnist/')
args = parser.parse_args(argv[1:])
# create directories if necessary
if not os.path.exists(args.output):
os.makedirs(args.output)
experiment = Experiment()
data = load('data/mnist.npz')['train']
data = data[:, permutation(data.shape[1])]
data = asarray(data, dtype=float) / 255.
data = asarray(rand(*data.shape) < data, dtype=float, order='F')
def callback(model):
if model.num_updates * args.max_iter_tr % 25:
return
callback.num_updates.append(model.num_updates)
callback.lower_bound.append(model.lower_bound(data))
print callback.lower_bound[-1]
p = []
for k in range(len(model)):
p.append(model[k].alpha / (model[k].alpha + model[k].beta))
p = hstack(p)
imsave(os.path.join(args.output, 'mnist.{0}.png').format(callback.counter),
stitch(p.T.reshape(-1, 28, 28), num_rows=4), cmap='gray', vmin=0., vmax=1.)
callback.counter += 1
callback.counter = 0
callback.num_updates = []
callback.lower_bound = []
os.system('rm -f {0}'.format(os.path.join(args.output, 'mnist.*.png')))
try:
model = MoBernoulli(dim=784, num_components=args.num_components)
model.train(data,
batch_size=200,
max_epochs=args.max_epochs,
max_iter_tr=args.max_iter_tr,
tau=100.,
callback=callback)
except KeyboardInterrupt:
pass
experiment['args'] = args
experiment['model'] = model
experiment['num_updates'] = callback.num_updates
experiment['lower_bound'] = callback.lower_bound
experiment.save(os.path.join(args.output, 'mnist.{0}.{1}.{{0}}.{{1}}.xpck').format(
args.num_components, args.max_iter_tr))
os.system('ffmpeg -r 25 -i {1} -vcodec mjpeg -sameq {0}'.format(
os.path.join(
args.output,
'mnist.{0}.{1}.avi'.format(args.num_components, args.max_iter_tr)),
os.path.join(args.output, 'mnist.%d.png')))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--model',
'-m',
type=str,
default='models/1_layer_ride/rim.10082016.221222.xpck')
parser.add_argument('--data',
'-d',
type=str,
default='data/BSDS_Cropped/img_data.mat')
parser.add_argument('--noise_std', '-n', type=int, default=-1)
parser.add_argument('--momentum', '-M', type=float, default=0.9)
parser.add_argument('--lr', '-l', type=float, default=5.0)
parser.add_argument('--niter', '-N', type=int, default=400)
parser.add_argument('--path', '-p', type=str, default='map_single_pixel/')
parser.add_argument('--mode',
'-q',
type=str,
default='CPU',
choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument('--size', '-s', type=int, default=160)
parser.add_argument('--samples', '-y', type=float, default=0.4)
parser.add_argument('--image_num', '-K', type=int, default=2)
parser.add_argument('--resume', '-r', type=int, default=-1)
parser.add_argument('--flip', '-f', type=int, default=0)
parser.add_argument('--ent_max', '-e', type=float, default=100.0)
args = parser.parse_args(argv[1:])
niter = args.niter
lr = args.lr
N = args.size
K = args.image_num
noise_std = args.noise_std
path = args.path
if not os.path.exists(path):
os.makedirs(path)
print 'Measurement Rate', args.samples
print 'Noise Level', noise_std
# select CPU or GPU for caffe
if args.mode.upper() == 'GPU':
print "setting the GPU mode"
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
if noise_std > -1:
noise_std = float(noise_std) * 10 / 255.0
path += str(args.noise_std) + '/'
if args.samples > -1:
path += str(args.samples) + '/'
if not os.path.exists(path):
os.makedirs(path)
sys.stdout = open(path + 'log.txt', 'w')
# load data
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
images = plt.imread(args.data)
img = rgb2gray(images[:args.size, :args.size])
img = img.astype('float64')
else:
images = loadmat(args.data)['data']
images = images.astype('float64')
img = images[:K, :args.size, :args.size]
# load model
print 'Loading model'
experiment = Experiment(args.model)
model = experiment['model']
input_mask = model.input_mask
output_mask = model.output_mask
Phi = np.load('map_single_pixel/Phi_g_' + str(N) +
'.npy')[1:int(args.samples * args.size**2), :]
del images
for k in range(K):
if not os.path.exists(path + str(k) + '/'):
os.makedirs(path + str(k) + '/')
mplimg.imsave(path + str(k) + '/original_img',
img[k].squeeze(),
cmap=cm.gray)
y = np.dot(Phi, img.reshape(K, -1).transpose())
np.random.seed(123)
if noise_std > -1:
y += noise_std * np.random.randn(*y.shape)
M = y.shape[0]
print 'Number of measurements', M
#Initializing
np.random.seed(123)
init_img = np.random.rand(N**2, K)
prev_grad = 0
if args.resume > 0:
init_img = np.load(path + 'cleaned_img/' + str(args.resume) + '.npy')
for k in range(K):
mplimg.imsave(path + str(k) + '/init_img',
init_img[:, k].reshape(N, N),
cmap=cm.gray)
psnr_list = [[] for i in range(K)]
ssim_list = [[] for i in range(K)]
for i in range(args.niter):
j = args.flip * i
f, grad_img, whitened_img = model.gradient(
init_img.transpose().reshape(K, N, N,
1)[:, ::(-1)**j, ::(-1)**(j / 2), :],
precond=None,
niter=i,
path=path,
ent_max=args.ent_max)
df_dh = grad_img[:, ::(-1)**j, ::(-1)**(j / 2), :].reshape(
K, -1).transpose()
print i, 'f', f.sum(), 'df_dh', np.abs(df_dh).sum(),
prev_grad = args.momentum * prev_grad + df_dh
x_up = init_img + lr * (prev_grad)
init_img = x_up - np.dot(Phi.transpose(), np.dot(Phi, x_up) - y)
init_img = np.clip(init_img, 0.0, 1.0)
if i % 10 == 0:
for k in range(K):
mplimg.imsave(path + str(k) + '/img' + str(i),
init_img[:, k].reshape(N, N),
cmap=cm.gray)
l = linalg.norm(y - np.dot(Phi, init_img))
print 'l', l
#For Saving Gradient Image
# if (i%10==0):
# for k in range(K):
# fig2 = plt.figure(2)
# plt.imshow(df_dh[:,k].reshape(N,N),vmin = -0.02,vmax=0.02)
# plt.colorbar()
# plt.savefig(path+str(k)+'/grad_img'+str(i))
# plt.close(fig2)
# if (i%1 ==0):
# for k in range(K):
# fig1 = plt.figure(1)
# plt.imshow(f[:,k].reshape(N,N))
# plt.colorbar()
# plt.savefig(path+str(k)+'/loglik_img'+str(i))
# plt.close(fig1)
m = 2 #Margin to remove for comparision
for k in range(K):
ssim1 = ssim(init_img[:, k].reshape(N, N)[m:-m, m:-m],
img[k].squeeze()[m:-m, m:-m],
dynamic_range=img.min() - img.max())
psnr1 = psnr(init_img[:, k].reshape(N, N)[m:-m, m:-m],
img[k].squeeze()[m:-m, m:-m],
dynamic_range=img.min() - img.max())
ssim_list[k].append(ssim1)
psnr_list[k].append(psnr1)
if not os.path.exists(path + 'cleaned_img/'):
os.makedirs(path + 'cleaned_img/')
np.save(path + 'cleaned_img/ssim_list', ssim_list)
np.save(path + 'cleaned_img/psnr_list', psnr_list)
print k, 'ssim', ssim1, 'psnr', psnr1
if (i % 50 == 0): #Storing npy files
np.save(path + 'cleaned_img/' + str(i), init_img)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--patch_size',
'-p',
type=int,
default=[8, 10, 12, 14, 16, 18, 20, 22],
nargs='+')
parser.add_argument('--row_multiplier',
'-R',
type=int,
default=[1],
nargs='+',
help='Can be used to train on elongated patches.')
parser.add_argument('--col_multiplier',
'-C',
type=int,
default=[1],
nargs='+',
help='Can be used to train on elongated patches.')
parser.add_argument('--num_patches',
'-P',
type=int,
default=None,
help='If given, subsample training data.')
parser.add_argument(
'--num_valid',
'-V',
type=int,
default=0,
help=
'Number of training images used for validation error based early stopping.'
)
parser.add_argument(
'--finetune',
'-F',
type=int,
default=[1],
nargs='+',
help='Indicate iterations in which to finetune MCGSM with L-BFGS.')
parser.add_argument('--learning_rate',
'-l',
type=float,
default=[1., .5, .1, .05, .01, 0.005, 0.001, 0.0005],
nargs='+')
parser.add_argument('--momentum',
'-m',
type=float,
default=[.9],
nargs='+')
parser.add_argument('--batch_size',
'-B',
type=int,
default=[50],
nargs='+')
parser.add_argument('--nb_size',
'-b',
type=int,
default=5,
help='Size of the causal neighborhood of pixels.')
parser.add_argument('--num_hiddens', '-n', type=int, default=64)
parser.add_argument('--num_components', '-c', type=int, default=32)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--num_features', '-f', type=int, default=32)
parser.add_argument('--num_epochs', '-e', type=int, default=[1], nargs='+')
parser.add_argument('--precondition', '-Q', type=int, default=1)
parser.add_argument('--method', '-M', type=str, default=['SGD'], nargs='+')
parser.add_argument('--data',
'-d',
type=str,
default='data/deadleaves_train.mat')
parser.add_argument(
'--noise',
'-N',
type=float,
default=None,
help=
'Standard deviation of Gaussian noise added to data before training (as fraction of data standard deviation).'
)
parser.add_argument(
'--model',
'-I',
type=str,
default='',
help=
'Start with this model as initialization. Other flags will be ignored.'
)
parser.add_argument('--add_layer', '-a', type=int, default=[0], nargs='+')
parser.add_argument('--train_top_layer',
'-T',
type=int,
default=[0],
nargs='+')
parser.add_argument('--train_means',
'-S',
type=int,
default=[0],
nargs='+')
parser.add_argument('--mode',
'-q',
type=str,
default='CPU',
choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument(
'--augment',
'-A',
type=int,
default=1,
help='Increase training set size by transforming data.')
parser.add_argument('--overlap', '-O', type=int, default=[1], nargs='+')
parser.add_argument('--output',
'-o',
type=str,
default='results/deadleaves/')
parser.add_argument(
'--patch_model',
type=int,
default=0,
help='Train a patch-based model instead of a stochastic process.')
parser.add_argument('--extended',
'-X',
type=int,
default=0,
help='Use extended version of spatial LSTM.')
parser.add_argument(
'--multiscale',
'-Y',
type=int,
default=0,
help=
'Apply recurrent image model to multiscale representation of images.')
parser.add_argument(
'--color',
'-Z',
type=int,
default=0,
help='Use separate models to model color and grayscale values.')
args = parser.parse_args(argv[1:])
experiment = Experiment()
if args.mode.upper() == 'GPU':
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
# load data
if args.data.lower()[-4:] in ['.gif', '.png', '.jpg', 'jpeg']:
data = imread(args.data)[None]
data += rand(*data.shape)
else:
data = loadmat(args.data)['data']
if args.augment > 0:
data = vstack([data, data[:, :, ::-1]])
if args.augment > 1:
data = vstack([data, data[:, ::-1, :]])
if args.noise is not None:
# add noise as a means for regularization
data += randn(*data.shape) * (std(data, ddof=1) / args.noise)
if args.num_valid > 0:
if args.num_valid >= data.shape[0]:
print 'Cannot use {0} for validation, there are only {1} training images.'.format(
args.num_valid, data.shape[0])
return 1
# select subset for validation
idx = random_select(args.num_valid, data.shape[0])
data_valid = data[idx]
data = asarray([image for i, image in enumerate(data) if i not in idx])
print '{0} training images'.format(data.shape[0])
print '{0} validation images'.format(data_valid.shape[0])
patches_valid = []
patch_size = min([64, data.shape[1], data.shape[2]])
for i in range(0, data_valid.shape[1] - patch_size + 1, patch_size):
for j in range(0, data_valid.shape[2] - patch_size + 1,
patch_size):
patches_valid.append(data_valid[:, i:i + patch_size,
j:j + patch_size])
patches_valid = vstack(patches_valid)
if args.model:
# load pretrained model
results = Experiment(args.model)
model = results['model']
loss = [results['loss']]
if args.patch_model and not isinstance(model, PatchRIDE):
model = PatchRIDE(model=model,
num_rows=args.patch_size[0],
num_cols=args.patch_size[0])
else:
# create recurrent image model
if args.patch_model:
model = PatchRIDE(
num_rows=args.patch_size[0],
num_cols=args.patch_size[0],
num_channels=data.shape[-1] if data.ndim > 3 else 1,
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
model_class=ColorRIDE if args.color else RIDE)
if args.extended:
print 'Extended patch model not supported.'
return 0
if args.multiscale:
print 'Multiscale patch model not supported.'
return 0
else:
if args.multiscale:
if data.ndim > 3 and data.shape[-1] > 1:
print 'Multiscale color model not supported.'
return 0
model = MultiscaleRIDE(num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
elif args.color:
if data.ndim < 4 or data.shape[-1] != 3:
print 'These images don\'t look like RGB images.'
return 0
model = ColorRIDE(num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
else:
model = RIDE(
num_channels=data.shape[-1] if data.ndim > 3 else 1,
num_hiddens=args.num_hiddens,
nb_size=args.nb_size,
num_components=args.num_components,
num_scales=args.num_scales,
num_features=args.num_features,
extended=args.extended > 0)
loss = []
# compute initial performance
loss_valid = []
if args.num_valid > 0:
print 'Computing validation loss...'
loss_valid.append(model.evaluate(patches_valid))
model_copy = deepcopy(model)
for k, patch_size in enumerate(args.patch_size):
if args.multiscale:
patch_size *= 2
if k < len(args.add_layer):
for _ in range(args.add_layer[k]):
# add spatial LSTM to the network
model.add_layer()
# extract patches of given patch size
patches = []
row_size = patch_size * args.row_multiplier[k %
len(args.row_multiplier)]
col_size = patch_size * args.col_multiplier[k %
len(args.col_multiplier)]
if isinstance(model, PatchRIDE):
model.num_rows = row_size
model.num_cols = col_size
for i in range(0, data.shape[1] - row_size + 1,
row_size / args.overlap[k % len(args.overlap)]):
for j in range(0, data.shape[2] - col_size + 1,
col_size / args.overlap[k % len(args.overlap)]):
patches.append(data[:, i:i + row_size, j:j + col_size])
patches = vstack(patches)
# randomize order of patches
if args.num_patches is not None and args.num_patches < len(patches):
patches = patches[random_select(args.num_patches, len(patches))]
else:
patches = patches[permutation(len(patches))]
# determine batch size
if args.method[k % len(args.method)].upper() == 'SFO':
num_batches = int(max([25, sqrt(patches.shape[0]) / 5.]))
batch_size = patches.shape[0] // num_batches
else:
batch_size = args.batch_size[k % len(args.batch_size)]
if batch_size < 1:
raise RuntimeError('Too little data.')
print 'Patch size: {0}x{1}'.format(row_size, col_size)
print 'Number of patches: {0}'.format(patches.shape[0])
print 'Batch size: {0}'.format(batch_size)
# train recurrent image model
print 'Training...'
loss.append(
model.train(
patches,
batch_size=batch_size,
method=args.method[k % len(args.method)],
num_epochs=args.num_epochs[k % len(args.num_epochs)],
learning_rate=args.learning_rate[k % len(args.learning_rate)],
momentum=args.momentum[k % len(args.momentum)],
precondition=args.precondition > 0,
train_top_layer=args.train_top_layer[k %
len(args.train_top_layer)]
> 0,
train_means=args.train_means[k % len(args.train_means)] > 0))
if args.finetune[k % len(args.finetune)]:
print 'Finetuning...'
model.finetune(patches, num_samples_train=1000000, max_iter=500)
if args.num_valid > 0:
print 'Computing validation loss...'
loss_valid.append(model.evaluate(patches_valid))
if loss_valid[-1] > loss_valid[-2]:
print 'Performance got worse. Stopping optimization.'
model = model_copy
break
print 'Copying model...'
model_copy = deepcopy(model)
experiment['batch_size'] = batch_size
experiment['args'] = args
experiment['model'] = model
experiment['loss_valid'] = loss_valid
experiment['loss'] = hstack(loss) if len(loss) > 0 else []
experiment.save(os.path.join(args.output, 'rim.{0}.{1}.xpck'))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data',
'-d',
type=str,
default='data/vanhateren_deq2_test.mat')
parser.add_argument('--batch_size', '-B', type=int, default=25)
parser.add_argument('--verbosity', '-v', type=int, default=1)
args = parser.parse_args(argv[1:])
### LOAD RESULTS
experiment = Experiment(args.model)
### DATA HANDLING
if args.verbosity > 0:
print 'Loading data...'
# load data
images = loadmat(args.data)['data']
images = images[permutation(images.shape[0])]
# causal neighborhood definition
input_mask = experiment['input_mask']
output_mask = experiment['output_mask']
# extract causal neighborhoods
def extract(images):
data = []
for i in range(images.shape[0]):
data.append(
generate_data_from_image(images[i], input_mask, output_mask))
inputs, outputs = zip(*data)
return hstack(inputs), hstack(outputs)
### MODEL EVALUATION
model = experiment['model']
pre = experiment['preconditioner']
def evaluate(images):
print 'Extracting...'
inputs, outputs = extract(images)
print 'Evaluating...'
loglik = model.loglikelihood(*pre(inputs, outputs)) \
+ pre.logjacobian(inputs, outputs)
return loglik.reshape(images.shape[0], -1)
logliks = []
for b in range(0, images.shape[0], args.batch_size):
batch = images[b:b + args.batch_size]
loglik = evaluate(batch)
num_pixels = loglik.shape[1]
loglik = [loglik.sum(1)]
loglik.append(evaluate(batch[:, ::-1]).sum(1))
loglik.append(evaluate(batch[:, :, ::-1]).sum(1))
loglik.append(evaluate(batch[:, ::-1, ::-1]).sum(1))
batch = transpose(batch, [0, 2, 1])
loglik.append(evaluate(batch).sum(1))
loglik.append(evaluate(batch[:, ::-1]).sum(1))
loglik.append(evaluate(batch[:, :, ::-1]).sum(1))
loglik.append(evaluate(batch[:, ::-1, ::-1]).sum(1))
loglik = logsumexp(loglik, 0) - log(len(loglik))
logliks.append(mean(loglik) / num_pixels / log(2.))
print 'Cross-entropy: {0:.4f} [bit/px]'.format(-mean(logliks))
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--data', '-d', type=str, default='data/BSDS300_8x8.mat')
parser.add_argument('--num_train', '-N', type=int, default=1000000)
parser.add_argument('--num_valid', '-V', type=int, default=200000)
parser.add_argument('--num_components', '-n', type=int, default=128)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--num_features', '-f', type=int, default=48)
parser.add_argument('--train_means', '-M', type=int, default=0)
parser.add_argument('--indices', '-I', type=int, default=[], nargs='+')
parser.add_argument('--initialize', '-i', type=str, default=None)
parser.add_argument('--verbosity', '-v', type=int, default=1)
parser.add_argument('--max_iter', '-m', type=int, default=2000)
args = parser.parse_args(argv[1:])
experiment = Experiment()
data_train = loadmat(args.data)['patches_train']
data_valid = loadmat(args.data)['patches_valid']
if args.initialize:
results = Experiment(args.initialize)
models = results['models']
preconditioners = results['preconditioners']
else:
models = [None] * data_train.shape[1]
preconditioners = [None] * data_train.shape[1]
def preprocess(data, i, N):
if N > 0 and N < data.shape[0]:
# select subset of data
idx = random_select(N, data.shape[0])
return data[idx, :i].T, data[idx, i][None, :]
return data.T[:i], data.T[[i]]
for i in range(data_train.shape[1]):
if args.indices and i not in args.indices:
# skip this one
continue
print 'Training model {0}/{1}...'.format(i + 1, data_train.shape[1])
inputs_train, outputs_train = preprocess(data_train, i, args.num_train)
inputs_valid, outputs_valid = preprocess(data_valid, i, args.num_valid)
if i > 0:
if preconditioners[i] is None:
preconditioners[i] = WhiteningPreconditioner(inputs_train, outputs_train)
inputs_train, outputs_train = preconditioners[i](inputs_train, outputs_train)
inputs_valid, outputs_valid = preconditioners[i](inputs_valid, outputs_valid)
if models[i] is None:
models[i] = MCGSM(
dim_in=i,
dim_out=1,
num_components=args.num_components,
num_features=args.num_features,
num_scales=args.num_scales)
models[i].train(
inputs_train, outputs_train,
inputs_valid, outputs_valid,
parameters={
'verbosity': 1,
'max_iter': args.max_iter,
'train_means': args.train_means > 0})
else:
preconditioners[i] = None
if models[i] is None:
models[i] = MoGSM(
dim=1,
num_components=4,
num_scales=8)
models[i].train(
outputs_train,
outputs_valid,
parameters={
'verbosity': 1,
'threshold': -1.,
'train_means': 1,
'max_iter': 100})
experiment['args'] = args
experiment['models'] = models
experiment['preconditioners'] = preconditioners
experiment.save('results/BSDS300/snapshots/mcgsm_{0}_{1}.{{0}}.{{1}}.xpck'.format(i, args.num_components))
if not args.indices:
experiment['args'] = args
experiment['models'] = models
experiment['preconditioners'] = preconditioners
experiment.save('results/BSDS300/mcgsm.{0}.{1}.xpck')
return 0
def main(argv):
experiment = Experiment(argv[1])
isa = experiment['model'].model[1].model
dct = experiment['model'].transforms[0]
### BASIS
# basis in pixel space
A = dot(dct.A[1:].T, isa.A)
# sort by norm
norms = sqrt(sum(square(A), 0))
indices = argsort(norms)[::-1]
# A = A[:, indices]
# adjust intensity range
a = percentile(abs(A).ravel(), PERC)
A = (A + a) / (2. * a) * 255. + 0.5
A[A < 0.] = 0.5
A[A > 256.] = 255.5
A = asarray(A, 'uint8')
# stitch together into a single image
patch_size = int(sqrt(A.shape[0]) + 0.5)
patches = stitch(A.T.reshape(-1, patch_size, patch_size), num_cols=NUM_COLS)
patches = repeat(repeat(patches, RES, 0), RES, 1)
imshow(patches, dpi=75 * RES)
axis('off')
draw()
### SAMPLES
samples = experiment['model'].sample(128)
a = percentile(abs(samples).ravel(), PERC)
samples = (samples + a) / (2. * a) * 255. + 0.5
samples[samples < 0.] = 0.5
samples[samples > 256.] = 255.5
samples = asarray(samples, 'uint8')
samples = stitch(samples.T.reshape(-1, patch_size, patch_size))
samples = repeat(repeat(samples, RES, 0), RES, 1)
# visualize samples
figure()
imshow(samples, dpi=75 * RES)
title('Samples')
axis('off')
draw()
### MARGINAL SOURCE DISTRIBUTIONS
figure()
samples = []
for gsm in isa.subspaces:
samples.append(gsm.sample(1000))
perc = percentile(hstack(samples), 99.5)
xvals = linspace(-perc, perc, 100)
for i in range(0, 8):
for j in range(0, 16):
try:
gsm = isa.subspaces[indices[i * NUM_COLS + j]]
except:
pass
else:
subplot(7 - i, j, spacing=0)
plot(xvals, laplace.logpdf(xvals, scale=sqrt(0.5)).ravel(), 'k', opacity=0.5)
plot(xvals, gsm.loglikelihood(xvals.reshape(1, -1)).ravel(), 'b-', line_width=1.)
gca().width = 0.8
gca().height = 0.8
axis([-perc, perc, -6., 2.])
xtick([])
ytick([])
draw()
return 0
def main(argv):
if len(argv) < 2:
print 'Usage:', argv[0], '<param_id>', '[experiment]'
print
print ' {0:>3} {1:>7} {2:>5} {3:>5} {4:>5} {5:>5} {6:>5}'.format(
'ID', 'PS', 'OC', 'TI', 'FI', 'LP', 'SC')
for id, params in enumerate(parameters):
print ' {0:>3} {1:>7} {2:>5} {3:>5} {4:>5} {5:>5} {6:>5}'.format(id, *params)
print
print ' ID = parameter set'
print ' PS = patch size'
print ' OC = overcompleteness'
print ' TI = number of training iterations'
print ' FI = number of fine-tuning iterations'
print ' LP = optimize marginal distributions'
print ' SC = initialize with sparse coding'
return 0
seterr(invalid='raise', over='raise', divide='raise')
# start experiment
experiment = Experiment()
# hyperparameters
patch_size, \
overcompleteness, \
max_iter, \
max_iter_ft, \
train_prior, \
sparse_coding = parameters[int(argv[1])]
### DATA PREPROCESSING
# load data, log-transform and center data
data = load('data/vanhateren.{0}.1.npz'.format(patch_size))['data']
data = data[:, :100000]
data = preprocess(data)
# discrete cosine transform and whitening transform
dct = LinearTransform(dim=int(sqrt(data.shape[0])), basis='DCT')
wt = WhiteningTransform(dct(data)[1:], symmetric=True)
### MODEL DEFINITION
isa = ISA(num_visibles=data.shape[0] - 1,
num_hiddens=data.shape[0] * overcompleteness - 1, ssize=1)
# model DC component with a mixture of Gaussians
model = StackedModel(dct,
ConcatModel(MoGaussian(20), StackedModel(wt, isa)))
### MODEL TRAINING
# variables to store in results
experiment['model'] = model
experiment['parameters'] = parameters[int(argv[1])]
def callback(phase, isa, iteration):
"""
Saves intermediate results every few iterations.
"""
if not iteration % 5:
# whitened filters
A = dot(dct.A[1:].T, isa.A)
patch_size = int(sqrt(A.shape[0]) + 0.5)
# save intermediate results
experiment.save('results/vanhateren.{0}/results.{1}.{2}.xpck'.format(argv[1], phase, iteration))
# visualize basis
imsave('results/vanhateren.{0}/basis.{1}.{2:0>3}.png'.format(argv[1], phase, iteration),
stitch(imformat(A.T.reshape(-1, patch_size, patch_size))))
if len(argv) > 2:
# initialize model with trained model
results = Experiment(argv[2])
model = results['model']
isa = model.model[1].model
dct = model.transforms[0]
experiment['model'] = model
else:
# enable regularization of marginals
for gsm in isa.subspaces:
gsm.gamma = 1e-3
gsm.alpha = 2.
gsm.beta = 1.
# train mixture of Gaussians on DC component
model.train(data, 0, max_iter=100)
# initialize filters and marginals
model.initialize(data, 1)
model.initialize(model=1, method='laplace')
experiment.progress(10)
if sparse_coding:
# initialize with sparse coding
if patch_size == '16x16':
model.train(data, 1,
method=('of', {
'max_iter': max_iter,
'noise_var': 0.05,
'var_goal': 1.,
'beta': 10.,
'step_width': 0.01,
'sigma': 0.3,
}),
callback=lambda isa, iteration: callback(0, isa, iteration))
else:
model.train(data, 1,
method=('of', {
'max_iter': max_iter,
'noise_var': 0.1,
'var_goal': 1.,
'beta': 10.,
'step_width': 0.01,
'sigma': 0.5,
}),
callback=lambda isa, iteration: callback(0, isa, iteration))
isa.orthogonalize()
else:
if patch_size == '16x16':
# prevents out-of-memory
mapp.max_processes = 1
# train model using a subset of the data
model.train(data[:, :20000], 1,
max_iter=max_iter,
train_prior=train_prior,
persistent=True,
init_sampling_steps=5,
method=('sgd', {'momentum': 0.8}),
callback=lambda isa, iteration: callback(0, isa, iteration),
sampling_method=('gibbs', {'num_steps': 1}))
experiment.progress(50)
if patch_size == '16x16':
# prevents out-of-memory
mapp.max_processes = 1
# disable regularization
for gsm in isa.subspaces:
gsm.gamma = 0.
# fine-tune model using all the data
model.train(data, 1,
max_iter=max_iter_ft,
train_prior=train_prior,
train_subspaces=False,
persistent=True,
init_sampling_steps=10 if not len(argv) > 2 and (sparse_coding or not train_prior) else 50,
method=('lbfgs', {'max_fun': 50}),
callback=lambda isa, iteration: callback(1, isa, iteration),
sampling_method=('gibbs', {'num_steps': 2}))
experiment.save('results/vanhateren/vanhateren.{0}.{{0}}.{{1}}.xpck'.format(argv[1]))
return 0
def main(argv):
### PLOT BASIS VECTOR NORMS
subplot(0, 0, spacing=1.)
legend_entries = []
for model in models:
results = Experiment(model['path'])
isa = results['model'].model[1].model
dct = results['model'].transforms[0]
# basis in whitened pixel space
A = dot(dct.A[1:].T, isa.A)
# basis vector norms
norms = sort(sqrt(sum(square(A), 0)))[::-1]
plot(norms, color=model['color'], line_width=1.2)
plot([len(norms), len(norms) + 1, 255], [norms[-1], 0, 0],
color=model['color'],
line_style='densely dashed',
line_width=1.2,
pgf_options=['forget plot'])
legend_entries.append(model['legend'])
xlabel('Basis coefficient, $i$')
ylabel('Basis vector norm, $||a_i||$')
legend(*legend_entries, location='north east')
axis(width=5, height=4)
axis([0, 256, 0, 1])
xtick([64, 128, 192, 256])
grid()
### VISUALIZE BASIS
subplot(0, 1)
results = Experiment(model['path'])
isa = results['model'].model[1].model
dct = results['model'].transforms[0]
# basis in whitened pixel space
A = dot(dct.A[1:].T, isa.A)
indices = argsort(sqrt(sum(square(A), 0)))[::-1]
A = A[:, indices]
# adjust intensity range
a = percentile(abs(A).ravel(), PERC)
A = (A + a) / (2. * a) * 255. + 0.5
A[A < 0.] = 0.5
A[A > 256.] = 255.5
A = asarray(A, 'uint8')
# stitch together into a single image
patch_size = int(sqrt(A.shape[0]) + 0.5)
patches = stitch(A.T.reshape(-1, patch_size, patch_size),
num_cols=NUM_COLS)
patches = repeat(repeat(patches, RES, 0), RES, 1)
imshow(patches, dpi=75 * RES)
rectangle(72 * RES,
80.8 * RES,
64 * RES,
55.2 * RES,
color=RGB(1.0, 0.8, 0.5),
line_width=1.,
line_style='densely dashed')
axis(height=4,
width=4,
ticks='none',
axis_on_top=False,
clip=False,
pgf_options=['xlabel style={yshift=-0.47cm}', 'clip=false'])
savefig('results/vanhateren/overcompleteness.tex')
draw()
### MARGINAL SOURCE DISTRIBUTIONS
figure()
samples = []
for gsm in isa.subspaces:
samples.append(gsm.sample(1000))
perc = percentile(hstack(samples), 99.5)
xvals = linspace(-perc, perc, 100)
for i in range(1, 7):
for j in range(8, 15):
try:
gsm = isa.subspaces[indices[i * NUM_COLS + j]]
except:
pass
else:
subplot(7 - i, j, spacing=0)
plot(xvals,
laplace.logpdf(xvals, scale=sqrt(0.5)).ravel(),
line_width=0.8,
color=RGB(0.1, 0.6, 1.0))
plot(xvals,
gsm.loglikelihood(xvals.reshape(1, -1)).ravel(),
'k',
line_width=1.)
gca().width = 4. / 6.
gca().height = 4. / 6.
axis([-perc, perc, -6., 2.])
xtick([])
ytick([])
savefig('results/vanhateren/marginals.tex')
draw()
return 0
def main(argv):
seterr(over='raise', divide='raise', invalid='raise')
try:
if int(os.environ['OMP_NUM_THREADS']) > 1 or int(os.environ['MKL_NUM_THREADS']) > 1:
print 'It seems that parallelization is turned on. This will skew the results. To turn it off:'
print '\texport OMP_NUM_THREADS=1'
print '\texport MKL_NUM_THREADS=1'
except:
print 'Parallelization of BLAS might be turned on. This could skew results.'
experiment = Experiment(seed=42)
if os.path.exists('results/toyexample/toyexample.xpck'):
results = Experiment('results/toyexample/toyexample.xpck')
ica = results['ica']
else:
# toy model
ica = ISA(1, 3)
ica.initialize(method='exponpow')
ica.A = 1. + randn(1, 3) / 5.
experiment['ica'] = ica
experiment.save('results/toyexample/toyexample.xpck')
# generate visible and corresponding hidden states
Y = ica.sample_prior(NUM_SAMPLES)
X = dot(ica.A, Y)
# energy of posterior samples should be around this value
energy = mean(ica.prior_energy(Y))
for method in sampling_methods:
# disable output and parallelization
Distribution.VERBOSITY = 0
mapp.max_processes = 1
# measure time required by transition operator
start = time()
# initial hidden states
Y = dot(pinv(ica.A), X)
# increase number of steps to reduce overhead
ica.sample_posterior(X, method=(method['method'],
dict(method['parameters'], Y=Y,
num_steps=method['parameters']['num_steps'] * NUM_STEPS_MULTIPLIER)))
# time required per transition operator application
duration = (time() - start) / NUM_STEPS_MULTIPLIER
# enable output and parallelization
Distribution.VERBOSITY = 2
mapp.max_processes = 2
energies = [mean(ica.prior_energy(Y))]
# Markov chain
for i in range(int(NUM_SECONDS / duration + 1.)):
Y = ica.sample_posterior(X,
method=(method['method'], dict(method['parameters'], Y=Y)))
energies.append(mean(ica.prior_energy(Y)))
plot(arange(len(energies)) * duration, energies, '-', color=method['color'],
line_width=1.2, pgf_options=['forget plot'], comment=str(method['parameters']))
plot([-2, NUM_SECONDS + 2], energy, 'k--', line_width=1.2)
xlabel('time in seconds')
ylabel('average energy')
title('toy example')
gca().width = 7
gca().height = 7
gca().xmin = -1
gca().xmax = NUM_SECONDS
savefig('results/toyexample/toyexample_trace.tex')
return 0
def main(argv):
if len(argv) < 2:
print 'Usage:', argv[0], '<param_id>'
print
print ' {0:>3} {1:>7} {2:>5} {3:>5} {4:>5}'.format(
'ID', 'PS', 'NS', 'TI', 'DC')
for id, params in enumerate(parameters):
print ' {0:>3} {1:>7} {2:>5} {3:>5} {4:>5}'.format(id, *params)
print
print ' ID = parameter set'
print ' PS = patch size'
print ' NS = number of scales'
print ' TI = number of training iterations'
print ' DC = model DC component separately'
return 0
# start experiment
experiment = Experiment(server='10.38.138.150')
# hyperparameters
patch_size, num_scales, max_iter, separate_dc = parameters[int(argv[1])]
### DATA PREPROCESSING
# load data, log-transform and center data
data = load('data/vanhateren.{0}.1.npz'.format(patch_size))['data']
data = data[:, :100000]
data = preprocess(data)
### MODEL DEFINITION AND TRAINING
if separate_dc:
# discrete cosine transform and symmetric whitening transform
dct = LinearTransform(dim=int(sqrt(data.shape[0])), basis='DCT')
wt = WhiteningTransform(dct(data)[1:], symmetric=True)
model = StackedModel(dct, ConcatModel(
MoGaussian(20),
StackedModel(wt, GSM(data.shape[0] - 1, num_scales))))
else:
# symmetric whitening transform
wt = WhiteningTransform(data, symmetric=True)
model = StackedModel(wt, GSM(data.shape[0], num_scales))
### MODEL TRAINING AND EVALUATION
model.train(data, max_iter=max_iter, tol=1e-7)
# load and preprocess test data
data = load('data/vanhateren.{0}.0.npz'.format(patch_size))['data']
data = preprocess(data, shuffle=False)
# log-likelihod in [bit/pixel]
logliks = model.loglikelihood(data) / log(2.) / data.shape[0]
loglik = mean(logliks)
sem = std(logliks, ddof=1) / sqrt(logliks.shape[1])
print 'log-likelihood: {0:.4f} +- {1:.4f} [bit/pixel]'.format(loglik, sem)
experiment['logliks'] = logliks
experiment['loglik'] = loglik
experiment['sem'] = sem
experiment.save('results/vanhateren/gsm.{0}.{{0}}.{{1}}.xpck'.format(argv[1]))
return 0
def main(argv):
experiment = Experiment()
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('--data', '-d', type=str, default='data/vanhateren_deq2_train.mat')
parser.add_argument('--num_data', '-N', type=int, default=1000000)
parser.add_argument('--num_valid', '-V', type=int, default=200000)
parser.add_argument('--input_size', '-i', type=int, default=9)
parser.add_argument('--max_iter', '-I', type=int, default=3000)
parser.add_argument('--num_components', '-c', type=int, default=128)
parser.add_argument('--num_features', '-f', type=int, default=48)
parser.add_argument('--num_scales', '-s', type=int, default=4)
parser.add_argument('--verbosity', '-v', type=int, default=1)
parser.add_argument('--output', '-o', type=str, default='results/vanhateren_deq2/mcgsm.{0}.{1}.xpck')
args = parser.parse_args(argv[1:])
### DATA HANDLING
if args.verbosity > 0:
print 'Loading data...'
# load data
images = loadmat(args.data)['data']
# define causal neighborhood
input_mask, output_mask = generate_masks(input_size=args.input_size, output_size=1)
# extract causal neighborhoods
num_samples = int((args.num_data + args.num_valid) / images.shape[0] + .9)
def extract(image):
return generate_data_from_image(
image, input_mask, output_mask, num_samples)
inputs, outputs = zip(*mapp(extract, images))
inputs, outputs = hstack(inputs), hstack(outputs)
inputs_train = inputs[:, :args.num_data]
outputs_train = outputs[:, :args.num_data]
inputs_valid = inputs[:, args.num_data:]
outputs_valid = outputs[:, args.num_data:]
if inputs_valid.size < 100:
print 'Not enough data for validation.'
inputs_valid = None
outputs_valid = None
### MODEL TRAINING
if args.verbosity > 0:
print 'Preconditioning...'
preconditioner = WhiteningPreconditioner(inputs_train, outputs_train)
inputs_train, outputs_train = preconditioner(inputs_train, outputs_train)
if inputs_valid is not None:
inputs_valid, outputs_valid = preconditioner(inputs_valid, outputs_valid)
# free memory
del inputs
del outputs
if args.verbosity > 0:
print 'Training model...'
model = MCGSM(
dim_in=inputs_train.shape[0],
dim_out=outputs_train.shape[0],
num_components=args.num_components,
num_features=args.num_features,
num_scales=args.num_scales)
def callback(i, mcgsm):
experiment['args'] = args
experiment['model'] = mcgsm
experiment['preconditioner'] = preconditioner
experiment['input_mask'] = input_mask
experiment['output_mask'] = output_mask
experiment.save(args.output)
model.train(
inputs_train, outputs_train,
inputs_valid, outputs_valid,
parameters={
'verbosity': args.verbosity,
'cb_iter': 500,
'callback': callback,
'max_iter': args.max_iter})
### SAVE RESULTS
experiment['args'] = args
experiment['model'] = model
experiment['preconditioner'] = preconditioner
experiment['input_mask'] = input_mask
experiment['output_mask'] = output_mask
experiment.save(args.output)
return 0
def main(argv):
parser = ArgumentParser(argv[0], description=__doc__)
parser.add_argument('model', type=str)
parser.add_argument('--data',
'-d',
type=str,
default='data/deadleaves_test.mat')
parser.add_argument(
'--patch_size',
'-p',
type=int,
default=64,
help=
'Images are split into patches of this size and evaluated separately.')
parser.add_argument('--fraction', '-f', type=float, default=1.)
parser.add_argument('--mode',
'-q',
type=str,
default='CPU',
choices=['CPU', 'GPU'])
parser.add_argument('--device', '-D', type=int, default=0)
parser.add_argument('--horizontal', '-H', type=int, default=1)
parser.add_argument('--vertical', '-V', type=int, default=1)
parser.add_argument('--transpose', '-T', type=int, default=1)
args = parser.parse_args(argv[1:])
# select CPU or GPU for caffe
if args.mode.upper() == 'GPU':
caffe.set_mode_gpu()
caffe.set_device(args.device)
else:
caffe.set_mode_cpu()
# load data
data = loadmat(args.data)['data']
if data.ndim < 4:
data = data[:, :, :, None]
# load model
experiment = Experiment(args.model)
model = experiment['model']
# apply model to data
logloss = []
def evaluate(patches):
"""
Returns a conditional log-likelihood for each pixel.
"""
# evaluate all reachable pixels
loglik = model.loglikelihood(patches)
# make sure the same pixels are evaluated with every transformation
loglik = loglik[:, :-(model.input_mask.shape[0] - 1), :]
# reshape into images x pixels
return loglik.reshape(loglik.shape[0], -1)
for i in range(0, data.shape[1] - args.patch_size + 1, args.patch_size):
for j in range(0, data.shape[2] - args.patch_size + 1,
args.patch_size):
# select random subset
idx = random_select(int(ceil(args.fraction * data.shape[0]) + .5),
data.shape[0])
patches = data[:, i:i + args.patch_size,
j:j + args.patch_size][idx]
loglik = []
loglik.append(evaluate(patches))
if args.horizontal:
loglik.append(evaluate(patches[:, :, ::-1]))
if args.vertical:
loglik.append(evaluate(patches[:, ::-1, :]))
if args.horizontal and args.vertical:
loglik.append(evaluate(patches[:, ::-1, ::-1]))
if args.transpose:
patches = transpose(patches, [0, 2, 1, 3])
loglik.append(evaluate(patches))
if args.horizontal:
loglik.append(evaluate(patches[:, :, ::-1]))
if args.vertical:
loglik.append(evaluate(patches[:, ::-1, :]))
if args.horizontal and args.vertical:
loglik.append(evaluate(patches[:, ::-1, ::-1]))
loglik = asarray(loglik)
# compute log-likelihood for each image and model by summing over pixels
num_pixels = loglik.shape[2]
loglik = loglik.sum(2) # sum over pixels
# compute log-likelihood for mixture model
loglik = logsumexp(loglik, 0) - log(loglik.shape[0])
# compute average log-loss in bit/px
logloss.append(-mean(loglik) / num_pixels / log(2.))
print 'Avg. log-likelihood: {0:.5f} [bit/px]'.format(
-mean(logloss))
return 0
