def make_masked_interferometer_7():
return al.MaskedInterferometer(
interferometer=make_interferometer_7(),
visibilities_mask=make_visibilities_mask_7(),
real_space_mask=make_mask_7x7(),
settings=al.SettingsMaskedInterferometer(
sub_size=1, transformer_class=al.TransformerNUFFT),
)
def test__fit_figure_of_merit__includes_hyper_image_and_noise__matches_fit(
self, interferometer_7, mask_7x7, visibilities_mask_7
):
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_interferometer_7 = al.PhaseInterferometer(
galaxies=dict(lens=lens_galaxy),
hyper_background_noise=hyper_background_noise,
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
sub_size=4
)
),
search=mock.MockSearch("test_phase"),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7,
results=mock.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
assert analysis.masked_interferometer.real_space_mask.sub_size == 4
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7,
real_space_mask=mask_7x7,
settings=al.SettingsMaskedInterferometer(sub_size=4),
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
hyper_background_noise=hyper_background_noise,
)
assert fit.log_likelihood == fit_figure_of_merit
def make_masked_interferometer_7_grid(
interferometer_7, mask_7x7, visibilities_mask_7x2, sub_grid_7x7, transformer_7x7_7
):
return al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7x2,
real_space_mask=mask_7x7,
settings=al.SettingsMaskedInterferometer(
grid_class=aa.Grid, sub_size=1, transformer_class=aa.TransformerDFT
),
)
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, interferometer_7, mask_7x7, visibilities_mask_7
):
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_interferometer_7 = al.PhaseInterferometer(
galaxies=dict(lens=lens_galaxy),
cosmology=cosmo.FLRW,
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
sub_size=2
)
),
search=mock.MockSearch("test_phase"),
real_space_mask=mask_7x7,
)
analysis = phase_interferometer_7.make_analysis(
dataset=interferometer_7,
mask=visibilities_mask_7,
results=mock.MockResults(),
)
instance = phase_interferometer_7.model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7,
real_space_mask=mask_7x7,
settings=al.SettingsMaskedInterferometer(sub_size=2),
)
tracer = analysis.tracer_for_instance(instance=instance)
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer, tracer=tracer
)
assert fit.log_likelihood == fit_figure_of_merit
def test__masked_interferometer_generator_from_aggregator(
interferometer_7, visibilities_mask_7, mask_7x7, samples
):
phase_interferometer_7x7 = al.PhaseInterferometer(
galaxies=dict(
lens=al.GalaxyModel(redshift=0.5, light=al.lp.EllipticalSersic),
source=al.GalaxyModel(redshift=1.0, light=al.lp.EllipticalSersic),
),
settings=al.SettingsPhaseInterferometer(
settings_masked_interferometer=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT,
grid_class=al.GridIterate,
grid_inversion_class=al.GridInterpolate,
fractional_accuracy=0.5,
sub_steps=[2],
pixel_scales_interp=0.1,
)
),
search=mock.MockSearch("test_phase_aggregator", samples=samples),
real_space_mask=mask_7x7,
)
phase_interferometer_7x7.run(
dataset=interferometer_7,
mask=visibilities_mask_7,
results=mock.MockResults(samples=samples),
)
agg = af.Aggregator(directory=phase_interferometer_7x7.paths.output_path)
masked_interferometer_gen = al.agg.MaskedInterferometer(aggregator=agg)
for masked_interferometer in masked_interferometer_gen:
assert (
masked_interferometer.interferometer.visibilities
== interferometer_7.visibilities
).all()
assert (masked_interferometer.real_space_mask == mask_7x7).all()
assert isinstance(masked_interferometer.grid, al.GridIterate)
assert isinstance(masked_interferometer.grid_inversion, al.GridInterpolate)
assert masked_interferometer.grid.sub_steps == [2]
assert masked_interferometer.grid.fractional_accuracy == 0.5
assert masked_interferometer.grid_inversion.pixel_scales_interp == (0.1, 0.1)
assert isinstance(masked_interferometer.transformer, al.TransformerDFT)
def test__masked_dataset_via_autoarray(
self,
interferometer_7,
sub_mask_7x7,
visibilities_mask_7,
visibilities_7,
visibilities_noise_map_7,
):
masked_interferometer_7 = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7,
real_space_mask=sub_mask_7x7,
settings=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT
),
)
assert (
masked_interferometer_7.visibilities == interferometer_7.visibilities
).all()
assert (masked_interferometer_7.visibilities == visibilities_7).all()
assert (masked_interferometer_7.noise_map == visibilities_noise_map_7).all()
assert (
masked_interferometer_7.visibilities_mask
== np.full(fill_value=False, shape=(7,))
).all()
assert (
masked_interferometer_7.interferometer.uv_wavelengths
== interferometer_7.uv_wavelengths
).all()
assert (
masked_interferometer_7.interferometer.uv_wavelengths[0, 0]
== -55636.4609375
)
assert type(masked_interferometer_7.transformer) == al.TransformerDFT
def test__inheritance_via_autoarray(
self,
interferometer_7,
sub_mask_7x7,
visibilities_mask_7x2,
grid_7x7,
sub_grid_7x7,
):
masked_interferometer_7 = al.MaskedInterferometer(
interferometer=interferometer_7,
visibilities_mask=visibilities_mask_7x2,
real_space_mask=sub_mask_7x7,
settings=al.SettingsMaskedInterferometer(grid_class=al.Grid),
)
assert (masked_interferometer_7.grid.in_1d_binned == grid_7x7).all()
assert (masked_interferometer_7.grid == sub_grid_7x7).all()
grid = al.Grid.from_mask(mask=sub_mask_7x7)
assert (masked_interferometer_7.grid == grid).all()
def test__log_likelihood_cap(self, interferometer_7, mask_7x7):
lens_galaxy = al.Galaxy(redshift=0.5,
light=al.lp.EllipticalSersic(intensity=0.1))
phase_imaging_7x7 = al.PhaseInterferometer(
phase_name="test_phase",
galaxies=dict(lens=lens_galaxy),
settings=al.SettingsPhaseInterferometer(
masked_interferometer=al.SettingsMaskedInterferometer(
sub_size=1),
log_likelihood_cap=100.0,
),
search=mock.MockSearch(),
real_space_mask=mask_7x7,
)
analysis = phase_imaging_7x7.make_analysis(dataset=interferometer_7,
mask=mask_7x7,
results=mock.MockResults())
assert analysis.log_likelihood_cap == 100.0
"""We also need a ‘visibilities mask’ which defining which visibilities are omitted from the chi-squared evaluation."""
visibilities_mask = np.full(fill_value=False,
shape=interferometer.visibilities.shape)
"""
__Settings__
The `SettingsPhaseInterferometer` describe how the model is fitted to the data in the log likelihood function.
These settings are used and described throughout the `autolens_workspace/examples/model` example scripts, with a
complete description of all settings given in `autolens_workspace/examples/model/customize/settings.py`.
The settings chosen here are applied to all phases in the pipeline.
"""
settings_masked_interferometer = al.SettingsMaskedInterferometer(
grid_class=al.Grid2D, sub_size=2, transformer_class=al.TransformerDFT)
settings = al.SettingsPhaseInterferometer(
settings_masked_interferometer=settings_masked_interferometer)
"""
__PIPELINE SETUP__
Transdimensional pipelines used the `SetupPipeline` object to customize the analysis performed by the pipeline,
for example if a shear was included in the mass model and the model used for the source galaxy.
SLaM pipelines break the analysis down into multiple pipelines which focus on modeling a specific aspect of the strong
lens, first the Source, then the (lens) Light and finally the Mass. Each of these pipelines has it own setup object
which is equivalent to the `SetupPipeline` object, customizing the analysis in that pipeline. Each pipeline therefore
has its own `SetupMass`, `SetupLightParametric` and `SetupSourceParametric` object.
The `Setup` used in earlier pipelines determine the model used in later pipelines. For example, if the `Source`
sersic_index=3.0,
)
source_galaxy = al.Galaxy(redshift=1.0, light=sersic)
mask = al.Mask2D.circular(shape_native=(250, 250),
pixel_scales=0.05,
sub_size=2,
radius=5.0)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer,
real_space_mask=mask,
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(
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"
)
"""We also need a ‘visibilities mask’ which defining which visibilities are omitted from the chi-squared evaluation."""
visibilities_mask = np.full(fill_value=False,
shape=interferometer.visibilities.shape)
"""
__Settings__
The `SettingsPhaseInterferometer` describe how the model is fitted to the data in the log likelihood function.
These settings are used and described throughout the `autolens_workspace/examples/model` example scripts, with a
complete description of all settings given in `autolens_workspace/examples/model/customize/settings.py`.
The settings chosen here are applied to all phases in the pipeline.
"""
settings_masked_interferometer = al.SettingsMaskedInterferometer(
grid_class=al.Grid2D, sub_size=2)
"""
We also specify the *SettingsInversion*, which describes how the `Inversion` fits the source `Pixelization` and
with `Regularization`.
This can perform the linear algebra calculation that performs the `Inversion` using two options:
- As matrices: this is numerically more accurate and does not approximate the `log_evidence` of the `Inversion`. For
datasets of < 100 0000 visibilities we recommend that you use this option. However, for > 100 000 visibilities this
approach requires excessive amounts of memory on your computer (> 16 GB) and thus becomes unfeasible.
- As linear operators: this numerically less accurate and approximates the `log_evidence` of the `Inversioon`. However,
it is the only viable options for large visibility datasets. It does not represent the linear algebra as matrices in
memory and thus makes the analysis of > 10 million visibilities feasible.
By default we use the linear operators approach.
"""
Set up the `MaskedInterferometer` dataset we fit. This includes the `real_space_mask` that the source galaxy's
`Inversion` is evaluated using via mapping to Fourier space using the `Transformer`.
"""
mask = al.Mask2D.circular(shape_native=(256, 256),
pixel_scales=0.05,
sub_size=1,
radius=3.0)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer,
real_space_mask=mask,
visibilities_mask=np.full(fill_value=False,
shape=interferometer.visibilities.shape),
settings=al.SettingsMaskedInterferometer(
transformer_class=transformer_class),
)
"""Print the size of the real-space mask and number of visiblities, which drive the run-time of the fit."""
print(
f"Number of points in real space = {masked_interferometer.grid.sub_shape_slim} \n"
)
print(
f"Number of visibilities = {masked_interferometer.visibilities.shape_slim}\n"
)
start_overall = time.time()
"""Time the complete fitting procedure."""
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
def test__simulate_interferometer_data_and_fit__chi_squared_is_0__noise_normalization_correct(
):
grid = al.Grid.uniform(shape_2d=(51, 51), pixel_scales=0.1, sub_size=2)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(centre=(0.1, 0.1),
einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalExponential(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_map=al.Array.full(fill_value=300.0,
shape_2d=grid.shape_2d),
background_sky_map=al.Array.zeros(shape_2d=grid.shape_2d),
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
path = "{}/data_temp/simulate_and_fit".format(
os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
try:
shutil.rmtree(path)
except FileNotFoundError:
pass
if os.path.exists(path) is False:
os.makedirs(path)
interferometer.output_to_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
interferometer = al.Interferometer.from_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
visibilities_mask = np.full(fill_value=False, shape=(7, 2))
real_space_mask = al.Mask.unmasked(shape_2d=(51, 51),
pixel_scales=0.1,
sub_size=2)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer,
visibilities_mask=visibilities_mask,
real_space_mask=real_space_mask,
settings=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=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.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(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(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert abs(fit.chi_squared) < 1.0e-4
path = "{}/data_temp".format(os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
if os.path.exists(path) == True:
shutil.rmtree(path)
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)
