pytensor 2.25.4__tar.gz → 2.26.0__tar.gz

{pytensor-2.25.4/pytensor.egg-info → pytensor-2.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytensor
-Version: 2.25.4
+Version: 2.26.0
 Summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
 Author-email: pymc-devs <pymc.devs@gmail.com>
 License: .. _license:

{pytensor-2.25.4 → pytensor-2.26.0}/doc/extending/creating_a_c_op.rst

@@ -152,7 +152,7 @@ This distance between consecutive elements of an array over a given dimension,
 is called the stride of that dimension.
 
 
-Accessing NumPy :class`ndarray`\s' data and properties
+Accessing NumPy :class:`ndarray`'s data and properties
 ------------------------------------------------------
 
 The following macros serve to access various attributes of NumPy :class:`ndarray`\s.

{pytensor-2.25.4 → pytensor-2.26.0}/doc/extending/creating_a_numba_jax_op.rst

@@ -4,7 +4,7 @@ Adding JAX, Numba and Pytorch support for `Op`\s
 PyTensor is able to convert its graphs into JAX, Numba and Pytorch compiled functions. In order to do
 this, each :class:`Op` in an PyTensor graph must have an equivalent JAX/Numba/Pytorch implementation function.
 
-This tutorial will explain how JAX, Numba and Pytorch implementations are created for an :class:`Op`. 
+This tutorial will explain how JAX, Numba and Pytorch implementations are created for an :class:`Op`.
 
 Step 1: Identify the PyTensor :class:`Op` you'd like to implement
 ------------------------------------------------------------------------
@@ -60,7 +60,7 @@ could also have any data type (e.g. floats, ints), so our implementation
 must be able to handle all the possible data types.
 
 It also tells us that there's only one return value, that it has a data type
-determined by :meth:`x.type()` i.e., the data type of the original tensor.
+determined by :meth:`x.type` i.e., the data type of the original tensor.
 This implies that the result is necessarily a matrix.
 
 Some class may have a more complex behavior. For example, the :class:`CumOp`\ :class:`Op`
@@ -116,7 +116,7 @@ Here's an example for :class:`DimShuffle`:
 
 .. tab-set::
 
-        .. tab-item:: JAX     
+        .. tab-item:: JAX
 
             .. code:: python
 
@@ -134,7 +134,7 @@ Here's an example for :class:`DimShuffle`:
                         res = jnp.copy(res)
 
                     return res
-        
+
         .. tab-item:: Numba
 
             .. code:: python
@@ -465,7 +465,7 @@ Step 4: Write tests
     .. tab-item:: JAX
 
         Test that your registered `Op` is working correctly by adding tests to the
-        appropriate test suites in PyTensor (e.g. in ``tests.link.jax``). 
+        appropriate test suites in PyTensor (e.g. in ``tests.link.jax``).
         The tests should ensure that your implementation can
         handle the appropriate types of inputs and produce outputs equivalent to `Op.perform`.
         Check the existing tests for the general outline of these kinds of tests. In
@@ -478,7 +478,7 @@ Step 4: Write tests
         Here's a small example of a test for :class:`CumOp` above:
 
         .. code:: python
-            
+
             import numpy as np
             import pytensor.tensor as pt
             from pytensor.configdefaults import config
@@ -514,22 +514,22 @@ Step 4: Write tests
         .. code:: python
 
             import pytest
-            
+
             def test_jax_CumOp():
                 """Test JAX conversion of the `CumOp` `Op`."""
                 a = pt.matrix("a")
                 a.tag.test_value = np.arange(9, dtype=config.floatX).reshape((3, 3))
-                
+
                 with pytest.raises(NotImplementedError):
                     out = pt.cumprod(a, axis=1)
                     fgraph = FunctionGraph([a], [out])
                     compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
-    
-    
+
+
     .. tab-item:: Numba
 
         Test that your registered `Op` is working correctly by adding tests to the
-        appropriate test suites in PyTensor (e.g. in ``tests.link.numba``). 
+        appropriate test suites in PyTensor (e.g. in ``tests.link.numba``).
         The tests should ensure that your implementation can
         handle the appropriate types of inputs and produce outputs equivalent to `Op.perform`.
         Check the existing tests for the general outline of these kinds of tests. In
@@ -542,7 +542,7 @@ Step 4: Write tests
         Here's a small example of a test for :class:`CumOp` above:
 
         .. code:: python
-            
+
             from tests.link.numba.test_basic import compare_numba_and_py
             from pytensor.graph import FunctionGraph
             from pytensor.compile.sharedvalue import SharedVariable
@@ -561,11 +561,11 @@ Step 4: Write tests
                         if not isinstance(i, SharedVariable | Constant)
                     ],
                 )
