class_docstr: Base class for the Sequential Monte Carlo kernels.
  
  To create a new SMC kernel you should subclass from this.
  
  Before sampling, the following methods are called once in order:
  
      initialize_population
          Choose initial population of SMC particles. Should return a dictionary
          with {var.name : numpy array of size (draws, var.size)}. Defaults
          to sampling from the prior distribution. This method is only called
          if `start` is not specified.
  
      _initialize_kernel : default
          Creates initial population of particles in the variable
          `self.tempered_posterior` and populates the `self.var_info` dictionary
          with information about model variables shape and size as
          {var.name : (var.shape, var.size)}.
  
          The functions `self.prior_logp_func` and `self.likelihood_logp_func` are
          created in this step. These expect a 1D numpy array with the summed
          sizes of each raveled model variable (in the order specified in
          :meth:`pymc.Model.initial_point`).
  
          Finally, this method computes the log prior and log likelihood for
          the initial particles, and saves them in `self.prior_logp` and
          `self.likelihood_logp`.
  
          This method should not be modified.
  
      setup_kernel : optional
          May include any logic that should be performed before sampling
          starts.
  
  During each sampling stage the following methods are called in order:
  
      update_beta_and_weights : default
          The inverse temperature self.beta is updated based on the `self.likelihood_logp`
          and `threshold` parameter.
  
          The importance `self.weights` of each particle are computed from the old and newly
          selected inverse temperature.
  
          The iteration number stored in `self.iteration` is updated by this method.
  
          Finally the model `log_marginal_likelihood` of the tempered posterior
          is updated from these weights.
  
      resample : default
          The particles in `self.posterior` are sampled with replacement based
          on `self.weights`, and the used resampling indexes are saved in
          `self.resampling_indexes`.
  
          The arrays `self.prior_logp` and `self.likelihood_logp` are rearranged according
          to the order of the resampled particles. `self.tempered_posterior_logp`
          is computed from these and the current `self.beta`.
  
      tune : optional
          May include logic that should be performed before every mutation step.
  
      mutate : REQUIRED
          Mutate particles in `self.tempered_posterior`.
  
          This method is further responsible to update the `self.prior_logp`,
          `self.likelihod_logp` and `self.tempered_posterior_logp`, corresponding
          to each mutated particle.
  
      sample_stats : default
          Returns important sampling_stats at the end of each stage in a dictionary
          format. This will be saved in the final InferenceData object under `sample_stats`.
  
  Finally, at the end of sampling the following methods are called:
  
      _posterior_to_trace : default
          Convert final population of particles to a posterior trace object.
          This method should not be modified.
  
      sample_settings : default
          Returns important sample_settings at the end of sampling in a dictionary
          format. This will be saved in the final InferenceData object under `sample_stats`.
docstr: Calculate the next inverse temperature (beta)
  
  The importance weights based on two successive tempered likelihoods (i.e.
  two successive values of beta) and updates the marginal likelihood estimate.
  
  ESS is calculated for importance sampling. BDA 3rd ed. eq 10.4
docstr_tok: ["Calculate","the","next","inverse","temperature","(","beta",")","The","importance","weights","based","on","two","successive","tempered","likelihoods","(","i.e",".","two","successive","values","of","beta",")","and","updates","the","marginal","likelihood","estimate",".","ESS","is","calculated","for","importance","sampling",".","BDA","3rd","ed",".","eq","10.4"]
code: def update_beta_and_weights(self):
      """Calculate the next inverse temperature (beta)
  
      The importance weights based on two successive tempered likelihoods (i.e.
      two successive values of beta) and updates the marginal likelihood estimate.
  
      ESS is calculated for importance sampling. BDA 3rd ed. eq 10.4
      """
      self.iteration += 1
  
      low_beta = old_beta = self.beta
      up_beta = 2.0
  
      rN = int(len(self.likelihood_logp) * self.threshold)
  
      while up_beta - low_beta > 1e-6:
          new_beta = (low_beta + up_beta) / 2.0
          log_weights_un = (new_beta - old_beta) * self.likelihood_logp
          log_weights = log_weights_un - logsumexp(log_weights_un)
          ESS = int(np.exp(-logsumexp(log_weights * 2)))
          if ESS == rN:
              break
          elif ESS < rN:
              up_beta = new_beta
          else:
              low_beta = new_beta
      if new_beta >= 1:
          new_beta = 1
          log_weights_un = (new_beta - old_beta) * self.likelihood_logp
          log_weights = log_weights_un - logsumexp(log_weights_un)
  
      self.beta = new_beta
      self.weights = np.exp(log_weights)
      # We normalize again to correct for small numerical errors that might build up
      self.weights /= self.weights.sum()
      self.log_marginal_likelihood += logsumexp(
          log_weights_un
      ) - np.log(self.draws)
  
imports: import abc
  import sys
  import warnings
  from abc import ABC
  from typing import Dict, Union, cast
  import numpy
  import pytensor.tensor
  from pytensor.graph.replace import clone_replace
  from scipy.special import logsumexp
  from scipy.stats import multivariate_normal
  from typing_extensions import TypeAlias
  from pymc.backends.ndarray import NDArray
  from pymc.blocking import DictToArrayBijection
  from pymc.initial_point import make_initial_point_expression
  from pymc.model import Point, modelcontext
  from pymc.pytensorf import compile_pymc, floatX, join_nonshared_inputs, make_shared_replacements
  from pymc.sampling.forward import draw
  from pymc.step_methods.metropolis import MultivariateNormalProposal
  from pymc.vartypes import discrete_types
label_desc: Use image node_id 5 for calling the SMC_KERNEL obj's underlying member method code with example usage: obj.update_beta_and_weights() without return types