def initialize_configs(config_path): config_modules = [] all_configs = config_names(config_path) if (len(all_configs) == 0): print("Error: no config files found in config path '{0}'".format( config_path), file=sys.stderr) sys.exit(1) config_helper = Configs(all_configs) config_helper.load_modules(config_modules) # Give at least one module the config helper config_modules[0].config_helper = config_helper # Step Four: Load jenni try: from __init__ import run except ImportError: try: from jenni import run except ImportError: print("Error: Couldn't find jenni to import", file=sys.stderr) sys.exit(1) # Step Five: Initialise And Run The jennies # @@ ignore SIGHUP for config_module in config_modules: run(config_module) # @@ thread this
def initialize_configs(config_path): config_modules = [] all_configs = config_names(config_path) if(len(all_configs) == 0): print("Error: no config files found in config path '{0}'".format(config_path), file=sys.stderr) sys.exit(1) config_helper = Configs(all_configs) config_helper.load_modules(config_modules) # Give at least one module the config helper config_modules[0].config_helper = config_helper # Step Four: Load jenni try: from __init__ import run except ImportError: try: from jenni import run except ImportError: print("Error: Couldn't find jenni to import", file=sys.stderr) sys.exit(1) # Step Five: Initialise And Run The jennies # @@ ignore SIGHUP for config_module in config_modules: run(config_module) # @@ thread this
def main(argv=None): # Step One: Parse The Command Line parser = optparse.OptionParser('%prog [options]') parser.add_option('-c', '--config', metavar='fn', help='use this configuration file or directory') opts, args = parser.parse_args(argv) if args: print >> sys.stderr, 'Warning: ignoring spurious arguments' # Step Two: Check Dependencies check_python_version() # require python2.4 or later if not opts.config: check_dotdir() # require ~/.caesar, or make it and exit # Step Three: Load The Configurations config_modules = [] for config_name in config_names(opts.config): name = os.path.basename(config_name).split('.')[0] + '_config' module = imp.load_source(name, config_name) module.filename = config_name if not hasattr(module, 'prefix'): module.prefix = r'\!' if not hasattr(module, 'name'): module.name = 'Caesar, a fork of Phenny inamidst.com/phenny' if not hasattr(module, 'port'): module.port = 6667 if not hasattr(module, 'password'): module.password = None if module.host == 'irc.example.net': error = ('Error: you must edit the config file first!\n' + "You're currently using %s" % module.filename) print >> sys.stderr, error sys.exit(1) config_modules.append(module) # Step Four: Load caesar try: from __init__ import run except ImportError: try: from caesar import run except ImportError: print >> sys.stderr, "Error: Couldn't find caesar to import" sys.exit(1) # Step Five: Initialise And Run The Phennies # @@ ignore SIGHUP for config_module in config_modules: run(config_module) # @@ thread this
def main(): pNode = AppCore.NodeGraph.createNode('Clip') pNode['xpos'].setValue(0) pNode['ypos'].setValue(0) pNode['file'].setValue('*NWSTORAGE/') AppCore.ViewerWidget.setInput(0, pNode) MyApp.run()
def install_hdf(): meta = get_meta('hdf5') fab.run('mkdir -p '+meta.src) with fab.cd(meta.src): fab.run('wget '+meta.url) fab.run('tar xzvf '+meta.tar_name) with fab.cd(meta.base): fab.run('./configure --prefix={0} --enable-shared --enable-hl'.format(meta.install))
def run_ssasc(self, theta, N, O): # Initialise the library for computing pattern probabilities transforms.initialise(N, O) # Compute probability from theta values p = numpy.zeros((self.T, 2**N)) for i in xrange(self.T): p[i,:] = transforms.compute_p(theta[i,:]) # Generate spikes according to those probabilities spikes = synthesis.generate_spikes(p, self.R, seed=self.spike_seed) # Run the algorithm! emd = __init__.run(spikes, O) # Compute the KL divergence between real and estimated parameters kld = klic(theta, emd.theta_s, emd.N) # Check that KL divergence is OK if numpy.any(kld[50:-50] > .01): self.plot(theta, emd.theta_s, emd.sigma_s, emd.y, kld, emd.N, emd.T, emd.D) self.assertFalse(numpy.any(kld[50:-50] > .01))
def install_netCDF4(): meta = get_meta('netCDF4') meta_hdf5 = get_meta('hdf5') fab.sudo('apt-get install libcurl4-openssl-dev') fab.run('mkdir -p '+meta.src) with fab.cd(meta.src): fab.run('wget '+meta.url) fab.run('tar xzvf '+meta.tar_name) with fab.cd(meta.base): fab.run('export LDFLAGS=-L{0}/lib'.format(meta_hdf5.install)) fab.run('export CPPFLAGS=-I{0}R/include'.format(meta_hdf5.install)) fab.run('export LD_LIBRARY_PATH={0}/lib'.format(meta_hdf5.install)) fab.run('./configure --enable-netcdf-4 --enable-dap --enable-shared --prefix='+meta.install)
#=============================================================================== # @License: # This example file is public domain. See ADDENDUM section in LICENSE. # You may do the following things with this file without restrictions or conditions: # 1. Modify it. # 2. Remove or modify this section to your liking. # 3. Redistribute it under any licensing terms that you wish. # 4. Make copyright claims to derivative works of this file. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. #=============================================================================== import os if __name__ == '__main__': if os.path.abspath(__file__).split(os.sep)[-2] == 'MediaApp': import __init__ as MediaApp MediaApp.run() else: ##### Rename MyApp to your App's name here ##### import __init__ as MyApp MyApp.run()
# Generate spikes by Gibbs sampling! # Sample steps: How many samples are dropped to make them independent # Pre_n: Determines how many samples are used for the burn in phase spikes = synthesis.generate_spikes_gibbs(theta, N, O, R, pre_n=100, sample_steps=1) # Generate spikes in parallel # num_proc: How many processes are started in parallel # spikes = synthesis.generate_spikes_gibbs_parallel(theta, N, O, R, pre_n=100, # sample_steps=1, num_proc=4) # ----- ALGORITHM EXECUTION ----- # Local module import __init__ # From outside this folder, this would be 'import ssll' # Run the algorithm with pseudo likelihood, bethe approximation! emd = __init__.run(spikes, O, map_function='cg', lmbda1=200, lmbda2=200, param_est='pseudo', param_est_eta='bethe_hybrid') # Run the algorithm with pseudo likelihood, TAP approximation! # emd = __init__.run(spikes, O, map_function='cg', lmbda1=200, lmbda2=200, # param_est='pseudo', param_est_eta='mf') # ----- PLOTTING ----- # Global module import pylab # Set up an output figure fig, ax = pylab.subplots(2, 1, sharex=True) # Plot underlying theta traces ax[0].plot(theta[:,0], c='b', linestyle='--') ax[0].plot(theta[:,1], c='r', linestyle='--')
def main(): global parser # use ArgumentParser to interpret commandline options parser = argparse.ArgumentParser(_("usage: sbot [options] inputfile.bot [args]")) parser.add_argument("script") parser.add_argument("-o", "--outputfile", dest="outputfile", help=_("run script and output to FILE (accepts .svg, .ps, .pdf and .png extensions)"), metavar="FILE") parser.add_argument("-w", "--window", action="store_true", dest="window", default=False, help=_("run script in a GTK window") ) parser.add_argument("-f", "--fullscreen", action="store_true", dest="fullscreen", default=False, help=_("run in fullscreen mode") ) parser.add_argument("-t", "--title", action="store", dest="title", default=None, help=_("Set window title") ) parser.add_argument("-s", "--socketserver", action="store_true", dest="socketserver", default=False, help=_("run a socket server for external control (will run the script in windowed mode)")) parser.add_argument("-dv", "--disable-vars", action="store_true", dest="disable_vars", default=False, help=_("disable the variables pane when in windowed mode.")) parser.add_argument("-dt", "--disable-background-thread", action="store_true", dest="disable_background_thread", default=False, help=_("disable running bot code in background thread.")) parser.add_argument("-p", "--serverport", type=int, dest="serverport", default=DEFAULT_SERVERPORT, help=_("set socketserver port to listen for connections (default is 7777)")) parser.add_argument("-r", "--repeat", type=int, dest="repeat", default=False, help=_("set number of iteration, multiple images will be produced")) parser.add_argument("-g", "--grammar", dest="grammar", default=NODEBOX, help=_("Select the bot grammar 'nodebox' (default) or 'drawbot' languages"), ) parser.add_argument("-c", "--close", action="store_true", dest="close", default=False, help=_("Close window after running bot (use with -r for benchmarking)"), ) parser.add_argument("-v", "--vars", dest="vars", default=False, help=_("Initial variables, in JSON (Note: Single quotes OUTSIDE, double INSIDE) --vars='{\"variable1\": 1}'"), ) parser.add_argument("-ns", "--namespace", dest="namespace", default=None, help=_("Initial namespace, in JSON (Note: Single quotes OUTSIDE, double INSIDE) --namespace='{\"variable1\": 1}'"), ) parser.add_argument("-l", "--l", dest="shell", action="store_true", default=False, help=_("Simple shell - for IDE interaction"), ) parser.add_argument("-a", "--args", dest="script_args", help=_("Pass to the bot"), ) parser.add_argument("-V", "--verbose", action="store_true", dest="verbose", default=False, help=_("Show internal shoebot error information in traceback"), ) parser.add_argument('script_args', nargs='?') # get argparse arguments and check for sanity args, extra = parser.parse_known_args() if not args.script and not args.window: error(_('Please specify an input script!\n (check /usr/share/shoebot/examples/ for example scripts)')) vars = None if args.vars: vars = json_arg(args.vars) # try: # import json # vars = json.loads(args.vars) # except Exception as e: # error(_('Error parsing JSON, remember single quotes OUTSIDE, double QUOTES inside.')) # raise e namespace = None if args.namespace: namespace = json_arg(args.namespace) # try: # import json # namespace = json.loads(args.namespace) # except Exception as e: # error(_('Error parsing JSON, remember single quotes OUTSIDE, double QUOTES inside.')) # raise e run(src = args.script, grammar = args.grammar, outputfile = args.outputfile, iterations = args.repeat or None, window = args.window or args.socketserver, fullscreen = args.fullscreen, title = args.title, close_window = args.close, server=args.socketserver, port=args.serverport, show_vars = args.window and args.disable_vars == False, vars = vars or None, namespace = namespace, run_shell = args.shell, args = shlex.split(args.script_args or ""), verbose = args.verbose, background_thread=not args.disable_background_thread, )
def generate_data_figure1(data_path = '../Data/'): N, O, R, T = 15, 2, 200, 500 mu = numpy.zeros(T) x = numpy.arange(1, 401) mu[100:] = 1. * (3. / (2. * numpy.pi * (x/400.*3.) ** 3)) ** .5 * \ numpy.exp(-3. * ((x/400.*3.) - 1.) ** 2 / (2. * (x/400.*3.))) theta1 = synthesis.generate_thetas(N, O, T, mu1=-2.) theta2 = synthesis.generate_thetas(N, O, T, mu1=-2.) theta1[:, :N] += mu[:, numpy.newaxis] theta2[:, :N] += mu[:, numpy.newaxis] D = transforms.compute_D(N * 2, O) theta_all = numpy.empty([T, D]) theta_all[:, :N] = theta1[:, :N] theta_all[:, N:2 * N] = theta2[:, :N] triu_idx = numpy.triu_indices(N, k=1) triu_idx_all = numpy.triu_indices(2 * N, k=1) for t in range(T): theta_ij = numpy.zeros([2 * N, 2 * N]) theta_ij[triu_idx] = theta1[t, N:] theta_ij[triu_idx[0] + N, triu_idx[1] + N] = theta2[t, N:] theta_all[t, 2 * N:] = theta_ij[triu_idx_all] psi1 = numpy.empty([T, 3]) psi2 = numpy.empty([T, 3]) eta1 = numpy.empty(theta1.shape) eta2 = numpy.empty(theta2.shape) alpha = [.999,1.,1.001] transforms.initialise(N, O) for i in range(T): for j, a in enumerate(alpha): psi1[i, j] = transforms.compute_psi(a * theta1[i]) p = transforms.compute_p(theta1[i]) eta1[i] = transforms.compute_eta(p) for j, a in enumerate(alpha): psi2[i, j] = transforms.compute_psi(a * theta2[i]) p = transforms.compute_p(theta2[i]) eta2[i] = transforms.compute_eta(p) psi_all = psi1 + psi2 S1 = -numpy.sum(eta1 * theta1, axis=1) + psi1[:, 1] S1 /= numpy.log(2) S2 = -numpy.sum(eta2 * theta2, axis=1) + psi2[:, 1] S2 /= numpy.log(2) S_all = S1 + S2 C1 = (psi1[:, 0] - 2. * psi1[:, 1] + psi1[:, 2]) / .001 ** 2 C1 /= numpy.log(2) C2 = (psi2[:, 0] - 2. * psi2[:, 1] + psi2[:, 2]) / .001 ** 2 C2 /= numpy.log(2) C_all = C1 + C2 spikes = synthesis.generate_spikes_gibbs_parallel(theta_all, 2 * N, O, R, sample_steps=10, num_proc=4) print 'Model and Data generated' emd = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta='bethe_hybrid', lmbda1=100, lmbda2=200) f = h5py.File(data_path + 'figure1data.h5', 'w') g_data = f.create_group('data') g_data.create_dataset('theta_all', data=theta_all) g_data.create_dataset('psi_all', data=psi_all) g_data.create_dataset('S_all', data=S_all) g_data.create_dataset('C_all', data=C_all) g_data.create_dataset('spikes', data=spikes) g_data.create_dataset('theta1', data=theta1) g_data.create_dataset('theta2', data=theta2) g_data.create_dataset('psi1', data=psi1) g_data.create_dataset('S1', data=S1) g_data.create_dataset('C1', data=C1) g_data.create_dataset('psi2', data=psi2) g_data.create_dataset('S2', data=S2) g_data.create_dataset('C2', data=C2) g_fit = f.create_group('fit') g_fit.create_dataset('theta_s', data=emd.theta_s) g_fit.create_dataset('sigma_s', data=emd.sigma_s) g_fit.create_dataset('Q', data=emd.Q) f.close() print 'Fit and saved' f = h5py.File(data_path + 'figure1data.h5', 'r+') g_fit = f['fit'] theta = g_fit['theta_s'].value sigma = g_fit['sigma_s'].value X = numpy.random.randn(theta.shape[0], theta.shape[1], 100) theta_sampled = \ theta[:, :, numpy.newaxis] + X * numpy.sqrt(sigma)[:, :, numpy.newaxis] T = range(theta.shape[0]) eta_sampled = numpy.empty([theta.shape[0], theta.shape[1], 100]) psi_sampled = numpy.empty([theta.shape[0], 100, 3]) func = partial(get_sampled_eta_psi, theta_sampled=theta_sampled, N=2*N) pool = multiprocessing.Pool(10) results = pool.map(func, T) for eta, psi, i in results: eta_sampled[i] = eta psi_sampled[i] = psi S_sampled = \ -(numpy.sum(eta_sampled*theta_sampled, axis=1) - psi_sampled[:, :, 1]) S_sampled /= numpy.log(2) C_sampled = \ (psi_sampled[:, :, 0] - 2.*psi_sampled[:, :, 1] + psi_sampled[:, :, 2])/.001**2 C_sampled /= numpy.log(2) g_sampled = f.create_group('sampled_results') g_sampled.create_dataset('theta_sampled', data=theta_sampled) g_sampled.create_dataset('eta_sampled', data=eta_sampled) g_sampled.create_dataset('psi_sampled', data=psi_sampled) g_sampled.create_dataset('S_sampled', data=S_sampled) g_sampled.create_dataset('C_sampled', data=C_sampled) f.close() print 'Done'
import __init__ __init__.run()
def generate_data_figure2(data_path='../Data/', max_network_size=60): N, O, R, T = 10, 2, 200, 500 num_of_networks = max_network_size/N mu = numpy.zeros(T) x = numpy.arange(1, 401) mu[100:] = 1. * (3. / (2. * numpy.pi * (x / 400. * 3.) ** 3)) ** .5 * \ numpy.exp(-3. * ((x / 400. * 3.) - 1.) ** 2 / (2. * (x / 400. * 3.))) D = transforms.compute_D(N, O) thetas = numpy.empty([num_of_networks, T, D]) etas = numpy.empty([num_of_networks, T, D]) psi = numpy.empty([num_of_networks, T]) S = numpy.empty([num_of_networks, T]) C = numpy.empty([num_of_networks, T]) transforms.initialise(N, O) for i in range(num_of_networks): thetas[i] = synthesis.generate_thetas(N, O, T, mu1=-2.) thetas[i, :, :N] += mu[:, numpy.newaxis] for t in range(T): p = transforms.compute_p(thetas[i, t]) etas[i, t] = transforms.compute_eta(p) psi[i, t] = transforms.compute_psi(thetas[i, t]) psi1 = transforms.compute_psi(.999 * thetas[i, t]) psi2 = transforms.compute_psi(1.001 * thetas[i, t]) C[i, t] = (psi1 - 2. * psi[i, t] + psi2) / .001 ** 2 S[i, t] = -(numpy.sum(etas[i, t] * thetas[i, t]) - psi[i, t]) C /= numpy.log(2) S /= numpy.log(2) f = h5py.File(data_path + 'figure2data.h5', 'w') g1 = f.create_group('data') g1.create_dataset('thetas', data=thetas) g1.create_dataset('etas', data=etas) g1.create_dataset('psi', data=psi) g1.create_dataset('S', data=S) g1.create_dataset('C', data=C) g2 = f.create_group('error') g2.create_dataset('MISE_thetas', shape=[num_of_networks]) g2.create_dataset('MISE_population_rate', shape=[num_of_networks]) g2.create_dataset('MISE_psi', shape=[num_of_networks]) g2.create_dataset('MISE_S', shape=[num_of_networks]) g2.create_dataset('MISE_C', shape=[num_of_networks]) g2.create_dataset('population_rate', shape=[num_of_networks, T]) g2.create_dataset('psi', shape=[num_of_networks, T]) g2.create_dataset('S', shape=[num_of_networks, T]) g2.create_dataset('C', shape=[num_of_networks, T]) f.close() for i in range(num_of_networks): print 'N=%d' % ((i + 1) * N) D = transforms.compute_D((i + 1) * N, O) theta_all = numpy.empty([T, D]) triu_idx = numpy.triu_indices(N, k=1) triu_idx_all = numpy.triu_indices((i + 1) * N, k=1) for j in range(i + 1): theta_all[:, N * j:(j + 1) * N] = thetas[j, :, :N] for t in range(T): theta_ij = numpy.zeros([(i + 1) * N, (i + 1) * N]) for j in range(i + 1): theta_ij[triu_idx[0] + j * N, triu_idx[1] + j * N] = \ thetas[j, t, N:] theta_all[t, (i + 1) * N:] = theta_ij[triu_idx_all] spikes = synthesis.generate_spikes_gibbs_parallel(theta_all , (i + 1) * N, O, R, sample_steps=10, num_proc=4) emd = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta='bethe_hybrid', lmbda1=100, lmbda2=200) eta_est = numpy.empty(emd.theta_s.shape) psi_est = numpy.empty(T) S_est = numpy.empty(T) C_est = numpy.empty(T) for t in range(T): eta_est[t], psi_est[t] = bethe_approximation.compute_eta_hybrid( emd.theta_s[t], (i + 1) * N, return_psi=1) psi1 = bethe_approximation.compute_eta_hybrid( .999 * emd.theta_s[t], (i + 1) * N, return_psi=1)[1] psi2 = bethe_approximation.compute_eta_hybrid( 1.001 * emd.theta_s[t], (i + 1) * N, return_psi=1)[1] S_est[t] = -(numpy.sum(eta_est[t] * emd.theta_s[t]) - psi_est[t]) C_est[t] = (psi1 - 2. * psi_est[t] + psi2) / .001 ** 2 S_est /= numpy.log(2) C_est /= numpy.log(2) population_rate = numpy.mean(numpy.mean(etas[:i + 1, :, :N], axis=0), axis=1) population_rate_est = numpy.mean(eta_est[:, :(i + 1) * N], axis=1) psi_true = numpy.sum(psi[:(i + 1), :], axis=0) S_true = numpy.sum(S[:(i + 1), :], axis=0) C_true = numpy.sum(C[:(i + 1), :], axis=0) f = h5py.File(data_path + 'figure2data.h5', 'r+') f['error']['MISE_thetas'][i] = numpy.mean( (theta_all - emd.theta_s) ** 2) f['error']['MISE_population_rate'][i] = numpy.mean( (population_rate - population_rate_est) ** 2) f['error']['MISE_psi'][i] = numpy.mean((psi_est - psi_true) ** 2) f['error']['MISE_S'][i] = numpy.mean((S_est - S_true) ** 2) f['error']['MISE_C'][i] = numpy.mean((C_est - C_true) ** 2) f['error']['population_rate'][i] = population_rate_est f['error']['psi'][i] = psi_est f['error']['S'][i] = S_est f['error']['C'][i] = C_est f.close() f = h5py.File(data_path + 'figure2data.h5', 'r+') thetas = f['data']['thetas'].value etas = f['data']['etas'].value psi = f['data']['psi'].value S = f['data']['S'].value C = f['data']['C'].value g2 = f.create_group('error500') g2.create_dataset('population_rate', shape=[num_of_networks, T]) g2.create_dataset('psi', shape=[num_of_networks, T]) g2.create_dataset('S', shape=[num_of_networks, T]) g2.create_dataset('C', shape=[num_of_networks, T]) g2.create_dataset('MISE_thetas', shape=[num_of_networks]) g2.create_dataset('MISE_population_rate', shape=[num_of_networks]) g2.create_dataset('MISE_psi', shape=[num_of_networks]) g2.create_dataset('MISE_S', shape=[num_of_networks]) g2.create_dataset('MISE_C', shape=[num_of_networks]) f.close() R = 500 for i in range(num_of_networks): print 'N=%d' % ((i + 1) * N) D = transforms.compute_D((i + 1) * N, O) theta_all = numpy.empty([T, D]) triu_idx = numpy.triu_indices(N, k=1) triu_idx_all = numpy.triu_indices((i + 1) * N, k=1) for j in range(i + 1): theta_all[:, N * j:(j + 1) * N] = thetas[j, :, :N] for t in range(T): theta_ij = numpy.zeros([(i + 1) * N, (i + 1) * N]) for j in range(i + 1): theta_ij[triu_idx[0] + j * N, triu_idx[1] + j * N] = \ thetas[j, t, N:] theta_all[t, (i + 1) * N:] = theta_ij[triu_idx_all] spikes = synthesis.generate_spikes_gibbs_parallel(theta_all, (i + 1) * N, O, R, sample_steps=10, num_proc=4) emd = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta='bethe_hybrid', lmbda1=100, lmbda2=200) eta_est = numpy.empty(emd.theta_s.shape) psi_est = numpy.empty(T) S_est = numpy.empty(T) C_est = numpy.empty(T) for t in range(T): eta_est[t], psi_est[t] = \ bethe_approximation.compute_eta_hybrid(emd.theta_s[t], (i + 1) * N, return_psi=1) psi1 = bethe_approximation.compute_eta_hybrid(.999 * emd.theta_s[t], (i + 1) * N, return_psi=1)[1] psi2 = bethe_approximation.compute_eta_hybrid( 1.001 * emd.theta_s[t], (i + 1) * N, return_psi=1)[1] S_est[t] = -(numpy.sum(eta_est[t] * emd.theta_s[t]) - psi_est[t]) C_est[t] = (psi1 - 2. * psi_est[t] + psi2) / .001 ** 2 S_est /= numpy.log(2) C_est /= numpy.log(2) population_rate = numpy.mean(numpy.mean(etas[:i + 1, :, :N], axis=0), axis=1) population_rate_est = numpy.mean(eta_est[:, :(i + 1) * N], axis=1) psi_true = numpy.sum(psi[:(i + 1), :], axis=0) S_true = numpy.sum(S[:(i + 1), :], axis=0) C_true = numpy.sum(C[:(i + 1), :], axis=0) f = h5py.File(data_path + 'figure2data.h5', 'r+') f['error500']['MISE_thetas'][i] = numpy.mean( (theta_all - emd.theta_s) ** 2) f['error500']['MISE_population_rate'][i] = numpy.mean( (population_rate - population_rate_est) ** 2) f['error500']['MISE_psi'][i] = numpy.mean((psi_est - psi_true) ** 2) f['error500']['MISE_S'][i] = numpy.mean((S_est - S_true) ** 2) f['error500']['MISE_C'][i] = numpy.mean((C_est - C_true) ** 2) f['error500']['population_rate'][i] = population_rate_est f['error500']['psi'][i] = psi_est f['error500']['S'][i] = S_est f['error500']['C'][i] = C_est f.close()
def run_em(orientation, O, monkey, spikes, spike_reverse=False, spike_shuffle=False, lmbda1=100, lmbda2=100, max_iter=100, param_est='exact', param_est_eta='exact', stationary='None', theta_o=0, sigma_o=0.1, mstep=True, trials='all', pop='', save=False): """ Performs the EM algorithm to fit an Ising model on a given spike train coming from a given population of neurons from a given monkey exposed to gratings at a given orientation. Then, is save is True, creates a pickle file with a name containing the index of the monkey, the orientation of the stimulus and the type of spike train analyzed (i.e. reversed in time and/or trial shuffled or not). The file is saved in the 'Data' folder in the working directory. This folder is created if inexistant. :param int orientation: Orientation of the stimulus to consider (0, 30, 60, 90,..., 330) :param int O: Order of interactions to consider in the Ising model (1 or 2) :param int monkey: Index of the monkey to consider (0, 1, 2) :param numpy.ndarray spikes Spike train to which the Ising model should be fitted (T,R,N) :param boolean spike_reverse: If True, the spike train to analyze will be reversed in time :param boolean spike_shuffle: If True, the spike train to analyze will be trial-shuffled to remove correlations :param float lmbda1: Inverse coefficient on the identity matrix of the initial state-transition covariance matrix for the first order theta parameters :param float lmbda2: Inverse coefficient on the identity matrix of the initial state-transition covariance matrix for the second order theta parameters :param int max_iter: Maximum number of iterations for which to run the EM algorithm. :param str param_est: Parameter whether exact likelihood ('exact') or pseudo likelihood ('pseudo') should be used :param str param_est_eta: Eta parameters are either calculated exactly ('exact'), by mean field TAP approximation ('TAP'), or Bethe approximation (belief propagation-'bethe_BP', CCCP-'bethe_CCCP', hybrid-'bethe_hybrid') :param stationary: To fit stationary model. Set 'all' to have stationary thetas (Default='None') :param numpy.ndarray theta_o: Prior mean at the first time bin (one-step predictor) :param numpy.ndarray sigma_o: Prior covariance at the first time bin (one-step predictor) :param boolean mstep: The m-step of the EM algorithm is performed only if this parameter is true :param str trials If 'all', all trials are considered. If 'odd', only odd-numbered trials are considered If 'even', only even-numbered trials are considered :param str pop Index of the population to analyze. Give different index numbers to populations of the same monkey, otherwise the results of different populations will overwrite each other. :param boolean save If True, the emd container will be saved in a pickle file in the "Data" folder. :returns: EMD container. Contains the results of the EM algorithm """ # Marker for the name of the created file b = pop if spike_reverse == True: b += '_i' if spike_shuffle == True: b += '_shuffle' if trials != 'all': b += '_' + trials # Run the algorithm emd = __init__.run(spikes, O, map_function='cg', lmbda1=lmbda1, \ lmbda2=lmbda2, max_iter=max_iter, param_est=param_est, \ param_est_eta=param_est_eta, stationary=stationary, \ theta_o=theta_o, sigma_o=sigma_o, mstep=mstep) if save == True: # Export emd container to a pickle file directory = os.getcwd() if not os.path.exists(directory + '/Data/'): os.makedirs(directory + '/Data/') f = open( directory + '/Data/m' + str(monkey + 1) + 'd' + str(orientation) + b, 'wb') pickle.dump(emd, f) f.close() print('Lambda = ' + str(1 / emd.Q[0, 0]) + ' for orientation ' + str(orientation)) return emd
from __init__ import run run()
def main(argv=None): # Step One: Parse The Command Line parser = optparse.OptionParser('%prog [options]') parser.add_option('-c', '--config', metavar='fn', help='use this configuration file or directory') opts, args = parser.parse_args(argv) if args: print >> sys.stderr, 'Warning: ignoring spurious arguments' # Step Two: Check Dependencies check_python_version() # require python2.4 or later if not opts.config: check_dotdir() # require ~/.phenny, or make it and exit # Step Three: Load The Configurations config_modules = [] for config_name in config_names(opts.config): name = os.path.basename(config_name).split('.')[0] + '_config' module = imp.load_source(name, config_name) module.filename = config_name if not hasattr(module, 'prefix'): module.prefix = r'\.' if not hasattr(module, 'name'): module.name = 'Phenny Palmersbot, http://inamidst.com/phenny/' if not hasattr(module, 'port'): module.port = 6667 if not hasattr(module, 'password'): module.password = None if module.host == 'irc.example.net': error = ('Error: you must edit the config file first!\n' + "You're currently using %s" % module.filename) print >> sys.stderr, error sys.exit(1) config_modules.append(module) # Step Four: Load Phenny try: from __init__ import run except ImportError: try: from phenny import run except ImportError: print >> sys.stderr, "Error: Couldn't find phenny to import" sys.exit(1) # Step Five: Initialise And Run The Phennies # @@ ignore SIGHUP for config_module in config_modules: run(config_module) # @@ thread this
from __init__ import run def myview(request): return "<h1>Hello world!</h1>" urls = { "/hello" : {"view": myview} } if __name__ == "__main__": run(urls)
# Compute P for each timestep p = numpy.zeros((T, 2**N)) for i in xrange(T): p[i,:] = transforms.compute_p(theta[i,:]) # Generate spikes! spikes = synthesis.generate_spikes(p, R, seed=1) # ----- ALGORITHM EXECUTION ----- # Global module import numpy # Local module import __init__ # From outside this folder, this would be 'import ssasc' # Run the algorithm! emd = __init__.run(spikes, O, lmbda=.005) # ----- PLOTTING ----- # Global module import pylab # Set up an output figure fig, ax = pylab.subplots(2, 1, sharex=1) # Plot theta traces ax[0].plot(emd.theta_s[:,0], c='b') ax[0].plot(emd.theta_s[:,1], c='r') ax[1].plot(emd.theta_s[:,2], c='g') # Set axis limits ax[0].set_ylim(-4.5, -1.5) ax[1].set_ylim(1.5, 4.5)
def generate_data_figure3and4(data_path = '../Data/', num_of_iterations=10): R, T, N, O = 200, 500, 15, 2 f = h5py.File(data_path + 'figure1data.h5', 'r') theta = f['data']['theta1'].value f.close() transforms.initialise(N, O) psi_true = numpy.empty(T) for i in range(T): psi_true[i] = transforms.compute_psi(theta[i]) p = numpy.zeros((T, 2 ** N)) for i in range(T): p[i, :] = transforms.compute_p(theta[i, :]) fitting_methods = ['exact', 'bethe_hybrid', 'mf'] f = h5py.File(data_path + 'figure2and3data.h5', 'w') f.create_dataset('psi_true', data=psi_true) f.create_dataset('theta_true', data=theta) for fit in fitting_methods: g = f.create_group(fit) g.create_dataset('MISE_theta', shape=[num_of_iterations]) g.create_dataset('MISE_psi', shape=[num_of_iterations]) g.create_dataset('psi', shape=[num_of_iterations, T]) f.close() for iteration in range(num_of_iterations): print 'Iteration %d' % iteration spikes = synthesis.generate_spikes(p, R, seed=None) for fit in fitting_methods: if fit == 'exact': emd = __init__.run(spikes, O, map_function='cg', param_est='exact', param_est_eta='exact') else: emd = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta=fit) psi = numpy.empty(T) if fit == 'exact': for i in range(T): psi[i] = transforms.compute_psi(emd.theta_s[i]) elif fit == 'bethe_hybrid': for i in range(T): psi[i] = bethe_approximation.compute_eta_hybrid( emd.theta_s[i], N, return_psi=1)[1] elif fit == 'mf': for i in range(T): eta_mf = mean_field.forward_problem(emd.theta_s[i], N, 'TAP') psi[i] = mean_field.compute_psi(emd.theta_s[i], eta_mf, N) mise_theta = numpy.mean((theta - emd.theta_s) ** 2) mise_psi = numpy.mean((psi_true - psi) ** 2) f = h5py.File(data_path + 'figure2and3data.h5', 'r+') g = f[fit] g['MISE_theta'][iteration] = mise_theta g['MISE_psi'][iteration] = mise_psi if iteration == 0: g.create_dataset('theta', data=emd.theta_s) g.create_dataset('sigma', data=emd.sigma_s) g['psi'][iteration] = psi f.close() print 'Fitted with %s' % fit
def main(): global parser # use ArgumentParser to interpret commandline options parser = argparse.ArgumentParser(_("usage: sbot [options] inputfile.bot [args]")) parser.add_argument("script", help="Shoebot / Nodebox script to run (filename or code)", nargs='?') group = parser.add_argument_group('Input / Output') # IO - Output to file group.add_argument("-o", "--outputfile", dest="outputfile", help=_("run script and output to image file (accepts .png .svg .pdf and .ps extensions)"), metavar="FILE") # Shoebot IO - Sockets group.add_argument("-s", "--socketserver", action="store_true", dest="socketserver", default=False, help=_("run a socket server for external control (will run the script in windowed mode)")) group.add_argument("-p", "--serverport", type=int, dest="serverport", default=DEFAULT_SERVERPORT, help=_("set socketserver port to listen for connections (default is 7777)")) # IO - Variables group.add_argument("-v", "--vars", dest="vars", default=False, help=_("Initial variables, in JSON (Note: Single quotes OUTSIDE, double INSIDE) --vars='{\"variable1\": 1}'"), ) # IO - Namespace group.add_argument("-ns", "--namespace", dest="namespace", default=None, help=_("Initial namespace, in JSON (Note: Single quotes OUTSIDE, double INSIDE) --namespace='{\"variable1\": 1}'"), ) # IO - IDE integration Shell group.add_argument("-l", "--l", dest="shell", action="store_true", default=False, help=_("Simple shell - for IDE interaction"), ) # IO - Passing args to the bot group.add_argument("-a", "--args", dest="script_args", help=_("Pass to the bot"), ) group.add_argument('script_args', nargs='?') group = parser.add_argument_group('Bot Lifecycle') # Bot Lifecycle group.add_argument("-r", "--repeat", type=int, dest="repeat", default=False, help=_("set number of iteration, multiple images will be produced")) group.add_argument("-g", "--grammar", dest="grammar", default=NODEBOX, help=_("Select the bot grammar 'nodebox' (default) or 'drawbot' languages"), ) group = parser.add_argument_group('Window Management') group.add_argument("-w", "--window", action="store_true", dest="window", default=True, help=_("run script in a GTK window") ) group.add_argument("-f", "--fullscreen", action="store_true", dest="fullscreen", default=False, help=_("run in fullscreen mode") ) group.add_argument("-t", "--title", action="store", dest="title", default=None, help=_("Set window title") ) group.add_argument("-c", "--close", action="store_true", dest="close", default=False, help=_("Close window after running bot (use with -r for benchmarking)"), ) group.add_argument("-dv", "--disable-vars", action="store_true", dest="disable_vars", default=False, help=_("disable the variables pane when in windowed mode.")) group = parser.add_argument_group('Debugging / Dev flags') group.add_argument("-dn", "--diagnose", action="store_true", default=False, help=_("Output information for debugging installation / graphics issues.")) group.add_argument("-dt", "--disable-background-thread", action="store_true", dest="disable_background_thread", default=sys.platform=='darwin', help=_("disable running bot code in background thread (default on OSX).")) group.add_argument("-V", "--verbose", action="store_true", dest="verbose", default=False, help=_("Show internal shoebot error information in traceback"), ) # get argparse arguments and check for sanity args, extra = parser.parse_known_args() if args.diagnose: from diagnose import diagnose diagnose() sys.exit() if not args.script: error(_('Please specify an input script!\n (check /usr/share/shoebot/examples/ for example scripts)')) if args.vars: vars = json_arg(args.vars) else: vars = None if args.namespace: namespace = json_arg(args.namespace) else: namespace = None from __init__ import run # https://github.com/shoebot/shoebot/issues/206 run(src=args.script, grammar=args.grammar, outputfile=args.outputfile, iterations=args.repeat or None, window=args.window or args.socketserver, fullscreen=args.fullscreen, title=args.title, close_window=args.close, server=args.socketserver, port=args.serverport, show_vars=args.window and args.disable_vars is False, vars=vars or None, namespace=namespace, run_shell=args.shell, args=shlex.split(args.script_args or ""), verbose=args.verbose, background_thread=not args.disable_background_thread, )
# Initial one-step predictor (hyperparameters mu and sigma) theta_o = numpy.zeros((1, D_fit)) sigma_o = 0.1 * numpy.eye(D_fit) # Initialise theta, sigma and marginal log likelihood theta_fit = numpy.zeros((T, D_fit)) lm = numpy.zeros(T) # Initialise a list of J estimates J_list = list() J_list.append(numpy.copy(J)) print('D_fit = ' + str(D_fit)) for t in range(T): # Fit to update J emd = __init__.run(spikes[t,numpy.newaxis], D_fit, lmbda=lmbda, J=J, \ theta_o=theta_o, sigma_o=sigma_o, exact=exact) # Retrieve and normalize J (unit variance) J = emd.J / (numpy.var(emd.J, axis=0)**0.5) # Save J J_list.append(numpy.copy(J)) # Update one-step predictors theta_o = numpy.dot(emd.F, emd.theta_f[0, :]) tmp = numpy.dot(emd.F, emd.sigma_f[0, :, :]) sigma_o = numpy.dot(tmp, emd.F.T) + emd.Q # Retrieve fitted weights and their variance theta_fit[t, :] = emd.theta_s[0, :] # Compute the current marginal log-likelihood lm[t] = probability.log_marginal(emd) print('step ' + str(t) + '/ ' + str(T)) # Save results
# Spikes list spikes_list = list() for r in range(rep): print(str(r + 1) + '/' + str(rep) + ' epochs') for t in range(T1): # Get the spike array if exact: spikes = synthesis.generate_spikes(p[t, numpy.newaxis, :], 1, seed=seed) else: spikes = synthesis.generate_spikes_gibbs(mixed_theta[t,:].reshape(1,dim), N, \ 2, 1) # Fit to update J emd = __init__.run(spikes, D_fit, lmbda=lmbda, J=J, \ theta_o=theta_o, sigma_o=sigma_o, exact=exact) # Retrieve updated J J = emd.J # Scale columns of J J = J / (numpy.var(J, axis=0)**0.5) # Save J J_list.append(J) # Update one-step predictors theta_o = numpy.dot(emd.F, emd.theta_f[0, :]) tmp = numpy.dot(emd.F, emd.sigma_f[0, :, :]) sigma_o = numpy.dot(tmp, emd.F.T) + emd.Q # Retrieve fitted weights and their variance theta_fit[t, :] = emd.theta_s[0, :] sigma[t, :] = numpy.diag(emd.sigma_s[0]) # Compute the current marginal log-likelihood lm[t] = probability.log_marginal(emd)
# Compute P for each time step p = numpy.zeros((T, 2**N)) for i in range(T): p[i,:] = transforms.compute_p(theta[i,:]) # Generate spikes! spikes = synthesis.generate_spikes(p, R, seed=1) # ----- ALGORITHM EXECUTION ----- # Global module import numpy # Local module import __init__ # From outside this folder, this would be 'import ssll' # Run the algorithm! emd = __init__.run(spikes, O, map_function='nr', lmbda1=200, lmbda2=200,) # ----- PLOTTING ----- # Global module import pylab # Set up an output figure fig, ax = pylab.subplots(2, 1, sharex=True) # Plot underlying theta traces ax[0].plot(theta[:,0], c='b', linestyle='--') ax[0].plot(theta[:,1], c='r', linestyle='--') ax[1].plot(theta[:,2], c='g', linestyle='--') # Plot estimated theta traces ax[0].plot(emd.theta_s[:,0], c='b')
def generate_data_ctime(data_path='../Data/', max_network_size=60, num_procs=4): N, O, R, T = 10, 2, 200, 500 num_of_networks = max_network_size/N mu = numpy.zeros(T) x = numpy.arange(1, 401) mu[100:] = 1. * (3. / (2. * numpy.pi * (x / 400. * 3.) ** 3)) ** .5 * \ numpy.exp(-3. * ((x / 400. * 3.) - 1.) ** 2 / (2. * (x / 400. * 3.))) D = transforms.compute_D(N, O) thetas = numpy.empty([num_of_networks, T, D]) transforms.initialise(N, O) for i in range(num_of_networks): thetas[i] = synthesis.generate_thetas(N, O, T, mu1=-2.) thetas[i, :, :N] += mu[:, numpy.newaxis] R = 500 f = h5py.File(data_path + 'comp_time_data.h5', 'w') f.create_dataset('N', data=numpy.arange(N, max_network_size+N, N)) f.create_dataset('ctime', shape=[2,num_of_networks]) f.close() for i in range(num_of_networks): print 'N=%d' % ((i + 1) * N) D = transforms.compute_D((i + 1) * N, O) theta_all = numpy.empty([T, D]) triu_idx = numpy.triu_indices(N, k=1) triu_idx_all = numpy.triu_indices((i + 1) * N, k=1) for j in range(i + 1): theta_all[:, N * j:(j + 1) * N] = thetas[j, :, :N] for t in range(T): theta_ij = numpy.zeros([(i + 1) * N, (i + 1) * N]) for j in range(i + 1): theta_ij[triu_idx[0] + j * N, triu_idx[1] + j * N] = \ thetas[j, t, N:] theta_all[t, (i + 1) * N:] = theta_ij[triu_idx_all] spikes = synthesis.generate_spikes_gibbs_parallel(theta_all, (i + 1) * N, O, R, sample_steps=10, num_proc=num_procs) t1 = time.time() result = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta='bethe_hybrid', lmbda1=100, lmbda2=200) t2 = time.time() ctime_bethe = t2 - t1 f = h5py.File(data_path + 'comp_time_data.h5', 'r+') f['ctime'][0, i] = ctime_bethe f.close() try: t1 = time.time() result = __init__.run(spikes, O, map_function='cg', param_est='pseudo', param_est_eta='mf', lmbda1=100, lmbda2=200) t2 = time.time() ctime_TAP = t2 - t1 except Exception: ctime_TAP = numpy.nan f = h5py.File(data_path + 'comp_time_data.h5', 'r+') f['ctime'][1, i] = ctime_TAP f.close()
import __init__ if __name__ == "__main__": __init__.welcome() __init__.init() __init__.run()