class_docstr: Runs one step of the Metropolis-Hastings algorithm.
  
  The [Metropolis-Hastings algorithm](
  https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm) is a
  Markov chain Monte Carlo (MCMC) technique which uses a proposal distribution
  to eventually sample from a target distribution.
  
  Note: `inner_kernel.one_step` must return `kernel_results` as a
  `collections.namedtuple` which must:
  
  - have a `target_log_prob` field,
  - optionally have a `log_acceptance_correction` field, and,
  - have only fields which are `Tensor`-valued.
  
  The Metropolis-Hastings log acceptance-probability is computed as:
  
  ```python
  log_accept_ratio = (current_kernel_results.target_log_prob
                      - previous_kernel_results.target_log_prob
                      + current_kernel_results.log_acceptance_correction)
  ```
  
  If `current_kernel_results.log_acceptance_correction` does not exist, it is
  presumed `0.` (i.e., that the proposal distribution is symmetric).
  
  The most common use-case for `log_acceptance_correction` is in the
  Metropolis-Hastings algorithm, i.e.,
  
  ```none
  accept_prob(x' | x) = p(x') / p(x) (g(x|x') / g(x'|x))
  
  where,
    p  represents the target distribution,
    g  represents the proposal (conditional) distribution,
    x' is the proposed state, and,
    x  is current state
  ```
  
  The log of the parenthetical term is the `log_acceptance_correction`.
  
  The `log_acceptance_correction` may not necessarily correspond to the ratio of
  proposal distributions, e.g, `log_acceptance_correction` has a different
  interpretation in Hamiltonian Monte Carlo.
  
  #### Examples
  
  ```python
  import tensorflow_probability as tfp
  hmc = tfp.mcmc.MetropolisHastings(
      tfp.mcmc.UncalibratedHamiltonianMonteCarlo(
          target_log_prob_fn=lambda x: -x - x**2,
          step_size=0.1,
          num_leapfrog_steps=3))
  # ==> functionally equivalent to:
  # hmc = tfp.mcmc.HamiltonianMonteCarlo(
  #     target_log_prob_fn=lambda x: -x - x**2,
  #     step_size=0.1,
  #     num_leapfrog_steps=3)
  ```
docstr: Returns an object with the same type as returned by `one_step`.
  
  Args:
    init_state: `Tensor` or Python `list` of `Tensor`s representing the
      initial state(s) of the Markov chain(s).
  
  Returns:
    kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of
      `Tensor`s representing internal calculations made within this function.
  
  Raises:
    ValueError: if `inner_kernel` results doesn't contain the member
      "target_log_prob".
docstr_tok: ["Returns","an","object","with","the","same","type","as","returned","by","`","one_step","`",".","Args",":","init_state",":","`","Tensor","`","or","Python","`","list","`","of","`","Tensor","`","s","representing","the","initial","state","(","s",")","of","the","Markov","chain","(","s",")",".","Returns",":","kernel_results",":","A","(","possibly","nested",")","`","tuple","`",",","`","namedtuple","`","or","`","list","`","of","`","Tensor","`","s","representing","internal","calculations","made","within","this","function",".","Raises",":","ValueError",":","if","`","inner_kernel","`","results","does","n't","contain","the","member","``","target_log_prob","''","."]
code: def bootstrap_results(self, init_state):
      """Returns an object with the same type as returned by `one_step`.
  
      Args:
        init_state: `Tensor` or Python `list` of `Tensor`s representing the
          initial state(s) of the Markov chain(s).
  
      Returns:
        kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of
          `Tensor`s representing internal calculations made within this function.
  
      Raises:
        ValueError: if `inner_kernel` results doesn't contain the member
          "target_log_prob".
      """
      with tf.name_scope(
          mcmc_util.make_name(self.name, "mh", "bootstrap_results")
      ):
          pkr = self.inner_kernel.bootstrap_results(init_state)
          if not has_target_log_prob(pkr):
              raise ValueError(
                  '"target_log_prob" must be a member of `inner_kernel` results.'
              )
          x = pkr.target_log_prob
          return MetropolisHastingsKernelResults(
              # See note regarding `strip_seeds` above in `one_step`.
              accepted_results=mcmc_util.strip_seeds(pkr),
              is_accepted=tf.ones_like(x, dtype=tf.bool),
              log_accept_ratio=tf.zeros_like(x),
              proposed_state=init_state,
              proposed_results=pkr,
              extra=[],
              # Allow room for one_step's seed.
              seed=samplers.zeros_seed(),
          )
  
imports: import collections
  import warnings
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import samplers
  from tensorflow_probability.python.mcmc import kernel
  from tensorflow_probability.python.mcmc.internal import util
label_desc: Use image node_id 7 for calling the MetropolisHastings obj's underlying member method code with example usage: obj.bootstrap_results(init_state) and returns: MetropolisHastingsKernelResults