def test__sets_up_hyper_galaxy_images__froms(self, masked_imaging_7x7):
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),
}
result = mock.MockResult(
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),
)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7,
hyper_dataset_result=result)
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__update_stellar_mass_priors_using_einstein_radius(self):
grid = al.Grid2D.uniform(shape_native=(200, 200), pixel_scales=0.05)
tracer = mock.MockTracer(einstein_radius=1.0, einstein_mass=4.0)
fit = mock.MockFit(grid=grid)
result = mock.MockResult(max_log_likelihood_tracer=tracer,
max_log_likelihood_fit=fit)
bulge_prior_model = af.PriorModel(al.lmp.SphericalSersic)
bulge_prior_model.intensity = af.UniformPrior(lower_limit=0.99,
upper_limit=1.01)
bulge_prior_model.effective_radius = af.UniformPrior(lower_limit=0.99,
upper_limit=1.01)
bulge_prior_model.sersic_index = af.UniformPrior(lower_limit=2.99,
upper_limit=3.01)
setup = al.SetupMassLightDark(bulge_prior_model=bulge_prior_model)
setup.update_stellar_mass_priors_from_result(
prior_model=bulge_prior_model,
result=result,
einstein_mass_range=[0.001, 10.0],
bins=10,
)
assert setup.bulge_prior_model.mass_to_light_ratio.lower_limit == pytest.approx(
0.00040519, 1.0e-1)
assert setup.bulge_prior_model.mass_to_light_ratio.upper_limit == pytest.approx(
4.051935, 1.0e-1)
def test__fit_interferometer_all_above_weight_gen(self, interferometer_7,
samples, model):
path_prefix = "aggregator_fit_interferometer_gen"
database_file = path.join(conf.instance.output_path,
"fit_interferometer.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
search = mock.MockSearch(samples=samples,
result=mock.MockResult(model=model,
samples=samples))
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = al.AnalysisInterferometer(dataset=interferometer_7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
fit_interferometer_agg = al.agg.FitInterferometerAgg(aggregator=agg)
fit_interferometer_pdf_gen = fit_interferometer_agg.all_above_weight_gen(
minimum_weight=-1.0)
i = 0
for fit_interferometer_gen in fit_interferometer_pdf_gen:
for fit_interferometer in fit_interferometer_gen:
i += 1
if i == 1:
assert fit_interferometer.tracer.galaxies[
0].redshift == 0.5
assert fit_interferometer.tracer.galaxies[
0].light.centre == (
1.0,
1.0,
)
assert fit_interferometer.tracer.galaxies[
1].redshift == 1.0
if i == 2:
assert fit_interferometer.tracer.galaxies[
0].redshift == 0.5
assert fit_interferometer.tracer.galaxies[
0].light.centre == (
10.0,
10.0,
)
assert fit_interferometer.tracer.galaxies[
1].redshift == 1.0
assert i == 2
clean(database_file=database_file, result_path=result_path)
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__tracer_all_above_weight_gen(self, masked_imaging_7x7, samples,
model):
path_prefix = "aggregator_tracer_gen"
database_file = path.join(conf.instance.output_path, "tracer.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
search = mock.MockSearch(samples=samples,
result=mock.MockResult(model=model,
samples=samples))
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
tracer_agg = al.agg.TracerAgg(aggregator=agg)
tracer_pdf_gen = tracer_agg.all_above_weight_gen(minimum_weight=-1.0)
weight_pdf_gen = tracer_agg.weights_above_gen(minimum_weight=-1.0)
i = 0
for (tracer_gen, weight_gen) in zip(tracer_pdf_gen, weight_pdf_gen):
for tracer in tracer_gen:
i += 1
if i == 1:
assert tracer.galaxies[0].redshift == 0.5
assert tracer.galaxies[0].light.centre == (1.0, 1.0)
assert tracer.galaxies[1].redshift == 1.0
if i == 2:
assert tracer.galaxies[0].redshift == 0.5
assert tracer.galaxies[0].light.centre == (10.0, 10.0)
assert tracer.galaxies[1].redshift == 1.0
for weight in weight_gen:
if i == 0:
assert weight == 0.0
if i == 1:
assert weight == 1.0
assert i == 2
clean(database_file=database_file, result_path=result_path)
def test__uses_hyper_fit_correctly(self, masked_imaging_7x7):
galaxies = af.ModelInstance()
galaxies.lens = al.Galaxy(redshift=0.5,
light=al.lp.EllSersic(intensity=1.0),
mass=al.mp.SphIsothermal)
galaxies.source = al.Galaxy(redshift=1.0, light=al.lp.EllSersic())
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
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}
result = mock.MockResult(
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=hyper_model_image,
)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7,
hyper_dataset_result=result)
hyper_galaxy = al.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0)
instance.galaxies.lens.hyper_galaxy = hyper_galaxy
analysis_log_likelihood = analysis.log_likelihood_function(
instance=instance)
g0 = al.Galaxy(
redshift=0.5,
light_profile=instance.galaxies.lens.light,
mass_profile=instance.galaxies.lens.mass,
hyper_galaxy=hyper_galaxy,
hyper_model_image=hyper_model_image,
hyper_galaxy_image=lens_hyper_image,
hyper_minimum_value=0.0,
)
g1 = al.Galaxy(redshift=1.0,
light_profile=instance.galaxies.source.light)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
assert (fit.tracer.galaxies[0].hyper_galaxy_image == lens_hyper_image
).all()
assert analysis_log_likelihood == fit.log_likelihood
def test__sets_up_hyper_galaxy_visibiltiies__from_results(
self, interferometer_7):
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),
}
hyper_galaxy_visibilities_path_dict = {
("galaxies", "lens"):
al.Visibilities.full(fill_value=4.0, shape_slim=(7, )),
("galaxies", "source"):
al.Visibilities.full(fill_value=5.0, shape_slim=(7, )),
}
result = mock.MockResult(
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),
hyper_galaxy_visibilities_path_dict=
hyper_galaxy_visibilities_path_dict,
hyper_model_visibilities=al.Visibilities.full(fill_value=6.0,
shape_slim=(7, )),
)
analysis = al.AnalysisInterferometer(dataset=interferometer_7,
hyper_result=result)
analysis.set_hyper_dataset(result=result)
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()
assert (analysis.hyper_galaxy_visibilities_path_dict[(
"galaxies", "lens")] == (4.0 + 4.0j) * np.ones((7, ))).all()
assert (analysis.hyper_galaxy_visibilities_path_dict[(
"galaxies", "source")] == (5.0 + 5.0j) * np.ones((7, ))).all()
assert (analysis.hyper_model_visibilities == (6.0 + 6.0j) * np.ones(
(7, ))).all()
def test__preload_pixelization():
result = mock.MockResult(max_log_likelihood_pixelization_grids_of_planes=1)
model = af.Collection(galaxies=af.Collection(lens=af.Model(al.Galaxy),
source=af.Model(al.Galaxy)))
with pytest.raises(exc.PreloadException):
pload.preload_pixelization_grid_from(result=result, model=model)
model = af.Collection(galaxies=af.Collection(
lens=af.Model(al.Galaxy),
source=af.Model(
al.Galaxy,
pixelization=al.pix.VoronoiBrightnessImage,
regularization=al.reg.AdaptiveBrightness,
),
))
with pytest.raises(exc.PreloadException):
pload.preload_pixelization_grid_from(result=result, model=model)
model = af.Collection(galaxies=af.Collection(
lens=af.Model(al.Galaxy),
source=af.Model(
al.Galaxy,
pixelization=al.pix.VoronoiBrightnessImage(),
regularization=al.reg.AdaptiveBrightness(),
),
))
preloads = pload.preload_pixelization_grid_from(result=result, model=model)
assert preloads.sparse_grids_of_planes == 1
preloads = pload.Preloads.setup(result=result,
model=model,
pixelization=True)
assert preloads.sparse_grids_of_planes == 1
def test__tracer_randomly_drawn_via_pdf_gen_from(self, masked_imaging_7x7,
samples, model):
path_prefix = "aggregator_tracer_gen"
database_file = path.join(conf.instance.output_path, "tracer.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
search = mock.MockSearch(samples=samples,
result=mock.MockResult(model=model,
samples=samples))
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = al.AnalysisImaging(dataset=masked_imaging_7x7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
tracer_agg = al.agg.TracerAgg(aggregator=agg)
tracer_pdf_gen = tracer_agg.randomly_drawn_via_pdf_gen_from(
total_samples=2)
i = 0
for tracer_gen in tracer_pdf_gen:
for tracer in tracer_gen:
i += 1
assert tracer.galaxies[0].redshift == 0.5
assert tracer.galaxies[0].light.centre == (10.0, 10.0)
assert tracer.galaxies[1].redshift == 1.0
assert i == 2
clean(database_file=database_file, result_path=result_path)
def run_hyper(*args, **kwargs):
return mock.MockResult()
def run(self, *args, **kwargs):
result = mock.MockResult()
result.settings = self.settings
return result
def test__preload_inversion_with_fixed_profiles(
fit_imaging_x2_plane_inversion_7x7):
result = mock.MockResult(
max_log_likelihood_fit=fit_imaging_x2_plane_inversion_7x7,
max_log_likelihood_pixelization_grids_of_planes=1,
)
# model = af.Collection(
# galaxies=af.Collection(lens=af.Model(al.Galaxy, mass=al.mp.SphIsothermal), source=af.Model(al.Galaxy))
# )
#
# with pytest.raises(exc.PreloadException):
# pload.preload_inversion_with_fixed_profiles(result=result, model=model)
model = af.Collection(galaxies=af.Collection(
lens=af.Model(al.Galaxy),
source=af.Model(
al.Galaxy,
pixelization=al.pix.VoronoiBrightnessImage,
regularization=al.reg.AdaptiveBrightness,
),
))
with pytest.raises(exc.PreloadException):
pload.preload_inversion_with_fixed_profiles(result=result, model=model)
model = af.Collection(galaxies=af.Collection(
lens=af.Model(al.Galaxy),
source=af.Model(
al.Galaxy,
pixelization=al.pix.VoronoiBrightnessImage(),
regularization=al.reg.AdaptiveBrightness(),
),
))
preloads = pload.preload_inversion_with_fixed_profiles(result=result,
model=model)
assert preloads.sparse_grids_of_planes == 1
assert (
preloads.blurred_mapping_matrix == fit_imaging_x2_plane_inversion_7x7.
inversion.blurred_mapping_matrix).all()
assert (preloads.curvature_matrix_sparse_preload ==
fit_imaging_x2_plane_inversion_7x7.inversion.
curvature_matrix_sparse_preload).all()
assert (preloads.curvature_matrix_preload_counts ==
fit_imaging_x2_plane_inversion_7x7.inversion.
curvature_matrix_preload_counts).all()
assert preloads.mapper == fit_imaging_x2_plane_inversion_7x7.inversion.mapper
preloads = pload.Preloads.setup(result=result, model=model, inversion=True)
assert preloads.sparse_grids_of_planes == 1
assert (
preloads.blurred_mapping_matrix == fit_imaging_x2_plane_inversion_7x7.
inversion.blurred_mapping_matrix).all()
assert (preloads.curvature_matrix_sparse_preload ==
fit_imaging_x2_plane_inversion_7x7.inversion.
curvature_matrix_sparse_preload).all()
assert (preloads.curvature_matrix_preload_counts ==
fit_imaging_x2_plane_inversion_7x7.inversion.
curvature_matrix_preload_counts).all()
assert preloads.mapper == fit_imaging_x2_plane_inversion_7x7.inversion.mapper
