def test___image_dict(self, analysis_imaging_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies result = ResultImaging( samples=mock.MockSamples(max_log_likelihood_instance=instance), model=af.ModelMapper(), analysis=analysis_imaging_7x7, search=None, ) image_dict = result.image_galaxy_dict assert isinstance(image_dict[("galaxies", "lens")], np.ndarray) assert isinstance(image_dict[("galaxies", "source")], np.ndarray) result.instance.galaxies.lens = al.Galaxy(redshift=0.5) image_dict = result.image_galaxy_dict assert (image_dict[("galaxies", "lens")].native == np.zeros( (7, 7))).all() assert isinstance(image_dict[("galaxies", "source")], np.ndarray)
def test_galaxies(self): galaxies = af.ModelInstance() galaxies.one = af.m.MockComponents() instance = af.ModelInstance() instance.galaxies = galaxies model = instance.as_model(model_classes=(af.m.MockComponents, )) assert model.prior_count == 1
def test___image_dict(self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies analysis = al.PhaseImaging.Analysis( masked_imaging=masked_imaging_7x7, settings=al.SettingsPhaseImaging(), results=mock.MockResults(), cosmology=cosmo.Planck15, ) result = al.PhaseImaging.Result( samples=mock.MockSamples(max_log_likelihood_instance=instance), previous_model=af.ModelMapper(), analysis=analysis, search=None, ) image_dict = result.image_galaxy_dict assert isinstance(image_dict[("galaxies", "lens")], np.ndarray) assert isinstance(image_dict[("galaxies", "source")], np.ndarray) result.instance.galaxies.lens = al.Galaxy(redshift=0.5) image_dict = result.image_galaxy_dict assert (image_dict[("galaxies", "lens")].native == np.zeros( (7, 7))).all() assert isinstance(image_dict[("galaxies", "source")], np.ndarray)
def test__stochastic_log_evidences_for_instance(self, masked_imaging_7x7): lens_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) lens_hyper_image[4] = 10.0 source_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) source_hyper_image[4] = 10.0 hyper_model_image = al.Array2D.full(fill_value=0.5, shape_native=(3, 3), pixel_scales=0.1) hyper_galaxy_image_path_dict = { ("galaxies", "lens"): lens_hyper_image, ("galaxies", "source"): source_hyper_image, } result = mock.MockResult( hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=hyper_model_image, ) galaxies = af.ModelInstance() galaxies.lens = al.Galaxy( redshift=0.5, mass=al.mp.SphIsothermal(einstein_radius=1.0)) galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiMagnification(shape=(3, 3)), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies analysis = al.AnalysisImaging(dataset=masked_imaging_7x7, hyper_result=result) stochastic_log_evidences = analysis.stochastic_log_evidences_for_instance( instance=instance) assert stochastic_log_evidences is None galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=9), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies analysis = al.AnalysisImaging(dataset=masked_imaging_7x7, hyper_result=result) stochastic_log_evidences = analysis.stochastic_log_evidences_for_instance( instance=instance) assert stochastic_log_evidences[0] != stochastic_log_evidences[1]
def test__stochastic_log_likelihoods_for_instance(self, interferometer_7): lens_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) lens_hyper_image[4] = 10.0 source_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) source_hyper_image[4] = 10.0 hyper_model_image = al.Array2D.full(fill_value=0.5, shape_native=(3, 3), pixel_scales=0.1) hyper_galaxy_image_path_dict = { ("galaxies", "lens"): lens_hyper_image, ("galaxies", "source"): source_hyper_image, } result = mock.MockResult( hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=hyper_model_image, ) analysis = al.AnalysisInterferometer( dataset=interferometer_7, settings_lens=al.SettingsLens(stochastic_samples=2), hyper_dataset_result=result, ) galaxies = af.ModelInstance() galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=5), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies log_evidences = analysis.stochastic_log_likelihoods_for_instance( instance=instance) assert len(log_evidences) == 2 assert log_evidences[0] != log_evidences[1] galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.DelaunayBrightnessImage(pixels=5), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies log_evidences = analysis.stochastic_log_likelihoods_for_instance( instance=instance) assert len(log_evidences) == 2 assert log_evidences[0] != log_evidences[1]
def test__uses_hyper_fit_correctly(self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.galaxy = ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(intensity=1.0), mass=ag.mp.SphIsothermal) galaxies.source = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic()) instance = af.ModelInstance() instance.galaxies = galaxies galaxy_hyper_image = ag.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) galaxy_hyper_image[4] = 10.0 hyper_model_image = ag.Array2D.full(fill_value=0.5, shape_native=(3, 3), pixel_scales=0.1) hyper_galaxy_image_path_dict = { ("galaxies", "galaxy"): galaxy_hyper_image } result = mock.MockResult( hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=hyper_model_image, ) analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7, hyper_dataset_result=result) hyper_galaxy = ag.HyperGalaxy(contribution_factor=1.0, noise_factor=1.0, noise_power=1.0) instance.galaxies.galaxy.hyper_galaxy = hyper_galaxy fit_likelihood = analysis.log_likelihood_function(instance=instance) g0 = ag.Galaxy( redshift=0.5, light_profile=instance.galaxies.galaxy.light, mass_profile=instance.galaxies.galaxy.mass, hyper_galaxy=hyper_galaxy, hyper_model_image=hyper_model_image, hyper_galaxy_image=galaxy_hyper_image, hyper_minimum_value=0.0, ) g1 = ag.Galaxy(redshift=1.0, light_profile=instance.galaxies.source.light) plane = ag.Plane(galaxies=[g0, g1]) fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane) assert (fit.plane.galaxies[0].hyper_galaxy_image == galaxy_hyper_image ).all() assert fit_likelihood == fit.log_likelihood
def test_instance_plus_instance(self): one = af.ModelInstance() two = af.ModelInstance() one.a = "a" two.b = "b" three = one + two assert three.a == "a" assert three.b == "b"
def test__stochastic_histogram_for_instance(self, masked_interferometer_7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy( redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=1.2) ) galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=5), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies lens_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) lens_hyper_image[4] = 10.0 source_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) source_hyper_image[4] = 10.0 hyper_model_image = al.Array2D.full( fill_value=0.5, shape_native=(3, 3), pixel_scales=0.1 ) hyper_galaxy_image_path_dict = { ("galaxies", "lens"): lens_hyper_image, ("galaxies", "source"): source_hyper_image, } results = mock.MockResults( use_as_hyper_dataset=True, hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=hyper_model_image, ) analysis = al.PhaseInterferometer.Analysis( masked_interferometer=masked_interferometer_7, settings=al.SettingsPhaseImaging( settings_lens=al.SettingsLens(stochastic_samples=2) ), results=results, cosmology=cosmo.Planck15, ) log_evidences = analysis.stochastic_log_evidences_for_instance( instance=instance ) assert len(log_evidences) == 2 assert log_evidences[0] != log_evidences[1]
def make_instance(galaxy_1, galaxy_2): sub = af.ModelInstance() instance = af.ModelInstance() sub.galaxy_1 = galaxy_1 instance.galaxy_2 = galaxy_2 instance.sub = sub sub_2 = af.ModelInstance() sub_2.galaxy_1 = galaxy_1 instance.sub.sub = sub_2 return instance
def make_instance(mock_components_1, mock_components_2): sub = af.ModelInstance() instance = af.ModelInstance() sub.mock_components_1 = mock_components_1 instance.mock_components_2 = mock_components_2 instance.sub = sub sub_2 = af.ModelInstance() sub_2.mock_components_1 = mock_components_1 instance.sub.sub = sub_2 return instance
def __init__( self, mask=None, model_image=None, galaxy_images=(), model_visibilities=None, galaxy_visibilities=(), instance=None, analysis=None, optimizer=None, pixelization=None, ): self.mask_2d = mask self.model_image = model_image self.unmasked_model_image = model_image self.galaxy_images = galaxy_images self.model_visibilities = model_visibilities self.galaxy_visibilities = galaxy_visibilities self.instance = instance or af.ModelInstance() self.model = af.ModelMapper() self.analysis = analysis self.optimizer = optimizer self.pixelization = pixelization self.hyper_combined = MockHyperCombinedPhase() self.use_as_hyper_dataset = False
def test_model_mapper(self): instance = af.ModelInstance() instance.simple = af.m.MockClassx2(1.0, 2.0) result = af.AbstractPriorModel.from_instance(instance) assert isinstance(result, af.ModelMapper)
def test__make_pixelization_model(self): instance = af.ModelInstance() mapper = af.ModelMapper() mapper.lens_galaxy = al.GalaxyModel( redshift=al.Redshift, pixelization=al.pix.Rectangular, regularization=al.reg.Constant, ) mapper.source_galaxy = al.GalaxyModel( redshift=al.Redshift, light=al.lp.EllipticalLightProfile) assert mapper.prior_count == 10 instance.lens_galaxy = al.Galaxy( pixelization=al.pix.Rectangular(), regularization=al.reg.Constant(), redshift=1.0, ) instance.source_galaxy = al.Galaxy( redshift=1.0, light=al.lp.EllipticalLightProfile()) # noinspection PyTypeChecker phase = al.ModelFixingHyperPhase( MockPhase(), "mock_phase", model_classes=(al.pix.Pixelization, al.reg.Regularization), ) mapper = mapper.copy_with_fixed_priors(instance, phase.model_classes) assert mapper.prior_count == 3 assert mapper.lens_galaxy.redshift == 1.0 assert mapper.source_galaxy.light.axis_ratio == 1.0
def run(self, dataset, results, mask=None, positions=None, info=None): self.save_metadata(dataset) self.dataset = dataset self.results = results self.mask = mask self.positions = positions return af.Result(af.ModelInstance(), 1)
def run(self, data, results, mask=None, positions=None): self.data = data self.results = results self.mask = mask self.positions = positions self.assert_and_save_pickle() return af.Result(af.ModelInstance(), 1)
def test__figure_of_merit__with_stochastic_likelihood_resamples_matches_galaxy_profiles( self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy( redshift=0.5, mass=al.mp.SphericalIsothermal(einstein_radius=1.2)) galaxies.source = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=5), regularization=al.reg.Constant(), ) instance = af.ModelInstance() instance.galaxies = galaxies lens_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) lens_hyper_image[4] = 10.0 source_hyper_image = al.Array2D.ones(shape_native=(3, 3), pixel_scales=0.1) source_hyper_image[4] = 10.0 hyper_model_image = al.Array2D.full(fill_value=0.5, shape_native=(3, 3), pixel_scales=0.1) hyper_galaxy_image_path_dict = { ("galaxies", "lens"): lens_hyper_image, ("galaxies", "source"): source_hyper_image, } results = mock.MockResults( use_as_hyper_dataset=True, hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=hyper_model_image, ) analysis = al.PhaseImaging.Analysis( masked_imaging=masked_imaging_7x7, settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens( stochastic_likelihood_resamples=2)), results=results, cosmology=cosmo.Planck15, ) fit_figure_of_merit = analysis.log_likelihood_function( instance=instance)
def test__extend_with_hyper_phases__sets_up_hyper_dataset_from_results( self, imaging_7x7, mask_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies hyper_galaxy_image_path_dict = { ("galaxies", "lens"): al.Array2D.ones(shape_native=(3, 3), pixel_scales=1.0), ("galaxies", "source"): al.Array2D.full(fill_value=2.0, shape_native=(3, 3), pixel_scales=1.0), } results = mock.MockResults( hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=al.Array2D.full(fill_value=3.0, shape_native=(3, 3), pixel_scales=1.0), mask=mask_7x7, use_as_hyper_dataset=True, ) phase_imaging_7x7 = al.PhaseImaging( galaxies=dict(lens=al.GalaxyModel(redshift=0.5, hyper_galaxy=al.HyperGalaxy)), search=mock.MockSearch(), ) analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7, results=results) assert (analysis.hyper_galaxy_image_path_dict[( "galaxies", "lens")].native == np.ones((3, 3))).all() assert (analysis.hyper_galaxy_image_path_dict[( "galaxies", "source")].native == 2.0 * np.ones((3, 3))).all() assert (analysis.hyper_model_image.native == 3.0 * np.ones( (3, 3))).all()
def test__associate_images(self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.lens = al.Galaxy(redshift=0.5) galaxies.source = al.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies hyper_galaxy_image_path_dict = { ("galaxies", "lens"): al.Array.ones(shape_2d=(3, 3), pixel_scales=1.0), ("galaxies", "source"): al.Array.full( fill_value=2.0, shape_2d=(3, 3), pixel_scales=1.0 ), } results = mock_pipeline.MockResults( instance=instance, hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=al.Array.full(fill_value=3.0, shape_2d=(3, 3)), use_as_hyper_dataset=True, ) analysis = al.PhaseImaging.Analysis( masked_imaging=masked_imaging_7x7, cosmology=cosmo.Planck15, image_path="files/", results=results, ) instance = analysis.associate_hyper_images(instance=instance) assert instance.galaxies.lens.hyper_galaxy_image.in_2d == pytest.approx( np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_galaxy_image.in_2d == pytest.approx( 2.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.lens.hyper_model_image.in_2d == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_model_image.in_2d == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 )
def test_model_instance_equality(self): model_instance = af.ModelInstance() model_instance.profile = af.m.MockClassx2Tuple() model_instance_copy = deepcopy(model_instance) assert model_instance == model_instance_copy model_instance.profile.centre = (1.0, 2.0) assert model_instance != model_instance_copy
def test__associate_hyper_images(self, masked_imaging_7x7): galaxies = af.ModelInstance() galaxies.galaxy = ag.Galaxy(redshift=0.5) galaxies.source = ag.Galaxy(redshift=1.0) instance = af.ModelInstance() instance.galaxies = galaxies hyper_galaxy_image_path_dict = { ("galaxies", "galaxy"): ag.Array2D.ones( shape_native=(3, 3), pixel_scales=1.0 ), ("galaxies", "source"): ag.Array2D.full( fill_value=2.0, shape_native=(3, 3), pixel_scales=1.0 ), } result = mock.MockResult( instance=instance, hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict, hyper_model_image=ag.Array2D.full( fill_value=3.0, shape_native=(3, 3), pixel_scales=1.0 ), ) analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7, hyper_result=result) instance = analysis.associate_hyper_images(instance=instance) assert instance.galaxies.galaxy.hyper_galaxy_image.native == pytest.approx( np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_galaxy_image.native == pytest.approx( 2.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.galaxy.hyper_model_image.native == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 ) assert instance.galaxies.source.hyper_model_image.native == pytest.approx( 3.0 * np.ones((3, 3)), 1.0e-4 )
def test__defaults_background_noise(self): # noinspection PyTypeChecker phase = al.InversionBackgroundNoisePhase(MockPhase()) instance = af.ModelInstance() instance.hyper_background_noise = al.hyper_data.HyperBackgroundNoise() mapper = phase.make_model(instance) assert isinstance(mapper.hyper_background_noise, af.PriorModel) assert mapper.hyper_background_noise.cls == al.hyper_data.HyperBackgroundNoise
def test__defaults_hyper_image_sky(self): # noinspection PyTypeChecker phase = al.InversionBackgroundSkyPhase(MockPhase()) instance = af.ModelInstance() instance.hyper_image_sky = al.hyper_data.HyperImageSky() mapper = phase.make_model(instance) assert isinstance(mapper.hyper_image_sky, af.PriorModel) assert mapper.hyper_image_sky.cls == al.hyper_data.HyperImageSky
def make_sensitivity(perturbation_model, search): # noinspection PyTypeChecker instance = af.ModelInstance() instance.gaussian = Gaussian() return s.Sensitivity( simulation_instance=instance, base_model=af.Collection(gaussian=af.PriorModel(Gaussian)), perturbation_model=perturbation_model, simulate_function=image_function, analysis_class=Analysis, search=search, number_of_steps=2, )
def __init__(self, model_image=None, mask=None, instance=None, analysis=None, optimizer=None): self.model_image = model_image self.unmasked_model_image = model_image self.mask = mask self.instance = instance or af.ModelInstance() self.model = af.ModelMapper() self.analysis = analysis self.optimizer = optimizer
def test_analysis(self, species_0, species_1, data): instance = af.ModelInstance() instance.abundances = [1.0, 1.0] instance.species = [species_0, species_1] analysis = SingleTimeAnalysis(data) # noinspection PyTypeChecker assert analysis.fit(instance) == 0.0 instance.abundances = [0.5, 0.5] # noinspection PyTypeChecker assert analysis.fit(instance) < 0.0
def make_collection(): collection = af.ResultsCollection() model = af.ModelMapper() model.one = af.PriorModel(mock.MockComponents, component=mock.MockClassx2) instance = af.ModelInstance() instance.one = mock.MockComponents(component=mock.MockClassx2()) result = af.MockResult(model=model, instance=instance) model = af.ModelMapper() instance = af.ModelInstance() model.hyper_galaxy = mock.HyperGalaxy instance.hyper_galaxy = mock.HyperGalaxy() hyper_result = af.MockResult(model=model, instance=instance) result.hyper_result = hyper_result collection.add("search name", result) return collection
def make_job(perturbation_model, search): instance = af.ModelInstance() instance.gaussian = af.Gaussian() base_instance = instance instance.perturbation = af.Gaussian() image = image_function(instance) # noinspection PyTypeChecker return s.Job(model=af.Collection(gaussian=af.PriorModel(af.Gaussian)), perturbation_model=af.PriorModel(af.Gaussian), base_instance=base_instance, perturbation_instance=instance, analysis_factory=MockAnalysisFactory(Analysis(image)), search=search, number=1)
def __init__( self, instance=None, likelihood=None, model=None, analysis=None, optimizer=None, mask=None, model_image=None, hyper_galaxy_image_path_dict=None, hyper_model_image=None, hyper_galaxy_visibilities_path_dict=None, hyper_model_visibilities=None, pixelization=None, positions=None, updated_positions=None, updated_positions_threshold=None, use_as_hyper_dataset=False, ): self.instance = instance self.likelihood = likelihood self.model = model self.previous_model = model self.gaussian_tuples = None self.mask_2d = None self.positions = None self.mask_2d = mask self.hyper_galaxy_image_path_dict = hyper_galaxy_image_path_dict self.hyper_model_image = hyper_model_image self.hyper_galaxy_visibilities_path_dict = hyper_galaxy_visibilities_path_dict self.hyper_model_visibilities = hyper_model_visibilities self.model_image = model_image self.unmasked_model_image = model_image self.instance = instance or af.ModelInstance() self.model = af.ModelMapper() self.analysis = analysis self.optimizer = optimizer self.pixelization = pixelization self.hyper_combined = MockHyperCombinedPhase() self.use_as_hyper_dataset = use_as_hyper_dataset self.positions = positions self.updated_positions = ( updated_positions if updated_positions is not None else [] ) self.updated_positions_threshold = updated_positions_threshold self.most_likely_tracer = al.Tracer.from_galaxies( galaxies=[al.Galaxy(redshift=0.5)] )
def __init__( self, samples=None, instance=None, model=None, analysis=None, search=None, ): self.instance = instance or af.ModelInstance() self.model = model or af.ModelMapper() self.samples = samples or MockSamples(max_log_likelihood_instance=self.instance) self.gaussian_tuples = None self.analysis = analysis self.search = search self.model = model
def test_job(perturbation_model): instance = af.ModelInstance() instance.gaussian = Gaussian() instance.perturbation = Gaussian() image = image_function(instance) # noinspection PyTypeChecker job = s.Job( model=af.Collection(gaussian=af.PriorModel(Gaussian)), perturbation_model=af.PriorModel(Gaussian), analysis=Analysis(image), search=GridSearch(), ) result = job.perform() assert isinstance(result, s.JobResult) assert isinstance(result.perturbed_result, af.Result) assert isinstance(result.result, af.Result) assert result.log_likelihood_difference > 0