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)