def _indvdl_t(hparams, std_x, n_samples, L_cov, verbose=0):
df_L = hparams.df_indvdl
dist_scale_indvdl = hparams.dist_scale_indvdl
scale1 = std_x[0] * _dist_from_str('scale_mu1s', dist_scale_indvdl)
scale2 = std_x[1] * _dist_from_str('scale_mu2s', dist_scale_indvdl)
scale1 = scale1 / np.sqrt(df_L / (df_L - 2))
scale2 = scale2 / np.sqrt(df_L / (df_L - 2))
u1s = StudentT('u1s',
nu=np.float32(df_L),
shape=(n_samples, ),
dtype=floatX)
u2s = StudentT('u2s',
nu=np.float32(df_L),
shape=(n_samples, ),
dtype=floatX)
L_cov_ = cholesky(L_cov).astype(floatX)
mu1s_ = Deterministic(
'mu1s_', L_cov_[0, 0] * u1s * scale1 + L_cov_[1, 0] * u2s * scale1)
mu2s_ = Deterministic('mu2s_', L_cov_[1, 0] * u1s * scale2 +
L_cov_[1, 1] * u2s * scale2) # [1, 0] is ... 0?
if 10 <= verbose:
print('StudentT for individual effect')
print('u1s.dtype = {}'.format(u1s.dtype))
print('u2s.dtype = {}'.format(u2s.dtype))
return mu1s_, mu2s_
def _indvdl_gauss(
hparams, std_x, n_samples, L_cov, Normal, Deterministic, floatX,
cholesky, tt, verbose):
scale1 = np.float32(std_x[0] * hparams['v_indvdl_1'])
scale2 = np.float32(std_x[1] * hparams['v_indvdl_2'])
u1s = Normal(
'u1s', mu=np.float32(0.), tau=np.float32(1.),
shape=(n_samples,), dtype=floatX
)
u2s = Normal(
'u2s', mu=np.float32(0.), tau=np.float32(1.),
shape=(n_samples,), dtype=floatX
)
L_cov_ = cholesky(L_cov).astype(floatX)
tt.set_subtensor(L_cov_[0, :], L_cov_[0, :] * scale1, inplace=True)
tt.set_subtensor(L_cov_[1, :], L_cov_[1, :] * scale2, inplace=True)
mu1s_ = Deterministic('mu1s_',
L_cov[0, 0] * u1s + L_cov[0, 1] * u2s)
mu2s_ = Deterministic('mu2s_',
L_cov[1, 0] * u1s + L_cov[1, 1] * u2s)
if 10 <= verbose:
print('Normal for individual effect')
print('u1s.dtype = {}'.format(u1s.dtype))
print('u2s.dtype = {}'.format(u2s.dtype))
return mu1s_, mu2s_
def _indvdl_t(
hparams, std_x, n_samples, L_cov, StudentT, Deterministic, floatX,
cholesky, tt, verbose):
df_L = hparams['df_indvdl']
scale1 = np.float32(std_x[0] * hparams['v_indvdl_1'] /
np.sqrt(df_L / (df_L - 2)))
scale2 = np.float32(std_x[1] * hparams['v_indvdl_2'] /
np.sqrt(df_L / (df_L - 2)))
u1s = StudentT('u1s', nu=np.float32(df_L), shape=(n_samples,),
dtype=floatX)
u2s = StudentT('u2s', nu=np.float32(df_L), shape=(n_samples,),
dtype=floatX)
L_cov_ = cholesky(L_cov).astype(floatX)
tt.set_subtensor(L_cov_[0, :], L_cov_[0, :] * scale1, inplace=True)
tt.set_subtensor(L_cov_[1, :], L_cov_[1, :] * scale2, inplace=True)
mu1s_ = Deterministic('mu1s_',
L_cov_[0, 0] * u1s + L_cov_[0, 1] * u2s)
mu2s_ = Deterministic('mu2s_',
L_cov_[1, 0] * u1s + L_cov_[1, 1] * u2s)
if 10 <= verbose:
print('StudentT for individual effect')
print('u1s.dtype = {}'.format(u1s.dtype))
print('u2s.dtype = {}'.format(u2s.dtype))
return mu1s_, mu2s_
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
"""
Get seismic likelihood formula for the model built. Has to be called
within a with model context.
Parameters
----------
input_rvs : list
of :class:`pymc3.distribution.Distribution`
fixed_rvs : dict
of :class:`numpy.array`
hyperparams : dict
of :class:`pymc3.distribution.Distribution`
problem_config : :class:`config.ProblemConfig`
Returns
-------
posterior_llk : :class:`theano.tensor.Tensor`
"""
hp_specific = problem_config.dataset_specific_residual_noise_estimation
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
logger.info('Seismic optimization on: \n '
' %s' % ', '.join(self.input_rvs.keys()))
t2 = time()
wlogpts = []
self.init_hierarchicals(problem_config)
if self.config.station_corrections:
logger.info('Initialized %i hierarchical parameters for '
'station corrections.' %
len(self.get_unique_stations()))
for wmap in self.wavemaps:
synths, tmins = self.synthesizers[wmap.name](self.input_rvs)
if len(self.hierarchicals) > 0:
tmins += self.hierarchicals[self.correction_name][
wmap.station_correction_idxs]
data_trcs = self.choppers[wmap.name](tmins)
residuals = data_trcs - synths
logpts = multivariate_normal_chol(wmap.datasets,
wmap.weights,
hyperparams,
residuals,
hp_specific=hp_specific)
wlogpts.append(logpts)
t3 = time()
logger.debug('Teleseismic forward model on test model takes: %f' %
(t3 - t2))
llk = Deterministic(self._like_name, tt.concatenate((wlogpts)))
return llk.sum()
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 get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
"""
Get geodetic likelihood formula for the model built. Has to be called
within a with model context.
Part of the pymc3 model.
Parameters
----------
input_rvs : dict
of :class:`pymc3.distribution.Distribution`
fixed_rvs : dict
of :class:`numpy.array`
hyperparams : dict
of :class:`pymc3.distribution.Distribution`
problem_config : :class:`config.ProblemConfig`
Returns
-------
posterior_llk : :class:`theano.tensor.Tensor`
"""
hp_specific = self.config.dataset_specific_residual_noise_estimation
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
logger.info('Geodetic optimization on: \n '
'%s' % ', '.join(self.input_rvs.keys()))
self.input_rvs.update(fixed_rvs)
t0 = time()
disp = self.get_synths(self.input_rvs)
t1 = time()
logger.debug('Geodetic forward model on test model takes: %f' %
(t1 - t0))
los_disp = (disp * self.slos_vectors).sum(axis=1)
residuals = self.Bij.srmap(
tt.cast((self.sdata - los_disp) * self.sodws, tconfig.floatX))
self.init_hierarchicals(problem_config)
if self.config.corrections_config.has_enabled_corrections:
logger.info('Applying corrections! ...')
residuals = self.apply_corrections(residuals, operation='-')
logpts = multivariate_normal_chol(self.datasets,
self.weights,
hyperparams,
residuals,
hp_specific=hp_specific)
llk = Deterministic(self._like_name, logpts)
return llk.sum()
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
"""
Formulation of the distribution problem for the model built. Has to be
called within a with-model-context.
Parameters
----------
input_rvs : list
of :class:`pymc3.distribution.Distribution`
hyperparams : dict
of :class:`pymc3.distribution.Distribution`
Returns
-------
llk : :class:`theano.tensor.Tensor`
log-likelihood for the distributed slip
"""
logger.info("Loading %s Green's Functions" % self.name)
self.load_gfs(crust_inds=[self.config.gf_config.reference_model_idx],
make_shared=True)
hp_specific = self.config.dataset_specific_residual_noise_estimation
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
ref_idx = self.config.gf_config.reference_model_idx
mu = tt.zeros((self.Bij.ordering.size), tconfig.floatX)
for var in self.slip_varnames:
key = self.get_gflibrary_key(crust_ind=ref_idx,
wavename='static',
component=var)
mu += self.gfs[key].stack_all(slips=input_rvs[var])
residuals = self.Bij.srmap(
tt.cast((self.sdata - mu) * self.sodws, tconfig.floatX))
self.init_hierarchicals(problem_config)
if len(self.hierarchicals) > 0:
residuals = self.remove_ramps(residuals)
logpts = multivariate_normal_chol(self.datasets,
self.weights,
hyperparams,
residuals,
hp_specific=hp_specific)
llk = Deterministic(self._like_name, logpts)
return llk.sum()
def get_hyper_formula(self, hyperparams):
"""
Get likelihood formula for the hyper model built. Has to be called
within a with model context.
"""
logpts = tt.zeros((self.n_t), tconfig.floatX)
for k in range(self.n_t):
logpt = self._eval_prior(hyperparams[bconfig.hyper_name_laplacian],
self._llks[k])
logpts = tt.set_subtensor(logpts[k:k + 1], logpt)
llk = Deterministic(self._like_name, logpts)
return llk.sum()
def get_hyper_formula(self, hyperparams, problem_config):
"""
Get likelihood formula for the hyper model built. Has to be called
within a with model context.
problem_config : :class:`config.ProblemConfig`
"""
hp_specific = problem_config.dataset_specific_residual_noise_estimation
logpts = hyper_normal(
self.datasets, hyperparams, self._llks,
hp_specific=hp_specific)
llk = Deterministic(self._like_name, logpts)
return llk.sum()
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 __init__(self, mean=0, sigma=1, name="", model=None):
super().__init__(name, model)
self.Var("v1", Normal.dist(mu=mean, sigma=sigma))
Normal("v2", mu=mean, sigma=sigma)
Normal("v3", mu=mean, sigma=HalfCauchy("sd", beta=10, testval=1.0))
Deterministic("v3_sq", self.v3 ** 2)
Potential("p1", aet.constant(1))
def built_hyper_model(self):
"""
Initialise :class:`pymc3.Model` depending on configuration file,
geodetic and/or seismic data are included. Estimates initial parameter
bounds for hyperparameters.
"""
logger.info('... Building Hyper model ...\n')
pc = self.config.problem_config
if len(self.hierarchicals) == 0:
self.init_hierarchicals()
point = self.get_random_point(include=['hierarchicals', 'priors'])
for param in pc.priors.values():
point[param.name] = param.testvalue
self.update_llks(point)
with Model() as self.model:
self.init_hyperparams()
total_llk = tt.zeros((1), tconfig.floatX)
for composite in self.composites.itervalues():
total_llk += composite.get_hyper_formula(self.hyperparams, pc)
like = Deterministic('tmp', total_llk)
llk = Potential(self._like_name, like)
logger.info('Hyper model building was successful!')
def __init__(self, mean=0, sigma=1, name="", model=None):
super().__init__(name, model)
self.register_rv(Normal.dist(mu=mean, sigma=sigma), "v1")
Normal("v2", mu=mean, sigma=sigma)
Normal("v3", mu=mean, sigma=Normal("sd", mu=10, sigma=1, initval=1.0))
Deterministic("v3_sq", self.v3 ** 2)
Potential("p1", at.constant(1))
def __init__(self, mean=0, sigma=1, name='', model=None):
super().__init__(name, model)
self.Var('v1', Normal.dist(mu=mean, sigma=sigma))
Normal('v2', mu=mean, sigma=sigma)
Normal('v3', mu=mean, sigma=HalfCauchy('sd', beta=10, testval=1.))
Deterministic('v3_sq', self.v3 ** 2)
Potential('p1', tt.constant(1))
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
"""
Get smoothing likelihood formula for the model built. Has to be called
within a with model context.
Part of the pymc3 model.
Parameters
----------
input_rvs : dict
of :class:`pymc3.distribution.Distribution`
fixed_rvs : dict
of :class:`numpy.array` here only dummy
hyperparams : dict
of :class:`pymc3.distribution.Distribution`
problem_config : :class:`config.ProblemConfig`
here it is not used
Returns
-------
posterior_llk : :class:`theano.tensor.Tensor`
"""
logger.info('Initialising Laplacian smoothing operator ...')
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
hp_name = bconfig.hyper_name_laplacian
self.input_rvs.update(fixed_rvs)
logpts = tt.zeros((self.n_t), tconfig.floatX)
for l, var in enumerate(self.slip_varnames):
Ls = self.shared_smoothing_op.dot(input_rvs[var])
exponent = Ls.T.dot(Ls)
logpts = tt.set_subtensor(
logpts[l:l + 1],
self._eval_prior(hyperparams[hp_name], exponent=exponent))
llk = Deterministic(self._like_name, logpts)
return llk.sum()
def built_model(self):
"""
Initialise :class:`pymc3.Model` depending on problem composites,
geodetic and/or seismic data are included. Composites also determine
the problem to be solved.
"""
logger.info('... Building model ...\n')
pc = self.config.problem_config
with Model() as self.model:
self.rvs, self.fixed_params = self.get_random_variables()
self.init_hyperparams()
total_llk = tt.zeros((1), tconfig.floatX)
for datatype, composite in self.composites.iteritems():
if datatype in bconfig.modes_catalog[pc.mode].keys():
input_rvs = utility.weed_input_rvs(self.rvs,
pc.mode,
datatype=datatype)
fixed_rvs = utility.weed_input_rvs(self.fixed_params,
pc.mode,
datatype=datatype)
if pc.mode == 'ffi':
# do the optimization only on the
# reference velocity model
logger.info("Loading %s Green's Functions" % datatype)
data_config = self.config[datatype + '_config']
composite.load_gfs(crust_inds=[
data_config.gf_config.reference_model_idx
],
make_shared=True)
total_llk += composite.get_formula(input_rvs, fixed_rvs,
self.hyperparams, pc)
# deterministic RV to write out llks to file
like = Deterministic('tmp', total_llk)
# will overwrite deterministic name ...
llk = Potential(self._like_name, like)
logger.info('Model building was successful!')
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 built_model(self):
"""
Initialise :class:`pymc3.Model` depending on problem composites,
geodetic and/or seismic data are included. Composites also determine
the problem to be solved.
"""
logger.info('... Building model ...\n')
pc = self.config.problem_config
with Model() as self.model:
self.rvs, self.fixed_params = self.get_random_variables()
self.init_hyperparams()
total_llk = tt.zeros((1), tconfig.floatX)
for datatype, composite in self.composites.items():
if datatype in bconfig.modes_catalog[pc.mode].keys():
input_rvs = weed_input_rvs(self.rvs,
pc.mode,
datatype=datatype)
fixed_rvs = weed_input_rvs(self.fixed_params,
pc.mode,
datatype=datatype)
else:
input_rvs = self.rvs
fixed_rvs = self.fixed_params
total_llk += composite.get_formula(input_rvs, fixed_rvs,
self.hyperparams, pc)
# deterministic RV to write out llks to file
like = Deterministic('tmp', total_llk)
# will overwrite deterministic name ...
llk = Potential(self._like_name, like)
logger.info('Model building was successful! \n')
def createSignalModelExponential(data):
"""
Toy model that treats the first ~10% of the waveform as an exponential. Does a good job of finding the start time (t_0)
Since I made this as a toy, its super brittle. Waveform must be normalized
"""
with Model() as signal_model:
switchpoint = Uniform('switchpoint', lower=0, upper=len(data), testval=len(data)/2)
noise_sigma = HalfNormal('noise_sigma', sd=1.)
#Modeling these parameters this way is why wf needs to be normalized
exp_rate = Uniform('exp_rate', lower=0, upper=.5, testval = 0.05)
exp_scale = Uniform('exp_scale', lower=0, upper=.5, testval = 0.1)
timestamp = np.arange(0, len(data), dtype=np.float)
rate = switch(switchpoint >= timestamp, 0, exp_rate)
baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) )
baseline_observed = Normal("baseline_observed", mu=baseline_model, sd=noise_sigma, observed= data )
return signal_model
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
hp_specific = problem_config.dataset_specific_residual_noise_estimation
tpoint = problem_config.get_test_point()
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
logger.info(
'Seismic optimization on: \n '
' %s' % ', '.join(self.input_rvs.keys()))
t2 = time()
wlogpts = []
self.analyse_noise(tpoint)
self.init_weights()
self.init_hierarchicals(problem_config)
if self.config.station_corrections:
logger.info(
'Initialized %i hierarchical parameters for '
'station corrections.' % len(self.get_unique_stations()))
self.input_rvs.update(fixed_rvs)
ref_idx = self.config.gf_config.reference_model_idx
nuc_strike = input_rvs['nucleation_strike']
nuc_dip = input_rvs['nucleation_dip']
t2 = time()
# convert velocities to rupture onset
logger.debug('Fast sweeping ...')
nuc_dip_idx, nuc_strike_idx = self.fault.fault_locations2idxs(
positions_dip=nuc_dip,
positions_strike=nuc_strike,
backend='theano')
starttimes0 = self.sweeper(
(1. / input_rvs['velocities']), nuc_dip_idx, nuc_strike_idx)
starttimes0 += input_rvs['nucleation_time']
wlogpts = []
for wmap in self.wavemaps:
# station corrections
if len(self.hierarchicals) > 0:
raise NotImplementedError(
'Station corrections not fully implemented! for ffi!')
starttimes = (
tt.tile(starttimes0, wmap.n_t) +
tt.repeat(self.hierarchicals[self.correction_name][
wmap.station_correction_idxs],
self.fault.npatches)).reshape(
wmap.n_t, self.fault.npatches)
targetidxs = shared(
num.atleast_2d(num.arange(wmap.n_t)).T, borrow=True)
else:
starttimes = starttimes0
targetidxs = shared(num.lib.index_tricks.s_[:], borrow=True)
logger.debug('Stacking %s phase ...' % wmap.config.name)
synthetics = tt.zeros(
(wmap.n_t, wmap.config.arrival_taper.nsamples(
self.config.gf_config.sample_rate)),
dtype=tconfig.floatX)
for var in self.slip_varnames:
logger.debug('Stacking %s variable' % var)
key = self.get_gflibrary_key(
crust_ind=ref_idx, wavename=wmap.name, component=var)
synthetics += self.gfs[key].stack_all(
targetidxs=targetidxs,
starttimes=starttimes,
durations=input_rvs['durations'],
slips=input_rvs[var],
interpolation=wmap.config.interpolation)
residuals = wmap.shared_data_array - synthetics
logger.debug('Calculating likelihoods ...')
logpts = multivariate_normal_chol(
wmap.datasets, wmap.weights, hyperparams, residuals,
hp_specific=hp_specific)
wlogpts.append(logpts)
t3 = time()
logger.debug(
'Seismic formula on test model takes: %f' % (t3 - t2))
llk = Deterministic(self._like_name, tt.concatenate((wlogpts)))
return llk.sum()
def __init__(self,
ploidy_config: PloidyModelConfig,
ploidy_workspace: PloidyWorkspace):
super().__init__()
# shorthands
t_j = ploidy_workspace.t_j
contig_exclusion_mask_jj = ploidy_workspace.contig_exclusion_mask_jj
n_s = ploidy_workspace.n_s
n_sj = ploidy_workspace.n_sj
ploidy_k = ploidy_workspace.int_ploidy_values_k
q_ploidy_sjk = tt.exp(ploidy_workspace.log_q_ploidy_sjk)
eps_mapping = ploidy_config.mapping_error_rate
register_as_global = self.register_as_global
register_as_sample_specific = self.register_as_sample_specific
# mean per-contig bias
mean_bias_j = self.PositiveNormal('mean_bias_j',
mu=1.0,
sd=ploidy_config.mean_bias_sd,
shape=(ploidy_workspace.num_contigs,))
register_as_global(mean_bias_j)
# contig coverage unexplained variance
psi_j = Exponential(name='psi_j',
lam=1.0 / ploidy_config.psi_j_scale,
shape=(ploidy_workspace.num_contigs,))
register_as_global(psi_j)
# sample-specific contig unexplained variance
psi_s = Exponential(name='psi_s',
lam=1.0 / ploidy_config.psi_s_scale,
shape=(ploidy_workspace.num_samples,))
register_as_sample_specific(psi_s, sample_axis=0)
# convert "unexplained variance" to negative binomial over-dispersion
alpha_sj = tt.maximum(tt.inv((tt.exp(psi_j.dimshuffle('x', 0) + psi_s.dimshuffle(0, 'x')) - 1.0)),
_eps)
# mean ploidy per contig per sample
mean_ploidy_sj = tt.sum(tt.exp(ploidy_workspace.log_q_ploidy_sjk)
* ploidy_workspace.int_ploidy_values_k.dimshuffle('x', 'x', 0), axis=2)
# mean-field amplification coefficient per contig
gamma_sj = mean_ploidy_sj * t_j.dimshuffle('x', 0) * mean_bias_j.dimshuffle('x', 0)
# gamma_rest_sj \equiv sum_{j' \neq j} gamma_sj
gamma_rest_sj = tt.dot(gamma_sj, contig_exclusion_mask_jj)
# NB per-contig counts
mu_num_sjk = (t_j.dimshuffle('x', 0, 'x') * mean_bias_j.dimshuffle('x', 0, 'x')
* ploidy_k.dimshuffle('x', 'x', 0))
mu_den_sjk = gamma_rest_sj.dimshuffle(0, 1, 'x') + mu_num_sjk
eps_mapping_j = eps_mapping * t_j / tt.sum(t_j) # average number of reads erroneously mapped to contig j
# the switch is required for a single contig edge case
mu_ratio_sjk = tt.switch(tt.eq(mu_den_sjk, 0.0), 0.0, mu_num_sjk / mu_den_sjk)
mu_sjk = ((1.0 - eps_mapping) * mu_ratio_sjk
+ eps_mapping_j.dimshuffle('x', 0, 'x')) * n_s.dimshuffle(0, 'x', 'x')
def _get_logp_sjk(_n_sj):
_logp_sjk = commons.negative_binomial_logp(
mu_sjk, # mean
alpha_sj.dimshuffle(0, 1, 'x'), # over-dispersion
_n_sj.dimshuffle(0, 1, 'x')) # contig counts
return _logp_sjk
DensityDist(name='n_sj_obs',
logp=lambda _n_sj: tt.sum(q_ploidy_sjk * _get_logp_sjk(_n_sj)),
observed=n_sj)
# for log ploidy emission sampling
Deterministic(name='logp_sjk', var=_get_logp_sjk(n_sj))
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
"""
Get seismic likelihood formula for the model built. Has to be called
within a with model context.
Parameters
----------
input_rvs : list
of :class:`pymc3.distribution.Distribution` of source parameters
fixed_rvs : dict
of :class:`numpy.array`
hyperparams : dict
of :class:`pymc3.distribution.Distribution`
problem_config : :class:`config.ProblemConfig`
Returns
-------
posterior_llk : :class:`theano.tensor.Tensor`
"""
chop_bounds = ['b', 'c'] # we want llk calculation only between b c
hp_specific = self.config.dataset_specific_residual_noise_estimation
tpoint = problem_config.get_test_point()
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
logger.info('Seismic optimization on: \n '
' %s' % ', '.join(self.input_rvs.keys()))
self.input_rvs.update(fixed_rvs)
t2 = time()
wlogpts = []
self.init_hierarchicals(problem_config)
self.analyse_noise(tpoint, chop_bounds=chop_bounds)
self.init_weights()
if self.config.station_corrections:
logger.info('Initialized %i hierarchical parameters for '
'station corrections.' %
len(self.get_all_station_names()))
for wmap in self.wavemaps:
if len(self.hierarchicals) > 0:
time_shifts = self.hierarchicals[wmap.time_shifts_id][
wmap.station_correction_idxs]
self.input_rvs[self.correction_name] = time_shifts
wc = wmap.config
logger.info('Preparing data of "%s" for optimization' %
wmap._mapid)
wmap.prepare_data(source=self.events[wc.event_idx],
engine=self.engine,
outmode='array',
chop_bounds=chop_bounds)
logger.info('Initializing synthesizer for "%s"' % wmap._mapid)
if self.nevents == 1:
logger.info('Using all sources for wavemap %s !' % wmap._mapid)
sources = self.sources
else:
logger.info('Using source based on event %i for wavemap %s!' %
(wc.event_idx, wmap._mapid))
sources = [self.sources[wc.event_idx]]
self.synthesizers[wmap._mapid] = theanof.SeisSynthesizer(
engine=self.engine,
sources=sources,
targets=wmap.targets,
event=self.events[wc.event_idx],
arrival_taper=wc.arrival_taper,
arrival_times=wmap._arrival_times,
wavename=wmap.name,
filterer=wc.filterer,
pre_stack_cut=self.config.pre_stack_cut,
station_corrections=self.config.station_corrections)
synths, _ = self.synthesizers[wmap._mapid](self.input_rvs)
residuals = wmap.shared_data_array - synths
logpts = multivariate_normal_chol(wmap.datasets,
wmap.weights,
hyperparams,
residuals,
hp_specific=hp_specific)
wlogpts.append(logpts)
t3 = time()
logger.debug('Teleseismic forward model on test model takes: %f' %
(t3 - t2))
llk = Deterministic(self._like_name, tt.concatenate((wlogpts)))
return llk.sum()
threshold = Normal('threshold', mu=0, sd=10)
# priors for latency
lf = HalfNormal('lf', sd=1)
le = HalfNormal('le', sd=1)
# compute activation
scaled_time = time ** (-decay)
def compute_activation(scaled_time_vector):
compare = tt.isinf(scaled_time_vector)
subvector = scaled_time_vector[(1-compare).nonzero()]
activation_from_time = tt.log(subvector.sum())
return activation_from_time
activation_from_time, _ = theano.scan(fn=compute_activation,\
sequences=scaled_time)
# latency likelihood -- this is where pyactr is used
pyactr_rt = actrmodel_latency(lf, le, decay, activation_from_time)
mu_rt = Deterministic('mu_rt', pyactr_rt)
rt_observed = Normal('rt_observed', mu=mu_rt, sd=0.01, observed=RT)
# accuracy likelihood
odds_reciprocal = tt.exp(-(activation_from_time - threshold)/noise)
mu_prob = Deterministic('mu_prob', 1/(1 + odds_reciprocal))
prob_observed = Normal('prob_observed', mu=mu_prob, sd=0.01,\
observed=ACCURACY)
# we start the sampling
#step = Metropolis()
#db = SQLite('lex_dec_pyactr_chain_no_imaginal.sqlite')
#trace = sample(draws=60000, trace=db, njobs=1, step=step, init='auto')
with lex_decision_with_bayes:
trace = load('./data/lex_dec_pyactr_chain_no_imaginal.sqlite')
trace = trace[10500:]
def hmetad_groupLevel(data: dict, sample_model: bool = True, **kwargs):
"""Compute hierachical meta-d' at the subject level.
This is an internal function. The group level 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"]
hits = data["hits"]
falsealarms = data["falsealarms"]
s = data["s"]
n = data["n"]
counts = data["counts"]
nRatings = data["nRatings"]
Tol = data["Tol"]
cr = data["cr"]
m = data["m"]
with Model() as model:
# hyperpriors on d, c and c2
mu_c1 = Normal(
"mu_c1", mu=0, tau=0.01, shape=(1), testval=np.random.rand() * 0.1
)
mu_c2 = Normal(
"mu_c2", mu=0, tau=0.01, shape=(1, 1), testval=np.random.rand() * 0.1
)
mu_d1 = Normal(
"mu_d1", mu=0, tau=0.01, shape=(1), testval=np.random.rand() * 0.1
)
sigma_c1 = HalfNormal(
"sigma_c1", tau=0.01, shape=(1), testval=np.random.rand() * 0.1
)
sigma_c2 = HalfNormal(
"sigma_c2", tau=0.01, shape=(1, 1), testval=np.random.rand() * 0.1
)
sigma_d1 = HalfNormal(
"sigma_d1", tau=0.01, shape=(1), testval=np.random.rand() * 0.1
)
# Type 1 priors
c1_tilde = Normal("c1_tilde", mu=0, sigma=1, shape=(nSubj, 1))
c1 = Deterministic("c1", mu_c1 + sigma_c1 * c1_tilde)
d1_tilde = Normal("d1_tilde", mu=0, sigma=1, shape=(nSubj, 1))
d1 = Deterministic("d1", mu_d1 + sigma_d1 * d1_tilde)
# TYPE 1 SDT BINOMIAL MODEL
h = cumulative_normal(d1 / 2 - c1)
f = cumulative_normal(-d1 / 2 - c1)
H = Binomial("H", n=s, p=h, observed=hits)
FA = Binomial("FA", n=n, p=f, observed=falsealarms)
# Hyperpriors on mRatio
mu_logMratio = Normal(
"mu_logMratio", mu=0, tau=1, shape=(1), testval=np.random.rand() * 0.1
)
sigma_delta = HalfNormal("sigma_delta", tau=1, shape=(1))
delta_tilde = Normal("delta_tilde", mu=0, sigma=1, shape=(nSubj, 1))
delta = Deterministic("delta", sigma_delta * delta_tilde)
epsilon_logMratio = Beta("epsilon_logMratio", 1, 1, shape=(1))
logMratio = Deterministic("logMratio", mu_logMratio + epsilon_logMratio * delta)
mRatio = Deterministic("mRatio", math.exp(logMratio))
# Type 2 priors
meta_d = Deterministic("meta_d", mRatio * d1)
# Specify ordered prior on criteria
# bounded above and below by Type 1 c1
cS1_hn = Normal(
"cS1_hn",
mu=0,
sigma=1,
shape=(nSubj, nRatings - 1),
testval=np.linspace(-1.5, -0.5, nRatings - 1)
.reshape(1, nRatings - 1)
.repeat(nSubj, axis=0),
)
cS1 = Deterministic("cS1", -mu_c2 + (cS1_hn * sigma_c2))
cS2_hn = Normal(
"cS2_hn",
mu=0,
sigma=1,
shape=(nSubj, nRatings - 1),
testval=np.linspace(0.5, 1.5, nRatings - 1)
.reshape(1, nRatings - 1)
.repeat(nSubj, axis=0),
)
cS2 = Deterministic("cS2", mu_c2 + (cS2_hn * sigma_c2))
# Means of SDT distributions
S2mu = meta_d / 2
S1mu = -meta_d / 2
# 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, 1)) - S1mu)
/ C_area_rS1,
nC_rS1[:, 1:] - nC_rS1[:, :-1],
(
(
cumulative_normal(c1 - S1mu)
- cumulative_normal(
cS1[:, nRatings - 2].reshape((nSubj, 1)) - S1mu
)
)
/ C_area_rS1
),
]
),
axis=1,
),
)
# 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, 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, 1)) - S1mu
)
)
/ I_area_rS2,
]
),
axis=1,
),
)
# 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, 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, 1)) - S2mu
)
)
/ I_area_rS1,
]
),
axis=1,
),
)
# 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, 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, 1)) - S2mu
)
)
/ C_area_rS2,
]
),
axis=1,
),
)
# 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)
# TYPE 2 SDT MODEL (META-D)
# Multinomial likelihood for response counts ordered as c(nR_S1,nR_S2)
Multinomial(
"CR_counts",
cr,
nC_rS1,
shape=(nSubj, nRatings),
observed=counts[:, :nRatings],
)
Multinomial(
"FA_counts",
FA,
nI_rS2,
shape=(nSubj, nRatings),
observed=counts[:, nRatings : nRatings * 2],
)
Multinomial(
"M_counts",
m,
nI_rS1,
shape=(nSubj, nRatings),
observed=counts[:, nRatings * 2 : nRatings * 3],
)
Multinomial(
"H_counts",
H,
nC_rS2,
shape=(nSubj, nRatings),
observed=counts[:, nRatings * 3 : nRatings * 4],
)
if sample_model is True:
trace = sample(return_inferencedata=True, **kwargs)
return model, trace
else:
return model
#print(predicted_rts)
return predicted_rts
stimuli_csv = load_file(SENTENCES, sep=",") #sentences with frequencies
sentences = stimuli_csv.groupby(['item', 'label'], sort=False)
parser_with_bayes = pm.Model()
with parser_with_bayes:
lf = HalfNormal('lf', sd=0.3)
le = HalfNormal('le', sd=0.5)
rf = HalfNormal('rf', sd=0.05)
emap = HalfNormal('emap', sd=1.0)
# latency likelihood -- this is where pyactr is used
pyactr_rt = actrmodel_latency(lf, le, rf, emap)
subj_mu_rt = Deterministic('subj_mu_rt', pyactr_rt[0])
subj_rt_observed = Normal('subj_rt_observed',
mu=subj_mu_rt,
sd=10,
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=10,
observed=obj_extraction['rt'])
# we start the sampling
step = Metropolis()
db = Text('subj_obj_extraction/')
trace = sample(draws=100, trace=db, step=step, init='auto', tune=10)
traceplot(trace)
plt.savefig("subj_obj_extraction_posteriors.pdf")
# define the model
# \sig ~ exp(50)
# why? stdev of returns is approx 0.02
# stdev of exp(lam=50) = 0.2
# \nu ~ exp(0.1)
# the DOF for the student T...which should be sample size
# mean of exp(lam=0.1) = 10
# s_i ~ normal(s_i-1, \sig^-2)
# log(y_i) ~ studentT(\nu, 0, exp(-2s_i))
with Model() as sp500_model:
nu = Exponential('nu', 1. / 10,
testval=5.) #50, testval=5.)#results similar...
sigma = Exponential('sigma', 1. / .02, testval=.1)
s = GaussianRandomWalk('s', sigma**-2, shape=len(returns))
volatility_process = Deterministic('volatility_process', exp(-2 * s))
r = StudentT('r', nu, lam=1 / volatility_process, observed=returns)
# fit the model using NUTS
# NUTS is auto-assigned in sample()...why?
# you may get an error like:
# WARNING (theano.gof.compilelock): Overriding existing lock by dead process '10876' (I am process '3456')
# ignore it...the process will move along
with sp500_model:
trace = sample(2000, progressbar=False)
# plot results from model fitting...
# is there a practical reason for starting the plot from 200th sample
traceplot(trace[200:], [nu, sigma])
# plot the results: volatility inferred by the model
fig, ax = plt.subplots() #figsize=(15, 8))
from pymc3 import Model, Normal, HalfNormal, Uniform, Bernoulli, find_MAP, NUTS, sample, Slice, Deterministic
from scipy import optimize
import pymc3 as pm
N = 100
basic_model = Model()
with basic_model:
p = Uniform("freq_cheating", 0, 1)
true_answers = Bernoulli("truths", p)
first_coin_flips = Bernoulli("first_flips", 0.5)
second_coin_flips = Bernoulli("second_flips", 0.5)
determin_val1 = Deterministic(
'determin_val1', first_coin_flips * true_answers +
(1 - first_coin_flips) * second_coin_flips)
determin_val = determin_val1.sum() / float(N)
start = find_MAP(fmin=optimize.fmin_powell)
# instantiate sampler
step = Slice(vars=[true_answers])
# draw 5000 posterior samples
trace = sample(100, step=step, start=start)
step = Slice(vars=[first_coin_flips])
# draw 5000 posterior samples
trace = sample(100, step=step, start=start)
step = Slice(vars=[second_coin_flips])
# draw 5000 posterior samples
trace = sample(100, step=step, start=start)
def mcmc(model_prior_params, data_prior_params, N, epsilon, Z, sensitivity,
num_samples):
data_dim = Z['XX'].shape[0] - 1
if data_dim > 1:
raise ValueError(f'MCMC only works for data dim 1! ({data_dim})')
Z = Z.copy()
Z['X'] = Z['XX'][:, -1][:, None]
import pymc3 as pm
from pymc3.distributions.continuous import InverseGamma
from pymc3.distributions.continuous import Normal
from pymc3.distributions.multivariate import MvNormal
from pymc3.distributions.continuous import Laplace
from pymc3 import Deterministic
import theano.tensor as T
num_tune_samples = 500
max_treedepth = 12
target_accept = .95
with pm.Model():
# data prior
tau_squared = InverseGamma('ts',
alpha=data_prior_params[2],
beta=data_prior_params[3][0, 0])
mu_x_offset = Normal('mu_x_offset', mu=0, sd=1)
mu_x = Deterministic(
'mu', data_prior_params[0][0, 0] + mu_x_offset *
pm.math.sqrt(tau_squared / data_prior_params[1][0, 0]))
x_offset = Normal('x_offset', mu=0, sd=1, shape=N)
x_temp = Deterministic('X',
mu_x + x_offset * pm.math.sqrt(tau_squared))
ones = T.shape_padright(pm.math.ones_like(x_temp))
x = pm.math.concatenate((T.shape_padright(x_temp), ones), axis=1)
# regression model
sigma_squared = InverseGamma('ss',
alpha=model_prior_params[2],
beta=model_prior_params[3])
L = pm.math.sqrt(sigma_squared) * np.linalg.cholesky(
np.linalg.inv(model_prior_params[1]))
theta_offset = MvNormal('theta_offset',
mu=[0] * (data_dim + 1),
cov=np.diag([1] * (data_dim + 1)),
shape=data_dim + 1)
thetas = Deterministic(
't',
model_prior_params[0].flatten() + pm.math.dot(L, theta_offset))
# response data
y_offset = Normal('y_offset', mu=0, sd=1, shape=N)
y = Deterministic(
'y',
pm.math.flatten(pm.math.dot(thetas, x.T)) +
y_offset * pm.math.sqrt(sigma_squared))
# noisy sufficient statistics
noise_scale = sensitivity / epsilon
Laplace('z-X', mu=pm.math.sum(x), b=noise_scale, observed=Z['X'])
Laplace('z-XX',
mu=pm.math.sum(pm.math.sqr(x)),
b=noise_scale,
observed=Z['XX'].flatten())
Laplace('z-Xy',
mu=pm.math.sum(x.T * y),
b=noise_scale,
observed=Z['Xy'])
Laplace('z-yy',
mu=pm.math.sum(pm.math.sqr(y)),
b=noise_scale,
observed=Z['yy'])
trace = pm.sampling.sample(draws=num_samples,
tune=num_tune_samples,
nuts_kwargs={
'max_treedepth': max_treedepth,
'target_accept': target_accept,
})
theta = trace.get_values('t')
sigma_squared = trace.get_values('ss')
return theta.squeeze(), sigma_squared
def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config):
# no a, d taper bounds as GF library saved between b c
chop_bounds = ['b', 'c']
logger.info("Loading %s Green's Functions" % self.name)
self.load_gfs(crust_inds=[self.config.gf_config.reference_model_idx],
make_shared=False)
hp_specific = self.config.dataset_specific_residual_noise_estimation
tpoint = problem_config.get_test_point()
self.input_rvs = input_rvs
self.fixed_rvs = fixed_rvs
logger.info('Seismic optimization on: \n '
' %s' % ', '.join(self.input_rvs.keys()))
t2 = time()
wlogpts = []
self.analyse_noise(tpoint, chop_bounds=chop_bounds)
for gfs in self.gfs.values():
gfs.init_optimization()
self.init_weights()
self.init_hierarchicals(problem_config)
if self.config.station_corrections:
logger.info('Initialized %i hierarchical parameters for '
'station corrections.' %
len(self.get_all_station_names()))
self.input_rvs.update(fixed_rvs)
ref_idx = self.config.gf_config.reference_model_idx
nuc_strike = input_rvs['nucleation_strike']
nuc_dip = input_rvs['nucleation_dip']
t2 = time()
# convert velocities to rupture onset
logger.debug('Fast sweeping ...')
starttimes0 = tt.zeros((self.fault.npatches), dtype=tconfig.floatX)
for index in range(self.fault.nsubfaults):
nuc_dip_idx, nuc_strike_idx = self.fault.fault_locations2idxs(
index=index,
positions_dip=nuc_dip[index],
positions_strike=nuc_strike[index],
backend='theano')
sf_patch_indexs = self.fault.cum_subfault_npatches[index:index + 2]
starttimes_tmp = self.sweepers[index](
(1. /
self.fault.vector2subfault(index, input_rvs['velocities'])),
nuc_dip_idx, nuc_strike_idx)
starttimes_tmp += input_rvs['time'][index]
starttimes0 = tt.set_subtensor(
starttimes0[sf_patch_indexs[0]:sf_patch_indexs[1]],
starttimes_tmp)
wlogpts = []
for wmap in self.wavemaps:
wc = wmap.config
# station corrections
if len(self.hierarchicals) > 0:
logger.info('Applying station corrections ...')
starttimes = (tt.tile(starttimes0, wmap.n_t) - tt.repeat(
self.hierarchicals[wmap.time_shifts_id][
wmap.station_correction_idxs],
self.fault.npatches)).reshape(
(wmap.n_t, self.fault.npatches))
else:
logger.info('No station corrections ...')
starttimes = tt.tile(starttimes0, wmap.n_t).reshape(
(wmap.n_t, self.fault.npatches))
targetidxs = shared(num.atleast_2d(num.arange(wmap.n_t)).T,
borrow=True)
logger.debug('Stacking %s phase ...' % wc.name)
synthetics = tt.zeros(
(wmap.n_t,
wc.arrival_taper.nsamples(self.config.gf_config.sample_rate)),
dtype=tconfig.floatX)
# make sure data is init as array, if non-toeplitz above-traces!
wmap.prepare_data(source=self.events[wc.event_idx],
engine=self.engine,
outmode='array',
chop_bounds=chop_bounds)
for var in self.slip_varnames:
logger.debug('Stacking %s variable' % var)
key = self.get_gflibrary_key(crust_ind=ref_idx,
wavename=wmap.name,
component=var)
synthetics += self.gfs[key].stack_all(
targetidxs=targetidxs,
starttimes=starttimes,
durations=input_rvs['durations'],
slips=input_rvs[var],
interpolation=wc.interpolation)
residuals = wmap.shared_data_array - synthetics
logger.debug('Calculating likelihoods ...')
logpts = multivariate_normal_chol(wmap.datasets,
wmap.weights,
hyperparams,
residuals,
hp_specific=hp_specific)
wlogpts.append(logpts)
t3 = time()
logger.debug('Seismic formula on test model takes: %f' % (t3 - t2))
llk = Deterministic(self._like_name, tt.concatenate((wlogpts)))
return llk.sum()
lf = HalfNormal('lf', sd=1)
le = HalfNormal('le', sd=1)
# compute activation
scaled_time = time**(-decay)
def compute_activation(scaled_time_vector):
compare = tt.isinf(scaled_time_vector)
subvector = scaled_time_vector[(1 - compare).nonzero()]
activation_from_time = tt.log(subvector.sum())
return activation_from_time
activation_from_time, _ = theano.scan(fn=compute_activation,
sequences=scaled_time)
# latency likelihood -- this is where pyactr is used
pyactr_rt = actrmodel_latency(lf, le, decay, activation_from_time)
mu_rt = Deterministic('mu_rt', pyactr_rt)
rt_observed = Normal('rt_observed', mu=mu_rt, sd=0.01, observed=RT)
# accuracy likelihood
odds_reciprocal = tt.exp(-(activation_from_time - threshold) / noise)
mu_prob = Deterministic('mu_prob', 1 / (1 + odds_reciprocal))
prob_observed = Normal('prob_observed',
mu=mu_prob,
sd=0.01,
observed=ACCURACY)
#with lex_decision_with_bayes:
#step = pm.SMC(parallel=True)
#trace = pm.sample(draws=5000, step=step, njobs=1, cores=25)
#dump('../data/lex_dec_pyactr_no_imaginal', trace)
#######################################
# Model definition
# MEASURE = exp(ALPHA)*exp(BETA)**log(X)
# mu = log(MEASURE) = ALPHA+BETA*log(X)
#######################################
with Model() as cost_model:
# Priors for unknown cost model parameters
ALPHA = Normal('ALPHA', mu=0, sigma=1000)
BETA = Normal('BETA', mu=0, sigma=1000, shape=len(ATT))
SIGMA = HalfNormal('SIGMA', sigma=100)
# Model
MU = ALPHA + dot(X_INPUT, BETA)
NU = Deterministic('NU', Exponential('nu_', 1 / 29))
# Likelihood (sampling distribution) of observations
# Y_OBS = Normal('Y_OBS', mu=mu, sigma=sigma, observed=Y_OUTPUT)
Y_OBS = StudentT('Y_OBS', mu=MU, sigma=SIGMA, observed=Y_OUTPUT, nu=NU)
with cost_model:
TRACE = sample(SAMPLES, tune=TUNE, cores=6)
traceplot(TRACE)
with cost_model:
Y_PRED = sample_posterior_predictive(TRACE, 1000, cost_model)
Y_ = Y_PRED['Y_OBS'].mean(axis=0)
PP['model_cost'] = exp(Y_) # depends on imput/output
SUMMARY = df_summary(TRACE)