astro query:docs

- Index
- Modules

### Navigation

- next »
- « previous |
- astroquery v0.4.11 »
- Astroquery utils (`astroquery.utils`) »
- RunTimePredictor

# RunTimePredictor

class astroquery.utils.timer.RunTimePredictor(func, *args, **kwargs)

  Bases: `object`

  Class to predict run time.

  Note

  Only predict for single varying numeric input parameter.

  Parameters:
    func function

      Function to time.

    args tuple

      Fixed positional argument(s) for the function.

    kwargs dict

      Fixed keyword argument(s) for the function.

  Examples

      >>> from astroquery.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`(*[, model, fitter, power, min_datapoints]) | Fit a function to the lists of arguments and their respective run time in the cache.
  `plot`(*[, xscale, yscale, xlabeltext, save_as]) | Plot prediction.
  `predict_time`(arg) | Predict run time for given argument.
  `time_func`(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(*, model=None, fitter=None, power=1, min_datapoints=3)

    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:
      model `astropy.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`.

      fitter `astropy.modeling.fitting.Fitter`

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

      power int, optional

        Power of values to fit.

      min_datapoints int, optional

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

    Returns:
      a array-like

        Fitted `FittableModel` parameters.

    Raises:
      ValueError

        Insufficient data points for fitting.

      ModelsError

        Invalid model or fitter.

  plot(*, xscale='linear', yscale='linear', xlabeltext='args', save_as='')

    Plot prediction.

    Note

    Uses matplotlib.

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

        Scaling for `matplotlib.axes.Axes`.

      xlabeltext str, optional

        Text for X-label.

      save_as str, optional

        Save plot as given filename.

    Raises:
      RuntimeError

        Insufficient data for plotting.

  predict_time(arg)

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

    Parameters:
      arg number

        Input argument to predict run time for.

    Returns:
      t_est float

        Estimated run time for given argument.

    Raises:
      RuntimeError

        No fitted data for prediction.

  time_func(arglist)

    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:
      arglist list of numbers

        List of input arguments to time.