class_docstr: Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques,
  namely Runge-Kutta method and a linear multi-step method.
  
  [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
  function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
  [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
  [`~SchedulerMixin.from_pretrained`] functions.
  
  For more details, see the original paper: https://arxiv.org/abs/2202.09778
  
  Args:
      num_train_timesteps (`int`): number of diffusion steps used to train the model.
      beta_start (`float`): the starting `beta` value of inference.
      beta_end (`float`): the final `beta` value.
      beta_schedule (`str`):
          the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
          `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
      trained_betas (`jnp.ndarray`, optional):
          option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
      skip_prk_steps (`bool`):
          allows the scheduler to skip the Runge-Kutta steps that are defined in the original paper as being required
          before plms steps; defaults to `False`.
      set_alpha_to_one (`bool`, default `False`):
          each diffusion step uses the value of alphas product at that step and at the previous one. For the final
          step there is no previous alpha. When this option is `True` the previous alpha product is fixed to `1`,
          otherwise it uses the value of alpha at step 0.
      steps_offset (`int`, default `0`):
          an offset added to the inference steps. You can use a combination of `offset=1` and
          `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
          stable diffusion.
      prediction_type (`str`, default `epsilon`, optional):
          prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion
          process), `sample` (directly predicting the noisy sample`) or `v_prediction` (see section 2.4
          https://imagen.research.google/video/paper.pdf)
      dtype (`jnp.dtype`, *optional*, defaults to `jnp.float32`):
          the `dtype` used for params and computation.
code: def _get_prev_sample(
      self,
      state: PNDMSchedulerState,
      sample,
      timestep,
      prev_timestep,
      model_output,
  ):
      # See formula (9) of PNDM paper https://arxiv.org/pdf/2202.09778.pdf
      # this function computes x_(t−δ) using the formula of (9)
      # Note that x_t needs to be added to both sides of the equation
  
      # Notation (<variable name> -> <name in paper>
      # alpha_prod_t -> α_t
      # alpha_prod_t_prev -> α_(t−δ)
      # beta_prod_t -> (1 - α_t)
      # beta_prod_t_prev -> (1 - α_(t−δ))
      # sample -> x_t
      # model_output -> e_θ(x_t, t)
      # prev_sample -> x_(t−δ)
      alpha_prod_t = state.common.alphas_cumprod[timestep]
      alpha_prod_t_prev = jnp.where(
          prev_timestep >= 0,
          state.common.alphas_cumprod[prev_timestep],
          state.final_alpha_cumprod,
      )
      beta_prod_t = 1 - alpha_prod_t
      beta_prod_t_prev = 1 - alpha_prod_t_prev
  
      if self.config.prediction_type == "v_prediction":
          model_output = (alpha_prod_t**0.5) * model_output + (
              beta_prod_t**0.5
          ) * sample
      elif self.config.prediction_type != "epsilon":
          raise ValueError(
              f"prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `v_prediction`"
          )
  
      # corresponds to (α_(t−δ) - α_t) divided by
      # denominator of x_t in formula (9) and plus 1
      # Note: (α_(t−δ) - α_t) / (sqrt(α_t) * (sqrt(α_(t−δ)) + sqr(α_t))) =
      # sqrt(α_(t−δ)) / sqrt(α_t))
      sample_coeff = (alpha_prod_t_prev / alpha_prod_t) ** (0.5)
  
      # corresponds to denominator of e_θ(x_t, t) in formula (9)
      model_output_denom_coeff = alpha_prod_t * beta_prod_t_prev ** (
          0.5
      ) + (alpha_prod_t * beta_prod_t * alpha_prod_t_prev) ** (0.5)
  
      # full formula (9)
      prev_sample = (
          sample_coeff * sample
          - (alpha_prod_t_prev - alpha_prod_t)
          * model_output
          / model_output_denom_coeff
      )
  
      return prev_sample
  
imports: from dataclasses import dataclass
  from typing import Optional, Tuple, Union
  import flax
  import jax
  import jax.numpy
  from ..configuration_utils import ConfigMixin, register_to_config
  from .scheduling_utils_flax import CommonSchedulerState, FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, add_noise_common
label_desc: Use image node_id 9 for calling the FlaxPNDMScheduler obj's underlying member method code with example usage: obj._get_prev_sample(state, sample, timestep, prev_timestep, model_output) and returns: prev_sample