xtensor.type – Types and Variables

XTensorVariable creation functions

pytensor.xtensor.type.as_xtensor(x, dims=None, *, name=None)

Convert a variable or data to an XTensorVariable.

Parameters:

• x (Variable or data) –

• dims (Sequence[str] or None, optional) – If dims are provided, TensorVariable (or data) will be converted to an XTensorVariable with those dims. XTensorVariables will be returned as is, if the dims match. Otherwise, a ValueError is raised. If dims are not provided, and the data is not a scalar, an XTensorVariable or xarray.DataArray, an error is raised.

• name (str or None, optional) – Name of the resulting XTensorVariable.

pytensor.xtensor.type.xtensor(name=None, *, dims, shape=None, dtype='floatX')

Create an XTensorVariable.

Parameters:

• name (str or None, optional) – The name of the variable

• dims (Sequence[str]) – The names of the dimensions of the tensor

• shape (Sequence[int | None] or None, optional) – The shape of the tensor. If None, defaults to a shape with None for each dimension.

• dtype (str or np.dtype, optional) – The data type of the tensor. Defaults to ‘floatX’ (config.floatX).

Returns:

A new XTensorVariable with the specified name, dims, shape, and dtype.

Return type:

XTensorVariable

pytensor.xtensor.type.xtensor_constant(x, name=None, dims=None)

Convert a constant value to an XTensorConstant.

XTensor Type and Variable classes

class pytensor.xtensor.type.XTensorConstant(type, data, name=None)

Constant of XtensorType.

signature()

Return a hashable object identifying this Constant by value.

The returned object must satisfy: 1. Hashable: hash(sig) must not raise. 2. Self-equality: sig == sig must be True (not an array). 3. Pickle-stable: pickle.loads(pickle.dumps(sig)) == sig

and same hash. This is required for C module cache keys.

The default (type, data) is sufficient for simple Python objects (None, slices, etc.) but breaks for numpy data (NaN, arrays). Subclasses with numeric data must override this. See TensorConstantSignature, ScalarConstantSignature.

class pytensor.xtensor.type.XTensorType(dtype, *, dims, shape=None, name=None)

A Type for Xtensors (Xarray-like tensors with dims).

clone(dtype=None, dims=None, shape=None, **kwargs)

Clone a copy of this type with the given arguments/keyword values, if any.

constant_type

alias of XTensorConstant

convert_variable(var)

Produce a Variable that’s compatible with both self and var.type, if possible.

A compatible Variable is a Variable with a Type that’s the “narrower” of self and var.type.

If a compatible Type cannot be found, this method will return None.

filter(value, strict=False, allow_downcast=None)

Return data or an appropriately wrapped/converted data.

Subclass implementations should raise a TypeError exception if the data is not of an acceptable type.

Parameters:

• data (array-like) – The data to be filtered/converted.

• strict (bool (optional)) – If True, the data returned must be the same as the data passed as an argument.

• allow_downcast (bool (optional)) – If strict is False, and allow_downcast is True, the data may be cast to an appropriate type. If allow_downcast is False, it may only be up-cast and not lose precision. If allow_downcast is None (default), the behaviour can be type-dependent, but for now it means only Python floats can be down-casted, and only to floatX scalars.

filter_variable(other, allow_convert=True)

Convert a other into a Variable with a Type that’s compatible with self.

If the involved Types are not compatible, a TypeError will be raised.

is_super(otype)

Determine if self is a supertype of otype.

This method effectively implements the type relation >.

In general, t1.is_super(t2) == True implies that t1 can be replaced with t2.

See Type.in_same_class.

Return type:

None if the type relation cannot be applied/determined.

static values_eq(a, b, **kwargs)

Return True if a and b can be considered exactly equal.

a and b are assumed to be valid values of this Type.

static values_eq_approx(a, b, **kwargs)

Return True if a and b can be considered approximately equal.

This function is used by PyTensor debugging tools to decide whether two values are equivalent, admitting a certain amount of numerical instability. For example, for floating-point numbers this function should be an approximate comparison.

By default, this does an exact comparison.

Parameters:

• a (array-like) – A potential value for a Variable of this Type.

• b (array-like) – A potential value for a Variable of this Type.

Return type:

bool

variable_type

alias of XTensorVariable

class pytensor.xtensor.type.XTensorVariable(type, owner, index=None, name=None)

Variable of XTensorType.

property T

Return the full transpose of the variable.

This is equivalent to calling transpose() with no arguments.

all(dim=None)

Reduce the variable by applying all along some dimension(s).

any(dim=None)

Reduce the variable by applying any along some dimension(s).

astype(dtype)

Convert the variable to a different data type.

broadcast_like(other, exclude=None)

Broadcast against another XTensorVariable.

clip(min, max)

Clip the values of the variable to a specified range.

conj()

Return the complex conjugate of the variable.

property coords

Not implemented.

copy(name=None)

Create a copy of the variable.

This is just an identity operation, as XTensorVariables are immutable.

cumprod(dim=None)

Compute the cumulative product along the given dimension(s).

cumsum(dim=None)

Compute the cumulative sum along the given dimension(s).

diff(dim, n=1)

Compute the n-th discrete difference along the given dimension.

property dims

The names of the dimensions of the variable.

dot(other, dim=None)

Generalized dot product with another XTensorVariable.

property dtype

The data type of the variable.

expand_dims(dim=None, create_index_for_new_dim=None, axis=None, **dim_kwargs)

Add one or more new dimensions to the variable.

Parameters:

• dim (str | Sequence[str] | dict[str, int | Sequence] | None) –

  If str or sequence of str, new dimensions with size 1. If dict, keys are dimension names and values are either:

  • int: the new size

  • sequence: coordinates (length determines size)

