class_docstr: The vectorization of the Exponential distribution on `R^k`.
  
  The vector exponential distribution is defined over a subset of `R^k`, and
  parameterized by a (batch of) length-`k` `loc` vector and a (batch of) `k x k`
  `scale` matrix:  `covariance = scale @ scale.T`, where `@` denotes
  matrix-multiplication.
  
  #### Mathematical Details
  
  The probability density function (pdf) is
  
  ```none
  pdf(y; loc, scale) = exp(-||x||_1) / Z,  for y in S(loc, scale),
  x = inv(scale) @ (y - loc),
  Z = |det(scale)|,
  ```
  
  where:
  
  * `loc` is a vector in `R^k`,
  * `scale` is a linear operator in `R^{k x k}`, `cov = scale @ scale.T`,
  * `S = {loc + scale @ x : x in R^k, x_1 > 0, ..., x_k > 0}`, is an image of
     the positive half-space,
  * `||x||_1` denotes the `l1` norm of `x`, `sum_i |x_i|`,
  * `Z` denotes the normalization constant.
  
  The VectorExponential distribution is a member of the [location-scale
  family](https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be
  constructed as,
  
  ```none
  X = (X_1, ..., X_k), each X_i ~ Exponential(rate=1)
  Y = (Y_1, ...,Y_k) = scale @ X + loc
  ```
  
  #### About `VectorExponential` and `Vector` distributions in TensorFlow.
  
  The `VectorExponential` is a non-standard distribution that has useful
  properties.
  
  The marginals `Y_1, ..., Y_k` are *not* Exponential random variables, due to
  the fact that the sum of Exponential random variables is not Exponential.
  
  Instead, `Y` is a vector whose components are linear combinations of
  Exponential random variables.  Thus, `Y` lives in the vector space generated
  by `vectors` of Exponential distributions.  This allows the user to decide the
  mean and covariance (by setting `loc` and `scale`), while preserving some
  properties of the Exponential distribution.  In particular, the tails of `Y_i`
  will be (up to polynomial factors) exponentially decaying.
  
  To see this last statement, note that the pdf of `Y_i` is the convolution of
  the pdf of `k` independent Exponential random variables.  One can then show by
  induction that distributions with exponential (up to polynomial factors) tails
  are closed under convolution.
  
  
  #### Examples
  
  ```python
  tfd = tfp.distributions
  
  # Initialize a single 2-variate VectorExponential, supported on
  # {(x, y) in R^2 : x > 0, y > 0}.
  mat = [[1.0, 0.1],
         [0.1, 1.0]]
  
  vex = tfd.VectorExponentialLinearOperator(
      scale=tf.linalg.LinearOperatorFullMatrix(mat))
  
  # Compute the pdf of an `R^2` observation; return a scalar.
  vex.prob([1., 2.])  # shape: []
  
  # Initialize a 2-batch of 3-variate Vector Exponential's.
  mu = [[1., 2, 3],
        [1., 0, 0]]              # shape: [2, 3]
  scale_diag = [[1., 2, 3],
                [0.5, 1, 1.5]]     # shape: [2, 3]
  
  vex = tfd.VectorExponentialLinearOperator(
      loc=mu,
      scale=tf.linalg.LinearOperatorDiag(scale_diag))
  
  # Compute the pdf of two `R^3` observations; return a length-2 vector.
  x = [[1.9, 2.2, 3.1],
       [10., 1.0, 9.0]]     # shape: [2, 3]
  vex.prob(x)    # shape: [2]
  ```
docstr: Construct Vector Exponential distribution supported on a subset of `R^k`.
  
  The `batch_shape` is the broadcast shape between `loc` and `scale`
  arguments.
  
  The `event_shape` is given by last dimension of the matrix implied by
  `scale`. The last dimension of `loc` (if provided) must broadcast with this.
  
  Recall that `covariance = scale @ scale.T`.
  
  Additional leading dimensions (if any) will index batches.
  
  Args:
    loc: Floating-point `Tensor`. If this is set to `None`, `loc` is
      implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where
      `b >= 0` and `k` is the event size.
    scale: Instance of `LinearOperator` with same `dtype` as `loc` and shape
      `[B1, ..., Bb, k, k]`.
    validate_args: Python `bool`, default `False`. Whether to validate input
      with asserts. If `validate_args` is `False`, and the inputs are
      invalid, correct behavior is not guaranteed.
    allow_nan_stats: Python `bool`, default `True`. If `False`, raise an
      exception if a statistic (e.g. mean/mode/etc...) is undefined for any
      batch member If `True`, batch members with valid parameters leading to
      undefined statistics will return NaN for this statistic.
    name: The name to give Ops created by the initializer.
  
  Raises:
    ValueError: if `scale` is unspecified.
    TypeError: if not `scale.dtype.is_floating`
docstr_tok: ["Construct","Vector","Exponential","distribution","supported","on","a","subset","of","`","R^k","`",".","The","`","batch_shape","`","is","the","broadcast","shape","between","`","loc","`","and","`","scale","`","arguments",".","The","`","event_shape","`","is","given","by","last","dimension","of","the","matrix","implied","by","`","scale","`",".","The","last","dimension","of","`","loc","`","(","if","provided",")","must","broadcast","with","this",".","Recall","that","`","covariance","=","scale","@","scale.T","`",".","Additional","leading","dimensions","(","if","any",")","will","index","batches",".","Args",":","loc",":","Floating-point","`","Tensor","`",".","If","this","is","set","to","`","None","`",",","`","loc","`","is","implicitly","`","0","`",".","When","specified",",","may","have","shape","`","[","B1",",","...",",","Bb",",","k","]","`","where","`","b",">","=","0","`","and","`","k","`","is","the","event","size",".","scale",":","Instance","of","`","LinearOperator","`","with","same","`","dtype","`","as","`","loc","`","and","shape","`","[","B1",",","...",",","Bb",",","k",",","k","]","`",".","validate_args",":","Python","`","bool","`",",","default","`","False","`",".","Whether","to","validate","input","with","asserts",".","If","`","validate_args","`","is","`","False","`",",","and","the","inputs","are","invalid",",","correct","behavior","is","not","guaranteed",".","allow_nan_stats",":","Python","`","bool","`",",","default","`","True","`",".","If","`","False","`",",","raise","an","exception","if","a","statistic","(","e.g",".","mean\/mode\/etc","...",")","is","undefined","for","any","batch","member","If","`","True","`",",","batch","members","with","valid","parameters","leading","to","undefined","statistics","will","return","NaN","for","this","statistic",".","name",":","The","name","to","give","Ops","created","by","the","initializer",".","Raises",":","ValueError",":","if","`","scale","`","is","unspecified",".","TypeError",":","if","not","`","scale.dtype.is_floating","`"]
code: def __init__(
      self,
      loc=None,
      scale=None,
      validate_args=False,
      allow_nan_stats=True,
      name="VectorExponentialLinearOperator",
  ):
      """Construct Vector Exponential distribution supported on a subset of `R^k`.
  
      The `batch_shape` is the broadcast shape between `loc` and `scale`
      arguments.
  
      The `event_shape` is given by last dimension of the matrix implied by
      `scale`. The last dimension of `loc` (if provided) must broadcast with this.
  
      Recall that `covariance = scale @ scale.T`.
  
      Additional leading dimensions (if any) will index batches.
  
      Args:
        loc: Floating-point `Tensor`. If this is set to `None`, `loc` is
          implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where
          `b >= 0` and `k` is the event size.
        scale: Instance of `LinearOperator` with same `dtype` as `loc` and shape
          `[B1, ..., Bb, k, k]`.
        validate_args: Python `bool`, default `False`. Whether to validate input
          with asserts. If `validate_args` is `False`, and the inputs are
          invalid, correct behavior is not guaranteed.
        allow_nan_stats: Python `bool`, default `True`. If `False`, raise an
          exception if a statistic (e.g. mean/mode/etc...) is undefined for any
          batch member If `True`, batch members with valid parameters leading to
          undefined statistics will return NaN for this statistic.
        name: The name to give Ops created by the initializer.
  
      Raises:
        ValueError: if `scale` is unspecified.
        TypeError: if not `scale.dtype.is_floating`
      """
      parameters = dict(locals())
      if loc is None:
          loc = 0.0  # Implicit value for backwards compatibility.
      if scale is None:
          raise ValueError("Missing required `scale` parameter.")
      if not dtype_util.is_floating(scale.dtype):
          raise TypeError(
              "`scale` parameter must have floating-point dtype."
          )
  
      with tf.name_scope(name) as name:
          # Since expand_dims doesn't preserve constant-ness, we obtain the
          # non-dynamic value if possible.
          # TODO(b/190433277): Verify GradientTape safety and use
          # `convert_nonref_to_tensor` on `loc`.
          loc = (
              loc
              if loc is None
              else tf.convert_to_tensor(
                  loc, name="loc", dtype=scale.dtype
              )
          )
          (
              batch_shape,
              event_shape,
          ) = distribution_util.shapes_from_loc_and_scale(loc, scale)
          self._loc = loc
          self._scale = scale
          super(VectorExponentialLinearOperator, self).__init__(
              # TODO(b/137665504): Use batch-adding meta-distribution to set the
              # batch shape instead of tf.ones.
              # We use `Sample` instead of `Independent` because `Independent`
              # requires concatenating `batch_shape` and `event_shape`, which loses
              # static `batch_shape` information when `event_shape` is not
              # statically known.
              distribution=sample.Sample(
                  exponential.Exponential(
                      rate=tf.ones(batch_shape, dtype=scale.dtype),
                      allow_nan_stats=allow_nan_stats,
                  ),
                  event_shape,
              ),
              bijector=shift_bijector.Shift(shift=loc)(
                  scale_matvec_linear_operator.ScaleMatvecLinearOperator(
                      scale=scale, validate_args=validate_args
                  )
              ),
              validate_args=validate_args,
              name=name,
          )
          self._parameters = parameters
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import chain
  from tensorflow_probability.python.bijectors import scale_matvec_linear_operator
  from tensorflow_probability.python.bijectors import shift
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.distributions import exponential
  from tensorflow_probability.python.distributions import sample
  from tensorflow_probability.python.distributions import transformed_distribution
  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 tensorshape_util
label_desc: Use image node_id 1 to create a new VectorExponentialLinearOperator object from inherited base classes: transformed_distribution with example: obj = VectorExponentialLinearOperator(loc, scale, validate_args, allow_nan_stats, name)