code: def make_initial_point_fns_per_chain(
      *,
      model,
      overrides: Optional[
          Union[StartDict, Sequence[Optional[StartDict]]]
      ],
      jitter_rvs: Optional[Set[TensorVariable]] = None,
      chains: int,
  ) -> List[Callable]:
      """Create an initial point function for each chain, as defined by initvals
  
      If a single initval dictionary is passed, the function is replicated for each
      chain, otherwise a unique function is compiled for each entry in the dictionary.
  
      Parameters
      ----------
      overrides : optional, list or dict
          Initial value strategy overrides that should take precedence over the defaults from the model.
          A sequence of None or dicts will be treated as chain-wise strategies and must have the same length as `seeds`.
      jitter_rvs : set, optional
          Random variable tensors for which U(-1, 1) jitter shall be applied.
          (To the transformed space if applicable.)
  
      Raises
      ------
      ValueError
          If the number of entries in initvals is different than the number of chains
  
      """
      if isinstance(overrides, dict) or overrides is None:
          # One strategy for all chains
          # Only one function compilation is needed.
          ipfns = [
              make_initial_point_fn(
                  model=model,
                  overrides=overrides,
                  jitter_rvs=jitter_rvs,
                  return_transformed=True,
              )
          ] * chains
      elif len(overrides) == chains:
          ipfns = [
              make_initial_point_fn(
                  model=model,
                  jitter_rvs=jitter_rvs,
                  overrides=chain_overrides,
                  return_transformed=True,
              )
              for chain_overrides in overrides
          ]
      else:
          raise ValueError(
              f"Number of initval dicts ({len(overrides)}) does not match the number of chains ({chains})."
          )
  
      return ipfns
  
file_path: pymc/pymc/initial_point.py
imports: import functools
  import warnings
  from typing import Callable, Dict, List, Optional, Sequence, Set, Union
  import numpy
  import pytensor
  import pytensor.tensor
  from pytensor.graph.basic import Variable
  from pytensor.graph.fg import FunctionGraph
  from pytensor.tensor.variable import TensorVariable
  from pymc.logprob.transforms import Transform
  from pymc.pytensorf import compile_pymc, find_rng_nodes, replace_rng_nodes, reseed_rngs
  from pymc.util import get_transformed_name, get_untransformed_name, is_transformed_name
label_desc: Use image node_id 2 for calling a global function with example usage: make_initial_point_fns_per_chain() and returns: ipfns