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
