code: def make_initial_point_fn(
      *,
      model,
      overrides: Optional[StartDict] = None,
      jitter_rvs: Optional[Set[TensorVariable]] = None,
      default_strategy: str = "moment",
      return_transformed: bool = True,
  ) -> Callable:
      """Create seeded function that computes initial values for all free model variables.
  
      Parameters
      ----------
      jitter_rvs : set
          The set (or list or tuple) of random variables for which a U(-1, +1) jitter should be
          added to the initial value. Only available for variables that have a transform or real-valued support.
      default_strategy : str
          Which of { "moment", "prior" } to prefer if the initval setting for an RV is None.
      overrides : dict
          Initial value (strategies) to use instead of what's specified in `Model.initial_values`.
      return_transformed : bool
          If `True` the returned variables will correspond to transformed initial values.
      """
  
      sdict_overrides = convert_str_to_rv_dict(model, overrides or {})
      initval_strats = {
          **model.rvs_to_initial_values,
          **sdict_overrides,
      }
  
      initial_values = make_initial_point_expression(
          free_rvs=model.free_RVs,
          rvs_to_transforms=model.rvs_to_transforms,
          initval_strategies=initval_strats,
          jitter_rvs=jitter_rvs,
          default_strategy=default_strategy,
          return_transformed=return_transformed,
      )
  
      # Replace original rng shared variables so that we don't mess with them
      # when calling the final seeded function
      initial_values = replace_rng_nodes(initial_values)
      func = compile_pymc(
          inputs=[],
          outputs=initial_values,
          mode=pytensor.compile.mode.FAST_COMPILE,
      )
  
      varnames = []
      for var in model.free_RVs:
          transform = model.rvs_to_transforms[var]
          if transform is not None and return_transformed:
              name = get_transformed_name(var.name, transform)
          else:
              name = var.name
          varnames.append(name)
  
      def make_seeded_function(func):
          rngs = find_rng_nodes(func.maker.fgraph.outputs)
  
          @functools.wraps(func)
          def inner(seed, *args, **kwargs):
              reseed_rngs(rngs, seed)
              values = func(*args, **kwargs)
              return dict(zip(varnames, values))
  
          return inner
  
      return make_seeded_function(func)
  
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 3 for calling a global function with example usage: make_initial_point_fn() and returns: make_seeded_function, inner, dict