• create_index_for_new_dim (bool, optional) – Ignored by PyTensor

• axis (int | Sequence[int] | None, default: None) – Not implemented yet. In xarray, specifies where to insert the new dimension(s). By default (None), new dimensions are inserted at the beginning (axis=0).

• **dim_kwargs (int | Sequence) – Alternative to dim dict. Only used if dim is None.

Returns:

A tensor with additional dimensions inserted at the front.

Return type:

XTensorVariable

property imag

Return the imaginary part of the variable.

inc(value)

Return a copy of the variable indexed by self with the indexed values incremented by value.

The original variable is not modified.

Raises:

ValueError – If self is not the result of an index operation

Examples

import pytensor.xtensor as ptx

x = ptx.as_xtensor([[1, 1], [1, 1]], dims=("a", "b"))
idx = ptx.as_xtensor([0, 1], dims=("a",))
out = x[:, idx].inc(1)
print(out.eval())

[[2 1]
 [1 2]]

import pytensor.xtensor as ptx

x = ptx.as_xtensor([[1, 1], [1, 1]], dims=("a", "b"))
idx = ptx.as_xtensor([0, 1], dims=("a",))
out = x.isel({"b": idx}).inc(-1)
print(out.eval())

[[0 1]
 [1 0]]

isel(indexers=None, drop=False, missing_dims='raise', **indexers_kwargs)

Index the variable along the specified dimension(s).

item()

Not implemented.

property loc

Not implemented.

max(dim=None)

Compute the maximum along the given dimension(s).

mean(dim=None)

Compute the mean along the given dimension(s).

min(dim=None)

Compute the minimum along the given dimension(s).

property ndim

The number of dimensions of the variable.

prod(dim=None)

Compute the product along the given dimension(s).

property real

Return the real part of the variable.

rename(new_name_or_name_dict=None, **names)

Rename the variable or its dimension(s).

sel(*args, **kwargs)

Not implemented.

set(value)

Return a copy of the variable indexed by self with the indexed values set to y.

The original variable is not modified.

Raises:

ValueError – If self is not the result of an index operation

Examples

import pytensor.xtensor as ptx

x = ptx.as_xtensor([[0, 0], [0, 0]], dims=("a", "b"))
idx = ptx.as_xtensor([0, 1], dims=("a",))
out = x[:, idx].set(1)
print(out.eval())

[[1 0]
 [0 1]]

import pytensor.xtensor as ptx

x = ptx.as_xtensor([[0, 0], [0, 0]], dims=("a", "b"))
idx = ptx.as_xtensor([0, 1], dims=("a",))
out = x.isel({"b": idx}).set(-1)
print(out.eval())

[[-1  0]
 [ 0 -1]]

property shape

The shape of the variable.

property size

The total number of elements in the variable.

property sizes

The sizes of the dimensions of the variable.

squeeze(dim=None, drop=None, axis=None)

Remove dimensions of size 1.

Parameters:

• dim (str or None or iterable of str, optional) – The name(s) of the dimension(s) to remove. If None, all dimensions of size 1 (known statically) will be removed. Dimensions with unknown static shape will be retained, even if they have size 1 at runtime.

• drop (bool, optional) – Ignored by PyTensor.

• axis (int or iterable of int, optional) – The axis(es) to remove. If None, all dimensions of size 1 will be removed.

Returns:

A new tensor with the specified dimension(s) removed.

Return type:

XTensorVariable

stack(dim, **dims)

Stack existing dimensions into a single new dimension.

std(dim=None, ddof=0)

Compute the standard deviation along the given dimension(s).

sum(dim=None)

Compute the sum along the given dimension(s).

transpose(*dim, missing_dims='raise')

Transpose the dimensions of the variable.

Parameters:

• *dim (str | Ellipsis) – Dimensions to transpose. If empty, performs a full transpose. Can use ellipsis (…) to represent remaining dimensions.

• missing_dims ({"raise", "warn", "ignore"}, default="raise") –

  How to handle dimensions that don’t exist in the tensor:

  • ”raise”: Raise an error if any dimensions don’t exist

  • ”warn”: Warn if any dimensions don’t exist

  • ”ignore”: Silently ignore any dimensions that don’t exist

Returns:

Transposed tensor with reordered dimensions.

Return type:

XTensorVariable

Raises:

ValueError – If missing_dims=”raise” and any dimensions don’t exist. If multiple ellipsis are provided.

unstack(dim, **dims)

Unstack a dimension into multiple dimensions of a given size.

Because XTensorVariables don’t have coords, this operation requires the sizes of each unstacked dimension to be specified. Also, unstacked dims will follow a C-style order, regardless of the order of the original dimensions.

import pytensor.xtensor as ptx

x = ptx.as_xtensor([[1, 2], [3, 4]], dims=("a", "b"))
stacked_cumsum = x.stack({"c": ["a", "b"]}).cumsum("c")
unstacked_cumsum = stacked_cumsum.unstack({"c": x.sizes})
print(unstacked_cumsum.eval())

[[ 1  3]
 [ 6 10]]

property values

Convert to a TensorVariable with the same data.

var(dim=None, ddof=0)

Compute the variance along the given dimension(s).

where(cond, other=None, drop=False)

Filter elements from this object according to a condition.

Parameters:

• cond (Variable) – Locations at which to preserve this object’s values.

• other (Variable, optional) – Value to use for locations in this object where cond is False. By default, these locations are filled with nan (which may cause upcasting).

• drop (bool) – Ignored by PyTensor

Returns:

A tensor with additional dimensions inserted at the front.

Return type:

XTensorVariable