コード例 #1
0
    def test__log_likelihood_via_analysis__matches_manual_fit(
            self, imaging_ci_7x7, pre_cti_data_7x7, traps_x1, ccd,
            parallel_clocker_2d):

        model = af.CollectionPriorModel(
            cti=af.Model(ac.CTI2D, parallel_traps=traps_x1, parallel_ccd=ccd),
            hyper_noise=af.Model(ac.ci.HyperCINoiseCollection),
        )

        analysis = ac.AnalysisImagingCI(dataset_ci=imaging_ci_7x7,
                                        clocker=parallel_clocker_2d)

        instance = model.instance_from_unit_vector([])

        log_likelihood_via_analysis = analysis.log_likelihood_function(
            instance=instance)

        post_cti_data = parallel_clocker_2d.add_cti(
            data=pre_cti_data_7x7.native,
            parallel_trap_list=traps_x1,
            parallel_ccd=ccd)

        fit = ac.ci.FitImagingCI(dataset=analysis.dataset_ci,
                                 post_cti_data=post_cti_data)

        assert fit.log_likelihood == log_likelihood_via_analysis
コード例 #2
0
ファイル: test_result_ci.py プロジェクト: Jammy2211/PyAutoCTI
    def test__fits_to_extracted_and_full_datasets_available(
        self,
        imaging_ci_7x7,
        mask_2d_7x7_unmasked,
        parallel_clocker_2d,
        samples_with_result,
    ):

        masked_imaging_ci = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)
        masked_imaging_ci = masked_imaging_ci.apply_settings(
            settings=ac.ci.SettingsImagingCI(parallel_pixels=(0, 1)))

        analysis = ac.AnalysisImagingCI(dataset_ci=masked_imaging_ci,
                                        clocker=parallel_clocker_2d)

        result = ResultImagingCI(samples=samples_with_result,
                                 analysis=analysis,
                                 model=None,
                                 search=None)

        assert (result.max_log_likelihood_fit.mask == np.full(
            fill_value=False, shape=(7, 1))).all()

        assert (result.max_log_likelihood_full_fit.mask == np.full(
            fill_value=False, shape=(7, 7))).all()
コード例 #3
0
ファイル: test_result_ci.py プロジェクト: Jammy2211/PyAutoCTI
    def test__noise_scaling_map_list_is_setup_correctly(
        self,
        imaging_ci_7x7,
        mask_2d_7x7_unmasked,
        layout_ci_7x7,
        parallel_clocker_2d,
        samples_with_result,
    ):

        imaging_ci_7x7.cosmic_ray_map = None

        masked_imaging_ci_7x7 = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)

        analysis = ac.AnalysisImagingCI(dataset_ci=masked_imaging_ci_7x7,
                                        clocker=parallel_clocker_2d)

        result = ResultImagingCI(samples=samples_with_result,
                                 analysis=analysis,
                                 model=None,
                                 search=None)

        assert (result.noise_scaling_map_list[0] ==
                result.noise_scaling_map_of_regions_ci).all()

        assert (result.noise_scaling_map_list[1] ==
                result.noise_scaling_map_of_parallel_epers).all()

        assert (result.noise_scaling_map_list[2] ==
                result.noise_scaling_map_of_serial_trails).all()

        assert (result.noise_scaling_map_list[3] ==
                result.noise_scaling_map_of_serial_overscan_no_trails).all()
コード例 #4
0
    def test__parallel_and_serial_checks_raise_exception(self, imaging_ci_7x7):

        model = af.CollectionPriorModel(cti=af.Model(
            ac.CTI2D,
            parallel_traps=[
                ac.TrapInstantCapture(density=1.1),
                ac.TrapInstantCapture(density=1.1),
            ],
            parallel_ccd=ac.CCDPhase(),
        ))

        analysis = ac.AnalysisImagingCI(
            dataset_ci=imaging_ci_7x7,
            clocker=None,
            settings_cti=ac.SettingsCTI2D(parallel_total_density_range=(1.0,
                                                                        2.0)),
        )

        instance = model.instance_from_prior_medians()

        with pytest.raises(exc.PriorException):
            analysis.log_likelihood_function(instance=instance)

        model = af.CollectionPriorModel(cti=af.Model(
            ac.CTI2D,
            serial_traps=[
                ac.TrapInstantCapture(density=1.1),
                ac.TrapInstantCapture(density=1.1),
            ],
            serial_ccd=ac.CCDPhase(),
        ))

        analysis = ac.AnalysisImagingCI(
            dataset_ci=[imaging_ci_7x7],
            clocker=None,
            settings_cti=ac.SettingsCTI2D(serial_total_density_range=(1.0,
                                                                      2.0)),
        )

        instance = model.instance_from_prior_medians()

        with pytest.raises(exc.PriorException):
            analysis.log_likelihood_function(instance=instance)
