def pso(self,
n_particles,
n_iterations,
lowerLimit,
upperLimit,
X2_chain,
threadCount=1,
print_positions=False):
"""
returns the best fit for the lense model on catalogue basis with particle swarm optimizer
"""
pso = ParticleSwarmOptimizer(X2_chain,
lowerLimit,
upperLimit,
n_particles,
threads=threadCount)
X2_list = []
vel_list = []
pos_list = []
for swarm in pso.sample(n_iterations):
X2_list.append(pso.gbest.fitness * 2)
vel_list.append(pso.gbest.velocity)
pos_list.append(pso.gbest.position)
print(pso.gbest.fitness / np.sum(X2_chain.mask),
'reduced X^2 of best position')
if print_positions == True:
print(pso.gbest.position)
result = tuple(pso.gbest.position)
return result, [X2_list, pos_list, vel_list]
def pso(self, n_particles, n_iterations, lower_start=None, upper_start=None, threadCount=1, init_pos=None,
mpi=False, print_key='PSO'):
"""
returns the best fit for the lense model on catalogue basis with particle swarm optimizer
"""
if lower_start is None or upper_start is None:
lower_start, upper_start = np.array(self.lower_limit), np.array(self.upper_limit)
print("PSO initialises its particles with default values")
else:
lower_start = np.maximum(lower_start, self.lower_limit)
upper_start = np.minimum(upper_start, self.upper_limit)
if mpi is True:
pso = MpiParticleSwarmOptimizer(self.chain, lower_start, upper_start, n_particles, threads=1)
if pso.isMaster():
print('MPI option chosen')
else:
pso = ParticleSwarmOptimizer(self.chain, lower_start, upper_start, n_particles, threads=threadCount)
if init_pos is None:
init_pos = (upper_start - lower_start) / 2 + lower_start
if not init_pos is None:
pso.gbest.position = init_pos
pso.gbest.velocity = [0]*len(init_pos)
pso.gbest.fitness, _ = self.chain.likelihood(init_pos)
X2_list = []
vel_list = []
pos_list = []
time_start = time.time()
if pso.isMaster():
print('Computing the %s ...' % print_key)
num_iter = 0
for swarm in pso.sample(n_iterations):
X2_list.append(pso.gbest.fitness*2)
vel_list.append(pso.gbest.velocity)
pos_list.append(pso.gbest.position)
num_iter += 1
if pso.isMaster():
if num_iter % 10 == 0:
print(num_iter)
if not mpi:
result = pso.gbest.position
else:
result = MpiUtil.mpiBCast(pso.gbest.position)
#if (pso.isMaster() and mpi is True) or self.chain.sampling_option == 'X2_catalogue':
if mpi is True and not pso.isMaster():
pass
else:
lens_dict, source_dict, lens_light_dict, ps_dict, kwargs_cosmo = self.chain.param.args2kwargs(result)
print(pso.gbest.fitness * 2 / (self.chain.effectiv_numData_points()), 'reduced X^2 of best position')
print(pso.gbest.fitness, 'logL')
print(self.chain.effectiv_numData_points(), 'effective number of data points')
print(lens_dict, 'lens result')
print(source_dict, 'source result')
print(lens_light_dict, 'lens light result')
print(ps_dict, 'point source result')
print(kwargs_cosmo, 'cosmo result')
time_end = time.time()
print(time_end - time_start, 'time used for PSO', print_key)
print('===================')
return result, [X2_list, pos_list, vel_list, []]
def pso(self,
n_particles=10,
n_iterations=10,
lowerLimit=-0.2,
upperLimit=0.2,
threadCount=1,
mpi=False,
print_key='default'):
"""
returns the best fit for the lense model on catalogue basis with particle swarm optimizer
"""
init_pos = self.chain.get_args(self.chain.kwargs_data_init)
num_param = self.chain.num_param
lowerLimit = [lowerLimit] * num_param
upperLimit = [upperLimit] * num_param
if mpi is True:
pso = MpiParticleSwarmOptimizer(self.chain,
lowerLimit,
upperLimit,
n_particles,
threads=1)
else:
pso = ParticleSwarmOptimizer(self.chain,
lowerLimit,
upperLimit,
n_particles,
threads=threadCount)
if not init_pos is None:
pso.gbest.position = init_pos
pso.gbest.velocity = [0] * len(init_pos)
pso.gbest.fitness, _ = self.chain.likelihood(init_pos)
X2_list = []
vel_list = []
pos_list = []
time_start = time.time()
if pso.isMaster():
print('Computing the %s ...' % print_key)
num_iter = 0
for swarm in pso.sample(n_iterations):
X2_list.append(pso.gbest.fitness * 2)
vel_list.append(pso.gbest.velocity)
pos_list.append(pso.gbest.position)
num_iter += 1
if pso.isMaster():
if num_iter % 10 == 0:
print(num_iter)
if not mpi:
result = pso.gbest.position
else:
result = MpiUtil.mpiBCast(pso.gbest.position)
kwargs_data = self.chain.update_data(result)
if mpi is True and not pso.isMaster():
pass
else:
time_end = time.time()
print("Shifts found: ", result)
print(time_end - time_start, 'time used for PSO', print_key)
return kwargs_data, [X2_list, pos_list, vel_list, []]
def optimise(self):
self.time_start = time.time()
if self.tweakml_type == "PS_from_residuals":
self.A_correction, _, _, _, _ = self.compute_set_A_correction(
self.theta_init)
if self.mpi is True:
pso = MpiParticleSwarmOptimizer(self, self.lower_limit,
self.upper_limit, self.n_particles)
else:
pso = ParticleSwarmOptimizer(self,
self.lower_limit,
self.upper_limit,
self.n_particles,
threads=self.max_thread)
X2_list = []
vel_list = []
pos_list = []
num_iter = 0
f = open(self.savefile, "wb")
for swarm in pso.sample(self.n_iter):
print "iteration : ", num_iter
X2_list_c = np.asarray(pso.gbest.fitness) * -2.0
X2_list.append(X2_list_c)
vel_list_c = np.asarray(pso.gbest.velocity)
vel_list.append(vel_list_c.tolist())
pos_list_c = np.asarray(pso.gbest.position)
pos_list.append(pos_list_c.tolist())
print X2_list_c, vel_list_c, pos_list_c
data = np.concatenate(([X2_list_c], vel_list_c, pos_list_c))
data = [str(d) for d in data.tolist()]
f.write(" ".join(data))
f.write("\n")
# np.savetxt(f, data.transpose(), delimiter=',', newline='\n')
num_iter += 1
f.close()
self.chain_list = [X2_list, pos_list, vel_list]
self.chi2_mini, self.best_param = self.get_best_param()
self.time_stop = time.time()
return self.chain_list