class_docstr: Runs one step of Uncalibrated Hamiltonian Monte Carlo.
  
  Warning: this kernel will not result in a chain which converges to the
  `target_log_prob`. To get a convergent MCMC, use
  `PreconditionedHamiltonianMonteCarlo(...)` or
  `MetropolisHastings(UncalibratedPreconditionedHamiltonianMonteCarlo(...))`.
  
  For more details on `UncalibratedPreconditionedHamiltonianMonteCarlo`, see
  `PreconditionedHamiltonianMonteCarlo`.
code: def one_step(self, current_state, previous_kernel_results, seed=None):
      with tf.name_scope(
          mcmc_util.make_name(self.name, "phmc", "one_step")
      ):
          if self._store_parameters_in_results:
              step_size = previous_kernel_results.step_size
              num_leapfrog_steps = (
                  previous_kernel_results.num_leapfrog_steps
              )
              momentum_distribution = (
                  previous_kernel_results.momentum_distribution
              )
          else:
              step_size = self.step_size
              num_leapfrog_steps = self.num_leapfrog_steps
              momentum_distribution = self.momentum_distribution
  
          [
              current_state_parts,
              step_sizes,
              momentum_distribution,
              current_target_log_prob,
              current_target_log_prob_grad_parts,
          ] = _prepare_args(
              self.target_log_prob_fn,
              current_state,
              step_size,
              momentum_distribution,
              previous_kernel_results.target_log_prob,
              previous_kernel_results.grads_target_log_prob,
              maybe_expand=True,
              state_gradients_are_stopped=self.state_gradients_are_stopped,
              experimental_shard_axis_names=self.experimental_shard_axis_names,
          )
  
          seed = samplers.sanitize_seed(seed)
          current_momentum_parts = list(
              momentum_distribution.sample(seed=seed)
          )
          momentum_log_prob = getattr(
              momentum_distribution,
              "_log_prob_unnormalized",
              momentum_distribution.log_prob,
          )
          kinetic_energy_fn = lambda *args: -momentum_log_prob(*args)
  
          integrator = leapfrog_impl.SimpleLeapfrogIntegrator(
              self.target_log_prob_fn, step_sizes, num_leapfrog_steps
          )
  
          [
              next_momentum_parts,
              next_state_parts,
              next_target_log_prob,
              next_target_log_prob_grad_parts,
          ] = integrator(
              current_momentum_parts,
              current_state_parts,
              target=current_target_log_prob,
              target_grad_parts=current_target_log_prob_grad_parts,
              kinetic_energy_fn=kinetic_energy_fn,
          )
          if self.state_gradients_are_stopped:
              next_state_parts = [
                  tf.stop_gradient(x) for x in next_state_parts
              ]
  
          def maybe_flatten(x):
              return (
                  x if mcmc_util.is_list_like(current_state) else x[0]
              )
  
          new_kernel_results = previous_kernel_results._replace(
              log_acceptance_correction=_compute_log_acceptance_correction(
                  kinetic_energy_fn,
                  current_momentum_parts,
                  next_momentum_parts,
              ),
              target_log_prob=next_target_log_prob,
              grads_target_log_prob=next_target_log_prob_grad_parts,
              initial_momentum=current_momentum_parts,
              final_momentum=next_momentum_parts,
              seed=seed,
          )
  
          return maybe_flatten(next_state_parts), new_kernel_results
  
imports: import collections
  import tensorflow.compat.v2
  from tensorflow_probability.python.experimental.mcmc import preconditioning_utils
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import samplers
  from tensorflow_probability.python.mcmc import hmc
  from tensorflow_probability.python.mcmc import metropolis_hastings
  from tensorflow_probability.python.mcmc.internal import leapfrog_integrator
  from tensorflow_probability.python.mcmc.internal import util
label_desc: Use image node_id 3 for calling the UncalibratedPreconditionedHamiltonianMonteCarlo obj's underlying member method code with example usage: obj.one_step(current_state, previous_kernel_results, seed) and returns: maybe_flatten,  new_kernel_results, unknown