def test__noise_map__with_and_without_hyper_background(
masked_imaging_7x7_no_blur):
g0 = al.Galaxy(redshift=0.5,
light_profile=al.m.MockLightProfile(image_2d_value=1.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0])
fit = al.FitImaging(
dataset=masked_imaging_7x7_no_blur,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.noise_map.slim == pytest.approx(
np.full(fill_value=2.0, shape=(9, )), 1.0e-1)
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(
noise_scale=1.0)
fit = al.FitImaging(
dataset=masked_imaging_7x7_no_blur,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.noise_map.slim == pytest.approx(
np.full(fill_value=3.0, shape=(9, )), 1.0e-1)
assert fit.log_likelihood == pytest.approx(-18.1579, 1.0e-4)
def test__total_mappers(interferometer_7):
g0 = al.Galaxy(redshift=0.5)
g1 = al.Galaxy(redshift=1.0)
g2 = al.Galaxy(redshift=2.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.total_mappers == 0
g2 = al.Galaxy(
redshift=2.0,
pixelization=al.pix.Rectangular(),
regularization=al.reg.Constant(),
)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.total_mappers == 1
def test___stochastic_mode__gives_different_log_likelihood_list(
interferometer_7):
pix = al.pix.VoronoiBrightnessImage(pixels=5)
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(
redshift=0.5,
pixelization=pix,
regularization=reg,
hyper_model_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
hyper_galaxy_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit_0 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
fit_1 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_0.log_evidence == fit_1.log_evidence
fit_0 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=True),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
fit_1 = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(is_stochastic=True),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_0.log_evidence != fit_1.log_evidence
def test__stochastic_log_likelihoods_for_instance(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 = al.m.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,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
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_via_instance_from(
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_via_instance_from(
instance=instance)
assert len(log_evidences) == 2
assert log_evidences[0] != log_evidences[1]
def fit_imaging_with_lens_and_source_galaxy(imaging, lens_galaxy, source_galaxy):
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
return al.FitImaging(
dataset=imaging,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
def print_fit_time_from(interferometer,
transformer_class,
use_w_tilde,
use_linear_operators,
repeats=1):
settings_interferometer = al.SettingsInterferometer(
transformer_class=transformer_class)
interferometer = interferometer.apply_settings(
settings=settings_interferometer)
"""
__Numba Caching__
Call FitImaging once to get all numba functions initialized.
"""
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(
use_w_tilde=use_w_tilde,
use_linear_operators=use_linear_operators),
)
print(fit.figure_of_merit)
"""
__Fit Time__
Time FitImaging by itself, to compare to profiling dict call.
"""
start = time.time()
for i in range(repeats):
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(
use_w_tilde=use_w_tilde,
use_linear_operators=use_linear_operators),
)
fit.figure_of_merit
fit_time = (time.time() - start) / repeats
print(f"Fit Time = {fit_time} \n")
def test__inversion_interferometer_from(sub_grid_2d_7x7, interferometer_7):
interferometer_7.data = al.Visibilities.ones(shape_slim=(7, ))
g_linear = al.Galaxy(redshift=0.5, light_linear=al.lp_linear.EllSersic())
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g_linear])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_interferometer_from(
dataset=interferometer_7,
visibilities=interferometer_7.visibilities,
noise_map=interferometer_7.noise_map,
w_tilde=None,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(0.000513447, 1.0e-5)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_interferometer_from(
dataset=interferometer_7,
visibilities=interferometer_7.visibilities,
noise_map=interferometer_7.noise_map,
w_tilde=None,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(-0.2662, 1.0e-4)
def test__inversion_imaging_from(sub_grid_2d_7x7, masked_imaging_7x7):
g_linear = al.Galaxy(redshift=0.5, light_linear=al.lp_linear.EllSersic())
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g_linear])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_imaging_from(
dataset=masked_imaging_7x7,
image=masked_imaging_7x7.image,
noise_map=masked_imaging_7x7.noise_map,
w_tilde=masked_imaging_7x7.w_tilde,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.reconstruction[0] == pytest.approx(0.002310, 1.0e-2)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.0)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
tracer_to_inversion = al.TracerToInversion(tracer=tracer)
inversion = tracer_to_inversion.inversion_imaging_from(
dataset=masked_imaging_7x7,
image=masked_imaging_7x7.image,
noise_map=masked_imaging_7x7.noise_map,
w_tilde=masked_imaging_7x7.w_tilde,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert inversion.mapped_reconstructed_image == pytest.approx(
masked_imaging_7x7.image, 1.0e-2)
def test__simulate_interferometer_data_and_fit__known_likelihood():
mask = al.Mask2D.circular(radius=3.0,
shape_native=(31, 31),
pixel_scales=0.2,
sub_size=1)
grid = al.Grid2D.from_mask(mask=mask)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.8),
)
source_galaxy_0 = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(16, 16)),
regularization=al.reg.Constant(coefficient=(1.0)),
)
source_galaxy_1 = al.Galaxy(
redshift=2.0,
pixelization=al.pix.Rectangular(shape=(16, 16)),
regularization=al.reg.Constant(coefficient=(1.0)),
)
tracer = al.Tracer.from_galaxies(
galaxies=[lens_galaxy, source_galaxy_0, source_galaxy_1])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_seed=1,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(
transformer_class=al.TransformerDFT))
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.figure_of_merit == pytest.approx(-5.433894158056919, 1.0e-2)
def test___fit_figure_of_merit__linear_operator(interferometer_7_lop):
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.01)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitInterferometer(
dataset=interferometer_7_lop,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_linear_operators=True),
)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-71.5177, 1e-4)
assert fit.figure_of_merit == pytest.approx(-71.5177, 1.0e-4)
def fit_imaging_with_source_galaxy(imaging, source_galaxy):
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllIsothermal(
centre=(0.0, 0.0),
einstein_radius=1.5,
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.9,
angle=45.0),
),
shear=al.mp.ExternalShear(elliptical_comps=(0.05, 0.05)),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
return al.FitImaging(
dataset=imaging,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
def test__fit_figure_of_merit__include_hyper_methods(masked_imaging_7x7):
hyper_galaxy = al.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0)
hyper_image_sky = al.hyper_data.HyperImageSky(sky_scale=1.0)
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(
noise_scale=1.0)
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
hyper_galaxy=hyper_galaxy,
hyper_model_image=np.ones(9),
hyper_galaxy_image=np.ones(9),
hyper_minimum_value=0.0,
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitImaging(
dataset=masked_imaging_7x7,
tracer=tracer,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
use_hyper_scaling=True,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.image == np.full(fill_value=2.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=5.0, shape=(9, ))).all()
assert fit.log_likelihood == pytest.approx(-186617.89365, 1e-4)
assert fit.figure_of_merit == pytest.approx(-186617.89365, 1.0e-4)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(
redshift=0.5,
pixelization=pix,
regularization=reg,
hyper_galaxy=hyper_galaxy,
hyper_model_image=np.ones(9),
hyper_galaxy_image=np.ones(9),
hyper_minimum_value=0.0,
)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitImaging(
dataset=masked_imaging_7x7,
tracer=tracer,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.image == np.full(fill_value=2.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=5.0, shape=(9, ))).all()
assert fit.log_evidence == pytest.approx(-30.14482, 1e-4)
assert fit.figure_of_merit == pytest.approx(-30.14482, 1.0e-4)
galaxy_light = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
hyper_galaxy=hyper_galaxy,
hyper_model_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
hyper_galaxy_image=al.Array2D.ones(shape_native=(3, 3),
pixel_scales=1.0),
hyper_minimum_value=0.0,
)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[galaxy_light, galaxy_pix])
fit = al.FitImaging(
dataset=masked_imaging_7x7,
tracer=tracer,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.image == np.full(fill_value=2.0, shape=(9, ))).all()
assert (fit.noise_map == np.full(fill_value=5.0, shape=(9, ))).all()
assert fit.log_evidence == pytest.approx(-6106.6402, 1e-4)
assert fit.figure_of_merit == pytest.approx(-6106.6402, 1.0e-4)
def test__fit_figure_of_merit(interferometer_7):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_likelihood == pytest.approx(-21709493.32, 1e-4)
assert fit.figure_of_merit == pytest.approx(-21709493.32, 1.0e-4)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.01)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-66.90612, 1e-4)
assert fit.figure_of_merit == pytest.approx(-66.90612, 1.0e-4)
galaxy_light = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0))
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[galaxy_light, galaxy_pix])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.noise_map.slim == np.full(fill_value=2.0 + 2.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-1570173.14216, 1e-4)
assert fit.figure_of_merit == pytest.approx(-1570173.14216, 1.0e-4)
g0_linear = al.Galaxy(
redshift=0.5,
light_profile=al.lp_linear.EllSersic(sersic_index=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1_linear = al.Galaxy(
redshift=1.0, light_profile=al.lp_linear.EllSersic(sersic_index=4.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0_linear, g1_linear])
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
assert fit.log_likelihood == pytest.approx(-23.44419, 1e-4)
assert fit.figure_of_merit == pytest.approx(-23.44419, 1.0e-4)
tracer = al.Tracer.from_galaxies(galaxies=[g0_linear, galaxy_pix])
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
assert fit.log_evidence == pytest.approx(-34.393456, 1e-4)
assert fit.figure_of_merit == pytest.approx(-34.393456, 1.0e-4)
def test___galaxy_model_image_dict(interferometer_7, interferometer_7_grid):
# Normal Light Profiles Only
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
g2 = al.Galaxy(redshift=1.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitInterferometer(
dataset=interferometer_7_grid,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
traced_grid_2d_list_from = tracer.traced_grid_2d_list_from(
grid=interferometer_7_grid.grid)
g0_image = g0.image_2d_from(grid=traced_grid_2d_list_from[0])
g1_image = g1.image_2d_from(grid=traced_grid_2d_list_from[1])
assert fit.galaxy_model_image_dict[g0] == pytest.approx(g0_image, 1.0e-4)
assert fit.galaxy_model_image_dict[g1] == pytest.approx(g1_image, 1.0e-4)
# Linear Light Profiles Only
g0_linear = al.Galaxy(
redshift=0.5,
light_profile=al.lp_linear.EllSersic(),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1_linear = al.Galaxy(redshift=1.0, light_profile=al.lp_linear.EllSersic())
tracer = al.Tracer.from_galaxies(galaxies=[g0_linear, g1_linear, g2])
fit = al.FitInterferometer(
dataset=interferometer_7_grid,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.galaxy_model_image_dict[g0_linear][4] == pytest.approx(
1.00018622848, 1.0e-2)
assert fit.galaxy_model_image_dict[g1_linear][3] == pytest.approx(
-3.89387356e-04, 1.0e-2)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0_no_light = al.Galaxy(
redshift=0.5, mass_profile=al.mp.SphIsothermal(einstein_radius=1.0))
galaxy_pix_0 = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0_no_light, galaxy_pix_0])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.galaxy_model_image_dict[g0_no_light].native == np.zeros(
(7, 7))).all()
assert fit.galaxy_model_image_dict[galaxy_pix_0][0] == pytest.approx(
-0.169439019, 1.0e-4)
# Normal light + Linear Light PRofiles + Pixelization + Regularizaiton
galaxy_pix_1 = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(
galaxies=[g0, g0_linear, g2, galaxy_pix_0, galaxy_pix_1])
fit = al.FitInterferometer(
dataset=interferometer_7_grid,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.galaxy_model_image_dict[g0] == pytest.approx(g0_image, 1.0e-4)
assert fit.galaxy_model_image_dict[g0_linear][4] == pytest.approx(
-1946.44265722, 1.0e-4)
assert fit.galaxy_model_image_dict[galaxy_pix_0][4] == pytest.approx(
0.0473537322, 1.0e-4)
assert fit.galaxy_model_image_dict[galaxy_pix_1][4] == pytest.approx(
0.0473505541, 1.0e-4)
assert (fit.galaxy_model_image_dict[g2] == np.zeros(9)).all()
def test__fit_figure_of_merit__include_hyper_methods(interferometer_7):
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(
noise_scale=1.0)
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.noise_map.slim == np.full(fill_value=3.0 + 3.0j,
shape=(7, ))).all()
assert fit.log_likelihood == pytest.approx(-9648681.9168, 1e-4)
assert fit.figure_of_merit == pytest.approx(-9648681.9168, 1.0e-4)
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
use_hyper_scaling=False,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.noise_map == pytest.approx(interferometer_7.noise_map, 1.0e-4)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.01)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.noise_map.slim == np.full(fill_value=3.0 + 3.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-68.63380, 1e-4)
assert fit.figure_of_merit == pytest.approx(-68.63380, 1.0e-4)
galaxy_light = al.Galaxy(redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0))
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[galaxy_light, galaxy_pix])
fit = al.FitInterferometer(
dataset=interferometer_7,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.noise_map.slim == np.full(fill_value=3.0 + 3.0j,
shape=(7, ))).all()
assert fit.log_evidence == pytest.approx(-892439.04665, 1e-4)
assert fit.figure_of_merit == pytest.approx(-892439.04665, 1.0e-4)
def test__perfect_fit__chi_squared_0():
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
light=al.lp.EllExponential(centre=(0.1, 0.1),
intensity=0.5))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
file_path = path.join(
"{}".format(path.dirname(path.realpath(__file__))),
"data_temp",
"simulate_and_fit",
)
try:
shutil.rmtree(file_path)
except FileNotFoundError:
pass
if path.exists(file_path) is False:
os.makedirs(file_path)
interferometer.output_to_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
)
real_space_mask = al.Mask2D.unmasked(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=2)
interferometer = al.Interferometer.from_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
real_space_mask=real_space_mask,
)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(
transformer_class=al.TransformerDFT))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.chi_squared == pytest.approx(0.0)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0001)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert abs(fit.chi_squared) < 1.0e-4
file_path = path.join("{}".format(path.dirname(path.realpath(__file__))),
"data_temp")
if path.exists(file_path) is True:
shutil.rmtree(file_path)
def test__simulate_interferometer_data_and_fit__linear_light_profiles_and_pixelization(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=100.0),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_pix = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=0.01),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_pix])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([
1.00338472e02,
9.55074606e-02,
9.24767167e-02,
9.45392540e-02,
1.41969109e-01,
1.41828976e-01,
1.41521130e-01,
1.84257307e-01,
1.85507562e-01,
1.83726575e-01,
]),
1.0e-2,
)
assert fit_linear.figure_of_merit == pytest.approx(-29.20551989, 1.0e-4)
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-2)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
def test__simulate_interferometer_data_and_fit__linear_light_profiles_agree_with_standard_light_profiles(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_linear = al.Galaxy(
redshift=1.0,
bulge=al.lp_linear.EllSersic(sersic_index=1.0),
disk=al.lp_linear.EllSersic(sersic_index=4.0),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_linear])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([0.1, 0.1, 0.2]), 1.0e-4)
assert fit_linear.linear_light_profile_intensity_dict[
lens_galaxy_linear.light] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.bulge] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.disk] == pytest.approx(0.2, 1.0e-2)
assert fit.log_likelihood == fit_linear.log_likelihood
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-4)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
assert fit_linear.galaxy_model_image_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_image, 1.0e-4)
lens_galaxy_visibilities = lens_galaxy.visibilities_via_transformer_from(
grid=interferometer.grid, transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_visibilities, 1.0e-4)
source_galaxy_visibilities = source_galaxy.visibilities_via_transformer_from(
grid=traced_grid_2d_list[1], transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_visibilities,
1.0e-4)
"""
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
"""
To use these hyper-galaxy-instrument parameters, we pass them to a lens-fit just like we do our `Tracer`.
"""
tracer = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_hyper, source_magnification_hyper]
)
al.FitImaging(
dataset=imaging,
tracer=tracer,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
fit_imaging_plotter = aplt.FitImagingPlotter(fit=fit, include_2d=include_2d)
fit_imaging_plotter.subplot_fit_imaging()
"""
__Wrap Up__
Is there any reason to scale the background noise other than if the background sky subtraction has a large
correction? There is. Lots of pixels in an image do not contain the lensed source but are fitted by the
inversion. As we've learnt in this chapter, this isn't problematic when we have our adaptive regularization scheme
because the regularization coefficient will be increased to large values.
However, if you ran a full **PyAutoLens** model-fit in hyper-mode (which we cover in the next tutorial), you will
find the method still dedicates a lot of source-pixels to fit these regions of the image, __even though they have no
def test__tag__mixture_of_values():
settings = al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.Grid,
grid_inversion_class=al.Grid,
sub_size=2,
signal_to_noise_limit=2,
bin_up_factor=None,
psf_shape_2d=None,
),
settings_lens=al.SettingsLens(positions_threshold=2.0),
)
assert settings.phase_tag_no_inversion == "settings__grid_sub_2__snr_2__pos_2.00"
assert (
settings.phase_tag_with_inversion
== "settings__grid_sub_2_inv_sub_2__snr_2__pos_2.00"
)
settings = al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
pixel_scales_interp=0.3,
bin_up_factor=3,
psf_shape_2d=(2, 2),
),
settings_lens=al.SettingsLens(auto_positions_factor=0.5),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True
),
log_likelihood_cap=200.01,
)
assert (
settings.phase_tag_no_inversion
== "settings__grid_facc_0.5__bin_3__psf_2x2__auto_pos_x0.50__lh_cap_200.0"
)
assert (
settings.phase_tag_with_inversion
== "settings__grid_facc_0.5_inv_interp_0.300__bin_3__psf_2x2__auto_pos_x0.50__no_border__stochastic__lh_cap_200.0"
)
settings = al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
pixel_scales_interp=0.3,
transformer_class=al.TransformerDFT,
),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True
),
log_likelihood_cap=100.01,
)
assert (
settings.phase_tag_no_inversion == "settings__grid_facc_0.5__dft__lh_cap_100.0"
)
assert (
settings.phase_tag_with_inversion
== "settings__grid_facc_0.5_inv_interp_0.300__dft__no_border__stochastic__lh_cap_100.0"
)
settings = al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerNUFFT
),
settings_inversion=al.SettingsInversion(use_linear_operators=True),
)
assert settings.phase_tag_no_inversion == "settings__grid_sub_2__nufft"
assert (
settings.phase_tag_with_inversion
== "settings__grid_sub_2_inv_sub_2__nufft__lop"
)
def test__masked_interferometer__settings_inputs_are_used_in_masked_interferometer(
self, interferometer_7, mask_7x7):
phase_interferometer_7 = al.PhaseInterferometer(
search=mock.MockSearch("phase_interferometer_7"),
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.Grid2D,
grid_inversion_class=al.Grid2D,
sub_size=3,
signal_to_noise_limit=1.0,
),
settings_pixelization=al.SettingsPixelization(
use_border=False, is_stochastic=True),
settings_inversion=al.SettingsInversion(
use_linear_operators=True),
),
real_space_mask=mask_7x7,
)
assert (phase_interferometer_7.settings.settings_masked_interferometer.
sub_size == 3)
assert (phase_interferometer_7.settings.settings_masked_interferometer.
signal_to_noise_limit == 1.0)
assert phase_interferometer_7.settings.settings_pixelization.use_border == False
assert (phase_interferometer_7.settings.settings_pixelization.
is_stochastic == True)
assert (phase_interferometer_7.settings.settings_inversion.
use_linear_operators == True)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.Grid2D)
assert isinstance(analysis.masked_dataset.grid_inversion, al.Grid2D)
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerNUFFT)
phase_interferometer_7 = al.PhaseInterferometer(
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
grid_class=al.Grid2DIterate,
sub_size=3,
fractional_accuracy=0.99,
sub_steps=[2],
transformer_class=al.TransformerDFT,
)),
search=mock.MockSearch("phase_interferometer_7"),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert isinstance(analysis.masked_dataset.grid, al.Grid2DIterate)
assert analysis.masked_dataset.grid.sub_size == 1
assert analysis.masked_dataset.grid.fractional_accuracy == 0.99
assert analysis.masked_dataset.grid.sub_steps == [2]
assert isinstance(analysis.masked_dataset.transformer,
al.TransformerDFT)
def test__galaxy_model_image_dict(masked_imaging_7x7):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
g2 = al.Galaxy(redshift=1.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
traced_grids_of_planes = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.grid)
traced_blurring_grids_of_planes = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.blurring_grid)
g0_image = g0.image_2d_from(grid=traced_grids_of_planes[0])
g0_blurring_image = g0.image_2d_from(
grid=traced_blurring_grids_of_planes[0])
g0_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g0_image, blurring_image=g0_blurring_image)
g1_image = g1.image_2d_from(grid=traced_grids_of_planes[1])
g1_blurring_image = g1.image_2d_from(
grid=traced_blurring_grids_of_planes[1])
g1_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g1_image, blurring_image=g1_blurring_image)
assert fit.galaxy_model_image_dict[g0] == pytest.approx(
g0_blurred_image, 1.0e-4)
assert fit.galaxy_model_image_dict[g1] == pytest.approx(
g1_blurred_image, 1.0e-4)
assert (fit.galaxy_model_image_dict[g2].slim == np.zeros(9)).all()
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g0].native +
fit.galaxy_model_image_dict[g1].native,
1.0e-4,
)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(redshift=0.5)
g1 = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
mapper = pix.mapper_from(source_grid_slim=masked_imaging_7x7.grid,
source_pixelization_grid=None)
inversion = al.Inversion(
dataset=masked_imaging_7x7,
linear_obj_list=[mapper],
regularization_list=[reg],
settings=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.galaxy_model_image_dict[g0] == np.zeros(9)).all()
assert fit.galaxy_model_image_dict[g1].native == pytest.approx(
inversion.mapped_reconstructed_image.native, 1.0e-4)
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g1].native, 1.0e-4)
g0 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=1.0))
g1 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=2.0))
g2 = al.Galaxy(redshift=0.5)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2, galaxy_pix])
masked_imaging_7x7.image[0] = 3.0
fit = al.FitImaging(dataset=masked_imaging_7x7, tracer=tracer)
traced_grids = tracer.traced_grid_list_from(grid=masked_imaging_7x7.grid)
traced_blurring_grids = tracer.traced_grid_list_from(
grid=masked_imaging_7x7.blurring_grid)
g0_image = g0.image_2d_from(grid=traced_grids[0])
g0_blurring_image = g0.image_2d_from(grid=traced_blurring_grids[0])
g0_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g0_image, blurring_image=g0_blurring_image)
g1_image = g1.image_2d_from(grid=traced_grids[1])
g1_blurring_image = g1.image_2d_from(grid=traced_blurring_grids[1])
g1_blurred_image = masked_imaging_7x7.convolver.convolve_image(
image=g1_image, blurring_image=g1_blurring_image)
blurred_image = g0_blurred_image + g1_blurred_image
profile_subtracted_image = masked_imaging_7x7.image - blurred_image
mapper = pix.mapper_from(
source_grid_slim=masked_imaging_7x7.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.InversionImaging(
image=profile_subtracted_image,
noise_map=masked_imaging_7x7.noise_map,
convolver=masked_imaging_7x7.convolver,
w_tilde=masked_imaging_7x7.w_tilde,
linear_obj_list=[mapper],
regularization_list=[reg],
)
assert (fit.galaxy_model_image_dict[g2] == np.zeros(9)).all()
assert fit.galaxy_model_image_dict[g0].native == pytest.approx(
g0_blurred_image.native, 1.0e-4)
assert fit.galaxy_model_image_dict[g1].native == pytest.approx(
g1_blurred_image.native, 1.0e-4)
assert fit.galaxy_model_image_dict[galaxy_pix].native == pytest.approx(
inversion.mapped_reconstructed_image.native, 1.0e-4)
assert fit.model_image.native == pytest.approx(
fit.galaxy_model_image_dict[g0].native +
fit.galaxy_model_image_dict[g1].native +
inversion.mapped_reconstructed_image.native,
1.0e-4,
)
def test___galaxy_model_visibilities_dict(interferometer_7,
interferometer_7_grid):
g0 = al.Galaxy(
redshift=0.5,
light_profile=al.lp.EllSersic(intensity=1.0),
mass_profile=al.mp.SphIsothermal(einstein_radius=1.0),
)
g1 = al.Galaxy(redshift=1.0, light_profile=al.lp.EllSersic(intensity=1.0))
g2 = al.Galaxy(redshift=1.0)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2])
fit = al.FitInterferometer(dataset=interferometer_7_grid, tracer=tracer)
traced_grids_of_planes = tracer.traced_grid_list_from(
grid=interferometer_7_grid.grid)
g0_profile_visibilities = g0.visibilities_via_transformer_from(
grid=traced_grids_of_planes[0],
transformer=interferometer_7_grid.transformer)
g1_profile_visibilities = g1.visibilities_via_transformer_from(
grid=traced_grids_of_planes[1],
transformer=interferometer_7_grid.transformer)
assert fit.galaxy_model_visibilities_dict[g0].slim == pytest.approx(
g0_profile_visibilities, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
g1_profile_visibilities, 1.0e-4)
assert (fit.galaxy_model_visibilities_dict[g2].slim == (0.0 + 0.0j) *
np.zeros((7, ))).all()
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim +
fit.galaxy_model_visibilities_dict[g1].slim,
1.0e-4,
)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
g0 = al.Galaxy(redshift=0.5)
g1 = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1])
fit = al.FitInterferometer(dataset=interferometer_7, tracer=tracer)
mapper = pix.mapper_from(source_grid_slim=interferometer_7.grid,
source_pixelization_grid=None)
inversion = al.Inversion(dataset=interferometer_7,
linear_obj_list=[mapper],
regularization_list=[reg])
assert (fit.galaxy_model_visibilities_dict[g0] == (0.0 + 0.0j) * np.zeros(
(7, ))).all()
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
inversion.mapped_reconstructed_data.slim, 1.0e-4)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g1].slim, 1.0e-4)
g0 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=1.0))
g1 = al.Galaxy(redshift=0.5, light_profile=al.lp.EllSersic(intensity=2.0))
g2 = al.Galaxy(redshift=0.5)
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=1.0)
galaxy_pix = al.Galaxy(redshift=1.0, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[g0, g1, g2, galaxy_pix])
fit = al.FitInterferometer(dataset=interferometer_7_grid, tracer=tracer)
traced_grids = tracer.traced_grid_list_from(
grid=interferometer_7_grid.grid)
g0_visibilities = g0.visibilities_via_transformer_from(
grid=traced_grids[0], transformer=interferometer_7_grid.transformer)
g1_visibilities = g1.visibilities_via_transformer_from(
grid=traced_grids[1], transformer=interferometer_7_grid.transformer)
profile_visibilities = g0_visibilities + g1_visibilities
profile_subtracted_visibilities = (interferometer_7_grid.visibilities -
profile_visibilities)
mapper = pix.mapper_from(
source_grid_slim=interferometer_7_grid.grid,
settings=al.SettingsPixelization(use_border=False),
)
inversion = al.InversionInterferometer(
visibilities=profile_subtracted_visibilities,
noise_map=interferometer_7_grid.noise_map,
transformer=interferometer_7_grid.transformer,
linear_obj_list=[mapper],
regularization_list=[reg],
settings=al.SettingsInversion(use_w_tilde=False),
)
assert (fit.galaxy_model_visibilities_dict[g2] == (0.0 + 0.0j) * np.zeros(
(7, ))).all()
assert fit.galaxy_model_visibilities_dict[g0].slim == pytest.approx(
g0_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[g1].slim == pytest.approx(
g1_visibilities.slim, 1.0e-4)
assert fit.galaxy_model_visibilities_dict[
galaxy_pix].slim == pytest.approx(
inversion.mapped_reconstructed_data.slim, 1.0e-4)
assert fit.model_visibilities.slim == pytest.approx(
fit.galaxy_model_visibilities_dict[g0].slim +
fit.galaxy_model_visibilities_dict[g1].slim +
inversion.mapped_reconstructed_data.slim,
1.0e-4,
)
print("Number of points = " + str(masked_interferometer.grid.sub_shape_1d) +
"\n")
print("Number of visibilities = " +
str(masked_interferometer.visibilities.shape_1d) + "\n")
start_overall = time.time()
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
start = time.time()
for i in range(repeats):
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_linear_operators=True),
)
print(fit.log_evidence)
diff = time.time() - start
print("Time to compute fit = {}".format(diff / repeats))
aplt.FitInterferometer.subplot_fit_real_space(fit=fit)
aplt.Inversion.reconstruction(inversion=fit.inversion)
start = time.time()
for i in range(repeats):
inversion = tracer.inversion_interferometer_from_grid_and_data(
grid=masked_interferometer.grid,
visibilities_mask=np.full(fill_value=False,
shape=interferometer.visibilities.shape),
settings=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerNUFFT),
)
print("Number of points = " + str(masked_interferometer.grid.sub_shape_slim) +
"\n")
print("Number of visibilities = " +
str(masked_interferometer.visibilities.shape_slim) + "\n")
start_overall = time.time()
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
start = time.time()
for i in range(repeats):
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_linear_operators=False),
)
print(fit.log_likelihood)
diff = time.time() - start
print("Time to compute fit = {}".format(diff / repeats))
aplt.FitInterferometer.subplot_fit_real_space(fit=fit)
def test___all_lens_fit_quantities__linear_operator(
self, interferometer_7_lop):
# Ensures the inversion grid is used, as this would cause the test to fail.
interferometer_7_lop.grid[0, 0] = -100.0
pix = al.pix.Rectangular(shape=(3, 3))
reg = al.reg.Constant(coefficient=0.01)
g0 = al.Galaxy(redshift=0.5, pixelization=pix, regularization=reg)
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5), g0])
fit = al.FitInterferometer(
interferometer=interferometer_7_lop,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_linear_operators=True),
)
mapper = pix.mapper_from_grid_and_sparse_grid(
grid=interferometer_7_lop.grid_inversion, sparse_grid=None)
inversion = inversions.InversionInterferometerLinearOperator.from_data_mapper_and_regularization(
mapper=mapper,
regularization=reg,
visibilities=interferometer_7_lop.visibilities,
noise_map=interferometer_7_lop.noise_map,
transformer=interferometer_7_lop.transformer,
settings=al.SettingsInversion(use_linear_operators=True),
)
assert inversion.mapped_reconstructed_visibilities == pytest.approx(
fit.model_visibilities, 1.0e-4)
residual_map = al.util.fit.residual_map_from(
data=interferometer_7_lop.visibilities,
model_data=inversion.mapped_reconstructed_visibilities,
)
assert residual_map.slim == pytest.approx(fit.residual_map.slim,
1.0e-4)
normalized_residual_map = al.util.fit.normalized_residual_map_complex_from(
residual_map=residual_map,
noise_map=interferometer_7_lop.noise_map)
assert normalized_residual_map.slim == pytest.approx(
fit.normalized_residual_map.slim, 1.0e-4)
chi_squared_map = al.util.fit.chi_squared_map_complex_from(
residual_map=residual_map,
noise_map=interferometer_7_lop.noise_map)
assert chi_squared_map.slim == pytest.approx(fit.chi_squared_map.slim,
1.0e-4)
chi_squared = al.util.fit.chi_squared_complex_from(
chi_squared_map=chi_squared_map)
noise_normalization = al.util.fit.noise_normalization_complex_from(
noise_map=interferometer_7_lop.noise_map)
log_likelihood = al.util.fit.log_likelihood_from(
chi_squared=chi_squared, noise_normalization=noise_normalization)
assert log_likelihood == pytest.approx(fit.log_likelihood, 1e-4)
log_likelihood_with_regularization = al.util.fit.log_likelihood_with_regularization_from(
chi_squared=chi_squared,
regularization_term=inversion.regularization_term,
noise_normalization=noise_normalization,
)
assert log_likelihood_with_regularization == pytest.approx(
fit.log_likelihood_with_regularization, 1e-4)
log_evidence = al.util.fit.log_evidence_from(
chi_squared=chi_squared,
regularization_term=inversion.regularization_term,
log_curvature_regularization_term=inversion.
log_det_curvature_reg_matrix_term,
log_regularization_term=inversion.
log_det_regularization_matrix_term,
noise_normalization=noise_normalization,
)
assert log_evidence == fit.log_evidence
assert log_evidence == fit.figure_of_merit
mapped_reconstructed_image = al.util.inversion.mapped_reconstructed_data_from(
mapping_matrix=fit.inversion.mapper.mapping_matrix,
reconstruction=fit.inversion.reconstruction,
)
assert (fit.inversion.mapped_reconstructed_image.slim ==
mapped_reconstructed_image).all()
