Improve tools for profiling the likelihood funciton of an analysis class, including making profiling work on interferometer datasets.
All example scripts now on the workspace include the following run-times section (or text which is much shorter):
"""
__Run Times__
modeling can be a computationally expensive process. When fitting complex models to high resolution datasets
run times can be of order hours, days, weeks or even months.
Run times are dictated by two factors:
- The log likelihood evaluation time: the time it takes for a single `instance` of the model to be fitted to
the dataset such that a log likelihood is returned.
- The number of iterations (e.g. log likelihood evaluations) performed by the non-linear search: more complex lens
models require more iterations to converge to a solution.
The log likelihood evaluation time can be estimated before a fit using the `profile_log_likelihood_function` method,
which returns two dictionaries containing the run-times and information about the fit.
"""
run_time_dict, info_dict = analysis.profile_log_likelihood_function(
instance=model.random_instance()
)
"""
The overall log likelihood evaluation time is given by the `fit_time` key.
For this example, it is ~0.01 seconds, which is extremely fast for modeling. More advanced lens
modeling features (e.g. shapelets, multi Gaussian expansions, pixelizations) have slower log likelihood evaluation
times (1-3 seconds), and you should be wary of this when using these features.
Feel free to go ahead a print the full `run_time_dict` and `info_dict` to see the other information they contain. The
former has a break-down of the run-time of every individual function call in the log likelihood function, whereas the
latter stores information about the data which drives the run-time (e.g. number of image-pixels in the mask, the
shape of the PSF, etc.).
"""
print(f"Log Likelihood Evaluation Time (second) = {run_time_dict['fit_time']}")
"""
To estimate the expected overall run time of the model-fit we multiply the log likelihood evaluation time by an
estimate of the number of iterations the non-linear search will perform.
Estimating this quantity is more tricky, as it varies depending on the model complexity (e.g. number of parameters)
and the properties of the dataset and model being fitted.
For this example, we conservatively estimate that the non-linear search will perform ~10000 iterations per free
parameter in the model. This is an upper limit, with models typically converging in far fewer iterations.
If you perform the fit over multiple CPUs, you can divide the run time by the number of cores to get an estimate of
the time it will take to fit the model. However, above ~6 cores the speed-up from parallelization is less efficient and
does not scale linearly with the number of cores.
"""
print(
"Estimated Run Time Upper Limit (seconds) = ",
(run_time_dict["fit_time"] * model.total_free_parameters * 10000)
/ search.number_of_cores,
)
Improve tools for profiling the likelihood funciton of an analysis class, including making profiling work on interferometer datasets.
All example scripts now on the workspace include the following run-times section (or text which is much shorter):