Do not guess order of inputs for users

Author: ricardoV94

pymc/model/core.py

@@ -35,7 +35,7 @@
 from pytensor.compile import DeepCopyOp, Function, ProfileStats, get_mode
 from pytensor.compile.sharedvalue import SharedVariable
 from pytensor.graph.basic import Constant, Variable
-from pytensor.graph.traversal import ancestors, graph_inputs
+from pytensor.graph.traversal import ancestors, explicit_graph_inputs, graph_inputs
 from pytensor.tensor import as_tensor
 from pytensor.tensor.math import variadic_add
 from pytensor.tensor.random.op import RandomVariable
@@ -62,7 +62,6 @@
     convert_observed_data,
     gradient,
     hessian,
-    inputvars,
     join_nonshared_inputs,
     rewrite_pregrad,
 )
@@ -588,6 +587,8 @@ def compile_logp(
     ) -> PointFunc:
         """Compiled log probability density function.
 
+        The function expects as input a dictionary with the same structure as self.initial_point()
+
         Parameters
         ----------
         vars : list of random variables or potential terms, optional
@@ -599,7 +600,12 @@ def compile_logp(
             Whether to sum all logp terms or return elemwise logp for each variable.
             Defaults to True.
         """
-        return self.compile_fn(self.logp(vars=vars, jacobian=jacobian, sum=sum), **compile_kwargs)
+        compile_kwargs.setdefault("on_unused_input", "ignore")
+        return self.compile_fn(
+            inputs=self.value_vars,
+            outs=self.logp(vars=vars, jacobian=jacobian, sum=sum),
+            **compile_kwargs,
+        )
 
     def compile_dlogp(
         self,
@@ -609,6 +615,9 @@ def compile_dlogp(
     ) -> PointFunc:
         """Compiled log probability density gradient function.
 
+        The function expects as input a dictionary with the same structure as self.initial_point()
+
+
         Parameters
         ----------
         vars : list of random variables or potential terms, optional
@@ -617,7 +626,12 @@ def compile_dlogp(
         jacobian : bool
             Whether to include jacobian terms in logprob graph. Defaults to True.
         """
-        return self.compile_fn(self.dlogp(vars=vars, jacobian=jacobian), **compile_kwargs)
+        compile_kwargs.setdefault("on_unused_input", "ignore")
+        return self.compile_fn(
+            inputs=self.value_vars,
+            outs=self.dlogp(vars=vars, jacobian=jacobian),
+            **compile_kwargs,
+        )
 
     def compile_d2logp(
         self,
@@ -628,6 +642,8 @@ def compile_d2logp(
     ) -> PointFunc:
         """Compiled log probability density hessian function.
 
+        The function expects as input a dictionary with the same structure as self.initial_point()
+
         Parameters
         ----------
         vars : list of random variables or potential terms, optional
@@ -636,8 +652,10 @@ def compile_d2logp(
         jacobian : bool
             Whether to include jacobian terms in logprob graph. Defaults to True.
         """
+        compile_kwargs.setdefault("on_unused_input", "ignore")
         return self.compile_fn(
-            self.d2logp(vars=vars, jacobian=jacobian, negate_output=negate_output),
+            inputs=self.value_vars,
+            outs=self.d2logp(vars=vars, jacobian=jacobian, negate_output=negate_output),
             **compile_kwargs,
         )
 
@@ -742,7 +760,7 @@ def dlogp(
         dlogp graph
         """
         if vars is None:
-            value_vars = None
+            value_vars = self.continuous_value_vars
         else:
             if not isinstance(vars, list | tuple):
                 vars = [vars]
@@ -782,7 +800,7 @@ def d2logp(
         d²logp graph
         """
         if vars is None:
-            value_vars = None
+            value_vars = self.continuous_value_vars
         else:
             if not isinstance(vars, list | tuple):
                 vars = [vars]
@@ -1616,7 +1634,7 @@ def compile_fn(
         outs : Variable or sequence of Variables
             PyTensor variable or iterable of PyTensor variables.
         inputs : sequence of Variables, optional
-            PyTensor input variables, defaults to pytensorf.inputvars(outs).
+            PyTensor input variables, Required if there is more than one input.
         mode
             PyTensor compilation mode, default=None.
         point_fn : bool
@@ -1630,7 +1648,11 @@ def compile_fn(
         Compiled PyTensor function
         """
         if inputs is None:
-            inputs = inputvars(outs)
+            inputs = list(explicit_graph_inputs(outs))
+            if len(inputs) > 1:
+                raise ValueError(
+                    "compile_fn requires inputs to be specified when there is more than one input."
+                )
 
         with self:
             fn = compile(
@@ -1793,7 +1815,7 @@ def point_logps(self, point=None, round_vals=2, **kwargs):
             factor.name: np.round(np.asarray(factor_logp), round_vals)
             for factor, factor_logp in zip(
                 factors,
-                self.compile_fn(factor_logps_fn, **kwargs)(point),
+                self.compile_fn(inputs=self.value_vars, outs=factor_logps_fn, **kwargs)(point),
             )
         }
 
@@ -2126,8 +2148,8 @@ def compile_fn(
     ----------
     outs
         PyTensor variable or iterable of PyTensor variables.
-    inputs
-        PyTensor input variables, defaults to pytensorf.inputvars(outs).
+    inputs, optional
+        PyTensor input variables. Required if there is more than one input.
     mode
         PyTensor compilation mode, default=None.
     point_fn : bool

pymc/pytensorf.py

@@ -35,7 +35,7 @@
 )
 from pytensor.graph.fg import FunctionGraph, Output
 from pytensor.graph.op import HasInnerGraph
-from pytensor.graph.traversal import graph_inputs, walk
+from pytensor.graph.traversal import explicit_graph_inputs, graph_inputs, walk
 from pytensor.scalar.basic import Cast
 from pytensor.scan.op import Scan
 from pytensor.tensor.basic import _as_tensor_variable
@@ -165,7 +165,7 @@ def extract_obs_data(x: TensorVariable) -> np.ndarray:
             mask[mask_idx] = 1
             return np.ma.MaskedArray(array_data, mask)
 
-    if not inputvars(x) and not rvs_in_graph(x):
+    if not len(list(explicit_graph_inputs(x))) and not rvs_in_graph(x):
         return x.eval(mode=_cheap_eval_mode)
 
     raise TypeError(f"Data cannot be extracted from {x}")
@@ -244,15 +244,17 @@ def cont_inputs(a):
     """
     Get the continuous inputs into PyTensor variables.
 
+    NOTE: No particular order is guaranteed across PyTensor versions
+
     Parameters
     ----------
         a: PyTensor variable
 
     Returns
     -------
-        r: list of tensor variables that are continuous inputs
+        r: list of tensor variables that are continuous inputs.
     """
-    return typefilter(inputvars(a), continuous_types)
+    return typefilter(explicit_graph_inputs(a), continuous_types)
 
 
 def floatX(X):
@@ -310,6 +312,10 @@ def gradient1(f, v):
 def gradient(f, vars=None):
     if vars is None:
         vars = cont_inputs(f)
+        if len(vars) > 1:
+            raise ValueError(
+                "gradient requires vars to be specified when there is more than one input."
+            )
 
     if vars:
         return pt.concatenate([gradient1(f, v) for v in vars], axis=0)
@@ -331,6 +337,10 @@ def grad_i(i):
 def jacobian(f, vars=None):
     if vars is None:
         vars = cont_inputs(f)
+        if len(vars) > 1:
+            raise ValueError(
+                "jacobian requires vars to be specified when there is more than one input."
+            )
 
     if vars:
         return pt.concatenate([jacobian1(f, v) for v in vars], axis=1)
@@ -378,6 +388,10 @@ def hess_ii(i):
 def hessian_diag(f, vars=None, negate_output=True):
     if vars is None:
         vars = cont_inputs(f)
+        if len(vars) > 1:
+            raise ValueError(
+                "hessian_diag requires vars to be specified when there is more than one input."
+            )
 
     if vars:
         res = pt.concatenate([hessian_diag1(f, v) for v in vars], axis=0)
@@ -612,7 +626,7 @@ def __call__(self, input):
         ----------
         input: TensorVariable
         """
-        (oldinput,) = inputvars(self.tensor)
+        (oldinput,) = explicit_graph_inputs(self.tensor)
         return pytensor.clone_replace(self.tensor, {oldinput: input}, rebuild_strict=False)
 
 

pymc/sampling/forward.py

@@ -1055,7 +1055,7 @@ def vectorize_over_posterior(
     # These variables need to be resized because they won't be resized implicitly by
     # the replacement of the needed_rvs or other random variables in the graph when we
     # later call vectorize_graph.
-    independent_rvs: list[TensorVariable] = []
+    independent_rvs: list[Variable] = []
     for rv in [
         rv
         for rv in general_toposort(  # type: ignore[call-overload]

pymc/tuning/scaling.py

@@ -54,6 +54,8 @@ def find_hessian(point, vars=None, model=None, negate_output=True):
         Variables for which Hessian is to be calculated.
     """
     model = modelcontext(model)
+    if vars is None:
+        vars = model.continuous_value_vars
     H = model.compile_d2logp(vars, negate_output=negate_output)
     return H(Point(point, filter_model_vars=True, model=model))
 
@@ -70,12 +72,16 @@ def find_hessian_diag(point, vars=None, model=None, negate_output=True):
         Variables for which Hessian is to be calculated.
     """
     model = modelcontext(model)
+    if vars is None:
+        vars = model.continuous_value_vars
     H = model.compile_fn(hessian_diag(model.logp(), vars, negate_output=negate_output))
     return H(Point(point, model=model))
 
 
 def guess_scaling(point, vars=None, model=None, scaling_bound=1e-8):
     model = modelcontext(model)
+    if vars is None:
+        vars = model.continuous_value_vars
     try:
         h = -find_hessian_diag(point, vars, model=model, negate_output=False)
     except NotImplementedError:

pymc/tuning/starting.py

@@ -185,7 +185,7 @@ def find_MAP(
 
     mx0 = RaveledVars(mx0, x0.point_map_info)
     unobserved_vars = get_default_varnames(model.unobserved_value_vars, include_transformed)
-    unobserved_vars_values = model.compile_fn(unobserved_vars)(
+    unobserved_vars_values = model.compile_fn(inputs=model.value_vars, outs=unobserved_vars)(
         DictToArrayBijection.rmap(mx0, start)
     )
     mx = {var.name: value for var, value in zip(unobserved_vars, unobserved_vars_values)}

tests/distributions/test_mixture.py

@@ -945,8 +945,8 @@ def test_vector_components(self):
             latent_m = Normal("latent_m", mu=mus[..., z], sigma=1e-5, shape=nd)
 
         size = 100
-        m_val = draw(m, draws=size, random_seed=998)
-        latent_m_val = draw(latent_m, draws=size, random_seed=998 * 2)
+        m_val = draw(m, draws=size, random_seed=997)
+        latent_m_val = draw(latent_m, draws=size, random_seed=997 * 2)
         assert m_val.shape == latent_m_val.shape
         # Test that each element in axis = -1 comes from the same mixture
         # component
@@ -959,7 +959,12 @@ def test_vector_components(self):
 
         # Check that mixing of values in the last axis leads to smaller logp
         logp_fn = model.compile_logp(vars=[m])
-        assert logp_fn({"m": [0, 0, 0]}) > logp_fn({"m": [0, 1, 0]}) > logp_fn({"m": [0, 1, 2]})
+        ip = model.initial_point()
+        assert (
+            logp_fn(ip | {"m": [0, 0, 0]})
+            > logp_fn(ip | {"m": [0, 1, 0]})
+            > logp_fn(ip | {"m": [0, 1, 2]})
+        )
         self.logp_matches(m, latent_m, z, npop, model=model)
 
     def samples_from_same_distribution(self, *args):

tests/logprob/test_utils.py

@@ -42,13 +42,13 @@
 from pytensor import tensor as pt
 from pytensor.compile import get_default_mode
 from pytensor.graph.basic import equal_computations
-from pytensor.graph.traversal import ancestors
+from pytensor.graph.traversal import ancestors, explicit_graph_inputs
 from pytensor.tensor.random.basic import NormalRV
 from pytensor.tensor.random.op import RandomVariable
 
 import pymc as pm
 
-from pymc import SymbolicRandomVariable, inputvars
+from pymc.distributions.distribution import SymbolicRandomVariable
 from pymc.distributions.transforms import Interval
 from pymc.logprob.abstract import MeasurableOp, valued_rv
 from pymc.logprob.basic import logp
@@ -231,7 +231,7 @@ def test_interdependent_transformed_rvs(self, reversed):
 
         assert_no_rvs(transform_values)
         # Test that we haven't introduced value variables in the random graph (issue #7054)
-        assert not inputvars(rvs)
+        assert not any(list(explicit_graph_inputs(rvs)))
 
         if reversed:
             transform_values = transform_values[::-1]

tests/model/test_core.py

@@ -1066,19 +1066,18 @@ def test_model_logp(jacobian):
     if not jacobian:
         expected_y_logp -= np.array([0.0, 1.0])
 
-    x_logp, y_logp = m.compile_logp(sum=False, jacobian=jacobian)(
-        {"x": test_vals, "y_log__": test_vals}
-    )
+    test_val_dict = {"x": test_vals, "y_log__": test_vals}
+    x_logp, y_logp = m.compile_logp(sum=False, jacobian=jacobian)(test_val_dict)
     assert np.all(np.isclose(x_logp, expected_x_logp))
     assert np.all(np.isclose(y_logp, expected_y_logp))
 
-    x_logp2 = m.compile_logp(vars=[x], sum=False, jacobian=jacobian)({"x": test_vals})
+    x_logp2 = m.compile_logp(vars=[x], sum=False, jacobian=jacobian)(test_val_dict)
     assert np.all(np.isclose(x_logp2, expected_x_logp))
 
-    y_logp2 = m.compile_logp(vars=[y], sum=False, jacobian=jacobian)({"y_log__": test_vals})
+    y_logp2 = m.compile_logp(vars=[y], sum=False, jacobian=jacobian)(test_val_dict)
     assert np.all(np.isclose(y_logp2, expected_y_logp))
 
-    logp_sum = m.compile_logp(sum=True, jacobian=jacobian)({"x": test_vals, "y_log__": test_vals})
+    logp_sum = m.compile_logp(sum=True, jacobian=jacobian)(test_val_dict)
     assert np.isclose(logp_sum, expected_x_logp.sum() + expected_y_logp.sum())