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: Create variables and logp function necessary to run SMC kernel
  
  This method should not be overwritten. If needed, use `setup_kernel`
  instead.
docstr_tok: ["Create","variables","and","logp","function","necessary","to","run","SMC","kernel","This","method","should","not","be","overwritten",".","If","needed",",","use","`","setup_kernel","`","instead","."]
code: def _initialize_kernel(self):
      """Create variables and logp function necessary to run SMC kernel
  
      This method should not be overwritten. If needed, use `setup_kernel`
      instead.
  
      """
      # Create dictionary that stores original variables shape and size
      initial_point = self.model.initial_point(
          random_seed=self.rng.integers(2**30)
      )
      for v in self.variables:
          self.var_info[v.name] = (
              initial_point[v.name].shape,
              initial_point[v.name].size,
          )
      # Create particles bijection map
      if self.start:
          init_rnd = self.start
      else:
          init_rnd = self.initialize_population()
  
      population = []
      for i in range(self.draws):
          point = Point(
              {v.name: init_rnd[v.name][i] for v in self.variables},
              model=self.model,
          )
          population.append(DictToArrayBijection.map(point).data)
  
      self.tempered_posterior = np.array(floatX(population))
  
      # Initialize prior and likelihood log probabilities
      shared = make_shared_replacements(
          initial_point, self.variables, self.model
      )
  
      self.prior_logp_func = _logp_forw(
          initial_point, [self.model.varlogp], self.variables, shared
      )
      self.likelihood_logp_func = _logp_forw(
          initial_point, [self.model.datalogp], self.variables, shared
      )
  
      priors = [
          self.prior_logp_func(sample)
          for sample in self.tempered_posterior
      ]
      likelihoods = [
          self.likelihood_logp_func(sample)
          for sample in self.tempered_posterior
      ]
  
      self.prior_logp = np.array(priors).squeeze()
      self.likelihood_logp = np.array(likelihoods).squeeze()
  
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 3 for calling the SMC_KERNEL obj's underlying member method code with example usage: obj._initialize_kernel() without return types