コード例 #5
0
    def test__make_result__result_imaging_is_returned(self, imaging_ci_7x7,
                                                      pre_cti_data_7x7,
                                                      traps_x1, ccd,
                                                      parallel_clocker_2d):
        model = af.CollectionPriorModel(
            cti=af.Model(ac.CTI2D, parallel_traps=traps_x1, parallel_ccd=ccd),
            hyper_noise=af.Model(ac.ci.HyperCINoiseCollection),
        )

        analysis = ac.AnalysisImagingCI(dataset_ci=imaging_ci_7x7,
                                        clocker=parallel_clocker_2d)

        search = mock.MockSearch(name="test_search")

        result = search.fit(model=model, analysis=analysis)

        assert isinstance(result, ResultImagingCI)
コード例 #6
0
    def test__full_and_extracted_fits_from_instance_and_imaging_ci(
            self, imaging_ci_7x7, mask_2d_7x7_unmasked, traps_x1, ccd,
            parallel_clocker_2d):

        model = af.CollectionPriorModel(
            cti=af.Model(ac.CTI2D, parallel_traps=traps_x1, parallel_ccd=ccd),
            hyper_noise=af.Model(ac.ci.HyperCINoiseCollection),
        )

        masked_imaging_ci = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)
        masked_imaging_ci = masked_imaging_ci.apply_settings(
            settings=ac.ci.SettingsImagingCI(parallel_pixels=(0, 1)))

        post_cti_data = parallel_clocker_2d.add_cti(
            data=masked_imaging_ci.pre_cti_data,
            parallel_trap_list=traps_x1,
            parallel_ccd=ccd,
        )

        analysis = ac.AnalysisImagingCI(dataset_ci=masked_imaging_ci,
                                        clocker=parallel_clocker_2d)

        instance = model.instance_from_unit_vector([])

        fit_analysis = analysis.fit_from_instance(instance=instance)

        fit = ac.ci.FitImagingCI(dataset=masked_imaging_ci,
                                 post_cti_data=post_cti_data)

        assert fit.image.shape == (7, 1)
        assert fit_analysis.log_likelihood == pytest.approx(fit.log_likelihood)

        fit_full_analysis = analysis.fit_full_dataset_from_instance(
            instance=instance)

        fit = ac.ci.FitImagingCI(dataset=imaging_ci_7x7,
                                 post_cti_data=post_cti_data)

        assert fit.image.shape == (7, 7)
        assert fit_full_analysis.log_likelihood == pytest.approx(
            fit.log_likelihood)
コード例 #7
0
    def test__extracted_fits_from_instance_and_imaging_ci__include_noise_scaling(
        self,
        imaging_ci_7x7,
        mask_2d_7x7_unmasked,
        traps_x1,
        ccd,
        parallel_clocker_2d,
        layout_ci_7x7,
    ):

        model = af.CollectionPriorModel(
            cti=af.Model(ac.CTI2D, parallel_traps=traps_x1, parallel_ccd=ccd),
            hyper_noise=af.Model(ac.ci.HyperCINoiseCollection,
                                 regions_ci=ac.ci.HyperCINoiseScalar),
        )

        noise_scaling_map_list_list_of_regions_ci = [
            ac.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
        ]

        imaging_ci_7x7.noise_scaling_map_list = [
            noise_scaling_map_list_list_of_regions_ci[0]
        ]

        masked_imaging_ci = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)
        masked_imaging_ci = masked_imaging_ci.apply_settings(
            settings=ac.ci.SettingsImagingCI(parallel_pixels=(0, 1)))

        analysis = ac.AnalysisImagingCI(dataset_ci=masked_imaging_ci,
                                        clocker=parallel_clocker_2d)

        instance = model.instance_from_prior_medians()

        fit_analysis = analysis.fit_from_instance(instance=instance,
                                                  hyper_noise_scale=True)

        post_cti_data = parallel_clocker_2d.add_cti(
            data=masked_imaging_ci.pre_cti_data,
            parallel_trap_list=traps_x1,
            parallel_ccd=ccd,
        )

        fit = ac.ci.FitImagingCI(
            dataset=masked_imaging_ci,
            post_cti_data=post_cti_data,
            hyper_noise_scalars=[instance.hyper_noise.regions_ci],
        )

        assert fit.image.shape == (7, 1)
        assert fit.log_likelihood == pytest.approx(fit_analysis.log_likelihood,
                                                   1.0e-4)

        fit = ac.ci.FitImagingCI(
            dataset=masked_imaging_ci,
            post_cti_data=post_cti_data,
            hyper_noise_scalars=[ac.ci.HyperCINoiseScalar(scale_factor=0.0)],
        )

        assert fit.log_likelihood != pytest.approx(fit_analysis.log_likelihood,
                                                   1.0e-4)

        fit_full_analysis = analysis.fit_full_dataset_from_instance(
            instance=instance, hyper_noise_scale=True)

        masked_imaging_ci = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)

        fit = ac.ci.FitImagingCI(
            dataset=masked_imaging_ci,
            post_cti_data=post_cti_data,
            hyper_noise_scalars=[instance.hyper_noise.regions_ci],
        )

        assert fit.image.shape == (7, 7)
        assert fit.log_likelihood == pytest.approx(
            fit_full_analysis.log_likelihood, 1.0e-4)

        fit = ac.ci.FitImagingCI(
            dataset=masked_imaging_ci,
            post_cti_data=post_cti_data,
            hyper_noise_scalars=[ac.ci.HyperCINoiseScalar(scale_factor=0.0)],
        )

        assert fit.log_likelihood != pytest.approx(
            fit_full_analysis.log_likelihood, 1.0e-4)
