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