def rprior(size, hyperparameters):
""" returns untransformed parameters """
parameters = zeros((L, size))
parameters[0, :] = random.uniform(low=0,
high=hyperparameters["high"],
size=size)
parameters[1, :] = random.uniform(low=0,
high=hyperparameters["high"],
size=size)
#parameters[0, :] = random.exponential(scale = 1 / hyperparameters["b1_rate"], size = size)
#parameters[ell, :] = norm.rvs(size = size, loc = hyperparameters["b_mean"], scale = hyperparameters["b_sd"])
return parameters
## Prior hyperparameters
modeltheta = ParameterModel(name="logistic diffusion model theta", dimension=L)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["tau, sigma"])
modeltheta.setTransformation(["log", "log"]) #(["none", "none"])
#modeltheta.setRprior({}) #seems useless
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["b_sd"]])
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"]])
set_argu = []
for m in range(L):
set_argu.append("priorfunction <- function(x) dexp(x, rate = %.5f)" %
hyperparameters["b1_rate"])
modeltheta.setRprior(set_argu)
sigma_w = 1 / gamma.rvs(hyperparameters["sigma_w_shape"], scale =
hyperparameters["sigma_w_scale"], size = size)
sigma_v = 1 / gamma.rvs(hyperparameters["sigma_v_shape"], scale = hyperparameters["sigma_v_scale"], size = size)
parameters = zeros((2, size))
parameters[0, :] = sigma_w
parameters[1, :] = sigma_v
return parameters
## Prior hyperparameters
hyperparameters = { \
"sigma_w_shape": 1, \
"sigma_w_scale": 1, \
"sigma_v_shape": 1, \
"sigma_v_scale": 1}
modeltheta = ParameterModel(name = "Periodic Gaussian model theta", dimension = 2)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(sigma[w]^2)", "expression(sigma[v]^2)"])
modeltheta.setTransformation(["log", "log"])
modeltheta.setRtruevalues([10, 1])
InverseGammaTemplate = """
priorfunction <- function(x){
shape <- %.5f
scale <- %.5f
return(scale**shape / gamma(shape) * x**(- shape - 1) * exp(-scale / x))
}
"""
modeltheta.setRprior([InverseGammaTemplate %
(hyperparameters["sigma_w_shape"], hyperparameters["sigma_w_scale"]), \
b_all += parameters[ell] - log(hyperparameters["high"]) #uniform prior
return b_all
def rprior(size, hyperparameters):
""" returns untransformed parameters """
parameters = zeros((L, size))
for ell in range(L):
##same as random.normal
#if ell==0:
parameters[ell, :] = random.exponential(scale = 1.0 / hyperparameters["b1_rate"], size = size)
#else:
# parameters[ell, :] = norm.rvs(size = size, loc = hyperparameters["b_mean"], scale = hyperparameters["b_sd"])
return parameters
## Prior hyperparameters
modeltheta = ParameterModel(name = "Nested LGSSM model theta", dimension = L)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(B)"])
#transType = ["log"]
transType = []
for m in range(L):
transType.append("log")
modeltheta.setTransformation(transType) #(["none", "none"])
#modeltheta.setRprior({}) #seems useless
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["b_sd"]])
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"]])
set_argu = []
## Prior hyperparameters
hyperparameters = { \
"eps_shape": 2, "eps_scale": 1, \
"w_shape": 2, "w_scale": 1, \
"r_scale": 1, \
"K_mean": 1, "K_sd": 1, "K_a": 0, "K_b": 10**10, \
"theta_scale": 1, \
"n0_mean": 1, "n0_sd": 1, "n0_a": 0, "n0_b": 10**10}
def updateHyperparametersWithData(hyperparameters, observations):
hyperparameters["K_mean"] = mean(observations)
hyperparameters["K_sd"] = 2 * sqrt(var(observations))
hyperparameters["n0_mean"] = mean(observations)
hyperparameters["n0_sd"] = 2 * sqrt(var(observations))
return hyperparameters
modeltheta = ParameterModel(name = "Population Dynamic model theta (M2), reparameterized", dimension = 6)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setUpdateHyperparametersWithData(updateHyperparametersWithData)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(sigma[epsilon]^2)", "expression(sigma[W]^2)", \
"expression(log(N[0]))", "expression(r)", "expression(K)", "expression(theta)"])
modeltheta.setTransformation(["log", "log", "none", "log", "log", "log"])
modeltheta.setRtruevalues([0.05**2, 0.05**2, log(1), 0.18, 1, 0.2])
parameters = zeros((5, size))
parameters[0, :] = mu
parameters[1, :] = beta
parameters[2, :] = xi
parameters[3, :] = omega2
parameters[4, :] = lamb
return parameters
hyperparameters = { \
"mu_mean": 0, "mu_sd": sqrt(2), \
"beta_mean": 0, "beta_sd": sqrt(2), \
"xi_rate": 0.2, "omega2_rate": 0.2, \
"lambda_rate": 1}
modeltheta = ParameterModel(name = "SV one-factor", dimension = 5)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(mu)", "expression(beta)", \
"expression(xi)", "expression(omega^2)", "expression(lambda)"])
modeltheta.setTransformation(["none", "none", "log", "log", "log"])
modeltheta.setRprior(["priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["mu_sd"], \
"priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["beta_sd"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["xi_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["omega2_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["lambda_rate"]])
parameters[0, :] = xi
parameters[1, :] = omega2
parameters[2, :] = lamb
return parameters
def dInitDistribution(parameters):
""" takes transformed parameters """
xi_part = parameters[0] - 1 * exp(parameters[0])
omega2_part = parameters[1] - 1 * exp(parameters[1])
lamb_part = parameters[2] - 1 * exp(parameters[2])
return xi_part + omega2_part + lamb_part
modeltheta = ParameterModel(name = "SV one-factor", dimension = 3)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setInitDistribution(rInitDistribution, dInitDistribution)
modeltheta.setParameterNames(["expression(xi)", "expression(omega^2)", "expression(lambda)"])
modeltheta.setTransformation(["log", "log", "log"])
modeltheta.priorandtruevaluesspecified = True
modeltheta.Rparameterstruevalues = "trueparameters <- c(0.5, 0.0625, 0.01)"
modeltheta.Rpriorfunctions = ["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["xi_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["omega2_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["lambda_rate"]]
""" Takes transformed parameters. When the parameter is transformed,
a jacobian appears in the formula.
"""
# the following is the log density of Y = logit(U) when U is Uniform(0,1)
rho_part = safelogdlogit(array([parameters[0]]))
return rho_part[0]
def rprior(size, hyperparameters):
""" returns untransformed parameters """
rho = random.uniform(size = size, low = 0.01, high = 0.99)
parameters = zeros((1, size))
parameters[0, :] = rho
return parameters
## Prior hyperparameters
modeltheta = ParameterModel(name = "Simplest model theta", dimension = 1)
modeltheta.setHyperparameters({})
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(rho)"])
modeltheta.setTransformation(["logit"])
uniformprior = \
"""
priorfunction <- function(x){
return(1)
}
"""
modeltheta.setRprior([uniformprior])
sigma = random.exponential(scale=1 / hyperparameters["sigma_rate"],
size=size)
parameters = zeros((3, size))
parameters[0, :] = nu
parameters[1, :] = xi
parameters[2, :] = sigma
return parameters
## Prior hyperparameters
hyperparameters = { \
"nu_rate": 0.2, \
"xi_rate": 0.5, \
"sigma_rate": 0.2}
modeltheta = ParameterModel(name="Athletics records", dimension=3)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(
["expression(nu)", "expression(xi)", "expression(sigma)"])
modeltheta.setTransformation(["log", "log", "log"])
Rpriornu = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters[
"nu_rate"]
Rpriorxi = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters[
"xi_rate"]
Rpriorsigma = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters[
"sigma_rate"]
modeltheta.setRprior([Rpriornu, Rpriorxi, Rpriorsigma])
parameters[0, :] = mu
parameters[1, :] = beta
parameters[2, :] = xi
parameters[3, :] = omega2
parameters[4, :] = lamb
parameters[5, :] = lambadd
parameters[6, :] = w
return parameters
hyperparameters = { \
"mu_mean": 0, "mu_sd": sqrt(2), \
"beta_mean": 0, "beta_sd": sqrt(2), \
"xi_rate": 0.2, "omega2_rate": 0.2, \
"lambda1_rate": 1, "lambdaadd_rate": 0.5}
modeltheta = ParameterModel(name="SV multi-factor", dimension=7)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(mu)", "expression(beta)", \
"expression(xi)", "expression(omega^2)", "expression(lambda[1])", "expression(lambda[2] - lambda[1])", \
"expression(w[1])"])
modeltheta.setTransformation(
["none", "none", "log", "log", "log", "log", "logit"])
modeltheta.setRprior(["priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["mu_sd"], \
"priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["beta_sd"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["xi_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["omega2_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["lambda1_rate"], \
"priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["lambdaadd_rate"], \
"priorfunction <- function(x) 1"])
scale=hyperparameters["tau_scale"],
size=size)
parameters = zeros((2, size))
parameters[0, :] = sigma
parameters[1, :] = tau
return parameters
## Prior hyperparameters
hyperparameters = { \
"sigma_shape": 1, \
"sigma_scale": 1, \
"tau_shape": 1, \
"tau_scale": 1}
modeltheta = ParameterModel(name="Linear Gaussian model theta", dimension=2)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(sigma^2)", "expression(tau^2)"])
modeltheta.setTransformation(["log", "log"])
modeltheta.setRtruevalues([0.8, 0.4])
InverseGammaTemplate = """
priorfunction <- function(x){
shape <- %.5f
scale <- %.5f
return(scale**shape / gamma(shape) * x**(- shape - 1) * exp(-scale / x))
}
"""
modeltheta.setRprior([InverseGammaTemplate % (hyperparameters["sigma_shape"], hyperparameters["sigma_scale"]), \
InverseGammaTemplate % (hyperparameters["tau_shape"], hyperparameters["tau_scale"])])
nu = random.exponential(scale = 1 / hyperparameters["nu_rate"], size = size)
xi = random.exponential(scale = 1 / hyperparameters["xi_rate"], size = size)
sigma = random.exponential(scale = 1 / hyperparameters["sigma_rate"], size = size)
parameters = zeros((3, size))
parameters[0, :] = nu
parameters[1, :] = xi
parameters[2, :] = sigma
return parameters
## Prior hyperparameters
hyperparameters = { \
"nu_rate": 0.2, \
"xi_rate": 0.5, \
"sigma_rate": 0.2}
modeltheta = ParameterModel(name = "Athletics records", dimension = 3)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(nu)", "expression(xi)", "expression(sigma)"])
modeltheta.setTransformation(["log", "log", "log"])
Rpriornu = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["nu_rate"]
Rpriorxi = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["xi_rate"]
Rpriorsigma = "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["sigma_rate"]
modeltheta.setRprior([Rpriornu, Rpriorxi, Rpriorsigma])
#modeltheta.plottingInstructions = ["No observations", "No evidence"]
#modeltheta.additionalPlots = """
return parameters
## Prior hyperparameters
hyperparameters = { \
"eps_shape": 2, "eps_scale": 1, \
"w_shape": 2, "w_scale": 1, \
"r_scale": 1, \
"K_mean": 1, "K_sd": 1, "K_a": 0, "K_b": 10**10, \
"theta_scale": 1, \
"n0_mean": 1, "n0_sd": 1, "n0_a": 0, "n0_b": 10**10}
def updateHyperparametersWithData(hyperparameters, observations):
hyperparameters["K_mean"] = mean(observations)
hyperparameters["K_sd"] = 2 * sqrt(var(observations))
hyperparameters["n0_mean"] = mean(observations)
hyperparameters["n0_sd"] = 2 * sqrt(var(observations))
return hyperparameters
modeltheta = ParameterModel(
name="Population Dynamic model theta (M2), reparameterized", dimension=6)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setUpdateHyperparametersWithData(updateHyperparametersWithData)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["expression(sigma[epsilon]^2)", "expression(sigma[W]^2)", \
"expression(log(N[0]))", "expression(r)", "expression(K)", "expression(theta)"])
modeltheta.setTransformation(["log", "log", "none", "log", "log", "log"])
parameters[1, :] = random.uniform(low=0,
high=hyperparameters["high"],
size=size)
parameters[2, :] = random.uniform(low=hyperparameters["low"],
high=hyperparameters["high"],
size=size)
parameters[3, :] = random.uniform(low=0,
high=hyperparameters["high"],
size=size)
#parameters[0, :] = random.exponential(scale = 1 / hyperparameters["b1_rate"], size = size)
#parameters[ell, :] = norm.rvs(size = size, loc = hyperparameters["b_mean"], scale = hyperparameters["b_sd"])
return parameters
## Prior hyperparameters
modeltheta = ParameterModel(name="logistic diffusion model theta", dimension=L)
modeltheta.setHyperparameters(hyperparameters)
modeltheta.setPriorlogdensity(logdprior)
modeltheta.setPriorgenerator(rprior)
modeltheta.setParameterNames(["tau, sigma, r, b"])
modeltheta.setTransformation(["log", "log", "none",
"log"]) #(["none", "none"])
#modeltheta.setRprior({}) #seems useless
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dnorm(x, sd = %.5f)" % hyperparameters["b_sd"]])
#modeltheta.setRprior(["priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"],\
# "priorfunction <- function(x) dexp(x, rate = %.5f)" % hyperparameters["b1_rate"]])
set_argu = []
for m in range(L):
set_argu.append("priorfunction <- function(x) dexp(x, rate = %.5f)" %
hyperparameters["b1_rate"])
