def run_example(): pso = PSO(save_sampled=False, verbose=True, num_proc=4) pso.set_cost_function(likelihood) pso.set_start_position(xnominal) pso.set_bounds(2) pso.set_speed(-.25, .25) pso.run(25, 100) display(pso.best)
def run_example(): pso = PSO(save_sampled=False, verbose=True, num_proc=4) pso.set_cost_function(likelihood) pso.set_start_position(xnominal) pso.set_bounds(lower=lower, upper=upper) pso.set_speed(-.25, .25) pso.run(25, 200) display(pso.best) np.save('calibrated_pars_pso1', pso.best)
def run_pso(lum, drug_conc, time, weights): # create global versions of lum, drug_conc, and time variables that can be used in cost function global _lum, _drug_conc, _time, _weights _lum = np.array(lum) _drug_conc = np.array(drug_conc) _time = np.array(time) _weights = np.array(weights) ########## # _dc, idx = np.unique(_drug_conc, return_index=True) # _lum_avg = np.array([np.mean(_lum[idx[i]:idx[i+1]], axis=0) for i in range(len(idx)-1)] + # [np.mean(_lum[idx[-1]:], axis=0)]) # colors = cmap(np.linspace(0, 1, len(_dc))) # plt.figure() # u_idx = 0 # for i in range(len(_lum)): # if i <= idx[-1] and i == idx[u_idx+1]: # u_idx += 1 # plt.plot(_time[i], _lum[i], 'o', color=colors[u_idx]) # plt.plot(_time[idx[u_idx]], _lum_avg[u_idx], '--', lw=2, color=colors[u_idx]) # plt.show() ########## # estimate slope m and y-intercept nC0 from control luminescence data global _m, _nC0 _m = 0 _nC0 = 0 # find indices of control experiments indices = np.where(_drug_conc == 0)[0] for idx in indices: fit = linregress(_time[idx], _lum[idx]) _m += fit.slope _nC0 += fit.intercept _m /= len(indices) _nC0 /= len(indices) # run PSO to estimate the other three parameters: kdiv-kdeath, kdiv*-kdeath*, koff/kon pso = PSO(save_sampled=True, verbose=True, shrink_steps=False) pso.set_start_position([2, 2, 2]) # allows particles to move +/- 2 orders of magnitude pso.set_bounds(2) # sets maximum speed that a particle can travel pso.set_speed(-0.1, 0.1) pso.run( num_particles=100, num_iterations=1000, stop_threshold=0, num_processors=1, max_iter_no_improv=1000, cost_function=cost ) return np.array([_m, _nC0] + list(pso.best.pos)) # [m, nC0, kdiv-kdeath, kdiv*-kdeath*, koff/kon]
def test_population_creation(): known_sol = [8.6998, 6.7665] pso = PSO(start=[0, 0], verbose=False, shrink_steps=False) pso.set_bounds(lower=[-100, -100], upper=[100, 100]) pso.set_speed(-10, 10) pso.run(num_iterations=100, num_particles=10, cost_function=h1, ) pso.return_ranked_populations() error = np.sum((pso.best.pos - known_sol) ** 2) print('True value: [8.6998, 6.7665]. Found:{0}. Error^2 = {1}'.format( pso.best.pos, error)) assert (error < 0.1)
def run_pso(run, iterations, bd): pso = PSO(save_sampled=False, verbose=True, shrink_steps=False) #pso.set_cost_function(costfunction) pso.set_start_position(starting_position) pso.set_bounds(bd) pso.set_speed(-.1, .1) pso.run(num_particles=20, num_iterations=iterations, stop_threshold=1e-5, cost_function=costfunction, max_iter_no_improv=50, num_processors=20, save_samples=True) param_sets = convert_to_flat_array(pso, model) #print(param_sets) param_sets.to_csv('run'+run+'.csv')
def __call__(self, pso_kwargs=None, cost_type='norm_logpdf', custom_cost=None): """Call the SwarmIt instance to construct to instance of the NestedSampling object. Args: pso_kwargs (dict): Dictionary of any additional optional keyword arguments to pass to the PSO object constructor. Defaults to dict(). cost_type (str): Define the type of cost estimator to use. Options are 'norm_logpdf'=>Compute the cost using the normal distribution estimator, 'mse'=>Compute the cost using the negative mean squared error estimator, 'sse'=>Compute the cost using the negative sum of squared errors estimator. Defaults to 'norm_logpdf'. Returns: type: Description of returned object. """ if pso_kwargs is None: pso_kwargs = dict() # self.ns_version = ns_version self._pso_kwargs = pso_kwargs #population_size = pso_population_size if cost_type == 'mse': cost = self.mse_cost elif cost_type == 'sse': cost = self.sse_cost elif (cost_type == 'custom') and (custom_cost is not None): self.set_custom_cost(custom_cost) cost = self.custom_cost else: cost = self.norm_logpdf_cost # Construct the PSO if 'save_sampled' not in pso_kwargs.keys(): pso_kwargs['save_sampled'] = False if 'verbose' not in pso_kwargs.keys(): pso_kwargs['verbose'] = False pso = PSO(**pso_kwargs) pso.set_start_position(self._starting_position) pso.set_cost_function(cost) pso.set_bounds(lower=self._lower, upper=self._upper) pso.set_speed(-.25, .25) return pso
def run_example(): # Runs the cost function to calculate error between model and data print("Error at start = {}".format(likelihood(starting_position)[0])) # Displays the model with defaul positions display(starting_position, save_name='starting_position') # create PSO object pso = PSO(save_sampled=False, verbose=True, num_proc=4) pso.set_cost_function(likelihood) pso.set_start_position(starting_position) # allows particles to move +/- 2 orders of magnitude pso.set_bounds(2) # sets maximum speed that a particle can travel pso.set_speed(-.25, .25) pso.run(num_particles=25, num_iterations=50, stop_threshold=1e-5) display(pso.best, save_name='best_fit') np.savetxt("pso_fit_for_model.csv", pso.best)
def run_example(): # Runs the cost function to calculate error between model and data print("Error at start = {}".format(likelihood(starting_position)[0])) # Displays the model with defaul positions display(starting_position, save_name='starting_position') # create PSO object pso = PSO(save_sampled=False, verbose=True, num_proc=4) pso.set_cost_function(likelihood) pso.set_start_position(starting_position) # allows particles to move +/- 2 orders of magnitude pso.set_bounds(2) # sets maximum speed that a particle can travel pso.set_speed(-.25, .25) pso.run(num_particles=25, num_iterations=50, stop_threshold=1e-5) display(pso.best, save_name='best_fit') np.savetxt("pso_fit_for_model.csv", pso.best)
def run_pso(run, iterations, bd): pso = PSO(save_sampled=False, verbose=True, shrink_steps=False, num_proc=14) pso.set_cost_function(costfunction) pso.set_start_position(starting_position) pso.set_bounds(bd) pso.set_speed(-.1, .1) pso.run(num_particles=200, num_iterations=iterations, stop_threshold=1e-5) #print('best pos: ', pso.best.pos) print('history ', pso.history) print('run ', run) print('fit ', pso.best.fitness) print('all fitness ', pso.values) np.savetxt("H841_params_" + run + ".txt", 10**pso.history, delimiter=",") np.savetxt("H841_fit_" + run + ".txt", pso.values, delimiter=",")
def run_example(): # create PSO object pso = PSO(save_sampled=False, verbose=True, shrink_steps=False) pso.set_start_position(starting_position) # allows particles to move +/- 2 orders of magnitude pso.set_bounds(2) # sets maximum speed that a particle can travel pso.set_speed(-.1, .1) pso.run(num_particles=24, num_iterations=100, stop_threshold=1e-5, num_processors=18, max_iter_no_improv=20, cost_function=likelihood) display(pso.best.pos, save_name='best_fit') np.savetxt("pso_fit_for_model.csv", pso.best.pos) create_gif_of_model_training(pso)
def run_example_multiple(): best_pars = np.zeros((100, len(model.parameters))) counter = 0 for i in range(100): pso = PSO(save_sampled=False, verbose=False, num_proc=4) pso.set_cost_function(likelihood) nominal_random = xnominal + np.random.uniform(-1, 1, len(xnominal)) pso.set_start_position(nominal_random) pso.set_bounds(2.5) pso.set_speed(-.25, .25) pso.run(25, 100) if pso.best.fitness.values[0] < 0.066: Y = np.copy(pso.best) param_values[rates_of_interest_mask] = 10**Y best_pars[counter] = param_values counter += 1 print(i, counter) # display(pso.best) np.save('jnk3_noASK1_ncalibrated_pars_1h', best_pars)
def run_pso(run, iterations, bd, outdir='', suffix=''): pso = PSO(save_sampled=True, verbose=True, shrink_steps=False) #pso.set_cost_function(costfunction) pso.set_start_position(starting_params) pso.set_bounds(bd) pso.set_speed(-0.1, 0.1) pso.run(num_particles=20, num_iterations=iterations, stop_threshold=1e-5, cost_function=costfunction, max_iter_no_improv=500, num_processors=20, save_samples=True) param_sets = convert_to_flat_array(pso, model) #print(param_sets) outfile = os.path.join(outdir, 'run%d%s.csv' % (run, suffix)) param_sets.to_csv(outfile, index_label='iter')
def run_example(): # Here we initial the class # We must proivde the cost function and a starting value optimizer = PSO(cost_function=obj_function, start=start_position, verbose=True) # We also must set bounds. This can be a single scalar or an array of len(start_position) optimizer.set_bounds(parameter_range=3) optimizer.set_speed(speed_min=-.5, speed_max=.5) optimizer.run(num_particles=25, num_iterations=100) if plot: display(start_position, optimizer.best) print("Original values {0}".format(log10_original_values ** 10)) print("Starting values {0}".format(start_position ** 10)) print("Best PSO values {0}".format(optimizer.best ** 10)) fig = plt.figure() fig.add_subplot(221) plt.scatter(log10_original_values[0], log10_original_values[1], marker='>', color='b', label='ideal') plt.scatter(start_position[0], start_position[1], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 0], optimizer.history[:, 1], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(223) plt.scatter(log10_original_values[0], log10_original_values[2], marker='>', color='b', label='ideal') plt.scatter(start_position[0], start_position[2], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 0], optimizer.history[:, 2], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(222) plt.scatter(log10_original_values[1], log10_original_values[2], marker='>', color='b', label='ideal') plt.scatter(start_position[1], start_position[2], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 1], optimizer.history[:, 2], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(224) plt.legend(loc=0) plt.colorbar() plt.tight_layout() plt.savefig('population.png')
def run_example(): # Here we initial the class # We must proivde the cost function and a starting value optimizer = PSO(cost_function=obj_function, start=start_position, verbose=True) # We also must set bounds. This can be a single scalar or an array of len(start_position) optimizer.set_bounds(parameter_range=3) optimizer.set_speed(speed_min=-.5, speed_max=.5) optimizer.run(num_particles=25, num_iterations=100) if plot: display(start_position, optimizer.best) print("Original values {0}".format(log10_original_values**10)) print("Starting values {0}".format(start_position**10)) print("Best PSO values {0}".format(optimizer.best**10)) fig = plt.figure() fig.add_subplot(221) plt.scatter(log10_original_values[0], log10_original_values[1], marker='>', color='b', label='ideal') plt.scatter(start_position[0], start_position[1], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 0], optimizer.history[:, 1], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(223) plt.scatter(log10_original_values[0], log10_original_values[2], marker='>', color='b', label='ideal') plt.scatter(start_position[0], start_position[2], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 0], optimizer.history[:, 2], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(222) plt.scatter(log10_original_values[1], log10_original_values[2], marker='>', color='b', label='ideal') plt.scatter(start_position[1], start_position[2], marker='^', color='r', label='start') plt.scatter(optimizer.history[:, 1], optimizer.history[:, 2], c=optimizer.values, cmap=plt.cm.coolwarm) fig.add_subplot(224) plt.legend(loc=0) plt.colorbar() plt.tight_layout() plt.savefig('population.png')
# USER-Set: must appropriately update cost function! def cost(position): Y = np.copy(position) param_values[calibrate_mask] = 10**Y sim = solver.run(param_values=param_values).all logp_data = np.sum(like_data.logpdf(sim['observable'])) if np.isnan(logp_data): logp_data = np.inf return -logp_data, # Setup the particle swarm optimization run # Set the number of particles in the swarm. num_particles = 25 # Set the number of iterations for PSO run. num_iterations = 50 # Construct the optimizer pso = PSO(save_sampled=False, verbose=True, num_procs=1) pso.set_cost_function(cost) starting_position = swarm_param.centers() pso.set_start_position(starting_position) pso.set_bounds(lower=swarm_param.lower(), upper=swarm_param.upper()) # sets maximum speed that a particle can travel pso.set_speed(-.25, .25) # run it pso.run(num_particles, num_iterations, stop_threshold=1e-5) print("Best parameters: ", pso.best)
def obj_function(params): params_tmp = np.copy(params) param_values[rate_mask] = 10 ** params_tmp # don't need to change result = solver1.run(param_values=param_values) ysim_array1 = result.observables['MLKLa_obs'][:] ysim_norm1 = normalize(ysim_array1) e1 = np.sum((ydata_norm - ysim_norm1) ** 2) return e1, def run_example(): print('run_example') best_pars = np.zeros((1000, len(model.parameters))) counter = 0 # Here we initial the class # We must proivde the cost function and a starting value for i in range(1000): optimizer = PSO(cost_function=obj_function,start = log10_original_values, verbose=True) # We also must set bounds. This can be a single scalar or an array of len(start_position) optimizer.set_bounds(parameter_range=2) optimizer.set_speed(speed_min=-.25, speed_max=.25) optimizer.run(num_particles=75, num_iterations=25) best_pars[i] = optimizer.best print(optimizer.best) # print(i, counter) np.save('optimizer_best_75_50_100TNF',best_pars) if '__main__' == __name__: run_example()
np.random.uniform(-1, 1, size=len(log_original_values)) display(start_position, "Before optimization") plt.tight_layout() plt.savefig("fit_before_pso.png", bbox_inches='tight') logger.info("Saving pre-fit figure as fit_before_pso.png") # Here we initial the class # We must proivde the cost function and a starting value optimizer = PSO(start=start_position, verbose=True, shrink_steps=False) # We also must set bounds of the parameter space, and the speed PSO will # travel (max speed in either direction) optimizer.set_bounds(parameter_range=4) optimizer.set_speed(speed_min=-.05, speed_max=.05) # Now we run the pso algorithm optimizer.run(num_particles=50, num_iterations=500, num_processors=12, cost_function=obj_function, max_iter_no_improv=25) best_params = optimizer.best.pos display(best_params, "After optimization") plt.tight_layout() plt.savefig("fit_after_pso.png", bbox_inches='tight') logger.info("Saving post-fit figure as fit_after_pso.png") plt.show()