pytensor 2.10.0__tar.gz → 2.11.0__tar.gz

{pytensor-2.10.0 → pytensor-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytensor
-Version: 2.10.0
+Version: 2.11.0
 Summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
 Author-email: pymc-devs <pymc.devs@gmail.com>
 License: .. _license:
@@ -69,6 +69,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 Provides-Extra: complete

{pytensor-2.10.0 → pytensor-2.11.0}/doc/extending/graph_rewriting.rst

@@ -603,7 +603,7 @@ An :class:`EquilibriumDB` contains :class:`NodeRewriter` or :class:`RewriteDatab
 has a name and an arbitrary number of tags. When a :class:`RewriteDatabaseQuery` is applied to
 an :class:`EquilibriumDB`, all :class:`NodeRewriter`\s that match the query are
 inserted into an :class:`EquilibriumGraphRewriter`, which is returned. If the
-:class:`SequenceDB` contains :class:`RewriteDatabase` instances, the
+:class:`EquilibriumDB` contains :class:`RewriteDatabase` instances, the
 :class:`RewriteDatabaseQuery` will be passed to them as well and the
 :class:`NodeRewriter`\s they return will be put in their places
 (note that as of yet no :class:`RewriteDatabase` can produce :class:`NodeRewriter` objects, so this

{pytensor-2.10.0 → pytensor-2.11.0}/doc/library/sparse/index.rst

@@ -196,7 +196,7 @@ List of Implemented Operations
     - ``ceil``
     - ``floor``
     - ``trunc``
-    - ``sgn``
+    - ``sign``
     - ``log1p``
     - ``expm1``
     - ``sqr``

{pytensor-2.10.0 → pytensor-2.11.0}/doc/library/tensor/basic.rst

@@ -577,7 +577,7 @@ them perfectly, but a `dscalar` otherwise.
     .. method:: round(mode="half_away_from_zero")
        :noindex:
     .. method:: trace()
-    .. method:: get_scalar_constant_value()
+    .. method:: get_underlying_scalar_constant_value()
     .. method:: zeros_like(model, dtype=None)
 
        All the above methods are equivalent to NumPy for PyTensor on the current tensor.
@@ -1462,7 +1462,7 @@ Mathematical
 
     Returns a variable representing the base e, 2 or 10 logarithm of a.
 
-.. function:: sgn(a)
+.. function:: sign(a)
 
     Returns a variable representing the sign of a.
 

{pytensor-2.10.0 → pytensor-2.11.0}/pyproject.toml

@@ -37,6 +37,7 @@ classifiers = [
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
 ]
 
 keywords = [

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/__init__.py

@@ -137,7 +137,7 @@ from pytensor.updates import OrderedUpdates
 # isort: on
 
 
-def get_scalar_constant_value(v):
+def get_underlying_scalar_constant(v):
     """Return the constant scalar (i.e. 0-D) value underlying variable `v`.
 
     If `v` is the output of dim-shuffles, fills, allocs, cast, etc.
@@ -153,8 +153,8 @@ def get_scalar_constant_value(v):
     if sparse and isinstance(v.type, sparse.SparseTensorType):
         if v.owner is not None and isinstance(v.owner.op, sparse.CSM):
             data = v.owner.inputs[0]
-            return tensor.get_scalar_constant_value(data)
-    return tensor.get_scalar_constant_value(v)
+            return tensor.get_underlying_scalar_constant_value(data)
+    return tensor.get_underlying_scalar_constant_value(v)
 
 
 # isort: off

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-02-13T12:31:15-0600",
+ "date": "2023-04-07T14:56:57+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "4730d0cb7db40bd25d937bcbcf187b8bdec4e6de",
- "version": "2.10.0"
+ "full-revisionid": "98de246293855def134b86b5af6599e74a44835b",
+ "version": "2.11.0"
 }
 '''  # END VERSION_JSON
 

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/compile/profiling.py

@@ -1509,7 +1509,7 @@ class ProfileStats:
             aes.Second,
             aes.Identity,
             aes.Cast,
-            aes.Sgn,
+            aes.Sign,
             aes.Neg,
             aes.Reciprocal,
             aes.Sqr,

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/gradient.py

@@ -1325,7 +1325,7 @@ def _populate_grad_dict(var_to_app_to_idx, grad_dict, wrt, cost_name=None):
                                 f" {i}. Since this input is only connected "
                                 "to integer-valued outputs, it should "
                                 "evaluate to zeros, but it evaluates to"
-                                f"{pytensor.get_scalar_constant_value(term)}."
+                                f"{pytensor.get_underlying_scalar_constant(term)}."
                             )
                             raise ValueError(msg)
 
@@ -2086,7 +2086,7 @@ def _is_zero(x):
 
     no_constant_value = True
     try:
-        constant_value = pytensor.get_scalar_constant_value(x)
+        constant_value = pytensor.get_underlying_scalar_constant(x)
         no_constant_value = False
     except pytensor.tensor.exceptions.NotScalarConstantError:
         pass

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/graph/basic.py

@@ -597,6 +597,22 @@ class Variable(Node, Generic[_TypeType, OptionalApplyType]):
         if inputs_to_values is None:
             inputs_to_values = {}
 
+        def convert_string_keys_to_variables(input_to_values):
+            new_input_to_values = {}
+            for key, value in inputs_to_values.items():
+                if isinstance(key, str):
+                    matching_vars = get_var_by_name([self], key)
+                    if not matching_vars:
+                        raise Exception(f"{key} not found in graph")
+                    elif len(matching_vars) > 1:
+                        raise Exception(f"Found multiple variables with name {key}")
+                    new_input_to_values[matching_vars[0]] = value
+                else:
+                    new_input_to_values[key] = value
+            return new_input_to_values
+
+        inputs_to_values = convert_string_keys_to_variables(inputs_to_values)
+
         if not hasattr(self, "_fn_cache"):
             self._fn_cache = dict()
 

pytensor-2.11.0/pytensor/link/jax/dispatch/scan.py

@@ -0,0 +1,193 @@
+import jax
+import jax.numpy as jnp
+
+from pytensor.link.jax.dispatch.basic import jax_funcify
+from pytensor.scan.op import Scan
+
+
+@jax_funcify.register(Scan)
+def jax_funcify_Scan(op: Scan, **kwargs):
+    info = op.info
+
+    if info.as_while:
+        raise NotImplementedError("While Scan cannot yet be converted to JAX")
+
+    if info.n_mit_mot:
+        raise NotImplementedError(
+            "Scan with MIT-MOT (gradients of scan) cannot yet be converted to JAX"
+        )
+
+    # Optimize inner graph
+    rewriter = op.mode_instance.optimizer
+    rewriter(op.fgraph)
+    scan_inner_func = jax_funcify(op.fgraph, **kwargs)
+
+    def scan(*outer_inputs):
+        # Extract JAX scan inputs
+        outer_inputs = list(outer_inputs)
+        n_steps = outer_inputs[0]  # JAX `length`
+        seqs = op.outer_seqs(outer_inputs)  # JAX `xs`
+
+        mit_sot_init = []
+        for tap, seq in zip(op.info.mit_sot_in_slices, op.outer_mitsot(outer_inputs)):
+            init_slice = seq[: abs(min(tap))]
+            mit_sot_init.append(init_slice)
+
+        sit_sot_init = [seq[0] for seq in op.outer_sitsot(outer_inputs)]
+
+        init_carry = (
+            mit_sot_init,
+            sit_sot_init,
+            op.outer_shared(outer_inputs),
+            op.outer_non_seqs(outer_inputs),
+        )  # JAX `init`
+
+        def jax_args_to_inner_func_args(carry, x):
+            """Convert JAX scan arguments into format expected by scan_inner_func.
+
+            scan(carry, x) -> scan_inner_func(seqs, mit_sot, sit_sot, shared, non_seqs)
+            """
+
+            # `carry` contains all inner taps, shared terms, and non_seqs
+            (
+                inner_mit_sot,
+                inner_sit_sot,
+                inner_shared,
+                inner_non_seqs,
+            ) = carry
+
+            # `x` contains the inner sequences
+            inner_seqs = x
+
+            mit_sot_flatten = []
+            for array, index in zip(inner_mit_sot, op.info.mit_sot_in_slices):
+                mit_sot_flatten.extend(array[jnp.array(index)])
+
+            inner_scan_inputs = [
+                *inner_seqs,
+                *mit_sot_flatten,
+                *inner_sit_sot,
+                *inner_shared,
+                *inner_non_seqs,
+            ]
+
+            return inner_scan_inputs
+
+        def inner_func_outs_to_jax_outs(
+            old_carry,
+            inner_scan_outs,
+        ):
+            """Convert inner_scan_func outputs into format expected by JAX scan.
+
+            old_carry + (mit_sot_outs, sit_sot_outs, nit_sot_outs, shared_outs) -> (new_carry, ys)
+            """
+            (
+                inner_mit_sot,
+                inner_sit_sot,
+                inner_shared,
+                inner_non_seqs,
+            ) = old_carry
+
+            inner_mit_sot_outs = op.inner_mitsot_outs(inner_scan_outs)
+            inner_sit_sot_outs = op.inner_sitsot_outs(inner_scan_outs)
+            inner_nit_sot_outs = op.inner_nitsot_outs(inner_scan_outs)
+            inner_shared_outs = op.inner_shared_outs(inner_scan_outs)
+
+            # Replace the oldest mit_sot tap by the newest value
+            inner_mit_sot_new = [
+                jnp.concatenate([old_mit_sot[1:], new_val[None, ...]], axis=0)
+                for old_mit_sot, new_val in zip(
+                    inner_mit_sot,
+                    inner_mit_sot_outs,
+                )
+            ]
+
+            # Nothing needs to be done with sit_sot
+            inner_sit_sot_new = inner_sit_sot_outs
+
+            inner_shared_new = inner_shared
+            # Replace old shared inputs by new shared outputs
+            inner_shared_new[: len(inner_shared_outs)] = inner_shared_outs
+
+            new_carry = (
+                inner_mit_sot_new,
+                inner_sit_sot_new,
+                inner_shared_new,
+                inner_non_seqs,
+            )
+
+            # Shared variables and non_seqs are not traced
+            traced_outs = [
+                *inner_mit_sot_outs,
+                *inner_sit_sot_outs,
+                *inner_nit_sot_outs,
+            ]
+
+            return new_carry, traced_outs
+
+        def jax_inner_func(carry, x):
+            inner_args = jax_args_to_inner_func_args(carry, x)
+            inner_scan_outs = list(scan_inner_func(*inner_args))
+            new_carry, traced_outs = inner_func_outs_to_jax_outs(carry, inner_scan_outs)
+            return new_carry, traced_outs
+
+        # Extract PyTensor scan outputs
+        final_carry, traces = jax.lax.scan(
+            jax_inner_func, init_carry, seqs, length=n_steps
+        )
+
+        def get_partial_traces(traces):
+            """Convert JAX scan traces to PyTensor traces.
+
+            We need to:
+                1. Prepend initial states to JAX output traces
+                2. Slice final traces if Scan was instructed to only keep a portion
+            """
+
+            init_states = mit_sot_init + sit_sot_init + [None] * op.info.n_nit_sot
+            buffers = (
+                op.outer_mitsot(outer_inputs)
+                + op.outer_sitsot(outer_inputs)
+                + op.outer_nitsot(outer_inputs)
+            )
+            partial_traces = []
+            for init_state, trace, buffer in zip(init_states, traces, buffers):
+                if init_state is not None:
+                    # MIT-SOT and SIT-SOT: The final output should be as long as the input buffer
+                    full_trace = jnp.concatenate(
+                        [jnp.atleast_1d(init_state), jnp.atleast_1d(trace)],
+                        axis=0,
+                    )
+                    buffer_size = buffer.shape[0]
+                else:
+                    # NIT-SOT: Buffer is just the number of entries that should be returned
+                    full_trace = jnp.atleast_1d(trace)
+                    buffer_size = buffer
+
+                partial_trace = full_trace[-buffer_size:]
+                partial_traces.append(partial_trace)
+
+            return partial_traces
+
+        def get_shared_outs(final_carry):
+            """Retrive last state of shared_outs from final_carry.
+
+            These outputs cannot be traced in PyTensor Scan
+            """
+            (
+                inner_out_mit_sot,
+                inner_out_sit_sot,
+                inner_out_shared,
+                inner_in_non_seqs,
+            ) = final_carry
+
+            shared_outs = inner_out_shared[: info.n_shared_outs]
+            return list(shared_outs)
+
+        scan_outs_final = get_partial_traces(traces) + get_shared_outs(final_carry)
+
+        if len(scan_outs_final) == 1:
+            scan_outs_final = scan_outs_final[0]
+        return scan_outs_final
+
+    return scan

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/link/jax/dispatch/tensor_basic.py

@@ -18,7 +18,7 @@ from pytensor.tensor.basic import (
     ScalarFromTensor,
     Split,
     TensorFromScalar,
-    get_scalar_constant_value,
+    get_underlying_scalar_constant_value,
 )
 from pytensor.tensor.exceptions import NotScalarConstantError
 
@@ -106,7 +106,7 @@ def jax_funcify_Join(op, **kwargs):
 def jax_funcify_Split(op: Split, node, **kwargs):
     _, axis, splits = node.inputs
     try:
-        constant_axis = get_scalar_constant_value(axis)
+        constant_axis = get_underlying_scalar_constant_value(axis)
     except NotScalarConstantError:
         constant_axis = None
         warnings.warn(
@@ -116,7 +116,7 @@ def jax_funcify_Split(op: Split, node, **kwargs):
     try:
         constant_splits = np.array(
             [
-                get_scalar_constant_value(splits[i])
+                get_underlying_scalar_constant_value(splits[i])
                 for i in range(get_vector_length(splits))
             ]
         )

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/link/numba/dispatch/basic.py

@@ -25,6 +25,7 @@ from pytensor.graph.basic import Apply, NoParams
 from pytensor.graph.fg import FunctionGraph
 from pytensor.graph.type import Type
 from pytensor.ifelse import IfElse
+from pytensor.link.numba.dispatch.sparse import CSCMatrixType, CSRMatrixType
 from pytensor.link.utils import (
     compile_function_src,
     fgraph_to_python,
@@ -32,6 +33,7 @@ from pytensor.link.utils import (
 )
 from pytensor.scalar.basic import ScalarType
 from pytensor.scalar.math import Softplus
+from pytensor.sparse import SparseTensorType
 from pytensor.tensor.blas import BatchedDot
 from pytensor.tensor.math import Dot
 from pytensor.tensor.shape import Reshape, Shape, Shape_i, SpecifyShape
@@ -105,6 +107,15 @@ def get_numba_type(
         dtype = np.dtype(pytensor_type.dtype)
         numba_dtype = numba.from_dtype(dtype)
         return numba_dtype
+    elif isinstance(pytensor_type, SparseTensorType):
+        dtype = pytensor_type.numpy_dtype
+        numba_dtype = numba.from_dtype(dtype)
+        if pytensor_type.format == "csr":
+            return CSRMatrixType(numba_dtype)
+        if pytensor_type.format == "csc":
+            return CSCMatrixType(numba_dtype)
+
+        raise NotImplementedError()
     else:
         raise NotImplementedError(f"Numba type not implemented for {pytensor_type}")
 

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/link/numba/dispatch/elemwise.py

@@ -841,7 +841,7 @@ def numba_funcify_DimShuffle(op, node, **kwargs):
 
         @numba_basic.numba_njit
         def dimshuffle_inner(x, shuffle):
-            return np.reshape(x, ())
+            return np.reshape(np.ascontiguousarray(x), ())
 
     # Without the following wrapper function we would see this error:
     # E   No implementation of function Function(<built-in function getitem>) found for signature:

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/link/numba/dispatch/sparse.py

@@ -1,11 +1,17 @@
+import numpy as np
 import scipy as sp
 import scipy.sparse
 from numba.core import cgutils, types
+from numba.core.imputils import impl_ret_borrowed
 from numba.extending import (
     NativeValue,
     box,
+    intrinsic,
     make_attribute_wrapper,
     models,
+    overload,
+    overload_attribute,
+    overload_method,
     register_model,
     typeof_impl,
     unbox,
@@ -16,7 +22,10 @@ class CSMatrixType(types.Type):
     """A Numba `Type` modeled after the base class `scipy.sparse.compressed._cs_matrix`."""
 
     name: str
-    instance_class: type
+
+    @staticmethod
+    def instance_class(data, indices, indptr, shape):
+        raise NotImplementedError()
 
     def __init__(self, dtype):
         self.dtype = dtype
@@ -26,6 +35,10 @@ class CSMatrixType(types.Type):
         self.shape = types.UniTuple(types.int64, 2)
         super().__init__(self.name)
 
+    @property
+    def key(self):
+        return (self.name, self.dtype)
+
 
 make_attribute_wrapper(CSMatrixType, "data", "data")
 make_attribute_wrapper(CSMatrixType, "indices", "indices")
@@ -139,3 +152,55 @@ def box_matrix(typ, val, c):
     c.pyapi.decref(shape_obj)
 
     return obj
+
+
+@overload(np.shape)
+def overload_sparse_shape(x):
+    if isinstance(x, CSMatrixType):
+        return lambda x: x.shape
+
+
+@overload_attribute(CSMatrixType, "ndim")
+def overload_sparse_ndim(inst):
+    if not isinstance(inst, CSMatrixType):
+        return
+
+    def ndim(inst):
+        return 2
+
+    return ndim
+
+
+@intrinsic
+def _sparse_copy(typingctx, inst, data, indices, indptr, shape):
+    def _construct(context, builder, sig, args):
+        typ = sig.return_type
+        struct = cgutils.create_struct_proxy(typ)(context, builder)
+        _, data, indices, indptr, shape = args
+        struct.data = data
+        struct.indices = indices
+        struct.indptr = indptr
+        struct.shape = shape
+        return impl_ret_borrowed(
+            context,
+            builder,
+            sig.return_type,
+            struct._getvalue(),
+        )
+
+    sig = inst(inst, inst.data, inst.indices, inst.indptr, inst.shape)
+
+    return sig, _construct
+
+
+@overload_method(CSMatrixType, "copy")
+def overload_sparse_copy(inst):
+    if not isinstance(inst, CSMatrixType):
+        return
+
+    def copy(inst):
+        return _sparse_copy(
+            inst, inst.data.copy(), inst.indices.copy(), inst.indptr.copy(), inst.shape
+        )
+
+    return copy

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/link/numba/linker.py

@@ -17,7 +17,7 @@ class NumbaLinker(JITLinker):
         if not isinstance(var, np.ndarray) and isinstance(
             var.type, pytensor.tensor.TensorType
         ):
-            return np.asarray(out, dtype=var.type.dtype)
+            return var.type.filter(out, allow_downcast=True)
 
         return out
 

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/misc/safe_asarray.py

@@ -32,7 +32,7 @@ def _asarray(a, dtype, order=None):
     if str(dtype) == "floatX":
         dtype = config.floatX
     dtype = np.dtype(dtype)  # Convert into dtype object.
-    rval = np.asarray(a, dtype=dtype, order=order)
+    rval = np.asarray(a, order=order).astype(dtype)
     # Note that dtype comparison must be done by comparing their `num`
     # attribute. One cannot assume that two identical data types are pointers
     # towards the same object (e.g. under Windows this appears not to be the

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/scalar/basic.py

@@ -240,6 +240,9 @@ def convert(x, dtype=None):
         The dtype to use for the conversion of `x`.
 
     """
+    if isinstance(x, np.ma.MaskedArray):
+        raise NotImplementedError("MaskedArrays are not supported")
+
     if dtype is not None:
         # in this case, the semantics are that the caller is forcing the dtype
         x_ = _asarray(x, dtype=dtype)
@@ -2566,7 +2569,7 @@ class Abs(UnaryScalarOp):
                 return [x.zeros_like()]
 
         if x.type in float_types:
-            return (gz * sgn(x),)
+            return (gz * sign(x),)
         return (gz * x / _abs(x),)  # formula works for complex and real
 
     def c_code(self, node, name, inputs, outputs, sub):
@@ -2590,7 +2593,7 @@ class Abs(UnaryScalarOp):
 abs = Abs(same_out)
 
 
-class Sgn(UnaryScalarOp):
+class Sign(UnaryScalarOp):
     nfunc_spec = ("sign", 1, 1)
 
     @staticmethod
@@ -2625,7 +2628,7 @@ class Sgn(UnaryScalarOp):
             )
         if type in int_types:
             return f"{z} = ({x} >= 0) ? ({x} == 0) ? 0 : 1 : -1;"
-        raise ComplexError("complex has no sgn")
+        raise ComplexError("complex has no sign")
 
     def c_code_cache_version(self):
         s = super().c_code_cache_version()
@@ -2635,7 +2638,7 @@ class Sgn(UnaryScalarOp):
             return s
 
 
-sgn = Sgn(name="sgn")
+sign = Sign(name="sign")
 
 
 class Ceil(UnaryScalarOp):

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/scan/basic.py

@@ -12,7 +12,7 @@ from pytensor.graph.replace import clone_replace
 from pytensor.graph.utils import MissingInputError, TestValueError
 from pytensor.scan.op import Scan, ScanInfo
 from pytensor.scan.utils import expand_empty, safe_new, until
-from pytensor.tensor.basic import get_scalar_constant_value
+from pytensor.tensor.basic import get_underlying_scalar_constant_value
 from pytensor.tensor.exceptions import NotScalarConstantError
 from pytensor.tensor.math import minimum
 from pytensor.tensor.shape import shape_padleft, unbroadcast
@@ -147,7 +147,7 @@ def isNaN_or_Inf_or_None(x):
         isStr = False
     if not isNaN and not isInf:
         try:
-            val = get_scalar_constant_value(x)
+            val = get_underlying_scalar_constant_value(x)
             isInf = np.isinf(val)
             isNaN = np.isnan(val)
         except Exception:
@@ -476,7 +476,7 @@ def scan(
         n_fixed_steps = int(n_steps)
     else:
         try:
-            n_fixed_steps = at.get_scalar_constant_value(n_steps)
+            n_fixed_steps = at.get_underlying_scalar_constant_value(n_steps)
         except NotScalarConstantError:
             n_fixed_steps = None
 

{pytensor-2.10.0 → pytensor-2.11.0}/pytensor/scan/op.py

@@ -674,7 +674,6 @@ class Scan(Op, ScanMethodsMixin, HasInnerGraph):
         typeConstructor: Optional[TensorConstructorType] = None,
         truncate_gradient: int = -1,
         name: Optional[str] = None,
-        as_while: bool = False,
         profile: Optional[Union[str, bool]] = None,
         allow_gc: bool = True,
         strict: bool = True,
@@ -1183,7 +1182,7 @@ class Scan(Op, ScanMethodsMixin, HasInnerGraph):
         # these are states that do not feed anything back in the recurrent
         # computation, and hence they do not have an initial state. The scan
         # node however receives an input for each such argument, the input
-        # in this case is just a int saying how many steps of this output we
+        # in this case is just an int saying how many steps of this output we
         # need to store. This input does not have the same dtype, nor is it the same
         # type of tensor as the output, it is always a scalar int.
         new_inputs += [as_tensor_variable(ons) for ons in self.outer_nitsot(inputs)]