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']),
]
