code: def windowed_mean(
      x, low_indices=None, high_indices=None, axis=0, name=None
  ):
      """Windowed estimates of mean.
  
      Computes means among data in the Tensor `x` along the given windows:
  
        result[i] = mean(x[low_indices[i]:high_indices[i]+1])
  
      efficiently.  To wit, if K is the size of `low_indices` and
      `high_indices`, and `N` is the size of `x` along the given `axis`,
      the computation takes O(K + N) work, O(log(N)) depth (the length of
      the longest series of operations that are performed sequentially),
      and only uses O(1) TensorFlow kernel invocations.
  
      This function can be useful for assessing the behavior over time of
      trailing-window estimators from some iterative process, such as the
      last half of an MCMC chain.
  
      Suppose `x` has shape `Bx + [N] + E`, where the `Bx` component has
      rank `axis`, and `low_indices` and `high_indices` broadcast to shape
      `[M]`.  Then each element of `low_indices` and `high_indices`
      must be between 0 and N+1, and the shape of the output will be
      `Bx + [M] + E`.  Batch shape in the indices is not currently supported.
  
      The default windows are
      `[0, 1), [1, 2), [1, 3), [2, 4), [2, 5), ...`
      This corresponds to analyzing `x` as though it were streaming, for
      example successive states of an MCMC sampler, and we were interested
      in the variance of the last half of the data at each point.
  
      Args:
        x: A numeric `Tensor` holding `N` samples along the given `axis`,
          whose windowed means are desired.
        low_indices: An integer `Tensor` defining the lower boundary
          (inclusive) of each window.  Default: elementwise half of
          `high_indices`.
        high_indices: An integer `Tensor` defining the upper boundary
          (exclusive) of each window.  Must be broadcast-compatible with
          `low_indices`.  Default: `tf.range(1, N+1)`, i.e., N windows
          that each end in the corresponding datum from `x` (inclusive).
        axis: Scalar `Tensor` designating the axis holding samples.  This
          is the axis of `x` along which we take windows, and therefore
          the axis that `low_indices` and `high_indices` index into.
          Other axes are treated in batch.  Default value: `0` (leftmost
          dimension).
        name: Python `str` name prefixed to Ops created by this function.
          Default value: `None` (i.e., `'windowed_mean'`).
  
      Returns:
        means: A numeric `Tensor` holding the windowed means of `x` along
          the `axis` dimension.
  
      """
      with tf.name_scope(name or "windowed_mean"):
          x = tf.convert_to_tensor(x)
          (
              low_indices,
              high_indices,
              low_counts,
              high_counts,
          ) = _prepare_window_args(x, low_indices, high_indices, axis)
  
          raw_cumsum = tf.cumsum(x, axis=axis)
          cum_sums = tf.concat(
              [
                  tf.zeros_like(tf.gather(raw_cumsum, [0], axis=axis)),
                  raw_cumsum,
              ],
              axis=axis,
          )
          low_sums = tf.gather(cum_sums, low_indices, axis=axis)
          high_sums = tf.gather(cum_sums, high_indices, axis=axis)
  
          counts = high_counts - low_counts
          return _safe_average(high_sums - low_sums, counts)
  
imports: import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import distribution_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensorshape_util
  from tensorflow_probability.python.math.generic import reduce_logmeanexp
label_desc: Use image node_id 9 for calling a global function with example usage: windowed_mean(x, low_indices, high_indices, axis, name) and returns: _safe_average