def select_variables(self):
"""
Return model variables depending on problem config.
"""
if self.mode not in modes_catalog.keys():
raise ValueError('Problem mode %s not implemented' % self.mode)
vars_catalog = modes_catalog[self.mode]
variables = []
for datatype in self.datatypes:
if datatype in vars_catalog.keys():
if self.mode == 'geometry':
if self.source_type in vars_catalog[datatype].keys():
source = vars_catalog[datatype][self.source_type]
svars = set(source.keys())
if isinstance(source(),
(PyrockoRS, gf.ExplosionSource)):
svars.discard('magnitude')
variables += utility.weed_input_rvs(
svars, self.mode, datatype)
else:
raise ValueError('Source Type not supported for type'
' of problem, and datatype!')
if datatype == 'seismic':
if self.stf_type in stf_catalog.keys():
stf = stf_catalog[self.stf_type]
variables += utility.weed_input_rvs(
set(stf.keys()), self.mode, datatype)
else:
variables += vars_catalog[datatype]
else:
raise ValueError(
'Datatype %s not supported for type of'
' problem! Supported datatype are: %s' %
(datatype, ', '.join('"%s"' % d
for d in vars_catalog.keys())))
unique_variables = utility.unique_list(variables)
if len(unique_variables) == 0:
raise Exception('Mode and datatype combination not implemented'
' or not resolvable with given datatypes.')
return unique_variables
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 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 built_model(self):
"""
Initialise :class:`pymc3.Model` depending on configuration file,
geodetic and/or seismic data are included. Estimates the fault(s)
geometry.
"""
logger.info('... Building model ...\n')
self.outfolder = os.path.join(self.config.project_dir, 'geometry')
util.ensuredir(self.outfolder)
with pm.Model() as self.model:
logger.debug('Optimization for %i sources', len(self.sources))
pc = self.config.problem_config
input_rvs = []
for param in pc.priors:
input_rvs.append(pm.Uniform(
param.name,
shape=param.dimension,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None))
self.hyperparams = {}
for hp_name in bconfig.hyper_pars.values():
if hp_name in pc.hyperparameters:
hyperpar = pc.hyperparameters[hp_name]
self.hyperparams[hp_name] = pm.Uniform(
hyperpar.name,
shape=hyperpar.dimension,
lower=hyperpar.lower,
upper=hyperpar.upper,
testval=hyperpar.testvalue,
transform=None)
else:
self.hyperparams[hp_name] = 0.
total_llk = tt.zeros((1), tconfig.floatX)
if self._seismic_flag:
self.seis_input_rvs = utility.weed_input_rvs(
input_rvs, dataset='seismic')
# seis
seis_names = [param.name for param in self.seis_input_rvs]
logger.debug(
'Teleseismic optimization on: \n '
' %s' % ', '.join(seis_names))
t2 = time.time()
synths, tmins = self.get_seis_synths(*self.seis_input_rvs)
t3 = time.time()
logger.debug(
'Teleseismic forward model on test model takes: %f' % \
(t3 - t2))
data_trcs = self.chop_traces(tmins)
seis_res = data_trcs - synths
logpts_s = tt.zeros((self.ns_t), tconfig.floatX)
M = seis_res.shape[1]
for k, target in enumerate(self.stargets):
sfactor = target.covariance.log_norm_factor
hp_name = bconfig.hyper_pars[target.codes[3]]
logpts_s = tt.set_subtensor(logpts_s[k:k + 1],
(-0.5) * (sfactor - \
(M * 2 * self.hyperparams[hp_name]) + \
tt.exp(self.hyperparams[hp_name] * 2) * \
(seis_res[k, :].dot(
self.sweights[k]).dot(seis_res[k, :].T))
)
)
seis_llk = pm.Deterministic(self._seis_like_name, logpts_s)
total_llk = total_llk + seis_llk.sum()
if self._geodetic_flag:
self.geo_input_rvs = utility.weed_input_rvs(
input_rvs, dataset='geodetic')
## calc residuals
# geo
geo_names = [param.name for param in self.geo_input_rvs]
logger.debug(
'Geodetic optimization on: \n '
'%s' % ', '.join(geo_names))
t0 = time.time()
disp = self.get_geo_synths(*self.geo_input_rvs)
t1 = time.time()
logger.debug(
'Geodetic forward model on test model takes: %f' % \
(t1 - t0))
los = (disp[:, 0] * self.lv[:, 0] + \
disp[:, 1] * self.lv[:, 1] + \
disp[:, 2] * self.lv[:, 2]) * self.odws
geo_res = self.Bij.srmap(
tt.cast((self.wdata - los), tconfig.floatX))
logpts_g = tt.zeros((self.ng_t), tconfig.floatX)
for l, target in enumerate(self.gtargets):
M = target.displacement.size
gfactor = target.covariance.log_norm_factor
hp_name = bconfig.hyper_pars[target.typ]
logpts_g = tt.set_subtensor(logpts_g[l:l + 1],
(-0.5) * (gfactor - \
(M * 2 * self.hyperparams[hp_name]) + \
tt.exp(self.hyperparams[hp_name] * 2) * \
(geo_res[l].dot(self.gweights[l]).dot(geo_res[l].T))
)
)
geo_llk = pm.Deterministic(self._geo_like_name, logpts_g)
total_llk = total_llk + geo_llk.sum()
like = pm.Deterministic(
self._like_name, total_llk)
llk = pm.Potential(self._like_name, like)
logger.info('Model building was successful!')