docs: def map_as_series(self, func, value_size=None, dtype=None, chunk_size='auto'):
          """
          Efficiently apply a function to images as series data.
  
          For images data that represent image sequences, this method
          applies a function to each pixel's series, and then returns to
          the images format, using an efficient intermediate block
          representation.
  
          Parameters
          ----------
          func : function
              Function to apply to each time series. Should take one-dimensional
              ndarray and return the transformed one-dimensional ndarray.
  
          value_size : int, optional, default = None
              Size of the one-dimensional ndarray resulting from application of
              func. If not supplied, will be automatically inferred for an extra
              computational cost.
  
          dtype : str, optional, default = None
              dtype of one-dimensional ndarray resulting from application of func.
              If not supplied it will be automatically inferred for an extra computational cost.
  
          chunk_size : str or tuple, size of image chunk used during conversion, default = 'auto'
              String interpreted as memory size (in kilobytes, e.g. '64').
              The exception is the string 'auto'. In spark mode, 'auto' will choose a chunk size to make the
              resulting blocks ~100 MB in size. In local mode, 'auto' will create a single block.
              Tuple of ints interpreted as 'pixels per dimension'.
          """
          blocks = self.toblocks(chunk_size=chunk_size)
  
          if value_size is not None:
              dims = list(blocks.blockshape)
              dims[0] = value_size
          else:
              dims = None
  
          def f(block):
              return apply_along_axis(func, 0, block)
  
          return blocks.map(f, value_shape=dims, dtype=dtype).toimages()