Do not guess order of inputs for users

Author: ricardoV94

pymc/logprob/basic.py

@@ -545,7 +545,7 @@ def conditional_logp(
                 UserWarning,
             )
 
-    return dict(zip(values, logprobs))
+    return dict(zip(original_values, logprobs))
 
 
 def transformed_conditional_logp(

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 (not point_fn) and len(inputs) > 1:
+                raise ValueError(
+                    "compile_fn requires inputs to be specified when there is more than one input and point_fn is disabled."
+                )
 
         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/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/distributions/test_timeseries.py

@@ -469,8 +469,9 @@ def test_order1_logp(self):
         with Model() as t:
             y = AR("y", phi, sigma=1, init_dist=Flat.dist(), shape=len(data))
             z = Normal("z", mu=phi * data[:-1], sigma=1, shape=len(data) - 1)
-        ar_like = t.compile_logp(y)({"y": data})
-        reg_like = t.compile_logp(z)({"z": data[1:]})
+        test_dict = {"y": data, "z": data[1:]}
+        ar_like = t.compile_logp(y)(test_dict)
+        reg_like = t.compile_logp(z)(test_dict)
         np.testing.assert_allclose(ar_like, reg_like)
 
         with Model() as t_constant:
@@ -483,8 +484,8 @@ def test_order1_logp(self):
                 constant=True,
             )
             z = Normal("z", mu=0.3 + phi * data[:-1], sigma=1, shape=len(data) - 1)
-        ar_like = t_constant.compile_logp(y)({"y": data})
-        reg_like = t_constant.compile_logp(z)({"z": data[1:]})
+        ar_like = t_constant.compile_logp(y)(test_dict)
+        reg_like = t_constant.compile_logp(z)(test_dict)
         np.testing.assert_allclose(ar_like, reg_like)
 
     def test_order2_logp(self):
@@ -495,8 +496,9 @@ def test_order2_logp(self):
             z = Normal(
                 "z", mu=phi[0] * data[1:-1] + phi[1] * data[:-2], sigma=1, shape=len(data) - 2
             )
-        ar_like = t.compile_logp(y)({"y": data})
-        reg_like = t.compile_logp(z)({"z": data[2:]})
+        test_dict = {"y": data, "z": data[2:]}
+        ar_like = t.compile_logp(y)(test_dict)
+        reg_like = t.compile_logp(z)(test_dict)
         np.testing.assert_allclose(ar_like, reg_like)
 
     @pytest.mark.parametrize("constant", (False, True))
@@ -749,8 +751,9 @@ def test_logp(self):
                 shape=data.shape,
             )
             z = Normal("z", mu=0, sigma=vol, shape=data.shape)
-        garch_like = t.compile_logp(y)({"y": data})
-        reg_like = t.compile_logp(z)({"z": data})
+        test_dict = {"y": data, "z": data}
+        garch_like = t.compile_logp(y)(test_dict)
+        reg_like = t.compile_logp(z)(test_dict)
         decimal = select_by_precision(float64=7, float32=4)
         np.testing.assert_allclose(garch_like, reg_like, 10 ** (-decimal))
 

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
@@ -205,7 +205,7 @@ def test_no_change_inplace(self):
         after = pytensor.clone_replace(m.free_RVs)
         assert equal_computations(before, after)
 
-    @pytest.mark.parametrize("reversed", (False,))
+    @pytest.mark.parametrize("reversed", (False, True))
     def test_interdependent_transformed_rvs(self, reversed):
         # Test that nested transformed variables, whose transformed values depend on other
         # RVs are properly replaced
@@ -231,11 +231,11 @@ 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]
-        transform_values_fn = m.compile_fn(transform_values, point_fn=False)
+        transform_values_fn = m.compile_fn(transform_values)
 
         x_interval_test_value = np.random.rand()
         y_interval_test_value = np.random.rand()
@@ -256,10 +256,12 @@ def test_interdependent_transformed_rvs(self, reversed):
 
         np.testing.assert_allclose(
             transform_values_fn(
-                x_interval__=x_interval_test_value,
-                y_interval__=y_interval_test_value,
-                z_interval__=z_interval_test_value,
-                w_interval__=w_interval_test_value,
+                {
+                    "x_interval__": x_interval_test_value,
+                    "y_interval__": y_interval_test_value,
+                    "z_interval__": z_interval_test_value,
+                    "w_interval__": w_interval_test_value,
+                }
             ),
             [expected_x, expected_y, expected_z, expected_w],
         )