-    
+
 
 
     .. tab-item:: Pytorch
-        
+
         Test that your registered `Op` is working correctly by adding tests to the
         appropriate test suites in PyTensor (``tests.link.pytorch``). The tests should ensure that your implementation can
         handle the appropriate types of inputs and produce outputs equivalent to `Op.perform`.
@@ -579,7 +579,7 @@ Step 4: Write tests
         Here's a small example of a test for :class:`CumOp` above:
 
         .. code:: python
-            
+
             import numpy as np
             import pytest
             import pytensor.tensor as pt
@@ -592,7 +592,7 @@ Step 4: Write tests
                 ["float64", "int64"],
             )
             @pytest.mark.parametrize(
-                "axis", 
+                "axis",
                 [None, 1, (0,)],
             )
             def test_pytorch_CumOp(axis, dtype):
@@ -650,4 +650,4 @@ as reported in issue `#654 <https://github.com/pymc-devs/pytensor/issues/654>`_.
 All jitted functions now must have constant shape, which means a graph like the
 one of :class:`Eye` can never be translated to JAX, since it's fundamentally a
 function with dynamic shapes. In other words, only PyTensor graphs with static shapes
-can be translated to JAX at the moment.
+can be translated to JAX at the moment.

{pytensor-2.25.4 → pytensor-2.26.0}/doc/extending/type.rst

@@ -333,7 +333,7 @@ returns eitehr a new transferred variable (which can be the same as
 the input if no transfer is necessary) or returns None if the transfer
 can't be done.
 
-Then register that function by calling :func:`register_transfer()`
+Then register that function by calling :func:`register_transfer`
 with it as argument.
 
 An example

{pytensor-2.25.4 → pytensor-2.26.0}/doc/library/compile/io.rst

@@ -36,7 +36,7 @@ The ``inputs`` argument to ``pytensor.function`` is a list, containing the ``Var
       ``self.<name>``. The default value is ``None``.
 
       ``value``: literal or ``Container``. The initial/default value for this
-        input. If update is`` None``, this input acts just like
+        input. If update is ``None``, this input acts just like
         an argument with a default value in Python. If update is not ``None``,
         changes to this
         value will "stick around", whether due to an update or a user's

{pytensor-2.25.4 → pytensor-2.26.0}/doc/library/config.rst

@@ -226,7 +226,7 @@ import ``pytensor`` and print the config variable, as in:
     in the future.
 
     The ``'numpy+floatX'`` setting attempts to mimic NumPy casting rules,
