def setUp1(self, nproc=1, multiproc=True): self.ndim = 3 self.harmonic = Harmonic(self.ndim) self.nreplicas = 10 self.stepsize = 0.1 self.nproc = nproc self.mc_runner = MonteCarloWalker(self.harmonic, mciter=40) if multiproc == False: hostname=socket.gethostname() host = Pyro4.socketutil.getIpAddress(hostname, workaround127=True) self.dispatcher_URI = "PYRO:"+"test@"+host+":9090" else: self.dispatcher_URI = None replicas = [] for i in xrange(self.nreplicas): x = self.harmonic.get_random_configuration() replicas.append(Replica(x, self.harmonic.get_energy(x))) self.ns = NestedSampling(replicas, self.mc_runner, stepsize=0.1, nproc=nproc, verbose=False, dispatcher_URI=self.dispatcher_URI) self.Emax0 = self.ns.replicas[-1].energy self.niter = 100 for i in xrange(self.niter): self.ns.one_iteration() self.Emax = self.ns.replicas[-1].energy self.Emin = self.ns.replicas[0].energy
def get_mc_walker(self, mciter): if _use_cython: return LJMonteCarloCompiled(self.radius, mciter=mciter) else: pot = self.get_potential() pot.get_energy = pot.getEnergy return MonteCarloWalker(pot, accept_test=self.get_config_tests()[0], mciter=mciter)
def prepare(self): self.ndim = 6 self.harmonic = Harmonic(self.ndim) self.x0 = np.zeros(self.ndim) self.energy = self.harmonic.get_energy(self.x0) self.mciter = 100 self.mcwalker = MonteCarloWalker(self.harmonic, mciter=self.mciter) self.stepsize = 0.1 self.Emax = 10. self.seed = None
def main(): parser = argparse.ArgumentParser( description="must pass the URI of the dispatcher") parser.add_argument("ndim", type=int, help="number of dimensions") parser.add_argument("dispatcher_URI", type=str, help="name for the worker") parser.add_argument("-n", "--mciter", type=int, default=1000, help="number of steps in the monte carlo walk") parser.add_argument("--radius", type=float, default=2.5, help="maintain atoms in a sphere of this radius") parser.add_argument("--worker-name", type=str, help="name for the worker", default=None) parser.add_argument( "--host", type=str, help="address of the host (node on which the worker is started)", default=None) parser.add_argument("--port", type=int, help="port number on which the worker is started)", default=0) parser.add_argument("--server-type", type=str, help="multiplex or threaded", default="multiplex") args = parser.parse_args() #=========================================================================== # MUST SET THE SYSTEM THEN GET THE RUNNER TO PASS #=========================================================================== system = Harmonic(args.ndim) mc_runner = MonteCarloWalker(system, mciter=args.mciter) dispatcher_URI = args.dispatcher_URI worker_name = args.worker_name host = args.host port = args.port server_type = args.server_type worker = pyro_worker(dispatcher_URI, mc_runner, worker_name=worker_name, host=host, port=port, server_type=server_type) worker._start_worker()
def do_nested_sampling(nreplicas=10, niter=200, mciter=1000, stepsize=.8, estop=-.9, x0=[1,1], r0=2, xlim=None, ylim=None, circle=False ): path = [] def mc_record_position_event(coords=None, **kwargs): if len(path) == 0 or not np.all(path[-1] == coords): path.append(coords) p = Pot() print p.get_energy(np.array([1,2.])) mc_walker = MonteCarloWalker(p, mciter=mciter, events=[mc_record_position_event]) # initialize the replicas with random positions replicas = [] for i in xrange(nreplicas): # choose points uniformly in a circle if circle: coords = vector_random_uniform_hypersphere(2) * r0 + x0 else: coords = np.zeros(2) coords[0] = np.random.uniform(xlim[0], xlim[1]) coords[1] = np.random.uniform(ylim[0], ylim[1]) # coords = np.random.uniform(-1,3,size=2) r = Replica(coords, p.get_energy(coords)) replicas.append(r) ns = NestedSampling(replicas, mc_walker, stepsize=stepsize) results = [Result()] results[0].replicas = [r.copy() for r in replicas] for i in xrange(niter): ns.one_iteration() new_res = Result() new_res.replicas = [r.copy() for r in replicas] new_res.starting_replica = ns.starting_replicas[0].copy() new_res.new_replica = ns.new_replicas[0].copy() path.insert(0, new_res.starting_replica.x) new_res.mc_path = path results.append(new_res) path = [] if ns.replicas[-1].energy < estop: break # plt.plot(ns.max_energies) # plt.show() return ns, results
def __init__(self, nsPotential, scale=1, takeStep=random_displace, acceptTest=None, nreplicas=10, mciter=10, nproc=1, verbose=False): self.mciter, self.nreplicas = mciter, nreplicas self.nproc, self.verbose = nproc, verbose self.pot = nsPotential mcrunner = MonteCarloWalker(self.pot, takestep=takeStep, accept_test=acceptTest, mciter=self.mciter) replicas = self.initialise_replicas() self.ns = nested_sampling.NestedSampling(replicas, mcrunner, nproc=self.nproc, verbose=self.verbose)
def setUp1(self, nproc=1): self.ndim = 3 self.harmonic = Harmonic(self.ndim) self.nreplicas = 10 self.stepsize = 0.1 self.nproc = nproc self.mc_runner = MonteCarloWalker(self.harmonic, mciter=40) replicas = [] for i in range(self.nreplicas): x = self.harmonic.get_random_configuration() replicas.append(Replica(x, self.harmonic.get_energy(x))) self.ns = NestedSampling(replicas, self.mc_runner, stepsize=0.1, nproc=nproc, verbose=False) self.etol = 0.01 run_nested_sampling(self.ns, label="test", etol=self.etol) self.Emax = self.ns.replicas[-1].energy self.Emin = self.ns.replicas[0].energy
def main(): parser = argparse.ArgumentParser(description="do nested sampling on a p[article in a n-dimensional Harmonic well") parser.add_argument("-K", "--nreplicas", type=float, help="number of replicas", default=1e1) parser.add_argument("-A", "--ndof", type=int, help="number of degrees of freedom", default=3) parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1) parser.add_argument("-N", "--nsteps", type=int, help="number of MC steps per NS iteration", default=int(1e3)) parser.add_argument("--stepsize", type=float, help="stepsize, adapted between NS iterations", default=20) parser.add_argument("--etol", type=float, help="energy tolerance: the calculation terminates when the energy difference \ between Emax and Emin is less than etol", default=0.1) parser.add_argument("-q", action="store_true", help="turn off verbose printing of information at every step") args = parser.parse_args() ndof = args.ndof nproc = args.nproc nsteps = int(args.nsteps)-8 nreplicas = int(args.nreplicas) stepsize = args.stepsize etol = args.etol #construct potential (cost function) potential = Harmonic(ndof) #construct Monte Carlo walker mc_runner = MonteCarloWalker(potential, mciter=nsteps) #initialise replicas (initial uniformly samples set of configurations) replicas = [] for _ in range(nreplicas): x = potential.get_random_configuration() print(x) print(potential.get_energy(x)) replicas.append(Replica(x, potential.get_energy(x))) #construct Nested Sampling object ns = NestedSampling(replicas, mc_runner, stepsize=stepsize, nproc=nproc, max_stepsize=10, verbose=not args.q) #run Nested Sampling (NS), output: ## label.energies (one for each iteration) ## label.replicas_final (live replica energies when NS terminates) run_nested_sampling(ns, label="run_hparticle", etol=etol)
def main(): parser = argparse.ArgumentParser( description= "do nested sampling on a p[article in a n-dimensional Harmonic well") parser.add_argument("-K", "--nreplicas", type=int, help="number of replicas", default=300) parser.add_argument("-A", "--ndof", type=int, help="number of degrees of freedom", default=4) parser.add_argument("-P", "--nproc", type=int, help="number of processors", default=1) parser.add_argument("-N", "--nsteps", type=int, help="number of MC steps per NS iteration", default=100) parser.add_argument("--stepsize", type=float, help="stepsize, adapted between NS iterations", default=0.1) parser.add_argument( "--etol", type=float, help= "energy tolerance: the calculation terminates when the energy difference \ between Emax and Emin is less than etol", default=0.01) parser.add_argument( "-q", action="store_true", help="turn off verbose printing of information at every step") parser.add_argument( "--dispatcherURI", action="store_true", help="use URI of the dispatcher server in default location", default=False) parser.add_argument( "--dispatcherURI-file", type=str, help="use URI of the dispatcher server if different from default", default=None) #set basic parameters args = parser.parse_args() ndof = args.ndof nproc = args.nproc nsteps = args.nsteps nreplicas = args.nreplicas stepsize = args.stepsize etol = args.etol #try to read dispatecher URI from default file location if args.dispatcherURI is True: with open("dispatcher_uri.dat", "r") as rfile: dispatcherURI = rfile.read().replace('\n', '') elif args.dispatcherURI_file != None: with open(args.dispatcherURI_file, "r") as rfile: dispatcherURI = rfile.read().replace('\n', '') else: dispatcherURI = None #construct potential (cost function) potential = Harmonic(ndof) #construct Monte Carlo walker mc_runner = MonteCarloWalker(potential, mciter=nsteps) #initialise replicas (initial uniformly samples set of configurations) replicas = [] for _ in xrange(nreplicas): x = potential.get_random_configuration() replicas.append(Replica(x, potential.get_energy(x))) #construct Nested Sampling object and pass dispatcher address ns = NestedSampling(replicas, mc_runner, stepsize=stepsize, nproc=nproc, dispatcher_URI=dispatcherURI, max_stepsize=10, verbose=not args.q) #run Nested Sampling (NS), output: ## label.energies (one for each iteration) ## label.replicas_final (live replica energies when NS terminates) run_nested_sampling(ns, label="run_hparticle", etol=etol)