class_docstr: Johnson's SU-distribution.
  
  This distribution has parameters: shape parameters `skewness` and
  `tailweight`, location `loc`, and `scale`.
  
  #### Mathematical details
  
  The probability density function (pdf) is,
  
  ```none
  pdf(x; s, t, xi, sigma) = exp(-0.5 (s + t arcsinh(y))**2) / Z
  where,
  s = skewness
  t = tailweight
  y = (x - xi) / sigma
  Z = sigma sqrt(2 pi) sqrt(1 + y**2) / t
  ```
  
  where:
  * `loc = xi`,
  * `scale = sigma`, and,
  * `Z` is the normalization constant.
  
  The JohnsonSU 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 ~ JohnsonSU(skewness, tailweight, loc=0, scale=1)
  Y = loc + scale * X
  ```
  
  #### Examples
  
  Examples of initialization of one or a batch of distributions.
  
  ```python
  import tensorflow_probability as tfp
  tfd = tfp.distributions
  
  # Define a single scalar Johnson's SU-distribution.
  single_dist = tfd.JohnsonSU(skewness=-2., tailweight=2., loc=1.1, scale=1.5)
  
  # Evaluate the pdf at 1, returning a scalar Tensor.
  single_dist.prob(1.)
  
  # Define a batch of two scalar valued Johnson SU's.
  # The first has shape parameters 1 and 2, mean 3, and scale 11.
  # The second 4, 5, 6 and 22.
  multi_dist = tfd.JohnsonSU(skewness=[1, 4], tailweight=[2, 5],
                             loc=[3, 6], scale=[11, 22.])
  
  # Evaluate the pdf of the first distribution on 0, and the second on 1.5,
  # returning a length two tensor.
  multi_dist.prob([0, 1.5])
  
  # Get 3 samples, returning a 3 x 2 tensor.
  multi_dist.sample(3)
  ```
  
  Arguments are broadcast when possible.
  
  ```python
  # Define a batch of two Johnson's SU distributions.
  # Both have skewness 2, tailweight 3 and mean 1, but different scales.
  dist = tfd.JohnsonSU(skewness=2, tailweight=3, loc=1, scale=[11, 22.])
  
  # Evaluate the pdf of both distributions on the same point, 3.0,
  # returning a length 2 tensor.
  dist.prob(3.0)
  ```
  
  Compute the gradients of samples w.r.t. the parameters:
  
  ```python
  skewness = tf.Variable(2.0)
  tailweight = tf.Variable(3.0)
  loc = tf.Variable(2.0)
  scale = tf.Variable(11.0)
  dist = tfd.JohnsonSU(skewness=skewness, tailweight=tailweight, loc=loc,
                       scale=scale)
  with tf.GradientTape() as tape:
    samples = dist.sample(5)  # Shape [5]
    loss = tf.reduce_mean(tf.square(samples))  # Arbitrary loss function
  # Unbiased stochastic gradients of the loss function
  grads = tape.gradient(loss, dist.variables)
  ```
code: def _mean(self):
      skewness, tailweight, scale, loc = [
          tf.convert_to_tensor(v)
          for v in (
              self.skewness,
              self.tailweight,
              self.scale,
              self.loc,
          )
      ]
  
      return loc - scale * tf.math.exp(
          0.5 / tf.math.square(tailweight)
      ) * tf.math.sinh(skewness / tailweight)
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import invert
  from tensorflow_probability.python.bijectors import scale
  from tensorflow_probability.python.bijectors import shift
  from tensorflow_probability.python.bijectors import sinh
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.distributions import normal
  from tensorflow_probability.python.distributions import transformed_distribution
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import tensor_util
label_desc: Use image node_id 7 for calling the JohnsonSU obj's underlying member method code with example usage: obj._mean() and returns: unknown