-    although it prefers to use ``float32` `numbers instead of ``float64`` when
+    although it prefers to use ``float32`` numbers instead of ``float64`` when
     ``config.floatX`` is set to ``'float32'`` and the associated data is not
     explicitly typed as ``float64`` (e.g. regular Python floats).  Note that
     ``'numpy+floatX'`` is not currently behaving exactly as planned (it is a

{pytensor-2.25.4 → pytensor-2.26.0}/doc/library/graph/graph.rst

@@ -4,12 +4,5 @@
 :mod:`graph` -- Interface for the PyTensor graph
 ================================================
 
----------
-Reference
----------
-
 .. automodule:: pytensor.graph.basic
-   :platform: Unix, Windows
-   :synopsis: Interface for types of symbolic variables
    :members:
-.. moduleauthor:: LISA

pytensor-2.26.0/doc/library/graph/index.rst

@@ -0,0 +1,21 @@
+
+.. _libdoc_graph:
+
+========================================
+:mod:`graph` -- PyTensor Graph Internals
+========================================
+
+.. module:: graph
+
+.. moduleauthor:: LISA
+
+.. toctree::
+    :maxdepth: 1
+
+    graph
+    fgraph
+    replace
+    features
+    op
+    type
+    utils

pytensor-2.26.0/doc/library/graph/op.rst

@@ -0,0 +1,8 @@
+.. _libdoc_graph_op:
+
+===========================================
+:mod:`op` -- Objects that define operations
+===========================================
+
+.. automodule:: pytensor.graph.op
+   :members:

pytensor-2.26.0/doc/library/graph/replace.rst

@@ -0,0 +1,8 @@
+.. _libdoc_graph_replace:
+
+==================================================
+:mod:`replace` -- High level graph transformations
+==================================================
+
+.. automodule:: pytensor.graph.replace
+   :members:

{pytensor-2.25.4 → pytensor-2.26.0}/doc/library/tensor/basic.rst

@@ -908,8 +908,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to compute the maximum
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: maximum of *x* along *axis*
 
     axis can be:
@@ -922,8 +922,8 @@ Reductions
     :Parameter: *x* - symbolic Tensor (or compatible)
     :Parameter: *axis* - axis along which to compute the index of the maximum
     :Parameter: *keepdims* - (boolean) If this is set to True, the axis which is reduced is
-		left in the result as a dimension with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as a dimension with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: the index of the maximum value along a given axis
 
     if ``axis == None``, `argmax` over the flattened tensor (like NumPy)
@@ -933,8 +933,8 @@ Reductions
     :Parameter: *x* - symbolic Tensor (or compatible)
     :Parameter: *axis* - axis along which to compute the maximum and its index
     :Parameter: *keepdims* - (boolean) If this is set to True, the axis which is reduced is
-		left in the result as a dimension with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as a dimension with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: the maximum value along a given axis and its index.
 
     if ``axis == None``, `max_and_argmax` over the flattened tensor (like NumPy)
@@ -944,8 +944,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to compute the minimum
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: minimum of *x* along *axis*
 
     `axis` can be:
@@ -958,8 +958,8 @@ Reductions
     :Parameter: *x* - symbolic Tensor (or compatible)
     :Parameter: *axis* - axis along which to compute the index of the minimum
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: the index of the minimum value along a given axis
 
     if ``axis == None``, `argmin` over the flattened tensor (like NumPy)
@@ -980,8 +980,8 @@ Reductions
         This default dtype does _not_ depend on the value of "acc_dtype".
 
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
 
     :Parameter: *acc_dtype* -  The dtype of the internal accumulator.
         If None (default), we use the dtype in the list below,
@@ -1015,8 +1015,8 @@ Reductions
         This default dtype does _not_ depend on the value of "acc_dtype".
 
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
 
     :Parameter: *acc_dtype* -  The dtype of the internal accumulator.
         If None (default), we use the dtype in the list below,
@@ -1031,16 +1031,16 @@ Reductions
          as we need to handle 3 different cases: without zeros in the
          input reduced group, with 1 zero or with more zeros.
 
-	 This could slow you down, but more importantly, we currently
-	 don't support the second derivative of the 3 cases. So you
-	 cannot take the second derivative of the default prod().
+    This could slow you down, but more importantly, we currently
+    don't support the second derivative of the 3 cases. So you
+    cannot take the second derivative of the default prod().
 
-	 To remove the handling of the special cases of 0 and so get
-	 some small speed up and allow second derivative set
-	 ``no_zeros_in_inputs`` to ``True``. It defaults to ``False``.
+    To remove the handling of the special cases of 0 and so get
+    some small speed up and allow second derivative set
+    ``no_zeros_in_inputs`` to ``True``. It defaults to ``False``.
 
-	 **It is the user responsibility to make sure there are no zeros
-	 in the inputs. If there are, the grad will be wrong.**
+    **It is the user responsibility to make sure there are no zeros
+    in the inputs. If there are, the grad will be wrong.**
 
     :Returns: product of every term in *x* along *axis*
 
@@ -1058,13 +1058,13 @@ Reductions
         done in float64 (acc_dtype would be float64 by default),
         but that result will be casted back in float32.
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Parameter: *acc_dtype* -  The dtype of the internal accumulator of the
         inner summation. This will not necessarily be the dtype of the
         output (in particular if it is a discrete (int/uint) dtype, the
         output will be in a float type).  If None, then we use the same
-        rules as :func:`sum()`.
+        rules as :func:`sum`.
     :Returns: mean value of *x* along *axis*
 
     `axis` can be:
@@ -1077,8 +1077,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to compute the variance
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: variance of *x* along *axis*
 
     `axis` can be:
@@ -1091,8 +1091,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to compute the standard deviation
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: variance of *x* along *axis*
 
     `axis` can be:
@@ -1105,8 +1105,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to apply 'bitwise and'
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: bitwise and of *x* along *axis*
 
     `axis` can be:
@@ -1119,8 +1119,8 @@ Reductions
     :Parameter: *x* -  symbolic Tensor (or compatible)
     :Parameter: *axis* - axis or axes along which to apply bitwise or
     :Parameter: *keepdims* - (boolean) If this is set to True, the axes which are reduced are
-		left in the result as dimensions with size one. With this option, the result
-		will broadcast correctly against the original tensor.
+        left in the result as dimensions with size one. With this option, the result
+        will broadcast correctly against the original tensor.
     :Returns: bitwise or of *x* along *axis*
 
     `axis` can be:
@@ -1745,7 +1745,7 @@ Linear Algebra
               when indexed, so that each returned argument has the same shape.
               The dimensions and number of the output arrays are equal to the
               number of indexing dimensions. If the step length is not a complex
-	      number, then the stop is not inclusive.
+              number, then the stop is not inclusive.
 
     Example:
 

{pytensor-2.25.4 → pytensor-2.26.0}/doc/library/tensor/conv.rst

@@ -8,4 +8,4 @@
 .. moduleauthor:: LISA, PyMC Developers, PyTensor Developers
 
 .. automodule:: pytensor.tensor.conv
-    :members:
+    :members:

pytensor-2.26.0/doc/library/tensor/functional.rst

@@ -0,0 +1,2 @@
+.. automodule:: pytensor.tensor.functional
+    :members: vectorize

pytensor-2.26.0/doc/library/tensor/index.rst

@@ -0,0 +1,33 @@
+.. _libdoc_tensor:
+
+===============================================
+:mod:`tensor`  -- Tensor operations in PyTensor
+===============================================
+
+.. module:: tensor
+
+PyTensor's strength is in expressing symbolic calculations involving tensors.
+
+PyTensor tries to emulate the numpy interface as much as possible in the tensor module.
+This means that once TensorVariables are created, it should be possibly to define
+symbolic expressions using calls that look just like numpy calls, such as
+`pt.exp(x).transpose(0, 1)[:, None]`
+
+
+
+.. toctree::
+    :maxdepth: 1
+
+    basic
+    random/index
+    utils
+    elemwise
+    extra_ops
+    io
+    slinalg
+    nlinalg
+    fft
+    conv
+    math_opt
+    basic_opt
+    functional

pytensor-2.26.0/doc/library/tensor/random/distributions.rst

@@ -0,0 +1,8 @@
+.. _libdoc_tensor_random_distributions:
+
+Distributions
+=============
+
+.. automodule:: pytensor.tensor.random.basic
+   :members:
+   :special-members: __call__

pytensor-2.25.4/doc/library/tensor/random/utils.rst → pytensor-2.26.0/doc/library/tensor/random/index.rst

@@ -1,36 +1,37 @@
-.. _libdoc_tensor_random_utils:
 
-======================================================
-:mod:`utils` -- Friendly random numbers
-======================================================
+.. _libdoc_tensor_random_basic:
 
-.. module:: pytensor.tensor.random.utils
-   :platform: Unix, Windows
+=============================================
+:mod:`random` -- Random number functionality
+=============================================
+
+.. module:: pytensor.tensor.random
    :synopsis: symbolic random variables
-.. moduleauthor:: LISA
 
-Guide
-=====
 
-PyTensor assigns NumPy RNG states (e.g. `Generator` or `RandomState` objects) to
+The :mod:`pytensor.tensor.random` module provides random-number drawing functionality
+that closely resembles the :mod:`numpy.random` module.
+
+
+High-level API
+==============
+
+PyTensor assigns NumPy RNG states (i.e. `Generator` objects) to
 each `RandomVariable`.  The combination of an RNG state, a specific
 `RandomVariable` type (e.g. `NormalRV`), and a set of distribution parameters
 uniquely defines the `RandomVariable` instances in a graph.
 
 This means that a "stream" of distinct RNG states is required in order to
-produce distinct random variables of the same kind.  `RandomStream` provides a
+produce distinct random variables of the same kind. `RandomStream` provides a
 means of generating distinct random variables in a fully reproducible way.
 
 `RandomStream` is also designed to produce simpler graphs and work with more
-sophisticated `Op`\s like `Scan`, which makes it the de facto random variable
+sophisticated `Op`\s like `Scan`, which makes it a user-friendly random variable
 interface in PyTensor.
 
 For an example of how to use random numbers, see :ref:`Using Random Numbers <using_random_numbers>`.
 
 
-Reference
-=========
-
 .. class:: RandomStream()
 
     This is a symbolic stand-in for `numpy.random.Generator`.
@@ -61,4 +62,28 @@ Reference
 
     .. method:: uniform, normal, binomial, multinomial, random_integers, ...
 
-        See :class:`basic.RandomVariable`.
+        See :ref: Available distributions `<_libdoc_tensor_random_distributions>`.
+
+
+   .. testcode:: constructors
+
+      from pytensor.tensor.random.utils import RandomStream
+
+      rng = RandomStream()
+      sample = rng.normal(0, 1, size=(2, 2))
+
+      fn = pytensor.function([], sample)
+      print(fn(), fn())  # different numbers due to default updates
+
+
+Low-level objects
+=================
+
+.. automodule:: pytensor.tensor.random.op
+   :members: RandomVariable, default_rng
+
+..automodule:: pytensor.tensor.random.type
+   :members: RandomType, RandomGeneratorType, random_generator_type
+
+.. automodule:: pytensor.tensor.random.var
+    :members: RandomGeneratorSharedVariable

{pytensor-2.25.4 → pytensor-2.26.0}/doc/optimizations.rst

@@ -262,8 +262,8 @@ Optimization                                              o4             o3  o2
     local_remove_all_assert
         This is an unsafe optimization.
         For the fastest possible PyTensor, this optimization can be enabled by
-	setting ``optimizer_including=local_remove_all_assert`` which will
-	remove all assertions in the graph for checking user inputs are valid.
+        setting ``optimizer_including=local_remove_all_assert`` which will
+        remove all assertions in the graph for checking user inputs are valid.
         Use this optimization if you are sure everything is valid in your graph.
 
-	See :ref:`unsafe_rewrites`
+    See :ref:`unsafe_rewrites`

{pytensor-2.25.4 → pytensor-2.26.0}/doc/tutorial/adding.rst

@@ -7,12 +7,12 @@ Baby Steps - Algebra
 Understanding Tensors
 ===========================
 
-Before diving into PyTensor, it's essential to understand the fundamental 
-data structure it operates on: the *tensor*. A *tensor* is a multi-dimensional 
+Before diving into PyTensor, it's essential to understand the fundamental
+data structure it operates on: the *tensor*. A *tensor* is a multi-dimensional
 array that serves as the foundation for symbolic computations.
 
-tensors can represent anything from a single number (scalar) to 
-complex multi-dimensional arrays. Each tensor has a type that dictates its 
+tensors can represent anything from a single number (scalar) to
+complex multi-dimensional arrays. Each tensor has a type that dictates its
 dimensionality and the kind of data it holds.
 
 For example, the following code creates a symbolic scalar and a symbolic matrix:
@@ -20,11 +20,11 @@ For example, the following code creates a symbolic scalar and a symbolic matrix:
 >>> x = pt.scalar('x')
 >>> y = pt.matrix('y')
 
-Here, `scalar` refers to a tensor with zero dimensions, while `matrix` refers 
-to a tensor with two dimensions. The same principles apply to tensors of other 
+Here, `scalar` refers to a tensor with zero dimensions, while `matrix` refers
+to a tensor with two dimensions. The same principles apply to tensors of other
 dimensions.
 
-For more information about tensors and their associated operations can be 
+For more information about tensors and their associated operations can be
 found here: :ref:`tensor <libdoc_tensor>`.