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