def _sample():
# Define MPI message tags
tags = distributed.enum('READY', 'INIT', 'DONE', 'EXIT', 'SAMPLE', 'BETA')
# Initializations and preliminaries
comm = MPI.COMM_WORLD
status = MPI.Status()
model = load_objects(distributed.pymc_model_name)
with model:
for i in range(comm.size):
if i == comm.rank:
logger.info('Working %i' % i)
comm.Barrier()
if comm.rank == 0:
logger.info('Loading passed arguments ...')
arguments = load_objects(distributed.mpiargs_name)
args = [model] + arguments
master_process(comm, tags, status, *args)
else:
worker_process(comm, tags, status)
def load_fault_geometry(self):
"""
Load fault-geometry, i.e. discretized patches.
Returns
-------
:class:`heart.FaultGeometry`
"""
return utility.load_objects(
os.path.join(self.gfpath, bconfig.fault_geometry_name))[0]
def load_fault_geometry(self):
"""
Load fault-geometry, i.e. discretized patches.
Returns
-------
:class:`heart.FaultGeometry`
"""
try:
return utility.load_objects(
os.path.join(self.gfpath, bconfig.fault_geometry_name))[0]
except Exception:
raise FaultGeometryNotFoundError()
def load_sampler_params(project_dir, stage_number, mode):
"""
Load saved parameters from given ATMIP stage.
Parameters
----------
project_dir : str
absolute path to directory of BEAT project
stage number : string
of stage number or 'final' for last stage
mode : str
problem mode that has been solved ('geometry', 'static', 'kinematic')
"""
stage_path = os.path.join(project_dir, mode, 'stage_%s' % stage_number,
config.sample_p_outname)
return utility.load_objects(stage_path)
def load_sampler_params(self, stage_number):
"""
Load saved parameters from last sampled stage.
Parameters
----------
stage number : int
of stage number or -1 for last stage
"""
if stage_number == -1:
if not os.path.exists(self.atmip_path(stage_number)):
prev = self.highest_sampled_stage()
else:
prev = stage_number
else:
prev = stage_number - 1
logger.info('Loading parameters from completed stage {}'.format(prev))
step, updates = utility.load_objects(self.atmip_path(prev))
step.stage = stage_number
return step, updates
def __init__(self, gc, project_dir, event, hypers=False):
super(GeodeticComposite, self).__init__()
self.event = event
logger.debug('Setting up geodetic structure ...\n')
self.name = 'geodetic'
self._like_name = 'geo_like'
geodetic_data_path = os.path.join(project_dir,
bconfig.geodetic_data_name)
self.datasets = utility.load_objects(geodetic_data_path)
logger.info('Number of geodetic datasets: %i ' % self.n_t)
# init geodetic targets
self.targets = heart.init_geodetic_targets(
datasets=self.datasets,
earth_model_name=gc.gf_config.earth_model_name,
interpolation=gc.interpolation,
crust_inds=[gc.gf_config.reference_model_idx],
sample_rate=gc.gf_config.sample_rate)
# merge geodetic data to calculate residuals on single array
datasets, los_vectors, odws, self.Bij = heart.concatenate_datasets(
self.datasets)
logger.info('Number of geodetic data points: %i ' %
self.Bij.ordering.size)
self.sdata = shared(datasets, name='geodetic_data', borrow=True)
self.slos_vectors = shared(los_vectors, name='los_vecs', borrow=True)
self.sodws = shared(odws, name='odws', borrow=True)
if gc.calc_data_cov:
logger.warning('Covariance estimation not implemented (yet)!'
' Using imported covariances!')
else:
logger.info('No data-covariance estimation! Using imported'
' covariances \n')
self.weights = []
for i, data in enumerate(self.datasets):
if int(data.covariance.data.sum()) == data.ncoords:
logger.warn('Data covariance is identity matrix!'
' Please double check!!!')
choli = data.covariance.chol_inverse
self.weights.append(
shared(choli, name='geo_weight_%i' % i, borrow=True))
data.covariance.update_slog_pdet()
if gc.fit_plane:
logger.info('Fit residual ramp selected!')
self._slocx = []
self._slocy = []
for j, data in enumerate(self.datasets):
if isinstance(data, heart.DiffIFG):
locy, locx = data.update_local_coords(self.event)
self._slocx.append(
shared(locx.astype(tconfig.floatX) / km,
name='localx_%s' % j,
borrow=True))
self._slocy.append(
shared(locy.astype(tconfig.floatX) / km,
name='localy_%s' % j,
borrow=True))
else:
logger.debug('Appending placeholder for non-SAR data!')
self._slocx.append(None)
self._slocy.append(None)
self.config = gc
if hypers:
self._llks = []
for t in range(self.n_t):
self._llks.append(
shared(num.array([1.]), name='geo_llk_%i' % t,
borrow=True))
def _test_sample(self, n_jobs, test_folder):
logger.info('Running on %i cores...' % n_jobs)
n = 4
mu1 = num.ones(n) * (1. / 2)
mu2 = -mu1
stdev = 0.1
sigma = num.power(stdev, 2) * num.eye(n)
isigma = num.linalg.inv(sigma)
dsigma = num.linalg.det(sigma)
w1 = stdev
w2 = (1 - stdev)
def two_gaussians(x):
log_like1 = - 0.5 * n * tt.log(2 * num.pi) \
- 0.5 * tt.log(dsigma) \
- 0.5 * (x - mu1).T.dot(isigma).dot(x - mu1)
log_like2 = - 0.5 * n * tt.log(2 * num.pi) \
- 0.5 * tt.log(dsigma) \
- 0.5 * (x - mu2).T.dot(isigma).dot(x - mu2)
return tt.log(w1 * tt.exp(log_like1) + w2 * tt.exp(log_like2))
with pm.Model() as PT_test:
X = pm.Uniform('X',
shape=n,
lower=-2. * num.ones_like(mu1),
upper=2. * num.ones_like(mu1),
testval=-1. * num.ones_like(mu1),
transform=None)
like = pm.Deterministic('tmp', two_gaussians(X))
llk = pm.Potential('like', like)
with PT_test:
step = metropolis.Metropolis(
n_chains=n_jobs,
likelihood_name=PT_test.deterministics[0].name,
proposal_name='MultivariateCauchy',
tune_interval=self.tune_interval)
pt.pt_sample(
step,
n_chains=n_jobs,
n_samples=self.n_samples,
swap_interval=self.swap_interval,
beta_tune_interval=self.beta_tune_interval,
n_workers_posterior=self.n_workers_posterior,
homepath=test_folder,
progressbar=False,
buffer_size=self.buffer_size,
model=PT_test,
rm_flag=False,
keep_tmp=False)
stage_handler = TextStage(test_folder)
mtrace = stage_handler.load_multitrace(-1, model=PT_test)
history = load_objects(os.path.join(stage_handler.stage_path(-1), sample_p_outname))
n_steps = self.n_samples
burn = self.burn
thin = self.thin
def burn_sample(x):
if n_steps == 1:
return x
else:
nchains = int(x.shape[0] / n_steps)
xout = []
for i in range(nchains):
nstart = int((n_steps * i) + (n_steps * burn))
nend = int(n_steps * (i + 1) - 1)
xout.append(x[nstart:nend:thin])
return num.vstack(xout)
from pymc3 import traceplot
from matplotlib import pyplot as plt
traceplot(mtrace, transform=burn_sample)
fig, axes = plt.subplots(
nrows=1, ncols=2, figsize=mpl_papersize('a5', 'portrait'))
axes[0].plot(history.acceptance, 'r')
axes[0].set_ylabel('Acceptance ratio')
axes[0].set_xlabel('Update interval')
axes[1].plot(num.array(history.t_scales), 'k')
axes[1].set_ylabel('Temperature scaling')
axes[1].set_xlabel('Update interval')
n_acceptances = len(history)
ncol = 3
nrow = int(num.ceil(n_acceptances / float(ncol)))
fig2, axes1 = plt.subplots(
nrows=nrow, ncols=ncol, figsize=mpl_papersize('a4', 'portrait'))
axes1 = num.atleast_2d(axes1)
fig3, axes2 = plt.subplots(
nrows=nrow, ncols=ncol, figsize=mpl_papersize('a4', 'portrait'))
axes2 = num.atleast_2d(axes2)
acc_arrays = history.get_acceptance_matrixes_array()
sc_arrays = history.get_sample_counts_array()
scvmin = sc_arrays.min(0).min(0)
scvmax = sc_arrays.max(0).max(0)
accvmin = acc_arrays.min(0).min(0)
accvmax = acc_arrays.max(0).max(0)
for i in range(ncol * nrow):
rowi, coli = mod_i(i, ncol)
#if i == n_acceptances:
# pass
#plt.colorbar(im, axes1[rowi, coli])
#plt.colorbar(im2, axes2[rowi, coli])
if i > n_acceptances - 1:
try:
fig2.delaxes(axes1[rowi, coli])
fig3.delaxes(axes2[rowi, coli])
except KeyError:
pass
else:
axes1[rowi, coli].matshow(
history.acceptance_matrixes[i],
vmin=accvmin[i], vmax=accvmax[i], cmap='hot')
axes1[rowi, coli].set_title('min %i, max%i' % (accvmin[i], accvmax[i]))
axes1[rowi, coli].get_xaxis().set_ticklabels([])
axes2[rowi, coli].matshow(
history.sample_counts[i], vmin=scvmin[i], vmax=scvmax[i], cmap='hot')
axes2[rowi, coli].set_title('min %i, max%i' % (scvmin[i], scvmax[i]))
axes2[rowi, coli].get_xaxis().set_ticklabels([])
fig2.suptitle('Accepted number of samples')
fig2.tight_layout()
fig3.tight_layout()
fig3.suptitle('Total number of samples')
plt.show()
def __init__(self, gc, project_dir, events, hypers=False):
super(GeodeticComposite, self).__init__(events)
logger.debug('Setting up geodetic structure ...\n')
self.name = 'geodetic'
self._like_name = 'geo_like'
geodetic_data_path = os.path.join(project_dir,
bconfig.geodetic_data_name)
self.datasets = utility.load_objects(geodetic_data_path)
logger.info('Number of geodetic datasets: %i ' % self.n_t)
# init geodetic targets
self.targets = heart.init_geodetic_targets(
datasets=self.datasets,
earth_model_name=gc.gf_config.earth_model_name,
interpolation=gc.interpolation,
crust_inds=[gc.gf_config.reference_model_idx],
sample_rate=gc.gf_config.sample_rate)
# merge geodetic data to calculate residuals on single array
datasets, los_vectors, odws, self.Bij = heart.concatenate_datasets(
self.datasets)
logger.info('Number of geodetic data points: %i ' %
self.Bij.ordering.size)
self.sdata = shared(datasets, name='geodetic_data', borrow=True)
self.slos_vectors = shared(los_vectors, name='los_vecs', borrow=True)
self.sodws = shared(odws, name='odws', borrow=True)
if gc.calc_data_cov:
logger.warning('Covariance estimation not implemented (yet)!'
' Using imported covariances!')
else:
logger.info('No data-covariance estimation! Using imported'
' covariances \n')
self.weights = []
for i, data in enumerate(self.datasets):
if int(data.covariance.data.sum()) == data.ncoords:
logger.warning('Data covariance is identity matrix!'
' Please double check!!!')
choli = data.covariance.chol_inverse
self.weights.append(
shared(choli, name='geo_weight_%i' % i, borrow=True))
data.covariance.update_slog_pdet()
if gc.corrections_config.has_enabled_corrections:
correction_configs = gc.corrections_config.iter_corrections()
logger.info('Initialising corrections ...')
for data in self.datasets:
data.setup_corrections(event=self.event,
correction_configs=correction_configs)
self.config = gc
if hypers:
self._llks = []
for t in range(self.n_t):
self._llks.append(
shared(num.array([1.]), name='geo_llk_%i' % t,
borrow=True))
def __init__(self, config):
logger.info('... Initialising Geometry Optimizer ... \n')
pc = config.problem_config
super(GeometryOptimizer, self).__init__(pc)
# Load event
if config.event is None:
if self._seismic_flag:
self.event = model.load_one_event(
os.path.join(
config.seismic_config.datadir, 'event.txt'))
else:
logger.warn('Found no event information!')
else:
self.event = config.event
# Init sources
self.sources = []
for i in range(pc.n_faults):
if self.event:
source = heart.RectangularSource.from_pyrocko_event(self.event)
# hardcoded inversion for hypocentral time
source.stf.anchor = -1.
else:
source = heart.RectangularSource()
self.sources.append(source)
dsources = utility.transform_sources(self.sources, pc.datasets)
if self._seismic_flag:
logger.debug('Setting up seismic structure ...\n')
sc = config.seismic_config
self.engine = gf.LocalEngine(
store_superdirs=[sc.gf_config.store_superdir])
seismic_data_path = os.path.join(
config.project_dir, bconfig.seismic_data_name)
stations, data_traces = utility.load_objects(
seismic_data_path)
stations = utility.apply_station_blacklist(stations, sc.blacklist)
self.stations = utility.weed_stations(
stations, self.event, distances=sc.distances)
self.data_traces = utility.weed_data_traces(
data_traces, self.stations)
target_deltat = 1. / sc.gf_config.sample_rate
if self.data_traces[0].deltat != target_deltat:
utility.downsample_traces(
self.data_traces, deltat=target_deltat)
self.stargets = heart.init_targets(
self.stations,
channels=sc.channels,
sample_rate=sc.gf_config.sample_rate,
crust_inds=[0], # always reference model
interpolation='multilinear')
self.ns_t = len(self.stargets)
logger.info('Number of seismic datasets: %i ' % self.ns_t)
if sc.calc_data_cov:
logger.info('Estimating seismic data-covariances ...\n')
cov_ds_seismic = cov.get_seismic_data_covariances(
data_traces=self.data_traces,
filterer=sc.filterer,
sample_rate=sc.gf_config.sample_rate,
arrival_taper=sc.arrival_taper,
engine=self.engine,
event=self.event,
targets=self.stargets)
else:
logger.info('No data-covariance estimation ...\n')
cov_ds_seismic = []
at = sc.arrival_taper
n_samples = int(num.ceil(
(num.abs(at.a) + at.d) * sc.gf_config.sample_rate))
for tr in self.data_traces:
cov_ds_seismic.append(
num.power(bconfig.default_seis_std, 2) * \
num.eye(n_samples))
self.sweights = []
for s_t in range(self.ns_t):
if self.stargets[s_t].covariance.data is None:
logger.debug(
'No data covariance given. Seting default: sigma2 * I')
self.stargets[s_t].covariance.data = cov_ds_seismic[s_t]
icov = self.stargets[s_t].covariance.inverse
self.sweights.append(shared(icov))
# syntetics generation
logger.debug('Initialising synthetics functions ... \n')
self.get_seis_synths = theanof.SeisSynthesizer(
engine=self.engine,
sources=dsources['seismic'],
targets=self.stargets,
event=self.event,
arrival_taper=sc.arrival_taper,
filterer=sc.filterer)
self.chop_traces = theanof.SeisDataChopper(
sample_rate=sc.gf_config.sample_rate,
traces=self.data_traces,
arrival_taper=sc.arrival_taper,
filterer=sc.filterer)
if self._geodetic_flag:
logger.debug('Setting up geodetic structure ...\n')
gc = config.geodetic_config
geodetic_data_path = os.path.join(
config.project_dir, bconfig.geodetic_data_name)
self.gtargets = utility.load_objects(geodetic_data_path)
self.ng_t = len(self.gtargets)
logger.info('Number of geodetic datasets: %i ' % self.ng_t)
# geodetic data
_disp_list = [self.gtargets[i].displacement
for i in range(self.ng_t)]
_lons_list = [self.gtargets[i].lons for i in range(self.ng_t)]
_lats_list = [self.gtargets[i].lats for i in range(self.ng_t)]
_odws_list = [self.gtargets[i].odw for i in range(self.ng_t)]
_lv_list = [self.gtargets[i].update_los_vector()
for i in range(self.ng_t)]
if gc.calc_data_cov:
logger.info('Using data covariance!')
else:
logger.info('No data-covariance estimation ...\n')
for g_t in self.gtargets:
g_t.covariance.data = num.power(
bconfig.default_geo_std, 2) * \
num.eye(g_t.lats.size)
self.gweights = []
for g_t in range(self.ng_t):
icov = self.gtargets[g_t].covariance.inverse
self.gweights.append(shared(icov))
# merge geodetic data to call pscmp only once each forward model
ordering = utility.ListArrayOrdering(_disp_list, intype='numpy')
self.Bij = utility.ListToArrayBijection(ordering, _disp_list)
odws = self.Bij.fmap(_odws_list)
lons = self.Bij.fmap(_lons_list)
lats = self.Bij.fmap(_lats_list)
logger.info('Number of geodetic data points: %i ' % lats.shape[0])
self.wdata = shared(self.Bij.fmap(_disp_list) * odws)
self.lv = shared(self.Bij.f3map(_lv_list))
self.odws = shared(odws)
# syntetics generation
logger.debug('Initialising synthetics functions ... \n')
self.get_geo_synths = theanof.GeoLayerSynthesizerStatic(
lats=lats,
lons=lons,
store_superdir=gc.gf_config.store_superdir,
crust_ind=0, # always reference model
sources=dsources['geodetic'])
self.config = config
