def __init__( self, dataset, hyper_result=None, cosmology=cosmo.Planck15, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): super().__init__( dataset=dataset, hyper_result=hyper_result, cosmology=cosmology, settings_pixelization=settings_pixelization, settings_inversion=settings_inversion, preloads=preloads, ) if self.hyper_result is not None: self.set_hyper_dataset(result=self.hyper_result) else: self.hyper_galaxy_visibilities_path_dict = None self.hyper_model_visibilities = None
def __init__( self, masked_interferometer, settings, cosmology, results=None, preloads=pload.Preloads(), ): super(Analysis, self).__init__( masked_dataset=masked_interferometer, settings=settings, cosmology=cosmology, results=results, preloads=preloads, ) result = ag_analysis.last_result_with_use_as_hyper_dataset( results=results) if result is not None: self.hyper_galaxy_visibilities_path_dict = ( result.hyper_galaxy_visibilities_path_dict) self.hyper_model_visibilities = result.hyper_model_visibilities else: self.hyper_galaxy_visibilities_path_dict = None self.hyper_model_visibilities = None
def mappers_of_planes_from_grid( self, grid, settings_pixelization=pix.SettingsPixelization(), preloads=pload.Preloads(), ): mappers_of_planes = [] traced_grids_of_planes = self.traced_grids_of_planes_from_grid( grid=grid) traced_sparse_grids_of_planes, sparse_image_plane_grid = self.traced_sparse_grids_of_planes_from_grid( grid=grid, settings_pixelization=settings_pixelization, preloads=preloads) for (plane_index, plane) in enumerate(self.planes): if not plane.has_pixelization: mappers_of_planes.append(None) else: mapper = plane.mapper_from_grid_and_sparse_grid( grid=traced_grids_of_planes[plane_index], sparse_grid=traced_sparse_grids_of_planes[plane_index], sparse_image_plane_grid=sparse_image_plane_grid, settings_pixelization=settings_pixelization, ) mappers_of_planes.append(mapper) return mappers_of_planes
def traced_sparse_grids_of_planes_from_grid( self, grid, settings_pixelization=pix.SettingsPixelization(), preloads=pload.Preloads(), ): if (preloads.sparse_grids_of_planes is None or settings_pixelization.is_stochastic): sparse_image_plane_grids_of_planes = self.sparse_image_plane_grids_of_planes_from_grid( grid=grid, pixelization_setting=settings_pixelization) else: sparse_image_plane_grids_of_planes = preloads.sparse_grids_of_planes traced_sparse_grids_of_planes = [] for (plane_index, plane) in enumerate(self.planes): if sparse_image_plane_grids_of_planes[plane_index] is None: traced_sparse_grids_of_planes.append(None) else: traced_sparse_grids = self.traced_grids_of_planes_from_grid( grid=sparse_image_plane_grids_of_planes[plane_index]) traced_sparse_grids_of_planes.append( traced_sparse_grids[plane_index]) if len(sparse_image_plane_grids_of_planes) > 1: return traced_sparse_grids_of_planes, sparse_image_plane_grids_of_planes[ 1] else: return traced_sparse_grids_of_planes, sparse_image_plane_grids_of_planes[ 0]
def __init__( self, dataset, hyper_result=None, cosmology=cosmo.Planck15, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): super().__init__(hyper_result=hyper_result, cosmology=cosmology) self.dataset = dataset if self.hyper_result is not None: if hyper_result.search is not None: hyper_result.search.paths = None self.set_hyper_dataset(result=self.hyper_result) else: self.hyper_galaxy_image_path_dict = None self.hyper_model_image = None self.settings_pixelization = settings_pixelization self.settings_inversion = settings_inversion self.preloads = preloads
def inversion_imaging_from_grid_and_data( self, grid, image, noise_map, convolver, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): if preloads.mapper is None: mappers_of_planes = self.mappers_of_planes_from_grid( grid=grid, settings_pixelization=settings_pixelization, preloads=preloads, ) else: mappers_of_planes = [preloads.mapper] return inv.InversionImagingMatrix.from_data_mapper_and_regularization( image=image, noise_map=noise_map, convolver=convolver, mapper=mappers_of_planes[-1], regularization=self.regularizations_of_planes[-1], settings=settings_inversion, preloads=preloads, )
def preload_inversion_with_fixed_profiles( result: af.Result, model: Optional[af.Collection] = None ) -> pload.Preloads: """ If the `MassProfile`'s in a model are all fixed parameters, and the parameters of the source `Pixelization` are also fixed, the mapping of image-pixels to the source-pixels does not change for every likelihood evaluations. Matrices used by the linear algebra calculation in an `Inversion` can therefore be preloaded. This function inspects the `Result` and `Model` and returns a `Preload` object with the correct quantities for p reloading. It raises an error if the `Model` is not suited to the preloading. The preload is typically used when the lens light is being fitted, and a fixed mass model and source pixelization and regularization are being used. This occurs in the LIGHT PIPELINE of the SLaM pipelines. Parameters ---------- result The result containing the linear algebra matrices which are to be preloaded (corresponding to the maximum likelihood model of the model-fit). model The model, which is inspected to make sure the model-fit can have its `Inversion` quantities preloaded. Returns ------- Grid2D The `Preloads` object containing the `Inversion` linear algebra matrices. """ if model is not None: # if model.has_model(cls=mp.MassProfile): # raise exc.PreloadException( # "Cannot preload inversion when the mass profile is a model" # ) if model_util.pixelization_is_model_from(model=model): raise exc.PreloadException( "Cannot preload inversion when the model includes a pixelization" ) preloads = preload_pixelization_grid_from(result=result, model=model) inversion = result.max_log_likelihood_fit.inversion return pload.Preloads( sparse_grids_of_planes=preloads.sparse_grids_of_planes, blurred_mapping_matrix=inversion.blurred_mapping_matrix, curvature_matrix_sparse_preload=inversion.curvature_matrix_sparse_preload, curvature_matrix_preload_counts=inversion.curvature_matrix_preload_counts, mapper=inversion.mapper, )
def __init__( self, masked_imaging, settings, cosmology, results=None, preloads=pload.Preloads(), ): super().__init__( masked_dataset=masked_imaging, settings=settings, cosmology=cosmology, results=results, preloads=preloads, )
def setup_preloads(self, results): # Preload the source-plane grid of coordinates if the source parameters are fixed, skipping the KMeans. sparse_grids_of_planes = None blurred_mapping_matrix = None curvature_matrix = None mapper = None if (not self.is_hyper_phase and results.last is not None and self.pixelization is not None and not self.pixelization_is_model): if self.pixelization.__class__ is results.last.pixelization.__class__: if hasattr(results.last, "hyper"): sparse_grids_of_planes = ( results.last.hyper. max_log_likelihood_pixelization_grids_of_planes) else: sparse_grids_of_planes = ( results.last. max_log_likelihood_pixelization_grids_of_planes) # Preload the blurred_mapping_matrix and curvature matrix calculation if only the parametric light profiles # are being fitted. if self.preload_inversion and not self.is_hyper_phase: if hasattr(results.last, "hyper"): inversion = results.last.hyper.max_log_likelihood_fit.inversion else: inversion = results.last.max_log_likelihood_fit.inversion if inversion is not None: blurred_mapping_matrix = inversion.blurred_mapping_matrix curvature_matrix = inversion.curvature_matrix mapper = inversion.mapper return pload.Preloads( sparse_grids_of_planes=sparse_grids_of_planes, mapper=mapper, blurred_mapping_matrix=blurred_mapping_matrix, curvature_matrix=curvature_matrix, )
def preload_pixelization_grid_from( result: af.Result, model: Optional[af.Collection] = None ) -> pload.Preloads: """ If a model contains a `Pixelization` that is an `instance` whose parameters are fixed and the `Result` contains the grid of this pixelization corresponding to these parameters, the grid can be preloaded to avoid repeating calculations which recompute the pixelization grid every iteration of the log likelihood function. This function inspects the `Result` and `Model` and returns a `Preloads` object with the appropriate pixelization grid for preloading. It raises an error if the `Model` is not suited to the preloading. Parameters ---------- result The result containing the pixelization grid which is to be preloaded (corresponding to the maximum likelihood model of the model-fit). model The model, which is inspected to make sure the model-fit can have its pixelization preloaded. Returns ------- Preloads The `Preloads` object containing the (y,x) grid of coordinates representing the source plane pixelization centres. """ if model is not None: if model_util.pixelization_from(model=model) is None: raise exc.PreloadException( "Cannot preload pixelization when the model does not include a pixelization" ) if model_util.pixelization_is_model_from(model=model): raise exc.PreloadException( "Cannot preload pixelization when the model include a pixelization but it is a model" "component (preloading its grid will nullify changing its parameters)" ) return pload.Preloads( sparse_grids_of_planes=result.max_log_likelihood_pixelization_grids_of_planes )
def __init__( self, dataset, positions: grid_2d_irregular.Grid2DIrregular = None, hyper_result=None, cosmology=cosmo.Planck15, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), settings_lens=settings.SettingsLens(), preloads=pload.Preloads(), ): """ Parameters ---------- dataset positions : grid_2d_irregular.Grid2DIrregular Image-pixel coordinates in arc-seconds of bright regions of the lensed source that will map close to one another in the source-plane(s) for an accurate mass model, which can be used to discard unphysical mass models during model-fitting. cosmology settings_pixelization settings_inversion settings_lens preloads """ super().__init__( dataset=dataset, hyper_result=hyper_result, cosmology=cosmology, settings_pixelization=settings_pixelization, settings_inversion=settings_inversion, preloads=preloads, ) AnalysisLensing.__init__(self=self, settings_lens=settings_lens, cosmology=cosmology) self.positions = positions self.settings_lens = settings_lens
def __init__( self, dataset, hyper_result=None, cosmology=cosmo.Planck15, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): super().__init__( dataset=dataset, hyper_result=hyper_result, cosmology=cosmology, settings_pixelization=settings_pixelization, settings_inversion=settings_inversion, preloads=preloads, ) self.dataset = dataset
def make_analysis(self, dataset, mask, results=None, preloads=pload.Preloads()): """ Returns an lens object. Also calls the prior passing and masked_interferometer modifying functions to allow child classes to change the behaviour of the phase. Parameters ---------- positions mask: Mask2D The default masks passed in by the pipeline dataset: im.Interferometer An masked_interferometer that has been masked results: autofit.tools.pipeline.ResultsCollection The result from the previous phase Returns ------- lens : Analysis An lens object that the `NonLinearSearch` calls to determine the fit of a set of values """ masked_interferometer = interferometer.MaskedInterferometer( interferometer=dataset, visibilities_mask=mask, real_space_mask=self.real_space_mask, settings=self.settings.settings_masked_interferometer, ) self.output_phase_info() return self.Analysis( masked_interferometer=masked_interferometer, settings=self.settings, cosmology=self.cosmology, results=results, preloads=preloads, )
def inversion_interferometer_from_grid_and_data( self, grid, visibilities, noise_map, transformer, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): mappers_of_planes = self.mappers_of_planes_from_grid( grid=grid, settings_pixelization=settings_pixelization, preloads=preloads ) return inv.AbstractInversionInterferometer.from_data_mapper_and_regularization( visibilities=visibilities, noise_map=noise_map, transformer=transformer, mapper=mappers_of_planes[-1], regularization=self.regularizations_of_planes[-1], settings=settings_inversion, )
def __init__( self, masked_imaging, tracer, hyper_image_sky=None, hyper_background_noise=None, use_hyper_scaling=True, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): """ An lens fitter, which contains the tracer's used to perform the fit and functions to manipulate \ the lens dataset's hyper_galaxies. Parameters ----------- tracer : ray_tracing.Tracer The tracer, which describes the ray-tracing and strong lens configuration. scaled_array_2d_from_array_1d : func A function which maps the 1D lens hyper_galaxies to its unmasked 2D arrays. """ self.tracer = tracer if use_hyper_scaling: image = hyper_image_from_image_and_hyper_image_sky( image=masked_imaging.image, hyper_image_sky=hyper_image_sky) noise_map = hyper_noise_map_from_noise_map_tracer_and_hyper_background_noise( noise_map=masked_imaging.noise_map, tracer=tracer, hyper_background_noise=hyper_background_noise, ) if (tracer.has_hyper_galaxy or hyper_image_sky is not None or hyper_background_noise is not None): masked_imaging = masked_imaging.modify_image_and_noise_map( image=image, noise_map=noise_map) else: image = masked_imaging.image noise_map = masked_imaging.noise_map self.blurred_image = tracer.blurred_image_from_grid_and_convolver( grid=masked_imaging.grid, convolver=masked_imaging.convolver, blurring_grid=masked_imaging.blurring_grid, ) self.profile_subtracted_image = image - self.blurred_image if not tracer.has_pixelization: inversion = None model_image = self.blurred_image else: inversion = tracer.inversion_imaging_from_grid_and_data( grid=masked_imaging.grid_inversion, image=self.profile_subtracted_image, noise_map=noise_map, convolver=masked_imaging.convolver, settings_pixelization=settings_pixelization, settings_inversion=settings_inversion, preloads=preloads, ) model_image = self.blurred_image + inversion.mapped_reconstructed_image super().__init__( masked_imaging=masked_imaging, model_image=model_image, inversion=inversion, use_mask_in_fit=False, )
def from_data_mapper_and_regularization( cls, image: array_2d.Array2D, noise_map: array_2d.Array2D, convolver: conv.Convolver, mapper: typing.Union[mappers.MapperRectangular, mappers.MapperVoronoi], regularization: reg.Regularization, settings=SettingsInversion(), preloads=pload.Preloads(), ): if preloads.blurred_mapping_matrix is None: blurred_mapping_matrix = convolver.convolve_mapping_matrix( mapping_matrix=mapper.mapping_matrix ) else: blurred_mapping_matrix = preloads.blurred_mapping_matrix data_vector = inversion_util.data_vector_via_blurred_mapping_matrix_from( blurred_mapping_matrix=blurred_mapping_matrix, image=image, noise_map=noise_map, ) if preloads.curvature_matrix_sparse_preload is None: curvature_matrix = inversion_util.curvature_matrix_via_mapping_matrix_from( mapping_matrix=blurred_mapping_matrix, noise_map=noise_map ) else: curvature_matrix = inversion_util.curvature_matrix_via_sparse_preload_from( mapping_matrix=blurred_mapping_matrix, noise_map=noise_map, curvature_matrix_sparse_preload=preloads.curvature_matrix_sparse_preload.astype( "int" ), curvature_matrix_preload_counts=preloads.curvature_matrix_preload_counts.astype( "int" ), ) regularization_matrix = regularization.regularization_matrix_from_mapper( mapper=mapper ) curvature_reg_matrix = np.add(curvature_matrix, regularization_matrix) try: values = np.linalg.solve(curvature_reg_matrix, data_vector) except np.linalg.LinAlgError: raise exc.InversionException() if settings.check_solution: if np.isclose(a=values[0], b=values[1], atol=1e-4).all(): if np.isclose(a=values[0], b=values, atol=1e-4).all(): raise exc.InversionException() return InversionImagingMatrix( image=image, noise_map=noise_map, convolver=convolver, mapper=mapper, regularization=regularization, blurred_mapping_matrix=blurred_mapping_matrix, curvature_matrix=curvature_matrix, regularization_matrix=regularization_matrix, curvature_reg_matrix=curvature_reg_matrix, reconstruction=values, settings=settings, )
def __init__( self, masked_interferometer, tracer, hyper_background_noise=None, use_hyper_scaling=True, settings_pixelization=pix.SettingsPixelization(), settings_inversion=inv.SettingsInversion(), preloads=pload.Preloads(), ): """ An lens fitter, which contains the tracer's used to perform the fit and functions to manipulate \ the lens dataset's hyper_galaxies. Parameters ----------- tracer : ray_tracing.Tracer The tracer, which describes the ray-tracing and strong lens configuration. scaled_array_2d_from_array_1d : func A function which maps the 1D lens hyper_galaxies to its unmasked 2D arrays. """ if use_hyper_scaling: if hyper_background_noise is not None: noise_map = hyper_background_noise.hyper_noise_map_from_complex_noise_map( noise_map=masked_interferometer.noise_map) else: noise_map = masked_interferometer.noise_map if hyper_background_noise is not None: masked_interferometer = masked_interferometer.modify_noise_map( noise_map=noise_map) else: noise_map = masked_interferometer.noise_map self.tracer = tracer self.profile_visibilities = tracer.profile_visibilities_from_grid_and_transformer( grid=masked_interferometer.grid, transformer=masked_interferometer.transformer, ) self.profile_subtracted_visibilities = ( masked_interferometer.visibilities - self.profile_visibilities) if not tracer.has_pixelization: inversion = None model_visibilities = self.profile_visibilities else: inversion = tracer.inversion_interferometer_from_grid_and_data( grid=masked_interferometer.grid_inversion, visibilities=self.profile_subtracted_visibilities, noise_map=noise_map, transformer=masked_interferometer.transformer, settings_pixelization=settings_pixelization, settings_inversion=settings_inversion, preloads=preloads, ) model_visibilities = (self.profile_visibilities + inversion.mapped_reconstructed_visibilities) super().__init__( masked_interferometer=masked_interferometer, model_visibilities=model_visibilities, inversion=inversion, use_mask_in_fit=False, )