コード例 #8
0
imaging_ci_trimmed_list = [
    imaging_ci.apply_mask(mask=mask_ci) for imaging_ci in imaging_ci_list
]

imaging_ci_trimmed_list = [
    imaging_ci.apply_settings(settings=ac.ci.SettingsImagingCI(parallel_columns=(0, 1)))
    for imaging_ci in imaging_ci_trimmed_list
]

"""
__Analysis__

The `AnalysisImagingCI` object defines the `log_likelihood_function` used by the non-linear search to fit the model to 
the `ImagingCI`dataset.
"""
analysis = ac.AnalysisImagingCI(dataset_ci=imaging_ci_trimmed_list, clocker=clocker)

analysis_list = [
    ac.AnalysisImagingCI(dataset_ci=imaging_ci, clocker=clocker)
    for imaging_ci in imaging_ci_trimmed_list
]
analysis = analysis_list[0] + analysis_list[1] + analysis_list[2] + analysis_list[3]

"""
__Model-Fit__

We can now begin the model-fit by passing the model and analysis object to the search, which performs a non-linear
search to find which models fit the data with the highest likelihood.

Checkout the folder `autocti_workspace/output/imaging_ci/parallel[x2]` for live outputs 
of the results of the fit, including on-the-fly visualization of the best fit model!
コード例 #9
0
ファイル: test_result_ci.py プロジェクト: Jammy2211/PyAutoCTI
    def test__noise_scaling_map_list_is_list_of_result__are_correct(
        self,
        imaging_ci_7x7,
        mask_2d_7x7_unmasked,
        parallel_clocker_2d,
        layout_ci_7x7,
        samples_with_result,
        traps_x1,
        ccd,
    ):

        noise_scaling_map_list_list_of_regions_ci = [
            ac.Array2D.ones(shape_native=(7, 7), pixel_scales=1.0)
        ]
        noise_scaling_map_list_list_of_parallel_epers = [
            ac.Array2D.full(fill_value=2.0,
                            shape_native=(7, 7),
                            pixel_scales=1.0)
        ]
        noise_scaling_map_list_list_of_serial_trails = [
            ac.Array2D.full(fill_value=3.0,
                            shape_native=(7, 7),
                            pixel_scales=1.0)
        ]
        noise_scaling_map_list_list_of_serial_overscan_no_trails = [
            ac.Array2D.full(fill_value=4.0,
                            shape_native=(7, 7),
                            pixel_scales=1.0)
        ]

        imaging_ci_7x7.noise_scaling_map_list = [
            noise_scaling_map_list_list_of_regions_ci[0],
            noise_scaling_map_list_list_of_parallel_epers[0],
            noise_scaling_map_list_list_of_serial_trails[0],
            noise_scaling_map_list_list_of_serial_overscan_no_trails[0],
        ]

        masked_imaging_ci_7x7 = imaging_ci_7x7.apply_mask(
            mask=mask_2d_7x7_unmasked)

        analysis = ac.AnalysisImagingCI(dataset_ci=masked_imaging_ci_7x7,
                                        clocker=parallel_clocker_2d)

        fit_analysis = analysis.fit_from_instance(
            instance=samples_with_result.max_log_likelihood_instance)

        result = ResultImagingCI(samples=samples_with_result,
                                 analysis=analysis,
                                 model=None,
                                 search=None)

        assert result.noise_scaling_map_of_regions_ci == pytest.approx(
            fit_analysis.chi_squared_map_of_regions_ci, 1.0e-2)
        assert result.noise_scaling_map_of_parallel_epers == pytest.approx(
            fit_analysis.chi_squared_map_of_parallel_epers, 1.0e-2)
        assert result.noise_scaling_map_of_serial_trails == pytest.approx(
            fit_analysis.chi_squared_map_of_serial_trails, 1.0e-2)
        assert result.noise_scaling_map_of_serial_overscan_no_trails == pytest.approx(
            fit_analysis.chi_squared_map_of_serial_overscan_no_trails, 1.0e-2)

        assert result.noise_scaling_map_of_regions_ci[1, 1] == pytest.approx(
            18.16, 1.0e-1)
        assert result.noise_scaling_map_of_parallel_epers[1,
                                                          1] == pytest.approx(
                                                              0.0, 1.0e-4)
        assert result.noise_scaling_map_of_serial_trails[1,
                                                         1] == pytest.approx(
                                                             0.0, 1.0e-4)
        assert result.noise_scaling_map_of_serial_overscan_no_trails[
            1, 1] == pytest.approx(0.0, 1.0e-4)

        model = af.CollectionPriorModel(
            cti=af.Model(
                ac.CTI2D,
                parallel_traps=traps_x1,
                parallel_ccd=ccd,
                serial_traps=traps_x1,
                serial_ccd=ccd,
            ),
            hyper_noise=af.Model(
                ac.ci.HyperCINoiseCollection,
                regions_ci=ac.ci.HyperCINoiseScalar(scale_factor=1.0),
                parallel_epers=ac.ci.HyperCINoiseScalar(scale_factor=1.0),
                serial_trails=ac.ci.HyperCINoiseScalar(scale_factor=1.0),
                serial_overscan_no_trails=ac.ci.HyperCINoiseScalar(
                    scale_factor=1.0),
            ),
        )

        instance = model.instance_from_prior_medians()

        fit_analysis = analysis.fit_from_instance(instance=instance)

        assert result.noise_scaling_map_of_regions_ci != pytest.approx(
            fit_analysis.chi_squared_map_of_regions_ci, 1.0e-2)
        assert result.noise_scaling_map_of_parallel_epers != pytest.approx(
            fit_analysis.chi_squared_map_of_parallel_epers, 1.0e-2)
        assert result.noise_scaling_map_of_serial_trails != pytest.approx(
            fit_analysis.chi_squared_map_of_serial_trails, 1.0e-2)
        assert result.noise_scaling_map_of_serial_overscan_no_trails != pytest.approx(
            fit_analysis.chi_squared_map_of_serial_overscan_no_trails, 1.0e-2)
コード例 #10
0
"""
__Search + Analysis + Model-Fit (Search 1)__

To reduce run-times, we trim the `ImagingCI` data from the high resolution data (e.g. 2000 columns) to just 50 columns 
to speed up the model-fit at the expense of inferring larger errors on the CTI model.
"""
search = af.DynestyStatic(path_prefix=path_prefix,
                          name="search[1]_parallel[x1]",
                          nlive=50)

imaging_ci_trimmed_list = [
    imaging_ci.apply_settings(settings=ac.ci.SettingsImagingCI(
        parallel_columns=(0, 50))) for imaging_ci in imaging_ci_list
]

analysis = ac.AnalysisImagingCI(dataset_ci=imaging_ci_trimmed_list,
                                clocker=parallel_clocker)

result_1 = search.fit(model=model, analysis=analysis)
"""
__Model (Search 2)__

We use the results of search 1 to create the lens model fitted in search 2, with:

 - Two or more parallel `TrapInstantCapture`'s species [4+ parameters: prior on density initialized from search 1].

 - A simple `CCD` volume filling parametrization with fixed notch depth and capacity [1 parameter: priors initialized 
 from search 1].

The number of free parameters and therefore the dimensionality of non-linear parameter space is N=5 or more.
"""
parallel_trap_0 = af.Model(ac.TrapInstantCapture)