class_docstr: Second pass through fmri_image.
  
  Parameters
  ----------
  fmri_image : `FmriImageList`
     object returning 4D array from ``np.asarray``, having attribute
     ``volume_start_times`` (if `volume_start_times` is None), and
     such that ``object[0]`` returns something with attributes ``shape``
  formula :  :class:`nipy.algorithms.statistics.formula.Formula`
  rho : ``Image``
     image of AR(1) coefficients.  Returning data from
     ``rho.get_fdata()``, and having attribute ``coordmap``
  outputs : list
      Store for model outputs.
  volume_start_times: None or float or (N,) ndarray
      start time of each frame. It can be specified either as an ndarray
      with ``N=len(images)`` elements or as a single float, the TR. None
      results in ``np.arange(len(images)).astype(np.float64)``
  
  Raises
  ------
  ValueError
      If `volume_start_times` not specified, and 4D image passed.
code: def execute(self):
      iterable = parcels(self.rho, exclude=[np.inf])
  
      def model_params(i):
          return (self.rho.get_fdata()[i].mean(),)
  
      # Generates indexer, data, model
      m = model_generator(
          self.formula,
          self.data,
          self.volume_start_times,
          iterable=iterable,
          model_type=ARModel,
          model_params=model_params,
      )
      # Generates indexer, data, 2D results
      r = results_generator(m)
  
      def reshape(i, x):
          """
          To write output, arrays have to be reshaped --
          this function does the appropriate reshaping for the two
          passes of fMRIstat.
  
          These passes are:
            i) 'slices through the z-axis'
            ii) 'parcels of approximately constant AR1 coefficient'
          """
          if len(x.shape) == 2:  # 2D input matrix
              if type(i) is int:  # integer indexing
                  # reshape to ND (where N is probably 4)
                  x.shape = (x.shape[0],) + self.fmri_image[0].shape[1:]
              # Convert lists to tuples, put anything else into a tuple
              if type(i) not in [type([]), type(())]:
                  i = (i,)
              else:
                  i = tuple(i)
              # Add : to indexing
              i = (slice(None, None, None),) + tuple(i)
          else:  # not 2D
              if type(i) is int:  # integer indexing
                  x.shape = self.fmri_image[0].shape[1:]
          return i, x
  
      # Put results pulled from results generator r, into outputs
      generate_output(self.outputs, r, reshape=reshape)
  
imports: import copy
  from os import path
  import numpy
  import numpy.linalg
  from nipy.algorithms.statistics.formula import make_recarray
  from nipy.algorithms.statistics.models.regression import ARModel, OLSModel, ar_bias_correct, ar_bias_corrector
  from nipy.core.api import AffineTransform, Image, matrix_generator, parcels
  from nipy.io.api import save_image
  from ..api import FmriImageList, axis0_generator
  from .None import outputters
label_desc: Use image node_id 2 for calling the AR1 obj's underlying member method code with example usage: obj.execute() and returns: self, i,  x