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): 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): 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