alpha[k] ~ dnorm(0, 0.0001) a[k] <- alpha[k] - mean(alpha[]) } beta ~ dflat()T(0, ) } """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dbern_llf, dflat_llf, ilogit # data: N=1000, R=32, T=5, culm[R], response[R,T] vars = "N,R,T,culm,response".split(',') _, data = load('../examples/Lsatdata.txt') N, R, T, culm, response = (data[p] for p in vars) # init: alpha[T], beta, theta[N] pars = "alpha,beta,theta".split(',') _, init = load('../examples/Lsatinits.txt') init["theta"] = np.zeros(N) p0, labels = define_pars(init, pars) def pre(): r = np.empty((N, T)) for i in range(R): if i == 0: r[:culm[0], :] = response[i] else: r[culm[i - 1]:culm[i]] = response[i]
theta[i] ~ dgamma(alpha, beta) lambda[i] <- theta[i] * t[i] x[i] ~ dpois(lambda[i]) } alpha ~ dexp(1) beta ~ dgamma(0.1, 1.0) } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dbin_llf, dnorm_llf, dgamma_llf, ilogit # data: N=21, r[N], n[N], x1[N], x2[N] vars = "r,n,x1,x2,N".split(',') _, data = load('../examples/Seedsdata.txt') r, n, x1, x2, N = (data[p] for p in vars) # init: alpha0, alpha1, alpha2, alpha12, tau pars = "alpha0,alpha1,alpha2,alpha12,tau,b".split(',') _, init = load('../examples/Seedsinits.txt') # implicit parameter b initialized to zero init['b'] = np.zeros(N) p0, labels = define_pars(init, pars) def nllf(p): alpha0, alpha1, alpha2, alpha12, tau = p[:5] b = p[5:] p = ilogit(alpha0 + alpha1 * x1 + alpha2 * x2 + alpha12 * x1 * x2 + b)
dL0.star[j] <- r * (t[j+1]-t[j]) } beta ~ dnorm(0.0,0.000001) } """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dpois_llf, dgamma_llf, step # data: N=42, T=17, eps, Npairs=21, t[Npairs], obs.t[N], pair[2*Npair], fail[T], Z[N] vars = "N,T,eps,Npairs,t,obs.t,pair,fail,Z".split(',') _, data = load('../examples/Leukfrdata.txt') N, T, eps, Npairs, t, obs_t, pair, fail, Z = (data[p] for p in vars) # init: beta, dL0[T] pars = "beta,tau,dL0,b".split(',') _, init = load('../examples/Leukfrinits.txt') init["b"] = np.zeros(Npairs) p0, labels = define_pars(init, pars) # constants c = 0.001 r = 0.1 dL0_star = r * np.diff(t) mu = dL0_star * c def nllf(p):
theta[i] ~ dgamma(alpha, beta) lambda[i] <- theta[i] * t[i] x[i] ~ dpois(lambda[i]) } alpha ~ dexp(1) beta ~ dgamma(0.1, 1.0) } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dbern_llf # data: Dogs=30, Trials=25, Y[Dogs,Trials] vars = "Dogs,Trials,Y".split(',') _, data = load('../examples/Dogsdata.txt') Dogs, Trials, Y = (data[p] for p in vars) # init: alpha, beta pars = "alpha,beta".split(',') _, init = load('../examples/Dogsinits.txt') p0, labels = define_pars(init, pars) def pre(): y = 1 - Y xa = np.empty(Y.shape) xs = np.empty(Y.shape) for i in range(Dogs): xa[i, 0] = 0 xs[i, 0] = 0 for j in range(1, Trials):
mu ~ dnorm(0.0, 1.0E-6) phi ~ dnorm(0.0, 1.0E-6) pi ~ dnorm(0.0, 1.0E-6) theta <- exp(phi) equiv <- step(theta - 0.8) - step(theta - 1.2) } """ from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, step # data: N=10, P=2, group[N], Y[N,P], sign[2] vars = "N,P,group,Y,sign".split(',') _, data = load('../examples/Equivdata.txt') N, P, group, Y, sign = (data[p] for p in vars) # init: alpha, beta, gamma, tau pars = "mu,phi,pi,tau1,tau2,delta".split(',') _, init = load('../examples/Equivinits.txt') init["delta"] = np.zeros(N) p0, labels = define_pars(init, pars) def pre(): k = np.arange(1.0, P + 1) T = group[:, None] * (k[None, :] - 1.5) + 1.5 k = np.asarray(k, 'i') T = np.asarray(T, 'i') sign_k = sign[k - 1] sign_T = sign[T - 1]
beta2 ~ dnorm(0.0, 1.0E-6) tau ~ dgamma(1.0E-3, 1.0E-3) sigma <- 1 / sqrt(tau) } """ #raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dbin_llf, ilogit # data: K=120, r1[K], n1[K], r0[K], n0[K], year[K] vars = "r1,n1,r0,n0,year,K".split(',') _, data = load('../examples/Oxforddata.txt') r1, n1, r0, n0, year, K = (data[p] for p in vars) # init: alpha, beta1, beta2, tau, mu[K], b[K] pars = "alpha,beta1,beta2,tau,mu,b".split(',') _, init = load('../examples/Oxfordinits.txt') p0, labels = define_pars(init, pars) def nllf(p): alpha, beta1, beta2, tau = p[:4] mu, b = p[4:4 + K], p[4 + K:] # median values from fit #alpha, beta1, beta2, tau = 0.5793, -0.0457, 0.007004, 1/0.08059**2 logPsi = alpha + beta1 * year + beta2 * (year * year - 22) + b
model { for( i in 1 : N ) { p[i] ~ dbeta(1.0, 1.0) r[i] ~ dbin(p[i], n[i]) } } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dbin_llf, dbeta_llf # data: N=12, n[N], r[N] vars = "n,r,N".split(',') _, data = load('../examples/Surgicaldata.txt') n, r, N = (data[p] for p in vars) # init: p[N] pars = "p".split(',') _, init = load('../examples/Surgicalinits.txt') p0, labels = define_pars(init, pars) def nllf(p): cost = 0 cost += np.sum(dbeta_llf(p, 1.0, 1.0)) cost += np.sum(dbin_llf(r, p, n)) return -cost
y[j] ~ dbin(p[j], n[j]) logit(p[j]) <- theta[1] + theta[2] * X[j] X[j] ~ dnorm(mu[j], tau) mu[j] <- alpha + beta * Z[j] } theta[1] ~ dnorm(0.0, 0.001) theta[2] ~ dnorm(0.0, 0.001) } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dbin_llf, dnorm_llf, logit, inverse # J=3, y[J], n[J], Z[J], tau, alpha, beta _, data = load('../examples/Airdata.txt') # J = data["J"] # theta[2], X[J] _, init = load('../examples/Airinits.txt') p0, labels = define_pars(init, ("theta", "X")) def nllf(pars): theta, X = pars[0:2], pars[2:] p = np.array([inverse[logit](theta[0] + theta[1] * Xj) for Xj in X]) mu = data["alpha"] + data["beta"] * data["Z"] cost = 0 cost += np.sum(dbin_llf(data["y"], p, data["n"])) cost += np.sum(dnorm_llf(X, mu, data["tau"])) cost += dnorm_llf(theta[0], 0.0, 0.001) cost += dnorm_llf(theta[1], 0.0, 0.001)
} """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") import sys import numpy as np from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dcat_llf, ilogit # data: N=286, T=2, G=2, Npattern=16, Ncut=3, # pattern[Npattern,T], Ncum[Npattern,G], # treat[G,T], period[G,T], carry[G,T] #_, data = load('../examples/Inhalersdata.txt') globals().update(load('../examples/Inhalersdata.txt')[1]) # inits: beta, pi, kappa, a[Ncut], tau _, init = load('../examples/Inhalersinits.txt') pars = ["beta", "pi", "kappa", "tau", "a"] #init["b"] = np.zeros(N); pars.append("b") p0, labels = define_pars(init, pars) def pre(): # Note: change to 0-origin indices for i and k and for group group = np.empty(N, 'i') response = np.empty((N, T), 'i') for i in range(0, Ncum[0, 0]): group[i] = 0 response[i] = pattern[0] for i in range(Ncum[0, 0], Ncum[0, 1]):
error[3,1 : 3] ~ ddirich(prior[1 : 3]) error[4,1 : 4] ~ ddirich(prior[1 : 4]) p[1 : 4] ~ ddirich(prior[]); # prior for p } """ # See below re: 'true'; the model implemented herein may be completely wrong. # Need to check it against OpenBUGS. raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dcat_llf, ddirich_llf, dmulti_llf # data: ns=157, biopsies[ns,4], error[4,4], prior[4] _, data = load('../examples/Biopsiesdata.txt') # init: p[4], error[4,4] _, init = load('../examples/Biopsiesinits.txt') #_,init = load('../examples/Biopsiesinits1.txt') ns = data['ns'] error = data['error'] prior = data['prior'] biopsies = data['biopsies'] nbiops = np.sum(biopsies, axis=1) #error_init = init['error'] #error[~np.isnan(error_init)] = error_init[~np.isnan(error_init)] # The variable 'true' is not initialized, but it may be a fitting variable #
} """ import warnings from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dweib_C_llf, dgamma_llf # TODO: fix kidney model raise NotImplementedError("Model fails to reproduce the OpenBUGS result") # Note: censored Weibull was tested in mice.py # data: N=38, M=2, t[N,M], t.cen[N,M], age[N,M], beta.dis[4], sex[N], disease[N] vars = "N,M,t,t.cen,age,beta.dis,sex,disease".split(',') _, data = load('../examples/Kidneydata.txt') N, M, t, t_cen, age, beta_dis, sex, disease = (data[p] for p in vars) # init: beta.age, beta.sex, beta.dis[4], alpha, r, tau pars = "beta.age,beta.sex,beta.dis,alpha,r,tau,b".split(',') _, init = load('../examples/Kidneyinits.txt') init['b'] = np.zeros(N) p0, labels = define_pars(init, pars) # TODO: add notion of fixed parameters to DirectProblem # remove beta.dis[1] since it is not a fitting parameter del labels[2] p0 = np.hstack((p0[:2], p0[3:])) # beta_dis[0] = 0 # corener-point constraint def nllf(p): beta_age, beta_sex = p[:2]
tau.b ~ dgamma(1.0E-3,1.0E-3); sigma.b <- 1.0/ sqrt(tau.b) # re-calculate intercept on original scale: alpha0 <- a0 - alpha.Base * log.Base4.bar - alpha.Trt * Trt.bar - alpha.BT * BT.bar - alpha.Age * log.Age.bar - alpha.V4 * V4.bar } """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dpois_llf, dnorm_llf, dgamma_llf # data: N=59, T=4, y[N,T], Trt[N], Base[N], Age[N], V4[T] globals().update(load('../examples/Epildata.txt')[1]) # inits: a0, alpha.Base, alpha.Trt, alpha.BT, alpha.Age, alpha.V4, tau.b1, tau.b _, init = load('../examples/Epilinits.txt') pars = list(sorted(init)) + ["b", "b1"] init["b"] = np.zeros((N, T)) init["b1"] = np.zeros(N) p0, labels = define_pars(init, pars) log_Age = log(Age) log_Base4 = log(Base / 4) BT = Trt * log_Base4 log_Age_bar = np.mean(log_Age) log_Base4_bar = np.mean(log_Base4) V4_bar = np.mean(V4) Trt_bar = np.mean(Trt)
b[i, k] <- beta[i, k] - mean(beta[, k]); # sum to zero constraint } for (j in 1 : J) { # loop around sizes g[j, k] <- gamma[j, k] - mean(gamma[, k]); # sum to zero constraint } } } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dpois_llf, dmulti_llf # data: I=4, J=2, K=5, X[I, J, K] vars = "I,J,K,X".split(',') _, data = load('../examples/Aligatorsdata.txt') I, J, K, X = (data[p] for p in vars) # init: alpha[K], beta[I, K], gamma[J, K], lambda[I, J] pars = "alpha,beta,gamma,lambda".split(',') #_, init = load('../examples/Aligatorsinits.txt') _, init = load('../examples/Aligatorsinits1.txt') p0, labels = define_pars(init, pars) active_index = ~np.isnan(p0) labels = [label for label, active in zip(labels, active_index) if active] def nllf(active_pars): pars = p0.copy() pars[active_index] = active_pars alpha = pars[0:K] beta = pars[K:K + I * K].reshape(I, K)
p[i, j, k] <- Q[i, j, k - 1] - Q[i, j, k] } p[i, j, ncat[j]] <- Q[i, j, ncat[j] - 1] grade[i, j] ~ dcat(p[i, j, 1 : ncat[j]]) } } } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dcat_llf, dnorm_llf, ilogit # data: nChild=13, nInd=34, gamma[nInd,4], delt[nInd], ncat[nInd], grade[nChild,nInd] vars = "nChild,nInd,gamma,delta,ncat,grade".split(',') _, data = load('../examples/Bonesdata.txt') nChild, nInd, gamma, delta, ncat, grade = (data[p] for p in vars) ncat = np.asarray(ncat, 'i') # init: theta[nChild], grade[nChild, nInd] pars = "theta,grade".split(',') _, init = load('../examples/Bonesinits1.txt') p0, labels = define_pars(init, pars) # Grade is being filled in with fitted values by setting NA in the data # for grade where it is missing, and setting NA in the initial value for # grade where it is present. That is, the same array is used for both # present and missing data. Rather than implementing that here, we will # simply keep an index of where grade is missing and reconstruct grade # from the two sources in the nllf function. See aligator.py for a # generic implementation of missing fit parameters. active_index = ~np.isnan(p0)
tauC ~ dgamma(1.0E-3, 1.0E-3) sigmaC <- 1 / sqrt(tauC) } """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from numpy import expm1 from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dmnorm_llf, dwish_llf from bugs.model import compress_pd, expand_pd, pd_size # data: n=7, K=5, x[N], Y[K,n], mean[3], R[3,3], prec[3,3] _, data = load('../examples/OtreesMVNdata.txt') globals().update(data) # init: theta[K,3], mu[3], tau[3,3], tauC pars = "theta,mu,tau.L,tauC".split(',') _, init = load('../examples/OtreesMVNinits.txt') # Convert tau into L for cholesky decomposition, and sample only over the lower # triangular portion; store diagonally, starting with main diagonal, so that # it is easy to constrain the diagonal entries to be positive. init['tau.L'] = compress_pd(init['tau']) p0, labels = define_pars(init, pars) n_tau_L = pd_size(3) def nllf(p): theta = p[:K * 3].reshape(K, 3)
bronchitis ~ dcat(p.bronchitis[smoking,1:2]) either <- max(tuberculosis,lung.cancer) xray ~ dcat(p.xray[either,1:2]) dyspnoea ~ dcat(p.dyspnoea[either,bronchitis,1:2]) } """ from __future__ import print_function, division from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dcat_llf, round # data: asia=2, dyspnoea=2, # p.smoking[2] p.tuberculosis[2,2] p.bronchitis[2,2], # p.lung.cancer[2,2], p.xray[2,2], p.dyspnoea[2,2,2] _, data = load('../examples/Asiadata.txt') # init: smoking, tuberculosis, lung.cancer, bronchitis, xray pars = "smoking,tuberculosis,lung.cancer,bronchitis,xray".split(',') _, init = load('../examples/Asiainits.txt') p0, labels = define_pars(init, pars) def nllf(pars): smoking, tuberculosis, lung_cancer, bronchitis, xray \ = np.asarray(np.floor(pars), 'i') cost = 0 cost += dcat_llf(smoking, data['p.smoking']) cost += dcat_llf(tuberculosis, data['p.tuberculosis'][data['asia'] - 1]) cost += dcat_llf(lung_cancer, data['p.lung.cancer'][smoking - 1]) cost += dcat_llf(bronchitis, data['p.bronchitis'][smoking - 1]) either = max(tuberculosis, lung_cancer)
r ~ dexp(0.001) veh.control <- beta[2] - beta[1] test.sub <- beta[3] - beta[1] pos.control <- beta[4] - beta[1] } """ from bumps.names import * from numpy import exp, sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dweib_C_llf, dexp_llf # data: M=4, N=20, t[M,N], t.cen[M,N] vars = "t,t.cen,M,N".split(',') _, data = load('../examples/Micedata.txt') t, t_cen, M, N = (data[p] for p in vars) # init: beta[M], r pars = "beta,r".split(',') _, init = load('../examples/Miceinits.txt') p0, labels = define_pars(init, pars) def nllf(p): beta, r = p[:M], p[M] mu = exp(beta) cost = 0 cost += np.sum(dweib_C_llf(t, r, mu[:, None], lower=t_cen)) cost += np.sum(dnorm_llf(beta, 0.0, 0.001)) cost += dexp_llf(r, 0.001)
d ~ dnorm(0.0,1.0E-6) tau ~ dgamma(0.001,0.001) delta.new ~ dt(d, tau, 4) sigma <- 1 / sqrt(tau) } """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dbin_llf, dt_llf, dgamma_llf, dnorm_llf, ilogit # data: Num=22, rt[Num], nt[Num], rc[Num], nc[Num] vars = "rt,nt,rc,nc,Num".split(',') _, data = load('../examples/Blockersdata.txt') rt, nt, rc, nc, Num = (data[p] for p in vars) # init: d, delta.new, tau, mu[Num], delta[Num] pars = "d,delta.new,tau,mu,delta".split(',') _, init = load('../examples/Blockersinits1.txt') p0, labels = define_pars(init, pars) def nllf(pars): d, delta_new, tau = pars[0:3] mu, delta = pars[3:3+Num], pars[3+Num:3+2*Num] pc = ilogit(mu) pt = ilogit(mu + delta) cost = 0 cost += np.sum(dbin_llf(rc, pc, nc))
plots have unexpected structure. Furthermore, when starting from a local maximum (e.g., after running Nelder-Mead simplex a few times with a random initial simplex), the estimated CI drops to almost zero. The independent parameters, *alpha[i]* and *beta[i]* for each rat provide too many degrees of freedom for blind search. """ from bumps.names import * ## Rats model from math import sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf # data: N=30, T=5, xbar, Y[N,T] _, data = load('../examples/Ratsdata.txt') N, T = data["N"], data["T"] x, xbar, Y = data["x"], data["xbar"], data["Y"] # init: alpha[N], beta[N], alpha.c, beta.c, tau.c, alpha.tau, beta.tau pars = 'alpha,beta,alpha.c,alpha.tau,beta.c,beta.tau,tau.c'.split(',') _, init = load('../examples/Ratsinits.txt') p0, labels = define_pars(init, pars) def nllf(p): alpha, beta = p[0:N], p[N:2 * N] alpha_c, alpha_tau, beta_c, beta_tau, tau_c = p[2 * N:2 * N + 5] mu = alpha[:, None] + beta[:, None] * (x[None, :] - xbar) cost = 0.
Because the precision matrix $R$ must be positive definite, we cannot sample its elements independently. Instead, we sample from a lower triangular matrix L with positive diagonal elements, and use $R = L L^T$. The matrix $L$ is initialized with the cholesky decomposition of the initial $R$ value. """ raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from math import sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dmnorm_llf, dwish_llf # data: N=12, Y[N,2]; note that many Y are fitted _, data = load('../examples/Cameldata.txt') N, Y = data["N"], data["Y"] # Convert R into L for cholesky decomposition, and sample only over the lower # triangular portion; store diagonally, starting with main diagonal, so that # it is easy to constrain the diagonal entries to be positive. pars = 'tau.L,Y.fit'.split(',') # init: tau[2,2], Y[N,2] _, init = load('../examples/Camelinits.txt') L = np.linalg.cholesky(init['tau']) init['tau.L'] = np.array([L[0, 0], L[1, 1], L[1, 0]]) Y_fit_index = np.nonzero(np.isfinite(init['Y'])) init['Y.fit'] = init['Y'][Y_fit_index] p0, labels = define_pars(init, pars) active = np.isfinite(p0)
} alpha ~ dnorm(0.0,1.0E-6) beta ~ dnorm(0.0,1.0E-6) gamma ~ dnorm(0.0,1.0E-6) tau ~ dgamma(0.001, 0.001) sigma <- 1 / sqrt(tau) } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dpois_llf # data: doses=6, plates=3, y[doses,plates], x[doses] vars = "doses,plates,y,x".split(',') _, data = load('../examples/Salmdata.txt') doses, plates, y, x = (data[p] for p in vars) # init: alpha, beta, gamma, tau pars = "alpha,beta,gamma,tau,lambda".split(',') _, init = load('../examples/Salminits.txt') # lambda not initialized; default to zero init["lambda"] = np.zeros((doses, plates)) p0, labels = define_pars(init, pars) def nllf(p): alpha, beta, gamma, tau = p[:4] lambda_ = p[4:].reshape(doses, plates) mu = exp(alpha + beta * log(x[:, None] + 10) + gamma * x[:, None] + lambda_)
} # calculate gamma1 = P(x=1|d=0) and gamma2 = P(x=1|d=1) gamma1 <- 1 / (1 + (1 + exp(beta0C + beta)) / (1 + exp(beta0C)) * (1 - q) / q) gamma2 <- 1 / (1 + (1 + exp(-beta0C - beta)) / (1 + exp(-beta0C)) * (1 - q) / q) } """ # Another effects model that is too big to succeed... raise NotImplementedError("Model fails to reproduce the OpenBUGS result") from bumps.names import * from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dbern_llf, ilogit # data: N=2044, d[N], x[N], w[N] ; many x are NA _, data = load('../examples/Cervixdata.txt') globals().update(data) x_index = np.isnan(x) # init: beta0C, beta, phi[2,2] pars = "beta0C beta phi q x".split() _, init = load('../examples/Cervixinits.txt') init['q'] = 1. init['x'] = np.ones(np.sum(x_index)) p0, labels = define_pars(init, pars) def nllf(p): beta0C, beta, phi, q, x[x_index] = p[0], p[1], p[2:6].reshape(2, 2), p[6], p[7:] p = ilogit(beta0C + beta*np.floor(x)) x_int, d_int = [np.asarray(np.floor(v), 'i') for v in (x, d)]
logit(p[i]) <- alpha.star + beta * (x[i] - mean(x[])) rhat[i] <- n[i] * p[i] } alpha <- alpha.star - beta * mean(x[]) beta ~ dnorm(0.0,0.001) alpha.star ~ dnorm(0.0,0.001) } """ from bumps.names import * from bugs.parse import load, define_pars from bugs.model import logit, probit, cloglog, inverse, dnorm_llf, dbin_llf # data: N=8, x[N],n[N],r[N] vars = "x n r N".split() _, data = load('../examples/Beetlesdata.txt') x, n, r, N = (data[p] for p in vars) xbar = np.mean(x) # init: alpha.star, beta pars = 'alpha.star,beta'.split(',') _, init = load('../examples/Beetlesinits.txt') p0, labels = define_pars(init, pars) model_name = sys.argv[1] if len(sys.argv) > 1 else 'logit' available_models = { 'logit': logit, 'probit': probit, 'cloglog': cloglog, } inv_p_model = inverse[available_models[model_name]]
from math import sqrt from bugs.parse import load, define_pars from bugs.model import dnorm_llf, dgamma_llf, dbin_llf, phi, logit, ilogit if len(sys.argv) < 0: raise RuntimeError("use 'bumps magnesium.py PRIOR MARG_N' to select prior and internal marginalization count") PRIOR = int(sys.argv[1]) MARGINALIZATION_COUNT = int(sys.argv[2]) Nprior = 6 if PRIOR == 0 else 1 Nstudy = 8 # not stored: Nstudy=8, Nprior=6 # data: rt[Nstudy], nt[Nstudy], rc[Nstudy], nc[Nstudy] _, data = load('../examples/Magnesiumdata.txt') rt, nt, rc, nc = data["rt"], data["nt"], data["rc"], data["nc"] # inits: mu[Nprior], tau[Nprior], tau.sqrd[Nprior], inv.tau.sqrd[Nprior] _, init = load('../examples/Magnesiuminits.txt') ## PAK: simplifying the parameter structure so it only contains active pars simple_init = [ ('inv.tau.sqrd[1]', init['inv.tau.sqrd'][0]), ('tau.sqrd[2]', init['tau.sqrd'][1]), ('tau[3]', init['tau'][2]), ('B0', 0.5), ('D0', 0.5), ('tau.sqrd[6]', init['tau.sqrd'][5]), ('mu', init['mu']), ]