def test_pdf_norm_methods_integration(): """Test integration of pdf normalization methods in ABCSMC.""" def model(par): return {'s0': par['p0'] + np.array([0.3, 0.7])} x_0 = {'s0': np.array([0.4, -0.6])} for pdf_norm in [ pyabc.pdf_norm_max_found, pyabc.pdf_norm_from_kernel, pyabc.ScaledPDFNorm(), ]: # just run acceptor = pyabc.StochasticAcceptor(pdf_norm_method=pdf_norm) eps = pyabc.Temperature() distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=20) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3)
def test_stochastic_acceptor(): acceptor = pyabc.StochasticAcceptor( pdf_norm_method=pyabc.pdf_norm_max_found) eps = pyabc.Temperature(initial_temperature=1) distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) def model(par): return {'s0': par['p0'] + np.array([0.3, 0.7])} x_0 = {'s0': np.array([0.4, -0.6])} # just run prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=1, minimum_epsilon=1.) # use no initial temperature and adaptive c acceptor = pyabc.StochasticAcceptor() eps = pyabc.Temperature() abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3, minimum_epsilon=1.)
def test_default_eps(): def model(par): return {'s0': par['p0'] + np.random.random(), 's1': np.random.random()} x_0 = {'s0': 0.4, 's1': 0.6} prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) # usual setting abc = pyabc.ABCSMC(model, prior, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3) assert abc.minimum_epsilon == 0.0 # noisy setting acceptor = pyabc.StochasticAcceptor() eps = pyabc.Temperature() distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3) assert abc.minimum_epsilon == 1.0
def test_stochastic_acceptor(): """Test the stochastic acceptor's features.""" # store pnorms pnorm_file = tempfile.mkstemp(suffix=".json")[1] acceptor = pyabc.StochasticAcceptor( pdf_norm_method=pyabc.pdf_norm_max_found, log_file=pnorm_file) eps = pyabc.Temperature(initial_temperature=1) distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) def model(par): return {'s0': par['p0'] + np.array([0.3, 0.7])} x_0 = {'s0': np.array([0.4, -0.6])} # just run prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) h = abc.run(max_nr_populations=1, minimum_epsilon=1.) # check pnorms pnorms = pyabc.storage.load_dict_from_json(pnorm_file) assert len(pnorms) == h.max_t + 2 # +1 t0, +1 one final update assert isinstance(list(pnorms.keys())[0], int) assert isinstance(pnorms[0], float) # use no initial temperature and adaptive c acceptor = pyabc.StochasticAcceptor() eps = pyabc.Temperature() abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=20) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3)
def __call__( self, prev_pdf_norm, get_weighted_distances, prev_temp, acceptance_rate, **kwargs): pdf_norm = pyabc.pdf_norm_max_found(prev_pdf_norm=prev_pdf_norm, get_weighted_distances=get_weighted_distances) print(" best: ", pdf_norm) if prev_temp is None or (acceptance_rate >= 0.1 and not self.hit): return pdf_norm self.hit = True temp = 0.6 * prev_temp offset = temp * np.log(10) used_norm = pdf_norm - offset used_norm = max(prev_pdf_norm, used_norm) print(" offsetted: ", pdf_norm - offset) return used_norm prior = pyabc.Distribution(**{key: pyabc.RV("uniform", a, b-a) for key, (a,b) in limits.items()}) acceptor = pyabc.StochasticAcceptor(log_file="acc_log_v5_higherc.json", pdf_norm_method=PDFNorm()) temperature = pyabc.Temperature(schemes=[pyabc.AcceptanceRateScheme(), pyabc.ExpDecayFixedRatioScheme(alpha=0.6)]) kernel = pyabc.IndependentNormalKernel(keys=keys, var=noise_vector**2) sampler = pyabc.sampler.RedisEvalParallelSampler(host="icb-mona", port=8776) #sampler = pyabc.sampler.MulticoreEvalParallelSampler(daemon=False) abc = pyabc.ABCSMC(model, prior, kernel, sampler=sampler, acceptor=acceptor, eps=temperature, population_size=500) db_path="sqlite:///tumor2d_stoch_acc_v5_higherc.db" abc.new(db_path, noisy_data) abc.run()
# distanceP2_adpt = pyabc.AdaptivePNormDistance(p=2, # scale_function=pyabc.distance.root_mean_square_deviation, # factors=factors # ) # distanceP2 = pyabc.PNormDistance(p=2) sigma_n = 5.66 sigma_m = 4.59 sigma_b = 5.15 sigma_a = 2.42 mu = 0. a = 0.05 var_list = [(a * sigma_n) ** 2]*30 + [(a * sigma_m) ** 2]*30 + [(a * sigma_b) ** 2]*30 + [(a * sigma_a) ** 2]*30 distance_s = pyabc.IndependentNormalKernel(var=var_list) # Measure distance and set it as minimum epsilon # min_eps = distanceP2(obs_data_noisy, obs_data_raw) acceptor_s = pyabc.StochasticAcceptor() # acceptor_adpt = pyabc.UniformAcceptor(use_complete_history=True) # eps0 = pyabc.MedianEpsilon(50) eps_s = pyabc.epsilon.Temperature() # eps_fixed = pyabc.epsilon.ListEpsilon([50, 46, 43, 40, 37, 34, 31, 29, 27, 25, # 23, 21, 19, 17, 15, 14, 13, 12, 11, 10]) # transition0 = pyabc.transition.LocalTransition(k=50, k_fraction=None) # transition1 = pyabc.transition.GridSearchCV()
vNM=pyabc.RV("uniform", lim2.lb, lim2.interval_length), lambdaM=pyabc.RV("uniform", lim3.lb, lim3.interval_length), kMB=pyabc.RV("uniform", lim2.lb, lim2.interval_length), muM=pyabc.RV("uniform", lim2.lb, lim2.interval_length), sBN=pyabc.RV("uniform", lim3.lb, lim3.interval_length), iBM=pyabc.RV("uniform", lim3.lb, lim3.interval_length), muB=pyabc.RV("uniform", lim3.lb, lim3.interval_length), sAM=pyabc.RV("uniform", lim.lb, lim.interval_length), muA=pyabc.RV("uniform", lim.lb, lim.interval_length)) # %% Define ABC-SMC model distanceP2_adaptive = pyabc.AdaptivePNormDistance( p=2, scale_function=pyabc.distance.root_mean_square_deviation) distanceP2 = pyabc.PNormDistance(p=2) kernel1 = pyabc.IndependentNormalKernel(var=1.0**2) # Measure distance and set it as minimum epsilon min_eps = distanceP2(obs_data_noisy, obs_data_raw) acceptor1 = pyabc.StochasticAcceptor() eps0 = pyabc.MedianEpsilon(50) eps1 = pyabc.Temperature() sampler0 = pyabc.sampler.MulticoreEvalParallelSampler(n_procs=8) def non_noisy_model(para): return solver.ode_model(para, add_noise=False)
def fit_cmd(self, observed_cmd, pop_size=1000, max_n_pop=np.Inf, savename='starwave', min_acceptance_rate=0.0001, gamma=0.5, cores=1, accept='uniform', alpha=0.5, population_strategy='constant', statistic='output'): if cores == 1: pyabc_sampler = pyabc.sampler.SingleCoreSampler() elif cores > 1: pyabc_sampler = pyabc.sampler.MulticoreEvalParallelSampler( n_procs=cores) else: print('invalid number of cores. defaulting to 1 core.') pyabc_sampler = pyabc.sampler.SingleCoreSampler() if population_strategy == 'constant': population_strategy = pyabc.populationstrategy.ConstantPopulationSize( pop_size) elif population_strategy == 'adapt': population_strategy = pyabc.populationstrategy.AdaptivePopulationSize( pop_size) scaled_observed_cmd = self.init_scaler(observed_cmd, gamma=gamma) obs = dict(output=self.kernel_representation(scaled_observed_cmd, self.mapping)) dummy_cmd = np.zeros(observed_cmd.shape) def simcmd(imf_type): return lambda params: self.cmd_sim(params, imf_type=imf_type) simulator = [] prior = [] for idx, imf in enumerate(self.imf_type): simulator.append(simcmd(imf)) prior.append(self.params[idx].to_pyabc()) if accept == 'uniform': acceptor = pyabc.acceptor.UniformAcceptor() eps = pyabc.epsilon.QuantileEpsilon(alpha=alpha) def distance(cmd1, cmd2): return np.sqrt(np.sum((cmd1[statistic] - cmd2[statistic])**2)) elif accept == 'stochastic': acceptor = pyabc.StochasticAcceptor() eps = pyabc.Temperature() base_params = make_params(self.imf_type[0]).get_values() sim_rep = np.asarray([ self.cmd_sim(base_params, imf_type=self.imf_type[0])['output'] for ii in range(25) ]) var = np.var(sim_rep, 0) distance = pyabc.IndependentNormalKernel(var=var, keys=['input']) abc = pyabc.ABCSMC(simulator, prior, distance, sampler=pyabc_sampler, population_size=pop_size, eps=eps, acceptor=acceptor) db_path = ("sqlite:///" + savename + ".db") abc.new(db_path, obs) self.history = abc.run(min_acceptance_rate=min_acceptance_rate, max_nr_populations=max_n_pop) return self.history
limits["K_M1"] = (-4, -2) prior = pyabc.Distribution(**{ key: pyabc.RV("uniform", lb, ub - lb) for key, (lb, ub) in limits.items() }) redis_sampler = RedisEvalParallelSampler(host=args.ip, port=args.port, look_ahead=False, wait_for_all_samples=True) acceptor = pyabc.StochasticAcceptor(pdf_norm_method=ScaledPDFNorm()) kernel = pyabc.IndependentNormalKernel( var=[0.061763933333333] * 60 + [0.050105066666667] * 60, keys=[ "IdSumstat__YAP_nuclear_observable", "IdSumstat__YAP_total_observable" ]) eps = pyabc.Temperature() abc = pyabc.ABCSMC(model, prior, kernel, population_size=1000, acceptor=acceptor, eps=eps, all_accepted=False, sampler=redis_sampler) db_path = "sqlite:///" + "/home/emad/Documents/test_liver_model_delete/" + "test_14param_Felipe.db" history = abc.new(db_path, dict_data)
# def distance(simulation, data): # return np.absolute(data["X_2"] - simulation["X_2"]).sum() parameter_prior = Distribution(r=RV("uniform", 0.1, 4.0), C=RV("uniform", 1.0, 10.0), d=RV("uniform", 1.0, 4.0), g=RV("uniform", 0.01, 0.1), l=RV("uniform", 1E-5, 2.0)) parameter_prior.get_parameter_names() #Noisey model sigma = 0.02 acceptor = pyabc.StochasticAcceptor() kernel = pyabc.IndependentNormalKernel(var=sigma**2) eps = pyabc.Temperature() abc = pyabc.ABCSMC(deterministic_run, parameter_prior, kernel, eps=eps, acceptor=acceptor, population_size=100) abc.new( db_path, {"Contamination": measurement_data} ) #This distance model assumes the name of the predicited and confirmed are the same history_acceptor = abc.run(max_nr_populations=10, minimum_epsilon=5) #No Noise # abc = ABCSMC(models=deterministic_run_NONOISE,