# RunTimePredictor¶

class astropy.utils.timer.RunTimePredictor(func, *args, **kwargs)[source]

Bases: object

Class to predict run time.

Note

Only predict for single varying numeric input parameter.

Parameters
funcfunction

Function to time.

argstuple

Fixed positional argument(s) for the function.

kwargsdict

Fixed keyword argument(s) for the function.

Examples

>>> from astropy.utils.timer import RunTimePredictor


Set up a predictor for $$10^{x}$$:

>>> p = RunTimePredictor(pow, 10)


Give it baseline data to use for prediction and get the function output values:

>>> p.time_func(range(10, 1000, 200))
>>> for input, result in sorted(p.results.items()):
...     print("pow(10, {0})\n{1}".format(input, result))
pow(10, 10)
10000000000
pow(10, 210)
10000000000...
pow(10, 410)
10000000000...
pow(10, 610)
10000000000...
pow(10, 810)
10000000000...


Fit a straight line assuming $$\text{arg}^{1}$$ relationship (coefficients are returned):

>>> p.do_fit()
array([1.16777420e-05,  1.00135803e-08])


Predict run time for $$10^{5000}$$:

>>> p.predict_time(5000)
6.174564361572262e-05


Plot the prediction:

>>> p.plot(xlabeltext='Power of 10')


When the changing argument is not the last, e.g., $$x^{2}$$, something like this might work:

>>> p = RunTimePredictor(lambda x: pow(x, 2))
>>> p.time_func([2, 3, 5])
>>> sorted(p.results.items())
[(2, 4), (3, 9), (5, 25)]


Attributes Summary

 results Function outputs from time_func.

Methods Summary

 do_fit(self[, model, fitter, power, …]) Fit a function to the lists of arguments and their respective run time in the cache. plot(self[, xscale, yscale, xlabeltext, save_as]) Plot prediction. predict_time(self, arg) Predict run time for given argument. time_func(self, arglist) Time the partial function for a list of single args and store run time in a cache.

Attributes Documentation

results

Function outputs from time_func.

A dictionary mapping input arguments (fixed arguments are not included) to their respective output values.

Methods Documentation

do_fit(self, model=None, fitter=None, power=1, min_datapoints=3)[source]

Fit a function to the lists of arguments and their respective run time in the cache.

By default, this does a linear least-square fitting to a straight line on run time w.r.t. argument values raised to the given power, and returns the optimal intercept and slope.

Parameters
modelastropy.modeling.Model

Model for the expected trend of run time (Y-axis) w.r.t. $$\text{arg}^{\text{power}}$$ (X-axis). If None, will use Polynomial1D with degree=1.

fitterastropy.modeling.fitting.Fitter

Fitter for the given model to extract optimal coefficient values. If None, will use LinearLSQFitter.

powerint, optional

Power of values to fit.

min_datapointsint, optional

Minimum number of data points required for fitting. They can be built up with time_func.

Returns
aarray-like

Fitted FittableModel parameters.

Raises
ValueError

Insufficient data points for fitting.

ModelsError

Invalid model or fitter.

plot(self, xscale='linear', yscale='linear', xlabeltext='args', save_as='')[source]

Plot prediction.

Note

Uses matplotlib.

Parameters
xscale, yscale{‘linear’, ‘log’, ‘symlog’}

Scaling for matplotlib.axes.Axes.

xlabeltextstr, optional

Text for X-label.

save_asstr, optional

Save plot as given filename.

Raises
RuntimeError

Insufficient data for plotting.

predict_time(self, arg)[source]

Predict run time for given argument. If prediction is already cached, cached value is returned.

Parameters
argnumber

Input argument to predict run time for.

Returns
t_estfloat

Estimated run time for given argument.

Raises
RuntimeError

No fitted data for prediction.

time_func(self, arglist)[source]

Time the partial function for a list of single args and store run time in a cache. This forms a baseline for the prediction.

This also stores function outputs in results.

Parameters
arglistlist of numbers

List of input arguments to time.