def sample_hypers(self, start=None, samples=1000, chains=1, trace=None, method='Slice'): if start is None: start = self.get_params_current() if self.outputs.get_value() is None: print('For sample_hypers it is necessary to have observations') return start with self.model: if len(self.fixed_vars) > 0: step = [ConstantStep(vars=self.fixed_vars) ] # Fue eliminado por error en pymc3 if len(self.sampling_vars) > 0: if method == 'HMC': step += [pm.HamiltonianMC(vars=self.sampling_vars)] else: step += [ RobustSlice(vars=self.sampling_vars) ] # Slice original se cuelga si parte del óptimo else: if method == 'HMC': step = pm.HamiltonianMC() else: step = RobustSlice() trace = pm.sample(samples, step=step, start=start, njobs=chains, trace=trace) return trace
def test_run(self): model = self.build_model() with model: # move the chain to the MAP which should be a good starting point start = pm.find_MAP() H = model.fastd2logp() # find a good orientation using the hessian at the MAP h = H(start) step = pm.HamiltonianMC(model.vars, h) pm.sample(50, step=step, start=start)
def sample(self, prior='umvt', method='NUTS', res=25.0, retrain=False, train=True, **step_kwargs): model = self.get_model(prior) if retrain: self.train_model() variances = self.read_cov(method, prior) #step_scale = res*(np.pi/180) / (self.n_d)**(0.25) step_scale = res * np.pi / 180 / (1 / self.n_d)**0.25 if method == 'NUTS': with model: step = pm.NUTS(scaling=variances, is_cov=True, step_scale=step_scale, adapt_step_size=False, **step_kwargs) elif method == 'HMC': scaling = variances with model: step = pm.HamiltonianMC(step_scale=step_scale, adapt_step_size=False, **step_kwargs) elif method == 'MH': S = variances with model: step = pm.Metropolis() with model: trace = pm.sample(step=step, cores=1, **self.mckwargs) self.pickle(trace, prior, method, model, dict(**step_kwargs)) myfile = 'corner_{ns}_{method}_{prior}.png'.format( ns=self.mckwargs['draws'], method=method, prior=prior) results = 'results' if self.hpc else 'test-results' mypath = os.path.join(self.samp_obj.output_directory, results, self.samp_obj.label, method, prior, myfile) save_plot(trace, self.tmodes, self.T, mypath) if not self.hpc: plot_MC_torsion_result(trace, self.tmodes, self.T) #full_cov = self.priors_dict[prior]['full_cov'] def flat_t(var): x = trace[str(var)] return x.reshape((x.shape[0], np.prod(x.shape[1:], dtype=int))) return trace
def too_slow(self): model = self.build_model() with model: start = pm.Point({ "groupmean": self.obs_means.mean(), "groupsd_interval__": 0, "sd_interval__": 0, "means": np.array(self.obs_means), "u_m": np.array([0.72]), "floor_m": 0.0, }) start = pm.find_MAP(start, model.vars[:-1]) H = model.fastd2logp() h = np.diag(H(start)) step = pm.HamiltonianMC(model.vars, h) pm.sample(50, step=step, start=start)
def too_slow(self): model = self.build_model() with model: start = pm.Point({ 'groupmean': self.obs_means.mean(), 'groupsd_interval__': 0, 'sd_interval__': 0, 'means': np.array(self.obs_means), 'u_m': np.array([.72]), 'floor_m': 0., }) start = pm.find_MAP(start, model.vars[:-1]) H = model.fastd2logp() h = np.diag(H(start)) step = pm.HamiltonianMC(model.vars, h) pm.sample(50, step=step, start=start)
def create_pp_sampler(sampler, context, priors, pp_engine='pymc3'): s = None if pp_engine == 'pymc3': with context['model']: if sampler == 'nuts': s = pymc3.NUTS( vars=[priors[k] for k in sorted(priors.keys())], max_treedepth=10, early_max_treedepth=8, ) elif sampler == 'hmc': s = pymc3.HamiltonianMC( vars=[priors[k] for k in sorted(priors.keys())], path_length=2.0, adapt_step_size=True, gamma=0.05, k=0.75, t0=10, target_accept=0.8) elif sampler == 'mh': s = pymc3.Metropolis( vars=[priors[k] for k in sorted(priors.keys())], S=None, proposal_dist=None, scaling=1.0, tune=True, tune_interval=100, model=None, mode=None, ) else: raise ValueError('Unrecognized sampler: {}'.format(sampler)) else: raise ValueError('Unrecognized PP engine: {}'.format(pp_engine)) return s
def test_leapfrog_reversible(): n = 3 start, model, _ = models.non_normal(n) with model: h = pm.find_hessian(start, model=model) step = pm.HamiltonianMC(model.vars, h, model=model) bij = DictToArrayBijection(step.ordering, start) logp, dlogp = list(map(bij.mapf, step.fs)) H = Hamiltonian(logp, dlogp, step.potential) q0 = bij.map(start) p0 = np.ones(n)*.05 for e in [.01, .1, 1.2]: for L in [1, 2, 3, 4, 20]: q, p = q0, p0 q, p = leapfrog(H, q, p, L, e) q, p = leapfrog(H, q, -p, L, e) close_to(q, q0, 1e-8, str((L, e))) close_to(-p, p0, 1e-8, str((L, e)))
import scipy.stats as ss xdata = np.array([-27.020, 3.570, 8.191, 9.898, 9.603, 9.945, 10.056]) n = len(xdata) model = pm.Model() with model: # priors mu = pm.Normal('mu', mu=0, tau=0.001) lmbda = pm.Gamma('lambda', alpha=0.001, beta=0.001, shape=n) sigma = pm.Deterministic('sigma', tt.sqrt(1/lmbda)) # data come from Gaussians with common mean, but n different precisions for ii in range(n): pm.Normal('x%d' % ii, mu=mu, tau=lmbda[ii], observed=xdata[ii]) # instantiate sampler stepFunc = pm.HamiltonianMC() # pm.NUTS() isn't working well here..? # draw posterior samples (in parallel running chains) Nsample = 5000 Nchains = 4 traces = pm.sample(Nsample, step=stepFunc, njobs=Nchains) plotVars = ('mu','sigma','lambda') ax = pm.traceplot(traces, vars=plotVars, combined=False) #%% separately plot each sigma[i] (sigma consists of Nchains x Nsample x n) sigma = traces.get_values('sigma', combine=False, burn=1000) sigma = np.squeeze(sigma) #sigma = sigma[:,burnin:,:] axs = plt.subplots(n, 2, squeeze=False, figsize=(10, n*2)) for ii in range(n): chains = sigma[:,:,ii].transpose()
def InitPyMCSampling(self, **kwargs): ''' PyMC3 initialisation: Sampler N_tune : N_chains : N_cores : IsProgressbar : Sampler_Name : ''' #Checking if all the necessary stuff is loaded if not self.VarNames: self.InitPar(kwargs["ParFile"]) try: self.Cov[0][0] except TypeError: self.SetCovMatrix(Scale=1.2) if not self.basic_model: self.InitPyMC() # Further initialisation print(' >> Logging calculation steps in {}'.format(self.log_file_name)) open(self.log_file_name, 'w+').close() with self.basic_model: Sampler_Name = kwargs.get("Sampler_Name", "Metropolis") N_tune = kwargs.get("N_tune", 0) N_chains = kwargs.get("N_chains", 1) N_cores = kwargs.get("N_cores", min(4, N_chains)) IsProgressbar = kwargs.get("IsProgressbar", 1) print( '\n >> using configuration : {:12}, N_tune = {}, N_chains = {}, N_cores = {}' .format(Sampler_Name, N_tune, N_chains, N_cores)) self.S = Storage_Container( 3 * N_chains * len(self.VarNames)) # updating the cach size # Setting up the samplers # Calling S = self.Cov[::-1,::-1] is a neccessary hack in order to avoid a problem in the PyMC3 code: # The order of the variables is inverted (by accident?) durint the BlockStep().__init__() (see terminal promts) if Sampler_Name == "DEMetropolis": step = pm.DEMetropolis( S=self.Cov[::-1, ::-1], proposal_dist=pm.MultivariateNormalProposal) elif Sampler_Name == "Metropolis": step = pm.Metropolis( S=self.Cov[::-1, ::-1], proposal_dist=pm.MultivariateNormalProposal, blocked=True) elif Sampler_Name == "Hamiltonian": # the settings for HMC are very tricky. allowing adapt_step_size=True may lead to very small step sizes causing the method to stuck. length = max( 0.3, 1.5 * np.sqrt(np.sum(np.array(self.STDs)**2)) ) # this is the length in the parameter-space to travel between two points #length = np.sqrt(self.STDs) * np.mean(self.STDs) sub_l = length / 7 # setting substeps step = pm.HamiltonianMC(scaling=self.Cov[::-1, ::-1], adapt_step_size=0, step_scale=sub_l, path_length=length, is_cov=True) self.step.adapt_step_size = False # workaround for PyMC3 bug ( 'adapt_step_size= 0' is ignored) print( ' >> Hamiltonian settings: {:7.4f} / {:7.4f} = {:4} substeps between points' .format(length, sub_l / (len(self.STDs)**0.25), int(length / (sub_l / (len(self.STDs)**0.25))))) else: print( ' >> Unknown Sampler_Name = {:20}, Using Metropolis instead' .format(Sampler_Name)) step = pm.Metropolis( S=self.Cov[::-1, ::-1], proposal_dist=pm.MultivariateNormalProposal, blocked=True) self.Custom_sample_args = { "step": step, "progressbar": IsProgressbar, "chains": N_chains, "cores": N_cores, "tune": N_tune, #"parallelize" : True, } self.trace = None self.Prev_End = None
def main(): ''' This python function is a wrapper used to fit behavioral models to data. Examples of how to call it: # Fitting Main Model to Exp 1 python fit_model_to_dataset.py --modelname "11" --exp 1 --steps 2000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 # Fitting Main Model to Exp 2 python fit_model_to_dataset.py --modelname "11" --exp 2 --steps 2000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 # Fitting Other Models python fit_model_to_dataset.py --modelname "1" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "2" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "3" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "4" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "5" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "6" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "7" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "8" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "9" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "10" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "11" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "12" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 python fit_model_to_dataset.py --modelname "13" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 # Interaction model python fit_model_to_dataset.py --modelname "11trip" --exp 1 --steps 1000 --steps_tune 100 --covariate Bi3itemCDM --seed 3 ''' parser = argparse.ArgumentParser() parser.add_argument('--seed', type=int, default=4) parser.add_argument('--modelname', '-m', type=str, default=None) parser.add_argument('--steps', '-st', type=int, default=1000) parser.add_argument('--steps_tune', '-stt', type=int, default=100) parser.add_argument('--covariate', '-c', type=str, default='None') parser.add_argument('--exp', '-e', type=int, default=1) parser.add_argument('--hierarchical', '-hh', type=str, default='True') parser.add_argument('--task', '-tt', type=str, default='both') parser.add_argument('--subset', '-sub', type=str, default='all') parser.add_argument('--covariatemask', '-cm', type=str, default='None') args = parser.parse_args() print(args.modelname) print(args.steps) print(args.steps_tune) print(args.exp) print(args.hierarchical) print(args.subset) print(args.covariatemask) args.hierarchical = eval(args.hierarchical) if args.steps > 500: save_state_variables = False else: save_state_variables = False B_max = 10 nonlinear_indicator = 0 # mag diff scaled if args.task == 'both': if args.modelname == '1': # Model 1 # import models_1_flex as model_specific params = [ 'lr_baseline', 'lr_stabvol', 'Gamma_baseline', 'Gamma_stabvol', 'Binv_baseline', 'Binv_stabvol', 'lr_rewpain', 'lr_rewpain_stabvol', 'Gamma_rewpain', 'Gamma_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_stabvol', ] B_max = 10 if args.modelname == '2': # Model 2 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_stabvol', 'Amix_baseline', 'Amix_stabvol', 'Binv_baseline', 'Binv_stabvol', 'lr_rewpain', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_stabvol', ] B_max = 10 if args.modelname == '3': # Model 3 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_stabvol', 'Binv_baseline', 'Binv_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_stabvol', ] B_max = 10 if args.modelname == '4': # Model 4 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'lr_rewpain', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', ] B_max = 10 if args.modelname == '5': # Model 5 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', ] B_max = 10 if args.modelname == '6': # Model 6 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'lr_rewpain_goodbad_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Amix_rewpain_goodbad_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'Binv_rewpain_goodbad_stabvol', ] B_max = 10 if args.modelname == '7': # Model 7 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'mag_baseline', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'mag_rewpain' ] B_max = 10 if args.modelname == '8': # Model 8 # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'mag_baseline', 'eps_baseline', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'mag_rewpain', 'eps_rewpain' ] B_max = 10 if args.modelname == '9': # Model 9 # import models_9_12 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'mag_baseline', 'decay_baseline', 'decay_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'mag_rewpain', 'decay_rewpain', 'decay_rewpain_stabvol', ] B_max = 10 if args.modelname == '10': # Model 10 # import models_10_13 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'mag_baseline', 'decay_baseline', 'decay_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'mag_rewpain', 'decay_rewpain', 'decay_rewpain_stabvol', ] B_max = 10 if args.modelname == '11': # Model 11 MAIN MODEL # import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'lr_c_baseline', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'Bc_baseline', 'mag_baseline', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'Bc_rewpain', 'mag_rewpain' ] B_max = 10 if args.modelname == '12': # Model 12 # import models_9_12 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'lr_c_baseline', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'Bc_baseline', 'mag_baseline', 'decay_baseline', 'decay_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'Bc_rewpain', 'mag_rewpain', 'decay_rewpain', 'decay_rewpain_stabvol', ] B_max = 10 if args.modelname == '13': # Model 13 # import models_10_13 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'lr_c_baseline', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'Bc_baseline', 'mag_baseline', 'decay_baseline', 'decay_stabvol', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'Bc_rewpain', 'mag_rewpain', 'decay_rewpain', 'decay_rewpain_stabvol', ] B_max = 10 if args.modelname == '11trip': # Model 11 with triple interaction import models_2thr9_11 as model_specific params = [ 'lr_baseline', 'lr_goodbad', 'lr_stabvol', 'lr_goodbad_stabvol', 'lr_c_baseline', 'Amix_baseline', 'Amix_goodbad', 'Amix_stabvol', 'Amix_goodbad_stabvol', 'Binv_baseline', 'Binv_goodbad', 'Binv_stabvol', 'Binv_goodbad_stabvol', 'Bc_baseline', 'mag_baseline', 'lr_rewpain', 'lr_rewpain_goodbad', 'lr_rewpain_stabvol', 'lr_rewpain_goodbad_stabvol', 'Amix_rewpain', 'Amix_rewpain_goodbad', 'Amix_rewpain_stabvol', 'Binv_rewpain', 'Binv_rewpain_goodbad', 'Binv_rewpain_stabvol', 'Bc_rewpain', 'mag_rewpain' ] B_max = 10 # load data if args.exp == 1: dftmp = pd.read_csv('../data/participant_table_exp1.csv') data = get_data(dftmp) else: dftmp = pd.read_csv('../data/participant_table_exp2.csv') data = get_data_online(dftmp) u_covariate_mask = None mask_name = '' if args.task == 'both': if args.subset == 'all': if args.exp == 1: includes_subjs_with_one_task = True # prepare for model code subj_indices = slice(0, 157) Nboth = data['Nboth'] Y = {} Y['participants_choice'] = data[ 'participants_choice'][:, subj_indices] X = {} for var in [ 'outcomes_c_flipped', 'mag_1_c', 'mag_0_c', 'stabvol', 'rewpain' ]: X[var] = data[var][:, subj_indices] X['NN'] = X[var].shape[1] X['Nboth'] = data['Nboth'] X['Nrewonly'] = data['Nrewonly'] X['Npainonly'] = data['Npainonly'] C = {} for stem in [ 'Bi1item_w_j_scaled', 'Bi2item_w_j_scaled', 'Bi3item_w_j_scaled', 'PSWQ_scaled_residG', 'MASQAA_scaled_residG', 'MASQAD_scaled_residG', 'BDI_scaled_residG', 'STAIanx_scaled_residG', 'STAI_scaled_residG', 'PSWQ_scaled', 'MASQAA_scaled', 'MASQAD_scaled', 'BDI_scaled', 'STAIanx_scaled', 'STAI_scaled' ]: for tail in ['both', 'pain_only', 'rew_only']: C[stem + '_' + tail] = data[stem + '_' + tail] elif args.exp == 2: includes_subjs_with_one_task = False # prepare for model code subj_indices = slice( 0, data['participants_choice'].shape[1] ) #list(np.where(np.array(data['MID_combined'])=='cb100')[0]) Nboth = data['Nboth'] Y = {} Y['participants_choice'] = data[ 'participants_choice'][:, subj_indices] X = {} for var in [ 'outcomes_c_flipped', 'mag_1_c', 'mag_0_c', 'stabvol', 'rewpain' ]: X[var] = data[var][:, subj_indices] X['NN'] = X[var].shape[1] X['Nboth'] = data['Nboth'] C = {} C['STAI_scaled_both'] = data['STAI_scaled_both'] for trait in [ 'Bi1item_w_j_scaled', 'Bi2item_w_j_scaled', 'Bi3item_w_j_scaled', 'PSWQ_scaled_residG', 'MASQAA_scaled_residG', 'MASQAD_scaled_residG', 'BDI_scaled_residG', 'STAIanx_scaled_residG', 'STAI_scaled_residG', 'PSWQ_scaled', 'MASQAA_scaled', 'MASQAD_scaled', 'BDI_scaled', 'STAIanx_scaled', 'STAI_scaled' ]: C[trait + '_both'] = np.array(list(data[trait + '_both'])) # Create base model (i.e. prior), embedding factors into the priors idx_first_reward_pain = np.min( [pi for (pi, p) in enumerate(params) if 'rew' in p]) print('compiling base model') model = create_model_base( X, Y, C, # Changed here params=params, K=len(params), Konetask=idx_first_reward_pain, rew_slice=slice(0, idx_first_reward_pain), pain_slice=slice(0, idx_first_reward_pain), split_by_reward=True, includes_subjs_with_one_task=includes_subjs_with_one_task, covariate=args.covariate, hierarchical=args.hierarchical, covv='diag', coding='deviance', u_covariate_mask=u_covariate_mask) # Create likelihood model print('compiling specific model') model = model_specific.combined_prior_model_to_choice_model( X, Y, param_names=params, model=model, save_state_variables=save_state_variables, B_max=B_max, nonlinear_indicator=nonlinear_indicator) # Save name print('saving') now = datetime.datetime.now() filename='model='+args.modelname+'_covariate='+args.covariate+'_date='+str(now.year)+\ '_'+str(now.month)+'_'+str(now.day)+'_samples='+str(args.steps)+'_seed='+str(args.seed)+'_exp='+str(args.exp) # Save empty placeholder with open('./model_fits/' + filename + '.pkl', "wb") as buff: pickle.dump({}, buff) # Fitting model with model: MAP = {} step = pm.HamiltonianMC(target_accept=.95) print('sampling ...') trace = pm.sample(args.steps, step=step, chains=4, tune=args.steps_tune, random_seed=args.seed) # cores = 4 ppc = pm.sample_ppc(trace, 500) with open('./model_fits/' + filename + '.pkl', "wb") as buff: pickle.dump({ 'model': model, 'trace': trace, 'ppc': ppc, 'MAP': MAP }, buff)
#X_train = (X_train - X_train.mean(axis=0)) / X_train.std(axis=0) #X_test = (X_test - X_train.mean(axis=0)) / X_train.std(axis=0) #X_train = (X_train - X_train.min(axis=0)) / (X_train.max(axis=0)- X_train.min(axis=0)) #X_test = (X_test - X_train.min(axis=0)) / (X_train.max(axis=0)- X_train.min(axis=0)) n_iter = 100 step_size = 0.1 dim = X_train.shape[1] classes = len(Y_train[0].unique()) print("model:") with pm.Model() as iris_model: sd = pm.Gamma('sd', alpha=10,beta=1) alfa = pm.Normal('alfa', mu=0, sd=sd, shape=classes) beta = pm.Normal('beta', mu=0, sd=sd, shape=(dim,classes)) mu = alfa + pm.math.dot(X_train, beta) theta = pm.Deterministic('theta', tt.nnet.softmax(mu)) yl = pm.Categorical('yl', p=theta, observed=Y_train) step = pm.HamiltonianMC(step_scale=step_size,path_length=1.0,is_cov=True) iris_trace = pm.sample(n_iter,step) print("post_pred:") with iris_model: post_pred = pm.sample_ppc(iris_trace, samples=10) traceplot(iris_trace) plt.show() plt.close()
def fitbayesianmodel(bayesian_model, ytrain, method=1, n_=3000, MAP=True, chains=1, jobs=1, star='rrlyr', classifier='RL', PCA=False): print('chains: ', chains) print('jobs: ', jobs) if method == 4: print('------- Slice Sampling--------') with bayesian_model as model: map = 0 step = pm.Slice() trace = pm.sample(n_, step=step, njobs=jobs) return trace, model, map if method == 5: print('------- HamiltonianMC--------') with bayesian_model as model: step = pm.HamiltonianMC() trace = pm.sample(n_, chain=chains, tune=2000, njobs=jobs, step=step, init=None) return trace, model, map if method == 6: print('------- Default--------') with bayesian_model as model: map = 0 trace = pm.sample(n_, chain=chains, njobs=jobs, callbacks=[CheckParametersConvergence()]) return trace, model, map if method == 7: print('------- Metropolis--------') with bayesian_model as model: map = 0 step = pm.Metropolis() trace = pm.sample(n_, step=step, chain=chains, njobs=jobs, callbacks=[CheckParametersConvergence()], tune=1000, step_size=100) pm.traceplot(trace) name = star + '_' + classifier + '_PCA_' + str(PCA) + '2.png' plt.savefig(name) plt.clf() return trace, model, map if method == 8: print('------- NUTS--------') with bayesian_model as model: stds = np.ones(model.ndim) for _ in range(5): args = {'is_cov': True} trace = pm.sample(500, tune=1000, chains=1, init='advi+adapt_diag_grad', nuts_kwargs=args) samples = [model.dict_to_array(p) for p in trace] stds = np.array(samples).std(axis=0) traces = [] for i in range(1): step = pm.NUTS(scaling=stds**2, is_cov=True, target_accept=0.8) # start = trace[-10 * i] trace_ = pm.sample(n_, cores=4, step=step, tune=1000, chain=chains, njobs=1, init='advi+adapt_diag_grad', start=start, callbacks=[CheckParametersConvergence()]) trace = trace_ map = 0 return trace, model, map
y = [5, 1, 5, 14, 3, 19, 1, 1, 4, 22] # Number of failure t = [94, 16, 63, 126, 5, 31, 1, 1, 2, 10] # Observation time length # Define hyperparameters alpha = 1.8 gam = 0.01 delta = 1.0 Nobs = len(y) ''' Model ''' HansModel = pm.Model() with HansModel: beta = pm.Gamma('beta_est', alpha=delta, beta=gam) lamb = pm.Gamma('lamb_est', alpha=alpha, beta=beta, shape=Nobs) # Model param poi_mu = t * lamb # likelihood data = pm.Poisson('data', mu=poi_mu, observed=y) ''' Model fitting''' with HansModel: start = pm.find_MAP(fmin=sp.optimize.fmin_powell) Method = pm.HamiltonianMC(vars=[beta, lamb]) trace = pm.sample(10000, step=Method, start=start) burnin = 5000 pm.traceplot(trace[burnin:]) print(pm.summary(trace[burnin:])) plt.show()
def train_model(self, method, prior, res=22.): test_model = self.get_model(prior, test=True) with test_model: # True step size is scaled down # by (1/n)^(1/4), so that a res of 20º -> 15º sampling in 3-d # therefore, we scale UP by (1/n)^(1/4) so when we specify # 20º, we get 20º! step_scale = res * np.pi / 180 / (1 / self.n_d)**0.25 if method == 'MH': step = pm.Metropolis() test_trace = pm.sample(step=step, cores=1, chains=1, draws=1, tune=8000, discard_tuned_samples=False) cov = pm.trace_cov(test_trace) self.write_(cov, method, prior) return elif method == 'HMC': step = pm.HamiltonianMC(step_scale=step_scale) test_trace = pm.sample(step=step, cores=1, chains=1, draws=1, tune=8000, discard_tuned_samples=False) cov = pm.trace_cov(test_trace) self.write_(cov, method, prior) return elif method == 'NUTS': step = pm.NUTS(step_scale=step_scale, adapt_step_size=False, target_accept=0.8) test_trace = pm.sample(step=step, cores=1, chains=1, draws=1, tune=8000, discard_tuned_samples=False) cov = pm.trace_cov(test_trace) accept = test_trace.get_sampler_stats("mean_tree_accept") print("Mean acceptance for method", method, "and prior", prior, "is", accept.mean()) print("Step size is", test_trace.get_sampler_stats("step_size_bar")) t_a = accept.mean() if accept.mean() > 0.5 else 0.8 training_model = self.get_model(prior) # Method is NUTS # NUTS tuning will be a little more intense: with training_model: step = pm.NUTS(scaling=cov, is_cov=True, step_scale=step_scale, adapt_step_size=False, target_accept=t_a) train_trace = pm.sample(step=step, cores=1, chains=1, draws=1, tune=500, discard_tuned_samples=False) cov = pm.trace_cov(train_trace) self.write_(cov, method, prior)
def main(): '''Example: python fit_model_to_generated_dataset.py --modelname "11" --exp 1 --steps 1000 --steps_tune 100 --seed 3 ''' parser = argparse.ArgumentParser() parser.add_argument('--seed', '-se', type=int, default=3) parser.add_argument('--modelname', '-m', type=str, default=None) parser.add_argument('--steps', '-st', type=int, default=1000) parser.add_argument('--steps_tune', '-stt', type=int, default=100) parser.add_argument('--task', '-tt', type=str, default='both') parser.add_argument('--exp', '-e', type=int, default=1) args = parser.parse_args() print(args.steps) print(args.steps_tune) print(args.seed) print(type(args.seed)) print(args.exp) # load behavioral data if args.exp == 1: dftmp = pd.read_csv('../data/participant_table_exp1.csv') data = get_data(dftmp) else: dftmp = pd.read_csv('../data/participant_table_exp2.csv') data = get_data_online(dftmp) # set up data for model fitting (extract relevant behavioral data) X = {} Y = {} C = {} subj_indices = slice(0, 157) subj_indices_86 = slice(0, 86) X['NN'] = data['outcomes_c_flipped'].shape[1] X['Nboth'] = data['Nboth'] X['Nrewonly'] = data['Nrewonly'] X['Npainonly'] = data['Npainonly'] subj_indices_both = slice(0, X['Nboth']) subj_indices_rew_only = slice(0, X['Nrewonly']) subj_indices_pain_only = slice(0, X['Npainonly']) Y['participants_choice'] = data['participants_choice'][:, subj_indices] for var in [ 'outcomes_c_flipped', 'mag_1_c', 'mag_0_c', 'stabvol', 'rewpain' ]: X[var] = data[var][:, subj_indices] C['Bi1item_w_j_scaled_both'] = data['Bi1item_w_j_scaled_both'][ subj_indices_both] C['Bi2item_w_j_scaled_both'] = data['Bi2item_w_j_scaled_both'][ subj_indices_both] C['Bi3item_w_j_scaled_both'] = data['Bi3item_w_j_scaled_both'][ subj_indices_both] C['Bi1item_w_j_scaled_rew_only'] = data['Bi1item_w_j_scaled_rew_only'][ subj_indices_rew_only] C['Bi2item_w_j_scaled_rew_only'] = data['Bi2item_w_j_scaled_rew_only'][ subj_indices_rew_only] C['Bi3item_w_j_scaled_rew_only'] = data['Bi3item_w_j_scaled_rew_only'][ subj_indices_rew_only] C['Bi1item_w_j_scaled_pain_only'] = data['Bi1item_w_j_scaled_pain_only'][ subj_indices_pain_only] C['Bi2item_w_j_scaled_pain_only'] = data['Bi2item_w_j_scaled_pain_only'][ subj_indices_pain_only] C['Bi3item_w_j_scaled_pain_only'] = data['Bi3item_w_j_scaled_pain_only'][ subj_indices_pain_only] # load estimated parameters from actual dataset if args.modelname == '11': # some specifications for fitting covariate = 'Bi3itemCDM' hierarchical = True B_max = 10 import models_2thr9_11 as model_specific # load previous fit / parameters # this file path might need to be changed, depending on how the main model was run. model_name = 'model=11_covariate=Bi3itemCDM_date=2021_1_5_samples=1000_seed=3_exp=1.pkl' with open('../fitting_behavioral_model/model_fits/' + model_name, "rb") as buff: model_output = pickle.load(buff) trace = model_output['trace'] ppc = model_output['ppc'] model = model_output['model'] params = model.params # extract previous parameters, these are the ground truth parameters that we want to recover Theta_est = trace['Theta'].mean(axis=0) #subset participants (not implemented right now) Theta_est = Theta_est[subj_indices, :] if args.modelname == '11trip': covariate = 'Bi3itemCDM' hierarchical = True B_max = 10 import models_2thr9_11 as model_specific # load previous fit / parameters model_name = 'model=11trip_covariate=Bi3itemCDM_date=2021_1_5_samples=1000_seed=3_exp=1.pkl' with open('../fitting_behavioral_model/model_fits/' + model_name, "rb") as buff: model_output = pickle.load(buff) trace = model_output['trace'] ppc = model_output['ppc'] model = model_output['model'] params = model.params # extract previous parameters, these are the ground truth parameters that we want to recover Theta_est = Theta_est[subj_indices, :] # specify generative model f = model_specific.create_gen_choice_model(X, Y, param_names=params, B_max=B_max, seed=int(args.seed)) # generate new data using ground truth parameters gen_choice, gen_outcome_valence, *_ = f(Theta_est) # replace participants choices with generative choices Y_gen = {} Y_gen['participants_choice'] = gen_choice X_gen = copy.deepcopy(X) X_gen[ 'outcome_valence'] = gen_outcome_valence # only used for visualization idx_first_reward_pain = np.min( [pi for (pi, p) in enumerate(params) if 'rew' in p]) # compile base model model = create_model_base( X_gen, Y_gen, C, params=params, K=len(params), Konetask=idx_first_reward_pain, rew_slice=slice(0, idx_first_reward_pain), pain_slice=slice(0, idx_first_reward_pain), split_by_reward=True, includes_subjs_with_one_task=True, covariate=covariate, hierarchical=hierarchical, covv='diag', coding='deviance', ) # compile specific model model = model_specific.combined_prior_model_to_choice_model( X_gen, Y_gen, param_names=params, model=model, save_state_variables=False, B_max=B_max) # save name now = datetime.datetime.now() filename='model='+args.modelname+'_date='+str(now.year)+\ '_'+str(now.month)+'_'+str(now.day)+'_samples='+str(args.steps)+'_seed='+str(args.seed)+'_exp='+str(args.exp) # save empty placeholder with open('./model_fits/' + filename + '.pkl', "wb") as buff: print('saving placeholder') pickle.dump({}, buff) # sample (fit) with model: print('sampling from posterior') MAP = {} step = pm.HamiltonianMC(target_accept=.95) trace = pm.sample(args.steps, step=step, chains=4, tune=args.steps_tune, random_seed=args.seed) ppc = pm.sample_ppc(trace, 500) if hierarchical: hier = 'hier' else: hier = 'nonhier' # save completed results with open('./model_fits/' + filename + '.pkl', "wb") as buff: pickle.dump( { 'model': model, 'trace': trace, 'ppc': ppc, 'MAP': MAP, 'Theta_est': Theta_est, 'X_gen': X_gen, 'Y_gen': Y_gen, 'C': C, 'subj_indices': subj_indices, 'subj_indices_both': subj_indices_both, 'subj_indices_rew_only': subj_indices_rew_only, 'subj_indices_pain_only': subj_indices_pain_only }, buff)
def NUTS_run(samp_obj, T, nsamples=1000, tune=200, nchains=1, ncpus=4, hpc=False, method='NUTS', prior='umvt'): """ Run the sampling job according to the given protocol (default: NUTS) """ # Define the model and model parameters beta = 1 / (constants.kB * T) * constants.E_h logpE = lambda E: -E # E must be dimensionless logp, Z, tmodes = generate_logprior(samp_obj, T, prior) syms = np.array([mode.get_symmetry_number() for mode in tmodes]) Ks = np.array([beta * mode.get_spline_fn()(0, 2) for mode in tmodes]) variances = get_initial_mass_matrix(tmodes, T) #variances = 1/Ks geom = Geometry(samp_obj, samp_obj.torsion_internal, syms) energy_fn = Energy(geom, beta) n_d = len(tmodes) resolution = 10.0 #degrees step_scale = resolution * (np.pi / 180) / (1 / n_d)**(0.25) L = 2 * np.pi / syms center_mod = lambda x: \ ((x.transpose() % L) - L*((x.transpose() % L) // (L/2))).transpose() if not hpc: with pm.Model() as model: xy = pmx.UnitDisk('xy', shape=(2, n_d)) x = pm.Deterministic('x', tt.arctan2(xy[1], xy[0])) phi = pm.DensityDist('phi', logp, observed=x) bE = pm.Deterministic('bE', -logp(phi)+\ (np.random.rand()-0.5)/10000) DeltaE = bE - (-logp(phi)) alpha = pm.Deterministic('a', np.exp(-DeltaE)) E_obs = pm.Potential('E_obs', logpE(DeltaE)) #E_obs = pm.DensityDist('E_obs', lambda E: logpE(E), # observed={'E':DeltaE}) with model: print("Method is", method) if method == 'NUTS': pass #nuts_kwargs = dict(target_accept=0.5, # step_scale=step_scale, early_max_treedepth=5, # max_treedepth=6, adapt_step_size=False) #step = pm.NUTS(scaling=variances, is_cov=True, # **nuts_kwargs) step = pm.NUTS(target_accept=0.6, step_scale=step_scale, adapt_step_size=False) trace = pm.sample(1000, cores=1, target_accept=0.6) elif method == 'HMC': return hmc_kwargs = dict(target_accept=0.5, step_scale=step_scale) step = pm.HamiltonianMC(scaling=variances, is_cov=True, **hmc_kwargs) trace = pm.sample(nsamples, tune=tune, step=step, chains=nchains, cores=1, discard_tuned_samples=False) elif method == 'MH': mh_kwargs = dict(S=variances) step = pm.Metropolis(**mh_kwargs) #step = pm.NUTS( # target_accept=0.65, scaling=variances, is_cov=True, # step_scale=step_scale, early_max_treedepth=6, # max_treedepth=6, adapt_step_size=False) trace = pm.sample(nsamples, tune=tune, step=step, chains=nchains, cores=1, discard_tuned_samples=False) else: with pm.Model() as model: #x = pm.DensityDist('x', logp, shape=n_d, testval=np.random.rand(n_d)*2*np.pi) x = pm.DensityDist('x', logp, shape=n_d, testval=get_initial_values(tmodes, T)) xmod = pm.Deterministic('xmod', center_mod(x)) bE = pm.Deterministic('bE', energy_fn(x)) DeltaE = (bE) - (-logp(x)) alpha = pm.Deterministic('a', np.exp(-DeltaE)) E_obs = pm.DensityDist('E_obs', lambda E: logpE(E), observed={'E': DeltaE}) with model: if method == 'NUTS': nuts_kwargs = dict(target_accept=0.5, step_scale=step_scale, early_max_treedepth=5, max_treedepth=6, adapt_step_size=False) step = pm.NUTS(scaling=variances, is_cov=True, **nuts_kwargs) elif method == 'HMC': step = pm.HamiltonianMC() pass elif method == 'MH': step = pm.Metropolis() pass trace = pm.sample(nsamples, tune=tune, step=step, chains=nchains, cores=1) #<- Indent the following lines to here after debugging: pickle_the_model(trace, model, Z, samp_obj, geom, tmodes, ncpus, nchains, tune, nsamples, T, prior=prior, method=method) #thermo_obj = MCThermoJob(trace, T, sampT=T, samp_obj=samp_obj, model=model) #a,b = thermo_obj.execute() if not hpc: plot_MC_torsion_result(trace, tmodes, T)
n=1, p=[type1success, type2success, type3success, type4success], shape=4).random() indexCancer = np.where(cancerType == 1)[0] cancerTypeGeneratedSample = cancerTypeValues[indexCancer[0]] age = pm.Normal('age', mu=meanValues[-1], sigma=(maxAge - meanValues[-1])).random() cov = np.cov(DataAccessProcessedSymptopmsOnly.T) # featurenumber = 41 x = pm.math.stack(cancerTypeGeneratedSample, genderType, age) allMu = pm.math.concatenate([sympsTheano, x], axis=0) test = pm.MvNormal('out', mu=allMu, cov=cov, shape=featurenumber) returns = test step = pm.HamiltonianMC() trace = pm.sample(5000, step=step, chains=2) #,init='adapt_diag' # #, cores=1, chains=1 plt.figure() # plot the trace file of the algorithm traceArray = trace['out'] pm.traceplot(trace, var_names=['age', 'gender', 'symp1'], compact=False) plt.show() traceArray = trace['out'] # plot the covariance fo original and generated data covv = np.cov(traceArray.T) # plt.show() fig = plt.figure() ax = sns.heatmap(covv[1:-3, 1:-3], center=0) #
total_size=total_size) return model, out # build BNN BNN, out = build_model(ann_output) # run inference with neural_network print( '\nStarting sampling. If it hangs early on (<20 samples) try restarting script or reducing path_length.\n' ) step = pm.HamiltonianMC(path_length=0.4, adapt_step_size=True, step_scale=0.04, gamma=0.05, k=0.9, t0=1, target_accept=0.9, model=BNN) trace = pm.sample(n_inf_samples, step=step, model=BNN, chains=1, n_jobs=1, tune=300) # make predictions - need to update inputs in this way with validation data ann_input.set_value(X_grid.astype('float32')) ann_input_per.set_value(X_grid_per.astype('float32')) init_rbf_pred = np.repeat(init_rbf_orig, X_grid.shape[0], axis=1) rbf_input.set_value(init_rbf_pred.astype('float32'))
import pymc3.math import time #%pdb basic_model = pymc3.Model() with basic_model: pymc_beta = pymc3.Normal('beta', mu=0, sd=1, shape=D) pymc_y = pymc3.Bernoulli('y', p=pymc3.math.sigmoid(pymc3.math.dot(x, pymc_beta)), observed=y) step = pymc3.HamiltonianMC(step_scale=step_size * (1. / D)**(-1. / 4), path_length=step_size * n_steps, step_rand=lambda x: x, scaling=np.ones(D)) #, np.float32)) t0 = time.time() #pymc_samples = pymc3.sample(n_iterations, step=step, init=None, njobs=1) pymc_samples = pymc3.sample(n_iterations, step=step, init=None, njobs=1, chains=1, tune=0) pymc_time = time.time() - t0 print('pymc (CPU multithreaded) took %.3f seconds' % pymc_time) #print 'PyMC3 (CPU, multi-threaded) took %.3f seconds (%.3f Edward time)' % (pymc_time, pymc_time / ed_time) #plot(pymc_samples.get_values('beta')[:, 0])