def new_player(name, sink=0.5, foul=1e-10): player = {} player['sink'] = pm.Beta(name + "_sink", alpha=3, beta=3, value=sink) player['foul_end'] = pm.Beta(name + "_foul_end", alpha=3, beta=3, value=foul) vars = player.values() player['balance'] = pm.Potential(logp = sum_less_than_one, name = name + "_balance", parents = {'vars': vars}, doc = name + "_balance") return player
def make_model(data): switchpoint = pm.DiscreteUniform('switchpoint', 0, len(data)) early_rate = pm.Beta('early_rate', 0.5, 0.5) late_rate = pm.Beta('late_rate', 0.5, 0.5) @pm.deterministic(plot=False) def rate(s=switchpoint, early=early_rate, late=late_rate): out = np.empty(len(data)) out[:s] = early out[s:] = late return out phredscore = pm.Bernoulli('phredscore', p=rate, value=data, observed=True) return locals()
def binomial_model(): n_samples = 100 xs = intX(np.random.binomial(n=1, p=0.2, size=n_samples)) with pm.Model() as model: p = pm.Beta("p", alpha=1, beta=1) pm.Binomial("xs", n=1, p=p, observed=xs) return model
def make_bernoulli(name, value=None, N=None, return_coeffs=False, fixed={}): """ creates a Bernoulli random variable with a uniform parent :param name: name of the variable :param value: optional - list of observed values of the variable. May be a masked array - if the variable has missing values :param N: size of the variable (number of values). Either N or value must be specified :param return_coeffs: if true, will return the parent Beta variable as well as the bernoulli child. False by defaut. :param fixed: optional dictionary of values of coefficients to be fixed. :return: Bernoulli pymc random variable, or (if return_coeffs == True) a tuple (bernoulli variable, a list with a single element - the Beta parent of the bernoulli) """ if value is None and N is None: raise ValueError('either "value" or "N" must be specified') if value is not None: value = mask_missing(value) parent_name = COEFFS_PREFIX + 'p(%s)' % name parent = fixed.get(parent_name, pymc.Beta(parent_name, 1, 1)) if value is None: child = pymc.Bernoulli(name, p=parent, value=np.zeros(N)) else: child = pymc.Bernoulli(name, p=parent, observed=True, value=value) set_levels_count(child, 2) if return_coeffs: return child, [parent] else: return child
def beta_binom(name, pi, p, n): """ Generate PyMC objects for a beta-binomial model :Parameters: - `name` : str - `pi` : pymc.Node, expected values of rates - `p` : array, observed values of rates - `n` : array, effective sample sizes of rates :Results: - Returns dict of PyMC objects, including 'p_obs' and 'p_pred' the observed stochastic likelihood and data predicted stochastic """ assert pl.all(p >= 0), 'observed values must be non-negative' assert pl.all(n >= 0), 'effective sample size must non-negative' p_n = mc.Uniform('p_n_%s'%name, lower=1.e4, upper=1.e9, value=1.e4) # convergence requires getting these bounds right pi_latent = [mc.Beta('pi_latent_%s_%d'%(name,i), pi[i]*p_n, (1-pi[i])*p_n, value=pi_i) for i, pi_i in enumerate(pi.value)] i_nonzero = (n!=0.) @mc.observed(name='p_obs_%s'%name) def p_obs(value=p, pi=pi_latent, n=n): pi_flat = pl.array(pi) return mc.binomial_like((value*n)[i_nonzero], n[i_nonzero], pi_flat[i_nonzero]) # for any observation with n=0, make predictions for n=1.e6, to use for predictive validity n_nonzero = pl.array(n.copy(), dtype=int) n_nonzero[n==0] = 1.e6 @mc.deterministic(name='p_pred_%s'%name) def p_pred(pi=pi_latent, n=n_nonzero): return mc.rbinomial(n, pi) / (1.*n) return dict(p_n=p_n, pi_latent=pi_latent, p_obs=p_obs, p_pred=p_pred)
def test_multivariate_observations(self): coords = {"direction": ["x", "y", "z"], "experiment": np.arange(20)} data = np.random.multinomial(20, [0.2, 0.3, 0.5], size=20) with pm.Model(coords=coords): p = pm.Beta("p", 1, 1, size=(3, )) pm.Multinomial("y", 20, p, dims=("experiment", "direction"), observed=data) idata = pm.sample(draws=50, chains=2, tune=100, return_inferencedata=True) test_dict = { "posterior": ["p"], "sample_stats": ["lp"], "log_likelihood": ["y"], "observed_data": ["y"], } fails = check_multiple_attrs(test_dict, idata) assert not fails assert "direction" not in idata.log_likelihood.dims assert "direction" in idata.observed_data.dims assert idata.log_likelihood["y"].shape == (2, 50, 20)
def getModel(): nA, nB, nK = 5, 2, 10; B = pm.Beta('1-Beta', alpha=nA/nK, beta=nB*(nK-1)/nK); #@UndefinedVariable # p_B = pm.Lambda('p_Bern', lambda b=B: np.where(b==0, 0.9, 0.1), doc='Pr[Bern|Beta]'); C = pm.Categorical('2-Cat', [1-B, B]); #@UndefinedVariable # C = pm.Categorical('1-Cat', [0.2, 0.4, 0.1, 0.3], observed=True, value=3); #@UndefinedVariable return pm.Model([B,C]);
def yield_models(dataframe): bin_ids = dataframe.distance_bin.unique() for bin_id in bin_ids: assert isinstance(bin_id, int) # get our distance binned r^2 d in a nice dataframe data = dataframe.query( "(distance_bin == {bin_id})".format(bin_id=bin_id)) # generate names for stocastics alpha_name = "{bin_id}_alpha".format(bin_id=bin_id) beta_name = "{bin_id}_beta".format(bin_id=bin_id) r2_dist_name = "{bin_id}_r2_distribution_beta".format(bin_id=bin_id) # set priors for parameters alpha_of_beta = mc.Uniform(alpha_name, 0.01, 10) beta_of_beta = mc.Uniform(beta_name, 0.01, 10) # set the d r2_distribution_beta = mc.Beta(name=r2_dist_name, alpha=alpha_of_beta, beta=beta_of_beta, value=data.R2_scaled_for_B.dropna(), observed=True, verbose=0) # create and yield the model object tagged with its bin_id model = mc.Model([r2_distribution_beta, alpha_of_beta, beta_of_beta]) model.bin_id_tag = bin_id model.MCMC_run = None # allow us to know how many times we had to do the experiments rather than MAP yield model
def simple_2model_continuous(): mu = -2.1 tau = 1.3 with Model() as model: x = pm.Normal("x", mu, tau=tau, initval=0.1) pm.Deterministic("logx", at.log(x)) pm.Beta("y", alpha=1, beta=1, size=2) return model.compute_initial_point(), model
def test_zeroinflatedpoisson(self): with pm.Model(): theta = pm.Beta("theta", alpha=1, beta=1) psi = pm.HalfNormal("psi", sd=1) pm.ZeroInflatedPoisson("suppliers", psi=psi, theta=theta, size=20) gen_data = pm.sample_prior_predictive(samples=5000) assert gen_data.prior["theta"].shape == (1, 5000) assert gen_data.prior["psi"].shape == (1, 5000) assert gen_data.prior["suppliers"].shape == (1, 5000, 20)
def getModel(): nA, nB, nK, nT = 5, 2, 10, 10 # @UnusedVariable nW = np.linspace(1, 9, nT) # B = pm.Beta('1-Beta', alpha=[nA/nK]*nT, beta=[nB*(nK-1)/nK]*nT); #@UndefinedVariable B = pm.Beta('1-Beta', alpha=nW, beta=[nB * (nK - 1) / nK] * nT) #@UndefinedVariable # Bern = pm.Bernoulli('2-Bern', np.linspace(0.1,0.9,nT)); #@UndefinedVariable return pm.Model([B])
def indep_samples(x1,n1,x2,n2): class experimental_data(object): def __init__(self,x1,n1,x2,n2): self.data1 = np.hstack( (np.ones((x1,)) , np.zeros((n1-x1,))) ) self.data2 = np.hstack( (np.ones((x2,)) , np.zeros((n2-x2,))) ) ### for testing purposes #example = True data = experimental_data(x1,n1,x2,n2) #if example: # example_data1 = np.hstack( (np.ones((15,)) , np.zeros((20,))) ) # example_data2 = np.hstack( (np.ones((16,)) , np.zeros((23,))) ) # sim_data_size = 14 # data1 = example_data1 # data2 = example_data2 p1_val = np.mean(data.data1) p2_val = np.mean(data.data2) ind_val = p1_val+p2_val-p1_val*p2_val print "P1 = " + str(p1_val) print "P2 = " + str(p2_val) print "Independence = " + str(ind_val) p1 = pymc.Beta('p1',alpha=0.5,beta=0.5) p2 = pymc.Beta('p2',alpha=0.5,beta=0.5) x1 = pymc.Binomial('x',n=len(data.data1),p=p1,value=np.sum(data.data1),observed=True) x2 = pymc.Binomial('x',n=len(data.data2),p=p2,value=np.sum(data.data2),observed=True) @pymc.deterministic def ind_assump(p1=p1,p2=p2): return p1+p2-p1*p2 return locals() #@pymc.deterministic #def sim(): # sim_data = pymc.Binomial('sim',n=sim_data_size, p=ind_assump) # return sim_data
def test_transformed(self): n = 18 at_bats = 45 * np.ones(n, dtype=int) hits = np.random.randint(1, 40, size=n, dtype=int) draws = 50 with pm.Model() as model: phi = pm.Beta("phi", alpha=1.0, beta=1.0) kappa_log = pm.Exponential("logkappa", lam=5.0) kappa = pm.Deterministic("kappa", at.exp(kappa_log)) thetas = pm.Beta("thetas", alpha=phi * kappa, beta=(1.0 - phi) * kappa, size=n) y = pm.Binomial("y", n=at_bats, p=thetas, observed=hits) gen = pm.sample_prior_predictive(draws) assert gen.prior["phi"].shape == (1, draws) assert gen.prior_predictive["y"].shape == (1, draws, n) assert "thetas" in gen.prior.data_vars
def HRBayes(pa, hr, alpha, beta): hrpg = np.zeros(pa) hrpg[:hr] = 1 phr = pm.Beta("phr", alpha, beta) obshr = pm.Bernoulli("obshr", phr, value=hrpg, observed=True) mcmc = pm.MCMC([phr, obshr]) mcmc.sample(20000, 7000) sumstats = mcmc.stats() loint = sumstats['phr']['95% HPD interval'][0] hiint = sumstats['phr']['95% HPD interval'][1] hr_trace = mcmc.trace('phr')[:] hr_trace = [x for x in hr_trace if (x > loint) and (x < hiint)] return hr_trace
def getModel(): B = pm.Beta('1-Beta', alpha=1.2, beta=5) #@UndefinedVariable # p_B = pm.Lambda('p_Bern', lambda b=B: np.where(b==0, 0.9, 0.1), doc='Pr[Bern|Beta]'); C = pm.Categorical('2-Cat', [1 - B, B]) #@UndefinedVariable # C = pm.Categorical('1-Cat', [0.2, 0.4, 0.1, 0.3], observed=True, value=3); #@UndefinedVariable p_N = pm.Lambda('p_Norm', lambda n=C: np.where(n == 0, 0, 5), doc='Pr[Norm|Cat]') N = pm.Normal('3-Norm', mu=p_N, tau=1) #@UndefinedVariable # N = pm.Normal('2-Norm', mu=p_N, tau=1, observed=True, value=2.5); #@UndefinedVariable return pm.Model([B, C, N])
def test_aesara_switch_broadcast_edge_cases_1(self): # Tests against two subtle issues related to a previous bug in Theano # where `tt.switch` would not always broadcast tensors with single # values https://github.com/pymc-devs/aesara/issues/270 # Known issue 1: https://github.com/pymc-devs/pymc/issues/4389 data = pm.floatX(np.zeros(10)) with pm.Model() as m: p = pm.Beta("p", 1, 1) obs = pm.Bernoulli("obs", p=p, observed=data) npt.assert_allclose( logpt_sum(obs).eval({p.tag.value_var: pm.floatX(np.array(0.0))}), np.log(0.5) * 10, )
def getModel(): nA, nB, nK, nT = 5, 2, 10, 10 # @UnusedVariable nW = np.linspace(1, 9, nT) # B = pm.Beta('Beta', alpha=[nA/nK]*nT, beta=[nB*(nK-1)/nK]*nT); #@UndefinedVariable B = pm.Beta('Beta', alpha=nW, beta=[nB * (nK - 1) / nK] * nT) #@UndefinedVariable BernO = pm.Bernoulli('Bern_O1', B, observed=True, value=[0, 1, 1, 1, 1, 0, 1, 1, 1, 1]) #@UndefinedVariable @UnusedVariable # BernO2 = pm.Bernoulli('Bern_O2', B, observed=True, value=[1]*nT); #@UndefinedVariable @UnusedVariable Bern = pm.Bernoulli('Bern', B) #@UndefinedVariable return pm.Model([B, Bern])
def test_marginal_likelihood(self): data = np.repeat([1, 0], [50, 50]) marginals = [] a_prior_0, b_prior_0 = 1.0, 1.0 a_prior_1, b_prior_1 = 20.0, 20.0 for alpha, beta in ((a_prior_0, b_prior_0), (a_prior_1, b_prior_1)): with pm.Model() as model: a = pm.Beta("a", alpha, beta) y = pm.Bernoulli("y", a, observed=data) trace = pm.sample_smc(2000, return_inferencedata=False) marginals.append(trace.report.log_marginal_likelihood) # compare to the analytical result assert abs( np.exp(np.nanmean(marginals[1]) - np.nanmean(marginals[0])) - 4.0) <= 1
def yield_models(dataframe): bin_ids = dataframe.distance_bin.unique() with click.progressbar(bin_ids) as bin_ids: for bin_id in bin_ids: assert isinstance(bin_id, int) # get our distance binned r^2 d in a nice dataframe # then drop any rows with R2 == NANs data = dataframe.query( "(distance_bin == {bin_id})".format(bin_id=bin_id)) na_mask = data.R2.apply(lambda r2: not np.isnan(r2)) data = data[na_mask] # generate names for stocastics alpha_name = "{bin_id}_alpha".format(bin_id=bin_id) beta_name = "{bin_id}_beta".format(bin_id=bin_id) r2_dist_name = "{bin_id}_r2_distribution_beta".format( bin_id=bin_id) # set priors for parameters alpha_of_beta = mc.Uniform(alpha_name, 0.01, 10) beta_of_beta = mc.Uniform(beta_name, 0.01, 10) # set the d try: r2_distribution_beta = mc.Beta( name=r2_dist_name, alpha=alpha_of_beta, beta=beta_of_beta, value=data.R2_scaled_for_B.dropna(), observed=True, verbose=0) # create and yield the model object tagged with its bin_id model = mc.Model( [r2_distribution_beta, alpha_of_beta, beta_of_beta]) model.bin_id_tag = bin_id model.MCMC_run = None # allow us to know how many times we had to do the experiments rather than MAP except ValueError as exc: if "but got (0,)" in exc.message: yield munch.Munch(bin_id_tag=bin_id) yield model
def _fit_beta_distribution(data, n_iter): alpha_var = pm.Exponential('alpha', .5) beta_var = pm.Exponential('beta', .5) observations = pm.Beta('observations', alpha_var, beta_var, value=data, observed=True) model = pm.Model([alpha_var, beta_var, observations]) mcmc = pm.MCMC(model) mcmc.sample(n_iter) alphas = mcmc.trace('alpha')[:] betas = mcmc.trace('beta')[:] return alphas, betas
def get_Models(): #Full Model (Beta & Bernoulli) nA, nB = 2, 1 aD = [0, 1, 1] Beta = pm.Beta('Beta', alpha=nA, beta=nB) # @UndefinedVariable BernD = [ pm.Bernoulli('BernD_' + str(i), p=Beta, observed=True, value=aD[i]) for i in range(len(aD)) ] # @UndefinedVariable @UnusedVariable BernQ = pm.Bernoulli('BernQ', p=Beta) # @UndefinedVariable #Collapsed Model (Bernoulli) nA2 = nA + sum(aD) nB2 = nB + len(aD) - sum(aD) nP = nA2 / (nA2 + nB2) BernQ2 = pm.Bernoulli('BernQ_2', p=nP) # @UndefinedVariable return np.concatenate([[Beta, BernQ, BernQ2], BernD])
def test_shared(self): n1 = 10 obs = shared(np.random.rand(n1) < 0.5) draws = 50 with pm.Model() as m: p = pm.Beta("p", 1.0, 1.0) y = pm.Bernoulli("y", p, observed=obs) o = pm.Deterministic("o", obs) gen1 = pm.sample_prior_predictive(draws) assert gen1.prior["y"].shape == (1, draws, n1) assert gen1.prior["o"].shape == (1, draws, n1) n2 = 20 obs.set_value(np.random.rand(n2) < 0.5) with m: gen2 = pm.sample_prior_predictive(draws) assert gen2.prior["y"].shape == (1, draws, n2) assert gen2.prior["o"].shape == (1, draws, n2)
def test_marginal_likelihood(self): """ Verifies that the log marginal likelihood function can be correctly computed for a Beta-Bernoulli model. """ data = np.repeat([1, 0], [50, 50]) marginals = [] a_prior_0, b_prior_0 = 1.0, 1.0 a_prior_1, b_prior_1 = 20.0, 20.0 for alpha, beta in ((a_prior_0, b_prior_0), (a_prior_1, b_prior_1)): with pm.Model() as model: a = pm.Beta("a", alpha, beta) y = pm.Bernoulli("y", a, observed=data) trace = pm.sample_smc(2000, chains=2, return_inferencedata=False) # log_marignal_likelihood is found in the last value of each chain lml = np.mean([chain[-1] for chain in trace.report.log_marginal_likelihood]) marginals.append(lml) # compare to the analytical result assert abs(np.exp(marginals[1] - marginals[0]) - 4.0) <= 1
def get_Models(): #Full Model (Beta & Binomial) nN, nA, nB = 3, 5, 1 aD = [0, 3, 1] Beta = pm.Beta('Beta', alpha=nA, beta=nB) # @UndefinedVariable BinomD = [ pm.Binomial('BinomD_' + str(i), n=nN, p=Beta, observed=True, value=aD[i]) for i in range(len(aD)) ] # @UndefinedVariable @UnusedVariable BinomQ = pm.Binomial('BinomQ', n=nN, p=Beta) # @UndefinedVariable #Collapsed Model (Binomial) nA2 = nA + sum(aD) nB2 = nB + nN * len(aD) - sum(aD) BetaBinQ = pm.Betabin('BetaBinQ', n=nN, alpha=nA2, beta=nB2) # @UndefinedVariable return np.concatenate([[Beta, BinomQ, BetaBinQ], BinomD])
def run_Bernoulli_Normal(): aD = [0, 1, 2, 8, 9] nPts = len(aD) + 1 #Cluster 1 Uh1 = pm.Uniform('UnifH1', lower=-50, upper=50) # @UndefinedVariable Nc1 = pm.Normal('NormC1', mu=Uh1, tau=1) #, observed=True, value=10); # @UndefinedVariable #Cluster 2 Uh2 = pm.Uniform('UnifH2', lower=-50, upper=50) # @UndefinedVariable Nc2 = pm.Normal('NormC2', mu=Uh2, tau=1) #, observed=True, value=10); # @UndefinedVariable #Beta & Bernoulli Nodes Bet = pm.Beta('Beta', alpha=1, beta=1) # @UndefinedVariable aB = [pm.Bernoulli('Bern' + str(i), Bet) for i in range(nPts)] # @UndefinedVariable aL = [ pm.Lambda('p_Norm1' + str(i), lambda k=aB[i], c1=Nc1, c2=Nc2: [c1, c2][int(k)]) for i in range(nPts) ] # @UndefinedVariable #Points aN = [ pm.Normal('NormX' + str(i), mu=aL[i], tau=1, observed=True, value=aD[i]) for i in range(nPts - 1) ] # @UndefinedVariable Nz = pm.Normal('NormZ', mu=aL[-1], tau=1) # @UndefinedVariable return np.concatenate([[Nz, Nc1, Nc2, Uh1, Uh2, Bet], aB, aN])
ax.hist(thetas[G1:], bins=50, normed=True) # Plot analytic posterior X = np.linspace(0,1, 1000) ax.plot(X, stats.beta(a1_hat, a2_hat).pdf(X), "r") # Plot prior ax.plot(X, stats.beta(a1, a2).pdf(X), "g") # Cleanup ax.set(title="Metropolis-Hastings via Cython (1,000,000 Draws; 100,000 Burned)", ylim=(0,12)) ax.legend(["Posterior (Analytic)", "Prior", "Posterior Draws (MH)"]) # Metropolis-Hastings using PyMC print("iming: 1 loops, best of 3: 590 ms per loop") pymc_theta = pymc.Beta('pymc_theta', a1, a2, value=0.5) pymc_Y = pymc.Bernoulli('pymc_Y', p=pymc_theta, value=Y, observed=True) model = pymc.MCMC([pymc_theta, pymc_Y]) model.sample(iter=G+G1, burn=G1, progress_bar=False) model.summary() thetas = model.trace("pymc_theta")[:] # Posterior Mean # (use all of `thetas` b/c PyMC already removed the burn-in runs here) print"Posterior Mean (MH):", np.mean(thetas)) # Plot the posterior fig = plt.figure(figsize=(10,4)) ax = fig.add_subplot(111) # Plot MH draws
means = np.array(zip(*means)).clip(0.001) variances = np.array(zip(*variances)) #.clip(0.001) transitions = np.array(zip(*transitions)) totals = np.sum(transitions, axis=2)[:, :, np.newaxis] transitions = (transitions / totals)[:, :, :n_states - 1] mean_params = [ pymc.Gamma('mean_param{}'.format(i), alpha=1, beta=.1) for i in range(n_states * 2) ] var_params = [ pymc.Gamma('var_param{}'.format(i), alpha=1, beta=.1) for i in range(n_states * 2) ] trans_params = [ pymc.Beta('trans_params{}'.format(i), alpha=1, beta=1) for i in range(n_states**2) ] mean_obs = [] mean_pred = [] var_obs = [] var_pred = [] trans_obs = [] trans_pred = [] for i in xrange(n_states): alpha = mean_params[i * 2] beta = mean_params[i * 2 + 1] mean_obs.append( pymc.Gamma("mean_obs{}".format(i),
def get_Bayes(measurements=[], chunksize=5, Ndp=5, iter=50000, burn=5000): sc = pymc.Uniform('sc', 0.1, 2.0, value=0.24) tau = pymc.Uniform('tau', 0.0, 1.0, value=0.5) concinit = 1.0 conclo = 0.1 conchi = 10.0 concentration = pymc.Uniform('concentration', lower=conclo, upper=conchi, value=concinit) # The stick-breaking construction: requires Ndp beta draws dependent on the # concentration, before the probability mass function is actually constructed. #betas = pymc.Beta('betas', alpha=1, beta=concentration, size=Ndp) betas = pymc.Beta('betas', alpha=1, beta=1, size=Ndp - 1) @pymc.deterministic def pmf(betas=betas): "Construct a probability mass function for the truncated Dirichlet process" # prod = lambda x: np.exp(np.sum(np.log(x))) # Slow but more accurate(?) prod = np.prod value = map(lambda i, u: u * prod(1.0 - betas[:i]), enumerate(betas)) value.append(1.0 - sum(value[:])) # force value to sum to 1 return value # The cluster assignments: each data point's estimated cluster ID. # Remove idinit to allow clusterid to be randomly initialized: Ndata = len(measurements) idinit = np.zeros(Ndata, dtype=np.int64) clusterid = pymc.Categorical('clusterid', p=pmf, size=Ndata, value=idinit) @pymc.deterministic(name='clustermean') def clustermean(clusterid=clusterid, sc=sc, Ndp=Ndp): return sc * np.arange(1, Ndp + 1)[clusterid] @pymc.deterministic(name='clusterprec') def clusterprec(clusterid=clusterid, sc=sc, tau=tau, Ndp=Ndp): return 1.0 / (sc * sc * tau * tau * (np.arange(1, Ndp + 1)[clusterid])) y = pymc.Normal('y', mu=clustermean, tau=clusterprec, observed=True, value=measurements) ## for predictive poeterior simulation @pymc.deterministic(name='y_sim') def y_sim(value=[0], sc=sc, tau=tau, clusterid=clusterid, Ndp=Ndp): n = np.arange(1, Ndp + 1)[np.random.choice(clusterid)] return np.random.normal(loc=sc * n, scale=sc * tau * n) m = pymc.Model({ "scale": sc, "tau": tau, "betas": betas, "clusterid": clusterid, "normal": y, "pred": y_sim }) sc_samples = [] modes = [] simulations = [] for i in range(0, chunksize): mc = pymc.MCMC(m) mc.sample(iter=50000, burn=10000) plot(mc) sc_sample = mc.trace('sc')[:] sc_samples.append(sc_sample) simulation = mc.trace('y_sim')[:] simulations.append(simulation) plt.hist(measurements, 50, fc='gray', histtype='stepfilled', alpha=0.3, normed=False) plt.hist(simulation, 30, fc='blue', histtype='stepfilled', alpha=0.3, normed=True) hist, edges = np.histogram( measurements, bins=100, range=[np.min(measurements) - 0.25, np.max(measurements) + 0.25]) argm = hist.argmax() (edges[argm] + edges[argm + 1]) / 2 modes.append((edges[argm] + edges[argm + 1]) / 2) if chunksize <= 1: gr = np.nan else: pymc.gelman_rubin(sc_samples) dic = { 'gelman_rubin': gr, 'modes': modes, 'simulations': simulations, 'sc_samples': sc_samples } return dic
import pymc as pm import numpy as np # True parameter values mu_true = 5 psi_true = 0.75 n = 100 # Simulate some data data = np.array( [pm.rpoisson(mu_true) * (np.random.random() < psi_true) for i in range(n)]) # Uniorm prior on Poisson mean mu = pm.Uniform('mu', 0, 20) # Beta prior on psi psi = pm.Beta('psi', alpha=1, beta=1) @pm.observed(dtype=int, plot=False) def zip(value=data, mu=mu, psi=psi): """ ZIP likelihood """ # Initialise likeihood like = 0.0 # Loop over data for x in value: if not x: # Zero values
# model, and present a few possible work arounds. import pymc as mc # We define a simple model of a survey with one data point. We use a $Beta$ # distribution for the $p$ parameter in a binomial. We would like to know both # the posterior distribution for p, as well as the predictive posterior # distribution over the survey parameter. alpha = 4 beta = 4 n = 20 yes = 15 with mc.Model() as model: p = mc.Beta('p', alpha, beta) surv_sim = mc.Binomial('surv_sim', n=n, p=p) surv = mc.Binomial('surv', n=n, p=p, observed=yes) # First let's try and use `find_MAP`. with model: print(mc.find_MAP()) # `find_map` defaults to find the MAP for only the continuous variables we have # to specify if we would like to use the discrete variables. with model: print(mc.find_MAP(vars=model.vars, disp=True)) # We set the `disp` variable to display a warning that we are using a