def init_hierarchicals(self, problem_config):
"""
Initialize hierarchical parameters.
Ramp estimation in azimuth and range direction of a radar scene.
"""
hierarchicals = problem_config.hierarchicals
if self.config.fit_plane:
logger.info('Estimating ramp for each dataset...')
for data in self.datasets:
if isinstance(data, heart.DiffIFG):
for hierarchical_name in data.plane_names():
hierarchical_keys = utility.list2string(
hierarchicals.keys())
if not self.config.fit_plane and \
hierarchical_name in hierarchicals:
raise ConfigInconsistentError(
'Plane removal disabled, but they are defined'
' in the problem configuration'
' (hierarchicals)! \n'
' Got: %s' % hierarchical_keys)
if self.config.fit_plane and \
hierarchical_name not in hierarchicals:
raise ConfigInconsistentError(
'Plane corrections enabled, but they are'
' not defined in the problem configuration!'
' (hierarchicals). Looking for: %s \n'
' Got: %s' %
(hierarchical_name, hierarchical_keys))
param = hierarchicals[hierarchical_name]
if not num.array_equal(param.lower, param.upper):
kwargs = dict(name=param.name,
shape=param.dimension,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None,
dtype=tconfig.floatX)
try:
self.hierarchicals[
hierarchical_name] = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
self.hierarchicals[hierarchical_name] = \
Uniform.dist(**kwargs)
else:
logger.info(
'not solving for %s, got fixed at %s' %
(param.name,
utility.list2string(param.lower.flatten())))
self.hierarchicals[hierarchical_name] = param.lower
else:
logger.info('No plane for GNSS data.')
logger.info('Initialized %i hierarchical parameters '
'(ramps).' % len(self.hierarchicals))
def get_random_variables(self):
"""
Evaluate problem setup and return random variables dictionary.
Has to be executed in a "with model context"!
Returns
-------
rvs : dict
variable random variables
fixed_params : dict
fixed random parameters
"""
pc = self.config.problem_config
logger.debug('Optimization for %i sources', pc.n_sources)
rvs = dict()
fixed_params = dict()
for param in pc.priors.values():
if not num.array_equal(param.lower, param.upper):
shape = bconfig.get_parameter_shape(param, pc)
kwargs = dict(
name=param.name,
shape=shape,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None,
dtype=tconfig.floatX)
try:
rvs[param.name] = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
rvs[param.name] = Uniform.dist(**kwargs)
else:
logger.info(
'not solving for %s, got fixed at %s' % (
param.name,
list2string(param.lower.flatten())))
fixed_params[param.name] = param.lower
return rvs, fixed_params
def init_hierarchicals(self, problem_config):
"""
Initialize hierarchical parameters.
Ramp estimation in azimuth and range direction of a radar scene.
"""
hierarchicals = problem_config.hierarchicals
if self.config.fit_plane:
logger.info('Estimating ramp for each dataset...')
for data in self.datasets:
hierarchical_name = data.name + '_ramp'
if not self.config.fit_plane and \
hierarchical_name in hierarchicals:
raise ConfigInconsistentError(
'Plane removal disabled, but they are defined'
' in the problem configuration (hierarchicals)!')
if isinstance(data, heart.DiffIFG):
if self.config.fit_plane and \
hierarchical_name not in hierarchicals:
raise ConfigInconsistentError(
'Plane corrections enabled, but they are'
' not defined in the problem configuration!'
' (hierarchicals)')
param = hierarchicals[hierarchical_name]
kwargs = dict(name=param.name,
shape=param.dimension,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None,
dtype=tconfig.floatX)
try:
self.hierarchicals[data.name] = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
self.hierarchicals[data.name] = \
Uniform.dist(**kwargs)
logger.info('Initialized %i hierarchical parameters '
'(ramps).' % len(self.hierarchicals.keys()))
def init_hierarchicals(self, problem_config):
"""
Initialise random variables for temporal station corrections.
"""
if not self.config.station_corrections and \
self.correction_name in problem_config.hierarchicals:
raise ConfigInconsistentError(
'Station corrections disabled, but they are defined'
' in the problem configuration!')
if self.config.station_corrections and \
self.correction_name not in problem_config.hierarchicals:
raise ConfigInconsistentError(
'Station corrections enabled, but they are not defined'
' in the problem configuration!')
if self.correction_name in problem_config.hierarchicals:
logger.info(
'Estimating time shift for each station and waveform map...')
for wmap in self.wavemaps:
nhierarchs = len(wmap.get_station_names())
logger.info('For %s with %i shifts' %
(wmap.time_shifts_id, nhierarchs))
param = problem_config.hierarchicals[self.correction_name]
kwargs = dict(name=wmap.time_shifts_id,
shape=nhierarchs,
lower=num.repeat(param.lower, nhierarchs),
upper=num.repeat(param.upper, nhierarchs),
testval=num.repeat(param.testvalue, nhierarchs),
transform=None,
dtype=tconfig.floatX)
try:
station_corrs_rv = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
station_corrs_rv = Uniform.dist(**kwargs)
self.hierarchicals[wmap.time_shifts_id] = station_corrs_rv
else:
nhierarchs = 0
def init_hyperparams(self):
"""
Evaluate problem setup and return hyperparameter dictionary.
"""
pc = self.config.problem_config
hyperparameters = copy.deepcopy(pc.hyperparameters)
hyperparams = {}
n_hyp = 0
modelinit = True
self._hypernames = []
for datatype, composite in self.composites.items():
hypernames = composite.get_hypernames()
for hp_name in hypernames:
if hp_name in hyperparameters.keys():
hyperpar = hyperparameters.pop(hp_name)
if composite.config: # only data composites
if composite.config.dataset_specific_residual_noise_estimation:
if datatype == 'seismic':
wmap = composite.hyper2wavemap(hp_name)
ndata = wmap.hypersize
else:
ndata = len(composite.get_all_station_names())
else:
ndata = 1
else:
ndata = 1
else:
raise InconsistentNumberHyperparametersError(
'Datasets and -types require additional '
' hyperparameter(s): %s!' % hp_name)
if not num.array_equal(hyperpar.lower, hyperpar.upper):
dimension = hyperpar.dimension * ndata
kwargs = dict(name=hyperpar.name,
shape=dimension,
lower=num.repeat(hyperpar.lower, ndata),
upper=num.repeat(hyperpar.upper, ndata),
testval=num.repeat(hyperpar.testvalue,
ndata),
dtype=tconfig.floatX,
transform=None)
try:
hyperparams[hp_name] = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
hyperparams[hp_name] = Uniform.dist(**kwargs)
modelinit = False
n_hyp += dimension
self._hypernames.append(hyperpar.name)
else:
logger.info(
'not solving for %s, got fixed at %s' %
(hyperpar.name, list2string(hyperpar.lower.flatten())))
hyperparams[hyperpar.name] = hyperpar.lower
if len(hyperparameters) > 0:
raise InconsistentNumberHyperparametersError(
'There are hyperparameters in config file, which are not'
' covered by datasets/datatypes.')
if modelinit:
logger.info('Optimization for %i hyperparameters in total!', n_hyp)
self.hyperparams = hyperparams
def init_hierarchicals(self, problem_config):
"""
Initialise random variables for temporal station corrections.
"""
hierarchicals = problem_config.hierarchicals
self._hierarchicalnames = []
if not self.config.station_corrections and \
self.correction_name in hierarchicals:
raise ConfigInconsistentError(
'Station corrections disabled, but they are defined'
' in the problem configuration!')
if self.config.station_corrections and \
self.correction_name not in hierarchicals:
raise ConfigInconsistentError(
'Station corrections enabled, but they are not defined'
' in the problem configuration!')
if self.correction_name in hierarchicals:
logger.info(
'Estimating time shift for each station and waveform map...')
for wmap in self.wavemaps:
hierarchical_name = wmap.time_shifts_id
nhierarchs = len(wmap.get_station_names())
logger.info('For %s with %i shifts' %
(hierarchical_name, nhierarchs))
if hierarchical_name in hierarchicals:
logger.info('Using wavemap specific imported:'
' %s ' % hierarchical_name)
param = hierarchicals[hierarchical_name]
else:
logger.info('Using global %s' % self.correction_name)
param = copy.deepcopy(
problem_config.hierarchicals[self.correction_name])
param.lower = num.repeat(param.lower, nhierarchs)
param.upper = num.repeat(param.upper, nhierarchs)
param.testvalue = num.repeat(param.testvalue, nhierarchs)
if hierarchical_name not in self.hierarchicals:
if not num.array_equal(param.lower, param.upper):
kwargs = dict(name=hierarchical_name,
shape=param.dimension,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None,
dtype=tconfig.floatX)
try:
self.hierarchicals[hierarchical_name] = Uniform(
**kwargs)
except TypeError:
kwargs.pop('name')
self.hierarchicals[hierarchical_name] = \
Uniform.dist(**kwargs)
self._hierarchicalnames.append(hierarchical_name)
else:
logger.info(
'not solving for %s, got fixed at %s' %
(param.name,
utility.list2string(param.lower.flatten())))
self.hierarchicals[hierarchical_name] = param.lower
def init_hierarchicals(self, problem_config):
"""
Initialize hierarchical parameters.
Ramp estimation in azimuth and range direction of a radar scene and/or
Rotation of GNSS stations around an Euler pole
"""
hierarchicals = problem_config.hierarchicals
self._hierarchicalnames = []
for number, corr in enumerate(
self.config.corrections_config.iter_corrections()):
logger.info('Evaluating config for %s corrections '
'for datasets...' % corr.feature)
if corr.enabled:
for data in self.datasets:
if data.name in corr.dataset_names:
hierarchical_names = corr.get_hierarchical_names(
name=data.name, number=number)
else:
hierarchical_names = []
for hierarchical_name in hierarchical_names:
if not corr.enabled and hierarchical_name in hierarchicals:
raise ConfigInconsistentError(
'%s %s disabled, but they are defined'
' in the problem configuration'
' (hierarchicals)!' %
(corr.feature, data.name))
if corr.enabled and hierarchical_name not in hierarchicals \
and data.name in corr.dataset_names:
raise ConfigInconsistentError(
'%s %s corrections enabled, but they are'
' not defined in the problem configuration!'
' (hierarchicals)' % (corr.feature, data.name))
param = hierarchicals[hierarchical_name]
if hierarchical_name not in self.hierarchicals:
if not num.array_equal(param.lower, param.upper):
kwargs = dict(name=param.name,
shape=param.dimension,
lower=param.lower,
upper=param.upper,
testval=param.testvalue,
transform=None,
dtype=tconfig.floatX)
try:
self.hierarchicals[
hierarchical_name] = Uniform(**kwargs)
except TypeError:
kwargs.pop('name')
self.hierarchicals[hierarchical_name] = \
Uniform.dist(**kwargs)
self._hierarchicalnames.append(
hierarchical_name)
else:
logger.info(
'not solving for %s, got fixed at %s' %
(param.name,
utility.list2string(
param.lower.flatten())))
self.hierarchicals[
hierarchical_name] = param.lower
else:
logger.info('No %s correction!' % corr.feature)
logger.info('Initialized %i hierarchical parameters.' %
len(self.hierarchicals))
