def doMCMC(n, nxx, nxy, nyy, x): # Optional setting for reproducibility use_seed = False d = nxx.shape[0] ns = 2000 if use_seed: # optional setting for reproducibility seed = 42 # Disable printing sys.stdout = open(os.devnull, 'w') # Sufficient statistics NXX = shared(nxx) NXY = shared(nxy) NYY = shared(nyy) # Define model and perform MCMC sampling with Model() as model: # Fixed hyperparameters for priors b0 = Deterministic('b0', th.zeros((d), dtype='float64')) ide = Deterministic('ide', th.eye(d, m=d, k=0, dtype='float64')) # Priors for parameters l0 = Gamma('l0', alpha=2.0, beta=2.0) l = Gamma('l', alpha=2.0, beta=2.0) b = MvNormal('b', mu=b0, tau=l0 * ide, shape=d) # Custom log likelihood def logp(xtx, xty, yty): return (n / 2.0) * th.log(l / (2 * np.pi)) + (-l / 2.0) * ( th.dot(th.dot(b, xtx), b) - 2 * th.dot(b, xty) + yty) # Likelihood delta = DensityDist('delta', logp, observed={ 'xtx': NXX, 'xty': NXY, 'yty': NYY }) # Inference print('doMCMC: start NUTS') step = NUTS() if use_seed: trace = sample(ns, step, progressbar=True, random_seed=seed) else: trace = sample(ns, step, progressbar=True) # Enable printing sys.stdout = sys.__stdout__ # Compute prediction over posterior return np.mean([np.dot(x, trace['b'][i]) for i in range(ns)], 0)
def gaussian(x, y): X = x.reshape(-1, 1) Z = linspace(-6, 6, 100).reshape(-1, 1) with Model() as gp_fit: ρ = Gamma('ρ', 1, 1) nu = Gamma('nu', 1, 1) K = nu * gp.cov.Matern32(1, ρ) with gp_fit: M = gp.mean.Zero() σ = HalfCauchy('σ', 2.5) with gp_fit: y_obs = gp.GP('y_obs', mean_func=M, cov_func=K, sigma=σ, observed={'X': X, 'Y': y}) with gp_fit: gp_samples = pm.gp.sample_gp(trace[1000:], y_obs, Z, samples=50)
def doADVI(n, xx, xy, yy, x): d = xx.shape[0] ns = 5000 seed = 42 # for reproducibility # Disable printing sys.stdout = open(os.devnull, 'w') # Sufficient statistics NXX = shared(xx) NXY = shared(xy) NYY = shared(yy) # Define model and perform MCMC sampling with Model() as model: # Fixed hyperparameters for priors b0 = Deterministic('b0', th.zeros((d), dtype='float64')) ide = Deterministic('ide', th.eye(d, m=d, k=0, dtype='float64')) # Priors for parameters l0 = Gamma('l0', alpha=2.0, beta=2.0) l = Gamma('l', alpha=2.0, beta=2.0) b = MvNormal('b', mu=b0, tau=l0 * ide, shape=d) # Custom log likelihood def logp(xtx, xty, yty): return (n / 2.0) * th.log(l / (2 * np.pi)) + (-l / 2.0) * ( th.dot(th.dot(b, xtx), b) - 2 * th.dot(b, xty) + yty) # Likelihood delta = DensityDist('delta', logp, observed={ 'xtx': NXX, 'xty': NXY, 'yty': NYY }) # Inference v_params = advi(n=ns, random_seed=seed) trace = sample_vp(v_params, draws=ns, random_seed=seed) # Enable printing sys.stdout = sys.__stdout__ # Compute prediction over posterior return np.mean([np.dot(x, trace['b'][i]) for i in range(ns)], 0)
def test_normal_mixture(self): with Model() as model: w = Dirichlet('w', np.ones_like(self.norm_w)) mu = Normal('mu', 0., 10., shape=self.norm_w.size) tau = Gamma('tau', 1., 1., shape=self.norm_w.size) x_obs = NormalMixture('x_obs', w, mu, tau=tau, observed=self.norm_x) step = Metropolis() trace = sample(5000, step, random_seed=self.random_seed, progressbar=False) assert_allclose(np.sort(trace['w'].mean(axis=0)), np.sort(self.norm_w), rtol=0.1, atol=0.1) assert_allclose(np.sort(trace['mu'].mean(axis=0)), np.sort(self.norm_mu), rtol=0.1, atol=0.1)
def test_mixture_list_of_normals(self): with Model() as model: w = Dirichlet('w', floatX(np.ones_like(self.norm_w))) mu = Normal('mu', 0., 10., shape=self.norm_w.size) tau = Gamma('tau', 1., 1., shape=self.norm_w.size) Mixture('x_obs', w, [ Normal.dist(mu[0], tau=tau[0]), Normal.dist(mu[1], tau=tau[1]) ], observed=self.norm_x) step = Metropolis() trace = sample(5000, step, random_seed=self.random_seed, progressbar=False, chains=1) assert_allclose([ np.sort(trace['w'].mean(axis=0)), np.sort(trace['mu'].mean(axis=0)) ], [np.sort(self.norm_w), np.sort(self.norm_mu)], rtol=0.1, atol=0.1) assert_allclose(np.sort(trace['mu'].mean(axis=0)), np.sort(self.norm_mu), rtol=0.1, atol=0.1)
def test_mixture_list_of_poissons(self): with Model() as model: w = Dirichlet('w', floatX(np.ones_like(self.pois_w)), shape=self.pois_w.shape) mu = Gamma('mu', 1., 1., shape=self.pois_w.size) Mixture( 'x_obs', w, [Poisson.dist(mu[0]), Poisson.dist(mu[1])], observed=self.pois_x) step = Metropolis() trace = sample(5000, step, random_seed=self.random_seed, progressbar=False, chains=1) assert_allclose(np.sort(trace['w'].mean(axis=0)), np.sort(self.pois_w), rtol=0.1, atol=0.1) assert_allclose(np.sort(trace['mu'].mean(axis=0)), np.sort(self.pois_mu), rtol=0.1, atol=0.1)
def test_mixture_list_of_normals(self): with Model() as model: w = Dirichlet("w", floatX(np.ones_like(self.norm_w)), shape=self.norm_w.size) mu = Normal("mu", 0.0, 10.0, shape=self.norm_w.size) tau = Gamma("tau", 1.0, 1.0, shape=self.norm_w.size) Mixture( "x_obs", w, [ Normal.dist(mu[0], tau=tau[0]), Normal.dist(mu[1], tau=tau[1]) ], observed=self.norm_x, ) step = Metropolis() trace = sample(5000, step, random_seed=self.random_seed, progressbar=False, chains=1) assert_allclose(np.sort(trace["w"].mean(axis=0)), np.sort(self.norm_w), rtol=0.1, atol=0.1) assert_allclose(np.sort(trace["mu"].mean(axis=0)), np.sort(self.norm_mu), rtol=0.1, atol=0.1)
def test_poisson_mixture(self): with Model() as model: w = Dirichlet("w", floatX(np.ones_like(self.pois_w)), shape=self.pois_w.shape) mu = Gamma("mu", 1.0, 1.0, shape=self.pois_w.size) Mixture("x_obs", w, Poisson.dist(mu), observed=self.pois_x) step = Metropolis() trace = sample(5000, step, random_seed=self.random_seed, progressbar=False, chains=1) assert_allclose(np.sort(trace["w"].mean(axis=0)), np.sort(self.pois_w), rtol=0.1, atol=0.1) assert_allclose( np.sort(trace["mu"].mean(axis=0)), np.sort(self.pois_mu), rtol=0.1, atol=0.1 )
def test_normal_mixture_nd(self): nd, ncomp = 3, 5 with Model() as model0: mus = Normal('mus', shape=(nd, ncomp)) taus = Gamma('taus', alpha=1, beta=1, shape=(nd, ncomp)) ws = Dirichlet('ws', np.ones(ncomp)) mixture0 = NormalMixture('m', w=ws, mu=mus, tau=taus, shape=nd) with Model() as model1: mus = Normal('mus', shape=(nd, ncomp)) taus = Gamma('taus', alpha=1, beta=1, shape=(nd, ncomp)) ws = Dirichlet('ws', np.ones(ncomp)) comp_dist = [ Normal.dist(mu=mus[:, i], tau=taus[:, i]) for i in range(ncomp) ] mixture1 = Mixture('m', w=ws, comp_dists=comp_dist, shape=nd) testpoint = model0.test_point testpoint['mus'] = np.random.randn(nd, ncomp) assert_allclose(model0.logp(testpoint), model1.logp(testpoint)) assert_allclose(mixture0.logp(testpoint), mixture1.logp(testpoint))
def _indvdl_gg( hparams, std_x, n_samples, L_cov, Normal, Gamma, Deterministic, sgn, gamma, floatX, cholesky, tt, verbose): # Uniform distribution on sphere gs = Normal('gs', np.float32(0.0), np.float32(1.0), shape=(n_samples, 2), dtype=floatX) ss = Deterministic('ss', gs + sgn(sgn(gs) + np.float32(1e-10)) * np.float32(1e-10)) ns = Deterministic('ns', ss.norm(L=2, axis=1)[:, np.newaxis]) us = Deterministic('us', ss / ns) # Scaling s.t. variance to 1 n = 2 # dimension beta = np.float32(hparams['beta_coeff']) m = n * gamma(0.5 * n / beta) \ / (2 ** (1 / beta) * gamma((n + 2) / (2 * beta))) L_cov_ = (np.sqrt(m) * cholesky(L_cov)).astype(floatX) # Scaling to v_indvdls scale1 = np.float32(std_x[0] * hparams['v_indvdl_1']) scale2 = np.float32(std_x[1] * hparams['v_indvdl_2']) tt.set_subtensor(L_cov_[0, :], L_cov_[0, :] * scale1, inplace=True) tt.set_subtensor(L_cov_[1, :], L_cov_[1, :] * scale2, inplace=True) # Draw samples ts = Gamma( 'ts', alpha=np.float32(n / (2 * beta)), beta=np.float32(.5), shape=n_samples, dtype=floatX )[:, np.newaxis] mus_ = Deterministic( 'mus_', ts**(np.float32(0.5 / beta)) * us.dot(L_cov_) ) mu1s_ = mus_[:, 0] mu2s_ = mus_[:, 1] if 10 <= verbose: print('GG for individual effect') print('gs.dtype = {}'.format(gs.dtype)) print('ss.dtype = {}'.format(ss.dtype)) print('ns.dtype = {}'.format(ns.dtype)) print('us.dtype = {}'.format(us.dtype)) print('ts.dtype = {}'.format(ts.dtype)) return mu1s_, mu2s_
def run_dirpfa(args): tf_vectorizer, docs_tr, docs_te = prepare_sparse_matrix_nonlabel(args.n_tr, args.n_te, args.n_word) feature_names = tf_vectorizer.get_feature_names() doc_tr_minibatch = pm.Minibatch(docs_tr.toarray(), args.bsz) doc_tr = shared(docs_tr.toarray()[:args.bsz]) def log_prob(beta, theta, n): """Returns the log-likelihood function for given documents. K : number of topics in the model V : number of words (size of vocabulary) D : number of documents (in a mini-batch) Parameters ---------- beta : tensor (K x V) Word distributions. theta : tensor (D x K) Topic distributions for documents. n: tensor (D x 1) Expected lengths of each documents """ def ll_docs_f(docs): dixs, vixs = docs.nonzero() vfreqs = docs[dixs, vixs] ll_docs = (vfreqs * (pmmath.logsumexp(tt.log(theta[dixs]) + tt.log(beta.T[vixs]), axis=1).ravel() + tt.log( n[dixs]).ravel()) - tt.exp( pmmath.logsumexp(tt.log(theta[dixs]) + tt.log(beta.T[vixs], ), axis=1)).ravel() * n[ dixs].ravel() - pm.distributions.special.gammaln(vfreqs + 1) ) return tt.sum(ll_docs) / (tt.sum(vfreqs) + 1e-9) return ll_docs_f with pm.Model() as model: n = Gamma("n", alpha=pm.floatX(10. * np.ones((args.bsz, 1))), beta=pm.floatX(0.1 * np.ones((args.bsz, 1))), shape=(args.bsz, 1), total_size=args.n_tr) beta = Dirichlet("beta", a=pm.floatX((1. / args.n_topic) * np.ones((args.n_topic, args.n_word))), shape=(args.n_topic, args.n_word), ) theta = Dirichlet("theta", a=pm.floatX((10. / args.n_topic) * np.ones((args.bsz, args.n_topic))), shape=(args.bsz, args.n_topic), total_size=args.n_tr, ) doc = pm.DensityDist("doc", log_prob(beta, theta, n), observed=doc_tr) encoder = ThetaNEncoder(n_words=args.n_word, n_hidden=100, n_topics=args.n_topic) local_RVs = OrderedDict([(theta, encoder.encode(doc_tr)[0]), (n, encoder.encode(doc_tr)[1])]) encoder_params = encoder.get_params() s = shared(args.lr) def reduce_rate(a, h, i): s.set_value(args.lr / ((i / args.bsz) + 1) ** 0.7) with model: approx = pm.MeanField(local_rv=local_RVs) approx.scale_cost_to_minibatch = False inference = pm.KLqp(approx) inference.fit(args.n_iter, callbacks=[reduce_rate, pm.callbacks.CheckParametersConvergence(diff="absolute")], obj_optimizer=pm.adam(learning_rate=s), more_obj_params=encoder_params, total_grad_norm_constraint=200, more_replacements={ doc_tr: doc_tr_minibatch }, ) doc_tr.set_value(docs_tr.toarray()) inp = tt.matrix(dtype="int64") sample_vi_theta = theano.function([inp], approx.sample_node(approx.model.theta, args.n_sample, more_replacements={ doc_tr: inp }), ) sample_vi_n = theano.function([inp], approx.sample_node(approx.model.n, args.n_sample, more_replacements={ doc_tr: inp })) test = docs_te.toarray() test_n = test.sum(1) beta_pymc3 = pm.sample_approx(approx, draws=args.n_sample)['beta'] theta_pymc3 = sample_vi_theta(test) n_pymc3 = sample_vi_n(test) assert beta_pymc3.shape == (args.n_sample, args.n_topic, args.n_word) assert theta_pymc3.shape == (args.n_sample, args.n_te, args.n_topic) assert n_pymc3.shape == (args.n_sample, args.n_te, 1) beta_mean = beta_pymc3.mean(0) theta_mean = theta_pymc3.mean(0) n_mean = n_pymc3.mean(0) pred_rate = theta_mean.dot(beta_mean) * n_mean pp_test = (test * np.log(pred_rate) - pred_rate - sc.gammaln(test + 1)).sum(1) / test_n posteriors = { 'theta': theta_pymc3, 'beta': beta_pymc3, 'n': n_pymc3} log_top_words(beta_pymc3.mean(0), feature_names, n_top_words=args.n_top_word) save_elbo(approx.hist) save_pp(pp_test) save_draws(posteriors)
def hmetad_rm1way(data: dict, sample_model: bool = True, **kwargs: int): """Compute hierachical meta-d' at the subject level. This is an internal function. The repeated measures model must be called using :py:func:`metadPy.hierarchical.hmetad`. Parameters ---------- data : dict Response data. sample_model : boolean If `False`, only the model is returned without sampling. **kwargs : keyword arguments All keyword arguments are passed to `func::pymc3.sampling.sample`. Returns ------- model : :py:class:`pymc3.Model` instance The pymc3 model. Encapsulates the variables and likelihood factors. trace : :py:class:`pymc3.backends.base.MultiTrace` or :py:class:`arviz.InferenceData` A `MultiTrace` or `ArviZ InferenceData` object that contains the samples. References ---------- .. [#] Fleming, S.M. (2017) HMeta-d: hierarchical Bayesian estimation of metacognitive efficiency from confidence ratings, Neuroscience of Consciousness, 3(1) nix007, https://doi.org/10.1093/nc/nix007 """ nSubj = data["nSubj"] nCond = data["nCond"] nRatings = data["nRatings"] hits = data["hits"].reshape(nSubj, 2) falsealarms = data["falsealarms"].reshape(nSubj, 2) counts = data["counts"] Tol = data["Tol"] cr = data["cr"].reshape(nSubj, 2) m = data["m"].reshape(nSubj, 2) c1 = data["c1"].reshape(nSubj, 2, 1) d1 = data["d1"].reshape(nSubj, 2, 1) with Model() as model: ############# # Hyperpriors ############# mu_c2 = Normal("mu_c2", tau=0.01, shape=(1, ), testval=np.random.rand() * 0.1) sigma_c2 = HalfNormal("sigma_c2", tau=0.01, shape=(1, ), testval=np.random.rand() * 0.1) mu_D = Normal("mu_D", tau=0.001, shape=(1), testval=np.random.rand() * 0.1) sigma_D = HalfNormal("sigma_D", tau=0.1, shape=(1), testval=np.random.rand() * 0.1) mu_Cond1 = Normal("mu_Cond1", mu=0, tau=0.001, shape=(1), testval=np.random.rand() * 0.1) sigma_Cond1 = HalfNormal("sigma_Cond1", tau=0.1, shape=(1), testval=np.random.rand() * 0.1) ############################# # Hyperpriors - Subject level ############################# dbase_tilde = Normal( "dbase_tilde", mu=0, sigma=1, shape=(nSubj, 1, 1), ) dbase = Deterministic("dbase", mu_D + sigma_D * dbase_tilde) Bd_Cond1_tilde = Normal( "Bd_Cond1_tilde", mu=0, sigma=1, shape=(nSubj, 1, 1), ) Bd_Cond1 = Deterministic( "Bd_Cond1", mu_Cond1 + sigma_Cond1 * Bd_Cond1_tilde, ) lambda_logMratio = Gamma( "lambda_logMratio", alpha=0.001, beta=0.001, shape=(nSubj, 1, 1), ) sigma_logMratio = Deterministic("sigma_logMratio", 1 / math.sqrt(lambda_logMratio)) ############################### # Hypterprior - Condition level ############################### mu_regression = [dbase + (Bd_Cond1 * c) for c in range(nCond)] log_mRatio_tilde = Normal("log_mRatio_tilde", mu=0, sigma=1, shape=(nSubj, 1, 1)) log_mRatio = Deterministic( "log_mRatio", tt.stack(mu_regression, axis=1)[:, :, :, 0] + tt.tile(log_mRatio_tilde, (1, 2, 1)) * tt.tile(sigma_logMratio, (1, 2, 1)), ) mRatio = Deterministic("mRatio", tt.exp(log_mRatio)) # Means of SDT distributions metad = Deterministic("metad", mRatio * d1) S2mu = Deterministic("S2mu", metad / 2) S1mu = Deterministic("S1mu", -metad / 2) # TYPE 2 SDT MODEL (META-D) # Multinomial likelihood for response counts # Specify ordered prior on criteria # bounded above and below by Type 1 c cS1_hn = Normal( "cS1_hn", mu=0, sigma=1, shape=(nSubj, nCond, nRatings - 1), testval=np.linspace(-1.5, -0.5, nRatings - 1).reshape( 1, 1, nRatings - 1).repeat(nSubj, axis=0).repeat(nCond, axis=1), ) cS1 = Deterministic("cS1", -mu_c2 + (cS1_hn * sigma_c2)) cS2_hn = Normal( "cS2_hn", mu=0, sigma=1, shape=(nSubj, nCond, nRatings - 1), testval=np.linspace(0.5, 1.5, nRatings - 1).reshape( 1, 1, nRatings - 1).repeat(nSubj, axis=0).repeat(nCond, axis=1), ) cS2 = Deterministic("cS2", mu_c2 + (cS2_hn * sigma_c2)) # Calculate normalisation constants C_area_rS1 = cumulative_normal(c1 - S1mu) I_area_rS1 = cumulative_normal(c1 - S2mu) C_area_rS2 = 1 - cumulative_normal(c1 - S2mu) I_area_rS2 = 1 - cumulative_normal(c1 - S1mu) # Get nC_rS1 probs nC_rS1 = cumulative_normal(cS1 - S1mu) / C_area_rS1 nC_rS1 = Deterministic( "nC_rS1", math.concatenate( ([ cumulative_normal(cS1[:, :, 0].reshape((nSubj, 2, 1)) - S1mu) / C_area_rS1, nC_rS1[:, :, 1:] - nC_rS1[:, :, :-1], ((cumulative_normal(c1 - S1mu) - cumulative_normal(cS1[:, :, (nRatings - 2)].reshape( (nSubj, 2, 1)) - S1mu)) / C_area_rS1), ]), axis=2, ), ) # Get nI_rS2 probs nI_rS2 = (1 - cumulative_normal(cS2 - S1mu)) / I_area_rS2 nI_rS2 = Deterministic( "nI_rS2", math.concatenate( ([ ((1 - cumulative_normal(c1 - S1mu)) - (1 - cumulative_normal(cS2[:, :, 0].reshape( (nSubj, nCond, 1)) - S1mu))) / I_area_rS2, nI_rS2[:, :, :-1] - (1 - cumulative_normal(cS2[:, :, 1:] - S1mu)) / I_area_rS2, (1 - cumulative_normal(cS2[:, :, nRatings - 2].reshape( (nSubj, nCond, 1)) - S1mu)) / I_area_rS2, ]), axis=2, ), ) # Get nI_rS1 probs nI_rS1 = (-cumulative_normal(cS1 - S2mu)) / I_area_rS1 nI_rS1 = Deterministic( "nI_rS1", math.concatenate( ([ cumulative_normal(cS1[:, :, 0].reshape((nSubj, nCond, 1)) - S2mu) / I_area_rS1, nI_rS1[:, :, :-1] + (cumulative_normal(cS1[:, :, 1:] - S2mu)) / I_area_rS1, (cumulative_normal(c1 - S2mu) - cumulative_normal(cS1[:, :, nRatings - 2].reshape( (nSubj, nCond, 1)) - S2mu)) / I_area_rS1, ]), axis=2, ), ) # Get nC_rS2 probs nC_rS2 = (1 - cumulative_normal(cS2 - S2mu)) / C_area_rS2 nC_rS2 = Deterministic( "nC_rS2", math.concatenate( ([ ((1 - cumulative_normal(c1 - S2mu)) - (1 - cumulative_normal(cS2[:, :, 0].reshape( (nSubj, nCond, 1)) - S2mu))) / C_area_rS2, nC_rS2[:, :, :-1] - ((1 - cumulative_normal(cS2[:, :, 1:] - S2mu)) / C_area_rS2), (1 - cumulative_normal(cS2[:, :, nRatings - 2].reshape( (nSubj, nCond, 1)) - S2mu)) / C_area_rS2, ]), axis=2, ), ) # Avoid underflow of probabilities nC_rS1 = math.switch(nC_rS1 < Tol, Tol, nC_rS1) nI_rS2 = math.switch(nI_rS2 < Tol, Tol, nI_rS2) nI_rS1 = math.switch(nI_rS1 < Tol, Tol, nI_rS1) nC_rS2 = math.switch(nC_rS2 < Tol, Tol, nC_rS2) for c in range(nCond): Multinomial( f"CR_counts_{c}", n=cr[:, c], p=nC_rS1[:, c, :], observed=counts[:, c, :nRatings], shape=(nSubj, nRatings), ) Multinomial( f"H_counts_{c}", n=hits[:, c], p=nC_rS2[:, c, :], observed=counts[:, c, nRatings * 3:nRatings * 4], shape=(nSubj, nRatings), ) Multinomial( f"FA_counts_{c}", n=falsealarms[:, c], p=nI_rS2[:, c, :], observed=counts[:, c, nRatings:nRatings * 2], shape=(nSubj, nRatings), ) Multinomial( f"M_counts_{c}", n=m[:, c], p=nI_rS1[:, c, :], observed=counts[:, c, nRatings * 2:nRatings * 3], shape=(nSubj, nRatings), ) if sample_model is True: trace = sample(return_inferencedata=True, **kwargs) return model, trace else: return model
#Get the temperatures T = data['T'] T = T.as_matrix() T = T.flatten() size = len(Y) #TRANSFORM FROM DATAFRAME TO NP ARRAY FORMAT # Specifing the parameters that control the MCMC (these will be used throughout the code). hypers = hyperparam['EFD'] basic_model_EFD = Model() print(hypers) bruh = Gamma('bruh', 2.475, 0.0158) with basic_model_EFD: #priors for unknown model parameters c = Gamma('c', 2.475, 0.0158) Tm = Gamma('Tm', 1.82580286, 4.67203779) T0 = Gamma('T0', 180.908498, 0.169325317) tau = Gamma('tau', 32.86091663, 0.56949197) #c = Gamma('c',1,10) #Tm= Uniform('Tm',30,45) #T0= Uniform('T0',0,20) #tau= Gamma('tau',0.0001, 0.0001) mu_temp = c * T * ((T - T0) * (T0 <= T)) * np.sqrt((Tm - T) * (Tm >= T))
from pymc3 import Gamma jul_rain = nash_precip.Jul jan_rain = nash_precip.Jan with Model() as rainfall_model: σ_jan = Uniform('σ_jan', 0, 1000) σ_jul = Uniform('σ_jul', 0, 1000) mu_jan = Uniform('mu_jan', 0, 25) mu_jul = Uniform('mu_jul', 0, 25) jan = Gamma('jan', mu=mu_jan, sd=σ_jan, observed=jan_rain) jul = Gamma('jul', mu=mu_jul, sd=σ_jul, observed=jul_rain) d = Deterministic('d', mu_jan - mu_jul) samples = fit(20000).sample(1000)
#Get the temperatures T = data['T'] T = T.as_matrix() T = T.flatten() size = len(Y) #TRANSFORM FROM DATAFRAME TO NP ARRAY FORMAT # Specifing the parameters that control the MCMC (these will be used throughout the code). basic_model_GCR = Model() with basic_model_GCR: #priors for unknown model parameters c = Gamma('c', 1, 10) Tm = Uniform('Tm', 25, 45) T0 = Uniform('T0', 0, 24) tau = Gamma('tau', 0.0001, 0.0001) mu_temp = c * T * ((T - T0) * (T0 < T)) * np.sqrt((Tm - T) * (Tm > T)) mu = 0 * (mu_temp < 0) + mu_temp * (mu_temp > 0) Y_obs = Normal('Y_obs', mu=mu, sd=tau, observed=Y) from pymc3 import Metropolis, sample, find_MAP from scipy import optimize with basic_model_GCR: # obtain starting values via MAP
last_time = sim.show_time() except simpy.core.EmptySchedule: #if you run out of actions, break last_time = 10.0 #some high value time so it is clear that this is not the right way to end break if not counting.goal: #if goal cleared (as should happen when you finish the task correctly and reach stop, break) break return np.repeat(np.array(1000 * last_time), size) # we return time in ms basic_model = Model() with basic_model: # Priors for unknown model parameters lf = Gamma('lf', alpha=2, beta=4) sigma = Uniform('sigma', lower=0.1, upper=50) #you can print searched values from every draw #lf_print = T.printing.Print('lf')(lf) #Deterministic value (RT in ms) established by the ACT-R model mu = model(lf) # Likelihood (sampling distribution) of observations Normal('Y_obs', mu=mu, sd=sigma, observed=Y) #Metropolis algorithm for steps in simulation step = Metropolis(basic_model.vars)
N_GROUPS = comm.Get_size( ) - 1 #Groups used for simulation - one less than used cores if rank == 0: #master print("CHAIN ", CHAIN) print("DRAWS", NDRAWS) print("How many sentences used?", n_sentences) basic_model = Model() #Below we specify the Bayesian model with basic_model: #Priors le = HalfNormal('le', sd=0.5, testval=abs(np.random.randn()) / 2) lf = Gamma('lf', alpha=1, beta=5, testval=abs(np.random.randn() / 4)) #emvt = Gamma('emvt', alpha=1, beta=3, testval=abs(np.random.randn())) emap = HalfNormal('emap', sd=1.0, testval=abs(np.random.randn() / 2)) intercept = Normal('intercept', mu=50, sd=25) sigma = HalfNormal('sigma', sd=20) # Expected value of outcome mu = intercept + model(lf, le, emap, intercept, sigma) # Likelihood (sampling distribution) of observations Normal('Y_obs', mu=mu, sd=50, observed=Y) step = Metropolis(basic_model.vars)
T=T.as_matrix() T= T.flatten() size= len(Y) #TRANSFORM FROM DATAFRAME TO NP ARRAY FORMAT # Specifing the parameters that control the MCMC (these will be used throughout the code). basic_model_GCR = Model() with basic_model_GCR: #priors for unknown model parameters c = Gamma('c',1,10) Tm= Uniform('Tm',25,45) T0= Uniform('T0',0,24) tau= Gamma('tau',0.0001, 0.0001) mu_temp= c*T*((T-T0)*(T0<T))*np.sqrt((Tm-T)*(Tm>T)) mu= 0*(mu_temp<0) + mu_temp*(mu_temp>0) Y_obs = Normal('Y_obs',mu=mu, sd=tau, observed= Y) from pymc3 import Metropolis, sample, find_MAP from scipy import optimize with basic_model_GCR:
else: testval_lf = past_simulations['lf'].iloc[-1] testval_rf = past_simulations['rf'].iloc[-1] testval_le = past_simulations['le'].iloc[-1] testval_weight = past_simulations['weight'].iloc[-1] testval_std = past_simulations['std'].iloc[-1] # the model starts here parser_with_bayes = pm.Model() with parser_with_bayes: # prior for activation #decay = Uniform('decay', lower=0, upper=1) #currently, ignored because it leads to problems in sampling # priors for latency std = Uniform('std', lower=1,upper=50, testval=testval_std) lf = Gamma('lf', alpha=2, beta=20, testval=testval_lf) # to get le = Gamma('le', alpha=2,beta=4, testval=testval_le) rf = Gamma('rf', alpha=2,beta=30, testval=testval_rf) weight = Uniform('weight', lower=1,upper=100, testval=testval_weight) # latency likelihood -- this is where pyactr is used pyactr_rt = actrmodel_latency(lf, le, rf, weight) subj_mu_rt = Deterministic('subj_mu_rt', pyactr_rt[0]) subj_rt_observed = Normal('subj_rt_observed', mu=subj_mu_rt, sd=std, observed=subj_extraction['rt']) obj_mu_rt = Deterministic('obj_mu_rt', pyactr_rt[1]) obj_rt_observed = Normal('obj_rt_observed', mu=obj_mu_rt, sd=std, observed=obj_extraction['rt']) step = Metropolis() db = Text('gg_6words_final_chain' + str(CHAIN)) trace = sample(draws=NDRAWS, trace=db, chains=1, step=step, init='auto', tune=1) posterior_checks_subj = pd.DataFrame.from_records(posterior_checks['subj_rt_observed']) posterior_checks_obj = pd.DataFrame.from_records(posterior_checks['obj_rt_observed'])
def test_normal_mixture_nd(self, nd, ncomp): nd = to_tuple(nd) ncomp = int(ncomp) comp_shape = nd + (ncomp, ) test_mus = np.random.randn(*comp_shape) test_taus = np.random.gamma(1, 1, size=comp_shape) observed = generate_normal_mixture_data(w=np.ones(ncomp) / ncomp, mu=test_mus, sd=1 / np.sqrt(test_taus), size=10) with Model() as model0: mus = Normal("mus", shape=comp_shape) taus = Gamma("taus", alpha=1, beta=1, shape=comp_shape) ws = Dirichlet("ws", np.ones(ncomp), shape=(ncomp, )) mixture0 = NormalMixture("m", w=ws, mu=mus, tau=taus, shape=nd, comp_shape=comp_shape) obs0 = NormalMixture("obs", w=ws, mu=mus, tau=taus, shape=nd, comp_shape=comp_shape, observed=observed) with Model() as model1: mus = Normal("mus", shape=comp_shape) taus = Gamma("taus", alpha=1, beta=1, shape=comp_shape) ws = Dirichlet("ws", np.ones(ncomp), shape=(ncomp, )) comp_dist = [ Normal.dist(mu=mus[..., i], tau=taus[..., i], shape=nd) for i in range(ncomp) ] mixture1 = Mixture("m", w=ws, comp_dists=comp_dist, shape=nd) obs1 = Mixture("obs", w=ws, comp_dists=comp_dist, shape=nd, observed=observed) with Model() as model2: # Expected to fail if comp_shape is not provided, # nd is multidim and it does not broadcast with ncomp. If by chance # it does broadcast, an error is raised if the mixture is given # observed data. # Furthermore, the Mixture will also raise errors when the observed # data is multidimensional but it does not broadcast well with # comp_dists. mus = Normal("mus", shape=comp_shape) taus = Gamma("taus", alpha=1, beta=1, shape=comp_shape) ws = Dirichlet("ws", np.ones(ncomp), shape=(ncomp, )) if len(nd) > 1: if nd[-1] != ncomp: with pytest.raises(ValueError): NormalMixture("m", w=ws, mu=mus, tau=taus, shape=nd) mixture2 = None else: mixture2 = NormalMixture("m", w=ws, mu=mus, tau=taus, shape=nd) else: mixture2 = NormalMixture("m", w=ws, mu=mus, tau=taus, shape=nd) observed_fails = False if len(nd) >= 1 and nd != (1, ): try: np.broadcast(np.empty(comp_shape), observed) except Exception: observed_fails = True if observed_fails: with pytest.raises(ValueError): NormalMixture("obs", w=ws, mu=mus, tau=taus, shape=nd, observed=observed) obs2 = None else: obs2 = NormalMixture("obs", w=ws, mu=mus, tau=taus, shape=nd, observed=observed) testpoint = model0.test_point testpoint["mus"] = test_mus testpoint["taus"] = test_taus assert_allclose(model0.logp(testpoint), model1.logp(testpoint)) assert_allclose(mixture0.logp(testpoint), mixture1.logp(testpoint)) assert_allclose(obs0.logp(testpoint), obs1.logp(testpoint)) if mixture2 is not None and obs2 is not None: assert_allclose(model0.logp(testpoint), model2.logp(testpoint)) if mixture2 is not None: assert_allclose(mixture0.logp(testpoint), mixture2.logp(testpoint)) if obs2 is not None: assert_allclose(obs0.logp(testpoint), obs2.logp(testpoint))
T=T.as_matrix() T= T.flatten() size= len(Y) #TRANSFORM FROM DATAFRAME TO NP ARRAY FORMAT # Specifing the parameters that control the MCMC (these will be used throughout the code). basic_model = Model() with basic_model: #priors for unknown model parameters c = Gamma('c',10,1) Tm= Uniform('Tm',31,45) T0= Uniform('T0',5,24) tau= Gamma('tau',0.0001, 0.0001) mu_temp= c*T*((T-T0)*(T0<T))*np.sqrt((Tm-T)*(Tm>T)) mu= 0*(mu_temp<0) + mu_temp*(mu_temp>0) Y_obs = Normal('Y_obs',mu=mu, sd=tau, observed= Y) from pymc3 import Metropolis, sample, find_MAP from scipy import optimize trace_copy= {} with basic_model:
pathways, features, path_dict, reverse_path_dict, evidence, metfrag_evidence = data for c, v in evidence.items(): print(c, v) for c, v in metfrag_evidence.items(): print(c, v) print("num_pathways:", len(pathways)) print("num_features:", len(features)) print("num_evidence:", len(evidence)) print("num_metfrag: ", len(metfrag_evidence)) rate_prior = 0.5 import theano.tensor as T #eps = Beta('eps', 0.005, 1) model = Model() with model: eps = 0.0001 ap = {p: Gamma('p_' + p, rate_prior, 1) for p in pathways} bmp = { p: { feat: Gamma('b_{' + p + ',' + feat + '}', ap[p], 1) for feat in path_dict[p] } for p in pathways } y_bmp = {} g = {} def logp_f(f, b, eps): if f in evidence: return T.log(1 - math.e**(-1 * b) + epsilon) if f in metfrag_evidence: a_p = (1.0 / (1 - metfrag_evidence[f])) - 1
testval_le = past_simulations['le'].iloc[-1] testval_threshold = past_simulations['threshold'].iloc[-1] testval_emma_prep_time = past_simulations['emma_prep_time'].iloc[-1] testval_prob_regression = past_simulations['prob_regression'].iloc[-1] testval_std = past_simulations['std'].iloc[-1] # here the model starts parser_with_bayes = pm.Model() with parser_with_bayes: # prior for activation #decay = Uniform('decay', lower=0, upper=1) #currently, ignored because it leads to problems in sampling # priors for latency std = Uniform('std', lower=1, upper=60, testval=testval_std) lf = Gamma('lf', alpha=2, beta=20, testval=testval_lf) le = Gamma('le', alpha=2, beta=4, testval=testval_le) threshold = Normal('threshold', mu=0, sd=10, testval=testval_threshold) emma_prep_time = Gamma('emma_prep_time', alpha=4, beta=30, testval=testval_emma_prep_time) prob_regression = Uniform('prob_regression', lower=0.01, upper=0.5, testval=testval_prob_regression) # latency likelihood -- this is where pyactr is used pyactr_rt = actrmodel_latency(lf, le, emma_prep_time, prob_regression, threshold) #RTs mu_rt = Deterministic('mu_rt', pyactr_rt[0])