class_docstr: Multinomial distribution.
  
  This Multinomial distribution is parameterized by `probs`, a (batch of)
  length-`K` `prob` (probability) vectors (`K > 1`) such that
  `tf.reduce_sum(probs, -1) = 1`, and a `total_count` number of trials, i.e.,
  the number of trials per draw from the Multinomial. It is defined over a
  (batch of) length-`K` vector `counts` such that
  `tf.reduce_sum(counts, -1) = total_count`. The Multinomial is identically the
  Binomial distribution when `K = 2`.
  
  #### Mathematical Details
  
  The Multinomial is a distribution over `K`-class counts, i.e., a length-`K`
  vector of non-negative integer `counts = n = [n_0, ..., n_{K-1}]`.
  
  The probability mass function (pmf) is,
  
  ```none
  pmf(n; pi, N) = prod_j (pi_j)**n_j / Z
  Z = (prod_j n_j!) / N!
  ```
  
  where:
  * `probs = pi = [pi_0, ..., pi_{K-1}]`, `pi_j > 0`, `sum_j pi_j = 1`,
  * `total_count = N`, `N` a positive integer,
  * `Z` is the normalization constant, and,
  * `N!` denotes `N` factorial.
  
  Distribution parameters are automatically broadcast in all functions; see
  examples for details.
  
  #### Pitfalls
  
  The number of classes, `K`, must not exceed:
  - the largest integer representable by `self.dtype`, i.e.,
    `2**(mantissa_bits+1)` (IEE754),
  - the maximum `Tensor` index, i.e., `2**31-1`.
  
  In other words,
  
  ```python
  K <= min(2**31-1, {
    tf.float16: 2**11,
    tf.float32: 2**24,
    tf.float64: 2**53 }[param.dtype])
  ```
  
  Note: This condition is validated only when `self.validate_args = True`.
  
  #### Examples
  
  Create a 3-class distribution, with the 3rd class is most likely to be drawn,
  using logits.
  
  ```python
  logits = [-50., -43, 0]
  dist = Multinomial(total_count=4., logits=logits)
  ```
  
  Create a 3-class distribution, with the 3rd class is most likely to be drawn.
  
  ```python
  p = [.2, .3, .5]
  dist = Multinomial(total_count=4., probs=p)
  ```
  
  The distribution functions can be evaluated on counts.
  
  ```python
  # counts same shape as p.
  counts = [1., 0, 3]
  dist.prob(counts)  # Shape []
  
  # p will be broadcast to [[.2, .3, .5], [.2, .3, .5]] to match counts.
  counts = [[1., 2, 1], [2, 2, 0]]
  dist.prob(counts)  # Shape [2]
  
  # p will be broadcast to shape [5, 7, 3] to match counts.
  counts = [[...]]  # Shape [5, 7, 3]
  dist.prob(counts)  # Shape [5, 7]
  ```
  
  Create a 2-batch of 3-class distributions.
  
  ```python
  p = [[.1, .2, .7], [.3, .3, .4]]  # Shape [2, 3]
  dist = Multinomial(total_count=[4., 5], probs=p)
  
  counts = [[2., 1, 1], [3, 1, 1]]
  dist.prob(counts)  # Shape [2]
  
  dist.sample(5) # Shape [5, 2, 3]
  ```
code: def _sample_n(self, n, seed=None):
      n_draws = math_ops.cast(self.total_count, dtype=dtypes.int32)
      k = self.event_shape_tensor()[0]
  
      # broadcast the total_count and logits to same shape
      n_draws = (
          array_ops.ones_like(self.logits[..., 0], dtype=n_draws.dtype)
          * n_draws
      )
      logits = (
          array_ops.ones_like(
              n_draws[..., array_ops.newaxis], dtype=self.logits.dtype
          )
          * self.logits
      )
  
      # flatten the total_count and logits
      flat_logits = array_ops.reshape(logits, [-1, k])  # [B1B2...Bm, k]
      flat_ndraws = n * array_ops.reshape(n_draws, [-1])  # [B1B2...Bm]
  
      # computes each total_count and logits situation by map_fn
      def _sample_single(args):
          logits, n_draw = args[0], args[1]  # [K], []
          x = random_ops.multinomial(
              logits[array_ops.newaxis, ...], n_draw, seed
          )  # [1, n*n_draw]
          x = array_ops.reshape(x, shape=[n, -1])  # [n, n_draw]
          x = math_ops.reduce_sum(
              array_ops.one_hot(x, depth=k), axis=-2
          )  # [n, k]
          return x
  
      x = map_fn.map_fn(
          _sample_single, [flat_logits, flat_ndraws], dtype=self.dtype
      )  # [B1B2...Bm, n, k]
  
      # reshape the results to proper shape
      x = array_ops.transpose(x, perm=[1, 0, 2])
      final_shape = array_ops.concat(
          [[n], self.batch_shape_tensor(), [k]], 0
      )
      x = array_ops.reshape(x, final_shape)  # [n, B1, B2,..., Bm, k]
      return x
  
imports: from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import check_ops
  from tensorflow.python.ops import control_flow_ops
  from tensorflow.python.ops import map_fn
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import nn_ops
  from tensorflow.python.ops import random_ops
  from tensorflow.python.ops.distributions import distribution
  from tensorflow.python.ops.distributions import util
  from tensorflow.python.util import deprecation
  from tensorflow.python.util.tf_export import tf_export
label_desc: Use image node_id 9 for calling the Multinomial obj's underlying member method code with example usage: obj._sample_n(n, seed) and returns: x, x