def _precondition(self, inputs, outputs=None):
"""
Remove any correlations within and between inputs and outputs.
"""
shape = inputs.shape
if outputs is None:
if self.preconditioner is None:
raise RuntimeError('No preconditioning possible.')
inputs = inputs.reshape(-1, inputs.shape[-1]).T
inputs = self.preconditioner(inputs)
inputs = inputs.T.reshape(*shape)
return inputs
else:
inputs = inputs.reshape(-1, inputs.shape[-1]).T
outputs = outputs.reshape(-1, outputs.shape[-1]).T
# avoids memory issues
MAX_SAMPLES = 5000000
if self.preconditioner is None:
inputs_ = inputs
if self._indicators:
# half of the inputs are indicators, don't preprocess them
inputs_ = inputs.copy()
inputs_[inputs.shape[0] // 2:] = randn(
inputs.shape[0] // 2, *inputs.shape[1:])
if inputs.shape[1] > MAX_SAMPLES:
idx = random_select(MAX_SAMPLES, inputs.shape[1])
self.preconditioner = WhiteningPreconditioner(
inputs_[:, idx], outputs[:, idx])
else:
self.preconditioner = WhiteningPreconditioner(
inputs_, outputs)
# precondition
for b in range(0, inputs.shape[1], MAX_SAMPLES):
inputs[:, b:b + MAX_SAMPLES], outputs[:, b:b + MAX_SAMPLES] = \
self.preconditioner(inputs[:, b:b + MAX_SAMPLES], outputs[:, b:b + MAX_SAMPLES])
inputs = inputs.T.reshape(*shape)
outputs = outputs.T.reshape(shape[0], shape[1], shape[2], -1)
return inputs, outputs
def train_model(img, input_mask, output_mask):
# generate data
inputs, outputs = generate_data_from_image(img, input_mask, output_mask,
120000)
# split data into training and validation sets
data_train = inputs[:, :100000], outputs[:, :100000]
data_valid = inputs[:, 100000:], outputs[:, 100000:]
# compute normalizing transformation
pre = WhiteningPreconditioner(*data_train)
# intialize model
model = MCGSM(dim_in=data_train[0].shape[0],
dim_out=data_train[1].shape[0],
num_components=8,
num_scales=4,
num_features=30)
# fit parameters
model.initialize(*pre(*data_train))
model.train(*chain(pre(*data_train), pre(*data_valid)),
parameters={
'verbosity': 1,
'max_iter': 1000,
'threshold': 1e-7,
'val_iter': 5,
'val_look_ahead': 10,
'num_grad': 20,
})
return model, pre
def test_fill_in_image(self):
xmask = asarray([[1, 1, 1], [1, 0, 0], [0, 0, 0]], dtype='bool')
ymask = asarray([[0, 0, 0], [0, 1, 0], [0, 0, 0]], dtype='bool')
fmask = rand(10, 10) > .9
fmask[0] = False
fmask[:, 0] = False
fmask[-1] = False
fmask[:, -1] = False
img = randn(10, 10)
model = MCGSM(4, 1)
# this should raise an exception
self.assertRaises(TypeError, fill_in_image,
(img, model, xmask, ymask, fmask, 10.))
# this should raise no exception
wt = WhiteningPreconditioner(randn(4, 1000), randn(1, 1000))
fill_in_image_map(img,
model,
xmask,
ymask,
fmask,
wt,
num_iter=1,
patch_size=20)
def _precondition(self, inputs, outputs=None):
"""
Remove any correlations within and between inputs and outputs (conditional whitening).
@type inputs: C{ndarray}
@param inputs: pixel neighborhoods stored column-wise
@type outputs: C{ndarray}
@param outputs: output pixels stored column-wise
"""
shape = inputs.shape
if outputs is None:
if self.preconditioner is None:
raise RuntimeError('No preconditioning possible.')
inputs = inputs.reshape(-1, inputs.shape[-1]).T
inputs = self.preconditioner(inputs)
inputs = inputs.T.reshape(*shape)
return inputs
else:
inputs = inputs.reshape(-1, inputs.shape[-1]).T
outputs = outputs.reshape(-1, outputs.shape[-1]).T
# avoids memory issues
MAX_SAMPLES = 500000
if self.preconditioner is None:
if inputs.shape[1] > MAX_SAMPLES:
idx = random_select(MAX_SAMPLES, inputs.shape[1])
self.preconditioner = WhiteningPreconditioner(
inputs[:, idx], outputs[:, idx])
else:
self.preconditioner = WhiteningPreconditioner(
inputs, outputs)
for b in range(0, inputs.shape[1], MAX_SAMPLES):
inputs[:, b:b + MAX_SAMPLES], outputs[:, b:b + MAX_SAMPLES] = \
self.preconditioner(inputs[:, b:b + MAX_SAMPLES], outputs[:, b:b + MAX_SAMPLES])
inputs = inputs.T.reshape(*shape)
outputs = outputs.T.reshape(shape[0], shape[1], shape[2], -1)
return inputs, outputs
def test_evaluate(self):
mcgsm = MCGSM(5, 3, 4, 2, 10)
inputs = randn(mcgsm.dim_in, 100)
outputs = mcgsm.sample(inputs)
pre = WhiteningPreconditioner(inputs, outputs)
loglik1 = -mcgsm.evaluate(inputs, outputs, pre)
loglik2 = (
mcgsm.loglikelihood(*pre(inputs, outputs)).mean() +
pre.logjacobian(inputs, outputs).mean()) / log(2.) / mcgsm.dim_out
self.assertAlmostEqual(loglik1, loglik2, 8)
def test_whitening_preconditioner(self):
X = dot(randn(5, 5), randn(5, 1000)) + randn(5, 1)
Y = dot(randn(2, 2), randn(2, 1000)) + dot(randn(2, 5), X)
wt = WhiteningPreconditioner(X, Y)
# joint covariance
C = cov(vstack(wt(X, Y)), bias=True)
self.assertLess(max(abs(C - eye(7))), 1e-8)
# test inverse
Xw, Yw = wt(X, Y)
Xr, Yr = wt.inverse(Xw, Yw)
self.assertLess(max(abs(Xr - X)), 1e-10)
self.assertLess(max(abs(Yr - Y)), 1e-10)
def test_whitening_preconditioner_pickle(self):
wt0 = WhiteningPreconditioner(randn(5, 1000), randn(2, 1000))
tmp_file = mkstemp()[1]
# store transformation
with open(tmp_file, 'w') as handle:
dump({'wt': wt0}, handle)
# load transformation
with open(tmp_file) as handle:
wt1 = load(handle)['wt']
X, Y = randn(5, 100), randn(2, 100)
X0, Y0 = wt0(X, Y)
X1, Y1 = wt1(X, Y)
# make sure linear transformation hasn't changed
self.assertLess(max(abs(X0 - X1)), 1e-20)
self.assertLess(max(abs(Y0 - Y1)), 1e-20)
def test_sample_image(self):
xmask = asarray([[1, 1], [1, 0]], dtype='bool')
ymask = asarray([[0, 0], [0, 1]], dtype='bool')
img_init = asarray([[1., 2.], [3., 4.]])
model = MCGSM(3, 1)
img_sample = sample_image(img_init, model, xmask, ymask)
# only the bottom right-pixel should have been replaced
self.assertLess(max(abs((img_init - img_sample).ravel()[:3])), 1e-10)
# test using preconditioner
wt = WhiteningPreconditioner(randn(3, 1000), randn(1, 1000))
sample_image(img_init, model, xmask, ymask, wt)
# test what happens if invalid preconditioner is given
self.assertRaises(TypeError, sample_image,
(img_init, model, xmask, ymask, 10.))
self.assertRaises(TypeError, sample_image,
(img_init, model, xmask, ymask, model))
def main(argv):
# load image and turn into grayscale
img = rgb2gray(imread('media/newyork.png'))
# generate data
inputs, outputs = generate_data_from_image(img, input_mask, output_mask,
220000)
# split data into training, test, and validation sets
inputs = split(inputs, [100000, 200000], 1)
outputs = split(outputs, [100000, 200000], 1)
data_train = inputs[0], outputs[0]
data_test = inputs[1], outputs[1]
data_valid = inputs[2], outputs[2]
# compute normalizing transformation
pre = WhiteningPreconditioner(*data_train)
# intialize model
model = MCGSM(dim_in=data_train[0].shape[0],
dim_out=data_train[1].shape[0],
num_components=8,
num_scales=4,
num_features=32)
# fit parameters
model.initialize(*pre(*data_train))
model.train(*chain(pre(*data_train), pre(*data_valid)),
parameters={
'verbosity': 1,
'max_iter': 1000,
'threshold': 1e-7,
'val_iter': 5,
'val_look_ahead': 10,
'num_grad': 20,
})
# evaluate model
print 'Average log-likelihood: {0:.4f} [bit/px]'.format(
-model.evaluate(data_test[0], data_test[1], pre))
# synthesize a new image
img_sample = sample_image(img, model, input_mask, output_mask, pre)
imwrite('newyork_sample.png',
img_sample,
cmap='gray',
vmin=min(img),
vmax=max(img))
# save model
with open('image_model.pck', 'wb') as handle:
dump(
{
'model': model,
'input_mask': input_mask,
'output_mask': output_mask
}, handle, 1)
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()
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
