Python module

tensor

Provides experimental tensor operations with eager execution capabilities.

Warning: This module contains experimental APIs that are subject to change or removal in future versions. Use with caution in production environments.

This module provides the tensor class which supports eager execution of tensor operations, complementing the graph-based execution model provided by graph. The tensor operations automatically compile and execute using the MAX runtime.

Key Features:

Eager execution: Operations execute immediately rather than building a graph.
Automatic compilation: Tensors are compiled and optimized automatically.
Lazy evaluation: Tensors may be computed lazily until their values are needed.
NumPy compatibility: Supports common NumPy-like operations and indexing.

Create and manipulate tensors with automatic compilation and optimization:

from max.experimental import tensor
from max.driver import CPU
from max.dtype import DType

x = tensor.Tensor.ones((2, 3), dtype=DType.float32, device=CPU())
y = tensor.Tensor.zeros((2, 3), dtype=DType.float32, device=CPU())
result = x + y  # Eager execution with automatic compilation

`ComputeGraph`

class max.experimental.tensor.ComputeGraph(context=None, sources=(), seed=0)

Computation graph for managing tensor operations.

This class manages the directed acyclic graph (DAG) of tensor operations for lazy evaluation and optimization. It tracks both realized tensors (with concrete data in memory) and unrealized tensors (pending computations) to enable efficient batch compilation and execution.

Parameters:

context (mlir.Context | None)
sources (dict[Value[Any], Tensor])
seed (int)

`add_source()`

add_source(tensor)

Parameters:: tensor (Tensor)
Return type:: None

`add_unrealized()`

add_unrealized(tensor)

Parameters:: tensor (Tensor)
Return type:: None

`evaluate()`

async evaluate(tensor)

Evaluates and realizes the specified tensor.

Compiles and executes the computation graph to produce concrete values for the input tensor and any other pending computations. This triggers lazy evaluation, converting unrealized tensors into realized ones with data in memory.

Parameters:: tensor (Tensor) – The tensor to realize. This triggers evaluation of its computation and any dependencies.
Return type:: None

`graph`

graph: Graph

`sources`

sources: dict[Value[Any], Tensor]

Keeps a strong reference to tensor data that we need to compute graph values

`unrealized`

unrealized: WeakValueDictionary[int, Tensor]

Keeps weak references to intermediate unrealized tensor values, which may never need to be realized.

`Tensor`

class max.experimental.tensor.Tensor(*, storage=None, value=None)

A multi-dimensional array with eager execution and automatic compilation.

The Tensor class provides a high-level interface for numerical computations with automatic compilation and optimization via the MAX runtime. Operations on tensors execute eagerly while benefiting from lazy evaluation and graph-based optimizations behind the scenes.

Key Features:

Eager execution: Operations execute immediately with automatic compilation.
Lazy evaluation: Computation may be deferred until results are needed.
High performance: Uses the Mojo compiler and optimized kernels.
NumPy-like API: Supports familiar array operations and indexing.
Device flexibility: Works seamlessly across CPU and accelerators.

Creating Tensors:

Create tensors using factory methods like ones(), zeros(), constant(), arange(), or from other array libraries via from_dlpack().

from max.experimental import tensor
from max.dtype import DType

# Create tensors with factory methods
x = tensor.Tensor.ones((2, 3), dtype=DType.float32)
y = tensor.Tensor.zeros((2, 3), dtype=DType.float32)

# Perform operations
result = x + y  # Eager execution with automatic compilation

# Access values
print(result.shape)  # (2, 3)
print(result.dtype)  # DType.float32

Implementation Notes:

Tensors use lazy evaluation internally - they don’t always hold concrete data in memory. A tensor may be “unrealized” (not yet computed) until its value is actually needed (e.g., when printing, converting to other formats, or calling item()). This allows the runtime to optimize sequences of operations efficiently.

Operations on tensors build a computation graph behind the scenes, which is compiled and executed when needed. All illegal operations fail immediately with clear error messages, ensuring a smooth development experience.

Interoperability:

Tensors support the DLPack protocol for zero-copy data exchange with NumPy, PyTorch, JAX, and other array libraries. Use from_dlpack() to import arrays and standard DLPack conversion for export.

Parameters:

storage (Tensor | None)
value (graph.BufferValue | graph.TensorValue | None)

`T`

property T: Tensor

Gets the transposed tensor.

Returns a tensor with the last two dimensions transposed. This is equivalent to calling transpose(-1, -2) and is commonly used for matrix operations.

Returns:: A tensor with the last two dimensions swapped.
Return type:: Tensor

`arange()`

classmethod arange(start=0, stop=None, step=1, *, dtype=None, device=None)

Creates a tensor with evenly spaced values within a given interval.

Returns a new 1D tensor containing a sequence of values starting from start (inclusive) and ending before stop (exclusive), with values spaced by step. This is similar to Python’s built-in range() function and NumPy’s arange().

from max.experimental import tensor
from max.dtype import DType

# Create a range from 0 to 10 (exclusive)
x = tensor.Tensor.arange(10)
# Result: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Create a range from 5 to 15 with step 2
y = tensor.Tensor.arange(5, 15, 2)
# Result: [5, 7, 9, 11, 13]

# Use a specific dtype
z = tensor.Tensor.arange(0, 5, dtype=DType.float32)
# Result: [0.0, 1.0, 2.0, 3.0, 4.0]

Parameters:

start (int) – The starting value of the sequence. If stop is not provided, this becomes the stop value and start defaults to 0.
stop (int | None) – The end value of the sequence (exclusive). If not specified, the sequence ends at start and begins at 0.
step (int) – The spacing between values in the sequence.
dtype (DType | None) – The data type for the tensor elements. If not specified, defaults to DType.float32 for CPU devices and DType.bfloat16 for accelerator devices.
device (Device | None) – The device where the tensor will be allocated. If not specified, defaults to an accelerator if available, otherwise CPU.

Returns:

A 1D tensor containing the evenly spaced values.

Return type:

Tensor

`argmax()`

argmax(axis=-1)

Finds the indices of the maximum values along an axis.

Returns a tensor containing the indices of the maximum values along the specified axis. This is useful for finding the position of the largest element, such as determining predicted classes in classification.

from max.experimental import tensor
from max.dtype import DType

# Create a 2x4 tensor
x = tensor.Tensor.constant(
    [[1.2, 3.5, 2.1, 0.8], [2.3, 1.9, 4.2, 3.1]], dtype=DType.float32
)

# Find argmax along last axis (within each row)
indices = x.argmax(axis=-1)
# Result: [1, 2] (index 1 in first row, index 2 in second row)

Parameters:: axis (int) – The axis along which to find the maximum indices. Defaults to -1 (the last axis).
Returns:: A tensor containing the indices of the maximum values.
Return type:: Tensor

`cast()`

cast(dtype)

Casts the tensor to a different data type.

Returns a new tensor with the same values but a different data type. This is useful for type conversions between different numeric types, such as converting float32 to int32 for indexing operations or float32 to bfloat16 for memory-efficient computations.

from max.experimental import tensor
from max.dtype import DType

# Create a float32 tensor
x = tensor.Tensor.constant([1.7, 2.3, 3.9], dtype=DType.float32)
print(x.dtype)  # DType.float32

# Cast to int32 (truncates decimal values)
y = x.cast(DType.int32)
print(y.dtype)  # DType.int32
# Values: [1, 2, 3]

Parameters:: dtype (DType) – The target data type for the tensor.
Returns:: A new tensor with the specified data type.
Return type:: Tensor

`constant()`

classmethod constant(value, *, dtype=None, device=None)

Creates a constant tensor from a scalar, array, or nested list.

Constructs a tensor with constant values that can be a scalar, a nested Python list, or a DLPack-compatible array. The shape is automatically inferred from the input data structure.

from max.experimental import tensor
from max.dtype import DType

# Create from scalar
x = tensor.Tensor.constant(42, dtype=DType.int32)

# Create from nested list
y = tensor.Tensor.constant([[1.0, 2.0], [3.0, 4.0]])

# Create from NumPy array
import numpy as np

z = tensor.Tensor.constant(np.array([1, 2, 3]))

Parameters:

value (DLPackArray | Sequence[float | number[Any] | Sequence[Number | NestedArray]] | float | number[Any]) – The constant value for the tensor. Can be a scalar number, a nested Python list, or any DLPack-compatible array.
dtype (DType | None) – The data type for the tensor elements. If not specified, defaults to DType.float32 for CPU devices and DType.bfloat16 for accelerator devices.
device (Device | None) – The device where the tensor will be allocated. If not specified, defaults to an accelerator if available, otherwise CPU.

Returns:

A new tensor containing the constant value(s).

Return type:

Tensor

`device`

property device: Device

Gets the device where the tensor is stored.

Returns the device (CPU or accelerator) where the tensor’s data is located.

Returns:: The device where the tensor is stored.
Return type:: Device

`driver_tensor`

property driver_tensor: Tensor

A pointer to the underlying memory.

Raises if the tensor is unrealized.

`dtype`

property dtype: DType

Gets the data type of the tensor elements.

Returns the data type (dtype) of the elements stored in the tensor, such as float32, int32, or bfloat16.

Returns:: The data type of the tensor elements.
Return type:: DType

`from_dlpack()`

classmethod from_dlpack(array)

Creates a tensor from a DLPack array.

Constructs a tensor by importing data from any object that supports the DLPack protocol (such as NumPy arrays and PyTorch tensors). This enables zero-copy interoperability with other array libraries.

import numpy as np
from max.experimental import tensor

# Create a NumPy array
np_array = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)

# Convert to MAX tensor via DLPack
x = tensor.Tensor.from_dlpack(np_array)

Parameters:: array (DLPackArray) – Any object supporting the DLPack protocol, such as NumPy arrays, PyTorch tensors, or JAX arrays.
Returns:: A new tensor containing the data from the DLPack array.
Return type:: Tensor

`from_graph_value()`

classmethod from_graph_value(value)

Creates a tensor from a graph value.

Constructs a tensor from an existing graph value, which can be either a TensorValue or BufferValue. This is useful for converting graph level values into tensor objects for eager execution.

Parameters:: value (TensorValue | BufferValue) – The graph value to wrap. Can be either a TensorValue or BufferValue from the MAX graph API.
Returns:: A new tensor backed by the provided graph value.
Return type:: Tensor

`full()`

classmethod full(shape, value, *, dtype=None, device=None)

Creates a tensor filled with a specified value.

Returns a new tensor with the given shape where all elements are initialized to the specified value. This is useful for creating tensors with uniform values other than zero or one.

from max.experimental import tensor
from max.dtype import DType

# Create a 3x3 tensor filled with 7
x = tensor.Tensor.full((3, 3), value=7, dtype=DType.int32)

# Create a 2x4 tensor filled with pi
y = tensor.Tensor.full((2, 4), value=3.14159)

Parameters:

shape (Iterable[int | str | Dim | integer[Any]]) – The shape of the output tensor. Can be a tuple of integers, a list of integers, or any value that can be converted to a shape.
value (float | number[Any]) – The scalar value to fill the tensor with.
dtype (DType | None) – The data type for the tensor elements. If not specified, defaults to DType.float32 for CPU devices and DType.bfloat16 for accelerator devices.
device (Device | None) – The device where the tensor will be allocated. If not specified, defaults to an accelerator if available, otherwise CPU.

Returns:

A new tensor with the specified shape filled with the given value.

Return type:

Tensor

`full_like()`

classmethod full_like(type, value)

Creates a tensor filled with a value, matching a given type’s properties.

Returns a new tensor filled with the specified value that matches the shape, data type, and device of the given tensor type. This is useful when you need to create a tensor with uniform values that’s compatible with an existing tensor’s properties.

from max.experimental import tensor
from max.graph import TensorType
from max.driver import CPU
from max.dtype import DType

# Create a reference tensor type
ref_type = TensorType(DType.float32, (2, 3), device=CPU())

# Create tensor filled with 5.0 matching the reference type
x = tensor.Tensor.full_like(ref_type, value=5.0)

Parameters:

type (TensorType) – The tensor type to match. The returned tensor will have the same shape, dtype, and device as this type.
value (float | number[Any]) – The scalar value to fill the tensor with.

Returns:

A new tensor filled with the specified value, matching the properties of the input type.

Return type:

Tensor

`item()`

item()

Gets the scalar value from a single-element tensor.

Extracts and returns the scalar value from a tensor containing exactly one element. The tensor is realized if needed and transferred to CPU before extracting the value.

Returns:: The scalar value from the tensor. The return type matches the tensor’s dtype (e.g., float for float32, int for int32).
Raises:: TypeError – If the tensor contains more than one element.

`max()`

max(axis=-1)

Computes the maximum values along an axis.

Returns a tensor containing the maximum values along the specified axis. This is useful for reduction operations and finding peak values in data.

from max.experimental import tensor
from max.dtype import DType

# Create a 2x4 tensor
x = tensor.Tensor.constant(
    [[1.2, 3.5, 2.1, 0.8], [2.3, 1.9, 4.2, 3.1]], dtype=DType.float32
)

# Find max along last axis (within each row)
row_max = x.max(axis=-1)
# Result: [3.5, 4.2]

# Find max along first axis (within each column)
col_max = x.max(axis=0)
# Result: [2.3, 3.5, 4.2, 3.1]

Parameters:: axis (int) – The axis along which to compute the maximum. Defaults to -1 (the last axis).
Returns:: A tensor containing the maximum values along the specified axis.
Return type:: Tensor

`mean()`

mean(axis=-1)

Computes the mean values along an axis.

Returns a tensor containing the arithmetic mean of values along the specified axis. This is useful for computing averages, normalizing data, or aggregating statistics.

from max.experimental import tensor
from max.dtype import DType

# Create a 2x4 tensor
x = tensor.Tensor.constant(
    [[2.0, 4.0, 6.0, 8.0], [1.0, 3.0, 5.0, 7.0]], dtype=DType.float32
)

# Compute mean along last axis (within each row)
row_mean = x.mean(axis=-1)
# Result: [5.0, 4.0] (mean of each row)

# Compute mean along first axis (within each column)
col_mean = x.mean(axis=0)
# Result: [1.5, 3.5, 5.5, 7.5] (mean of each column)

Parameters:: axis (int) – The axis along which to compute the mean. Defaults to -1 (the last axis).
Returns:: A tensor containing the mean values along the specified axis.
Return type:: Tensor

`num_elements()`

num_elements()

Gets the total number of elements in the tensor.

Computes the product of all dimensions in the tensor’s shape to determine the total number of elements.

Returns:: The total number of elements in the tensor.
Return type:: int

`ones()`

classmethod ones(shape, *, dtype=None, device=None)

Creates a tensor filled with ones.

Returns a new tensor with the specified shape where all elements are initialized to one. The tensor is created with eager execution and automatic compilation.

from max.experimental import tensor
from max.driver import CPU
from max.dtype import DType

# Create a 2x3 tensor of ones
x = tensor.Tensor.ones((2, 3), dtype=DType.float32, device=CPU())
# Result: [[1.0, 1.0, 1.0],
#          [1.0, 1.0, 1.0]]

# Create a 1D tensor using default dtype and device
y = tensor.Tensor.ones((5,))

Parameters:

shape (Iterable[int | str | Dim | integer[Any]]) – The shape of the output tensor. Can be a tuple of integers, a list of integers, or any value that can be converted to a shape.
dtype (DType | None) – The data type for the tensor elements. If not specified, defaults to DType.float32 for CPU devices and DType.bfloat16 for accelerator devices.
device (Device | None) – The device where the tensor will be allocated. If not specified, defaults to an accelerator if available, otherwise CPU.

Returns:

A new tensor with the specified shape filled with ones.

Return type:

Tensor

`ones_like()`

classmethod ones_like(type)

Creates a tensor of ones matching a given type’s properties.

Returns a new tensor filled with ones that matches the shape, data type, and device of the specified tensor type. This is useful when you need to create a ones tensor that’s compatible with an existing tensor’s properties.

from max.experimental import tensor
from max.graph import TensorType
from max.driver import CPU
from max.dtype import DType

# Create a reference tensor type
ref_type = TensorType(DType.float32, (3, 4), device=CPU())

# Create ones tensor matching the reference type
x = tensor.Tensor.ones_like(ref_type)
# Result: 3x4 tensor of ones with dtype float32 on CPU

Parameters:: type (TensorType) – The tensor type to match. The returned tensor will have the same shape, dtype, and device as this type.
Returns:: A new tensor filled with ones matching the properties of the input type.
Return type:: Tensor

`permute()`

permute(dims)

Permutes the dimensions of the tensor.

Returns a tensor with its dimensions reordered according to the specified permutation. This is useful for changing the layout of multi-dimensional data.

Parameters:: dims (list[int]) – A list specifying the new order of dimensions. For example, [2, 0, 1] moves dimension 2 to position 0, dimension 0 to position 1, and dimension 1 to position 2.
Returns:: A tensor with permuted dimensions.
Return type:: Tensor

`range_like()`

classmethod range_like(type)

Creates a range tensor matching a given type’s properties.

Returns a new tensor containing sequential indices along the last dimension, broadcasted to match the shape of the specified tensor type. Each row (along the last dimension) contains values from 0 to the dimension size minus one. This is useful for creating position indices or coordinate tensors.

from max.experimental import tensor
from max.graph import TensorType
from max.driver import CPU
from max.dtype import DType

# Create a reference tensor type with shape (2, 4)
ref_type = TensorType(DType.int32, (2, 4), device=CPU())

# Create range tensor matching the reference type
x = tensor.Tensor.range_like(ref_type)
# Result: [[0, 1, 2, 3],
#          [0, 1, 2, 3]]

Parameters:: type (TensorType) – The tensor type to match. The returned tensor will have the same shape, dtype, and device as this type, with values representing indices along the last dimension.
Returns:: A new tensor with sequential indices broadcasted to match the input type’s shape.
Return type:: Tensor

`rank`

property rank: int

Gets the number of dimensions in the tensor.

Returns the rank (number of dimensions) of the tensor. For example, a scalar has rank 0, a vector has rank 1, and a matrix has rank 2.

Returns:: The number of dimensions in the tensor.
Return type:: int

`real`

property real: bool

`realize`

property realize

Force the tensor to realize if it is not already.

`reshape()`

reshape(shape)

Reshapes the tensor to a new shape.

Returns a tensor with the same data but a different shape. The total number of elements must remain the same. This is useful for changing tensor dimensions for different operations, such as flattening a multi-dimensional tensor or converting a 1D tensor into a matrix.

from max.experimental import tensor
from max.dtype import DType

# Create a 2x3 tensor
x = tensor.Tensor.constant([[1, 2, 3], [4, 5, 6]], dtype=DType.int32)
print(x.shape)  # (2, 3)

# Flatten to 1D
y = x.reshape((6,))
print(y.shape)  # (6,)
# Values: [1, 2, 3, 4, 5, 6]

Parameters:: shape (Iterable[int | str | Dim | integer[Any]]) – The desired output shape. Can be a tuple or list of integers. The total number of elements must equal the original tensor’s element count.
Returns:: A reshaped tensor with the specified shape.
Return type:: Tensor

`shape`

property shape: Shape

Gets the shape of the tensor.

Returns the dimensions of the tensor as a shape object.

Returns:: The shape of the tensor.
Return type:: Shape

`storage`

storage: Tensor | None

Underlying memory for a realized tensor.

`to()`

to(device)

Transfers the tensor to a different device.

Creates a new tensor with the same data on the specified device. This allows moving tensors between CPU and accelerators or between different accelerator devices.

from max.experimental import tensor
from max.driver import CPU, Accelerator

# Create a tensor on CPU
x = tensor.Tensor.ones((2, 3), device=CPU())
print(x.device)  # CPU

# Transfer to accelerator
y = x.to(Accelerator())
print(y.device)  # Accelerator(0)

Parameters:: device (Device) – The target device for the tensor.
Returns:: A new tensor with the same data on the specified device.
Return type:: Tensor

`transpose()`

transpose(dim1, dim2)

Transposes two dimensions of the tensor.

Returns a tensor with the specified dimensions swapped. This is a special case of permutation that swaps exactly two dimensions.

Parameters:

dim1 (int) – The first dimension to swap.
dim2 (int) – The second dimension to swap.

Returns:

A tensor with the specified dimensions transposed.

Return type:

Tensor

`type`

property type: TensorType

Gets the tensor type information.

Returns the type information for the tensor, including shape, dtype, and device. If the underlying value is a buffer type, it’s converted to a tensor type.

Returns:: The type information for the tensor.
Return type:: TensorType

`zeros()`

classmethod zeros(shape, *, dtype=None, device=None)

Creates a tensor filled with zeros.

Returns a new tensor with the specified shape where all elements are initialized to zero. The tensor is created with eager execution and automatic compilation.

from max.experimental import tensor
from max.driver import CPU
from max.dtype import DType

# Create a 2x3 tensor of zeros
x = tensor.Tensor.zeros((2, 3), dtype=DType.float32, device=CPU())
# Result: [[0.0, 0.0, 0.0],
#          [0.0, 0.0, 0.0]]

# Create a 1D tensor using default dtype and device
y = tensor.Tensor.zeros((5,))

Parameters:

shape (Iterable[int | str | Dim | integer[Any]]) – The shape of the output tensor. Can be a tuple of integers, a list of integers, or any value that can be converted to a shape.
dtype (DType | None) – The data type for the tensor elements. If not specified, defaults to DType.float32 for CPU devices and DType.bfloat16 for accelerator devices.
device (Device | None) – The device where the tensor will be allocated. If not specified, defaults to an accelerator if available, otherwise CPU.

Returns:

A new tensor with the specified shape filled with zeros.

Return type:

Tensor

`zeros_like()`

classmethod zeros_like(type)

Creates a tensor of zeros matching a given type’s properties.

Returns a new tensor filled with zeros that matches the shape, data type, and device of the specified tensor type. This is useful when you need to create a zero tensor that’s compatible with an existing tensor’s properties.

from max.experimental import tensor
from max.graph import TensorType
from max.driver import CPU
from max.dtype import DType

# Create a reference tensor type
ref_type = TensorType(DType.float32, (3, 4), device=CPU())

# Create zeros tensor matching the reference type
x = tensor.Tensor.zeros_like(ref_type)
# Result: 3x4 tensor of zeros with dtype float32 on CPU

Parameters:: type (TensorType) – The tensor type to match. The returned tensor will have the same shape, dtype, and device as this type.
Returns:: A new tensor filled with zeros matching the properties of the input type.
Return type:: Tensor

`contextvar_context()`

max.experimental.tensor.contextvar_context(var, value)

Parameters:

var (ContextVar[T])
value (T)

`default_device()`

max.experimental.tensor.default_device(device)

Context manager for setting the default device for tensor creation.

Sets the default device used for tensor creation within the context. All tensors created inside the context block without an explicit device parameter will use this device.

from max.experimental import tensor
from max.driver import CPU

# Use CPU as default device in this context
with tensor.default_device(CPU()):
    x = tensor.Tensor.ones((2, 3))  # Created on CPU
    y = tensor.Tensor.zeros((2, 3))  # Also on CPU

Parameters:: device (Device) – The device to use as the default for tensor creation within the context.
Returns:: A context manager that sets the default device.

`default_dtype()`

max.experimental.tensor.default_dtype(dtype)

Context manager for setting the default dtype for tensor creation.

Sets the default data type used for tensor creation within the context. All tensors created inside the context block without an explicit dtype parameter will use this data type.

from max.experimental import tensor
from max.dtype import DType

# Use int32 as default dtype in this context
with tensor.default_dtype(DType.int32):
    x = tensor.Tensor.ones((2, 3))  # Created with int32
    y = tensor.Tensor.zeros((2, 3))  # Also int32

Parameters:: dtype (DType) – The data type to use as the default for tensor creation within the context.
Returns:: A context manager that sets the default dtype.

`defaults()`

max.experimental.tensor.defaults(dtype=None, device=None)

Gets the default dtype and device for tensor creation.

Returns a tuple containing the dtype and device to use for tensor creation, applying defaults when values are not specified. If no dtype is provided, defaults to DType.float32 for CPU and DType.bfloat16 for accelerators. If no device is provided, defaults to an accelerator if available, otherwise CPU.

Parameters:

dtype (DType | None) – The data type to use. If not specified, a default dtype based on the device is returned.
device (Device | None) – The device to use. If not specified, defaults to an available accelerator or CPU.

Returns:

A tuple containing the resolved dtype and device.

Return type:

tuple[DType, Device]

`driver_tensor_type()`

max.experimental.tensor.driver_tensor_type(t)

Converts a driver tensor to a :obj:TensorType.

Creates a TensorType instance from a driver-level tensor by extracting its dtype, shape, and device information.

Parameters:: t (Tensor) – The driver tensor to convert.
Returns:: A tensor type representing the driver tensor’s properties.
Return type:: TensorType

View source

Was this page helpful?

Thank you! We'll create more content like this.

Thank you for helping us improve!

ComputeGraph​

add_source()​

add_unrealized()​

evaluate()​

graph​

sources​

unrealized​

Tensor​

T​

arange()​

argmax()​

cast()​

constant()​

device​

driver_tensor​

dtype​

from_dlpack()​

from_graph_value()​

full()​

full_like()​

item()​

max()​

mean()​

num_elements()​

ones()​

ones_like()​

permute()​

range_like()​

rank​

real​

realize​

reshape()​

shape​

storage​

to()​

transpose()​

type​

zeros()​

zeros_like()​

contextvar_context()​

default_device()​

default_dtype()​

defaults()​

driver_tensor_type()​

`ComputeGraph`

`add_source()`

`add_unrealized()`

`evaluate()`

`graph`

`sources`

`unrealized`

`Tensor`

`T`

`arange()`

`argmax()`

`cast()`

`constant()`

`device`

`driver_tensor`

`dtype`

`from_dlpack()`

`from_graph_value()`

`full()`

`full_like()`

`item()`

`max()`

`mean()`

`num_elements()`

`ones()`

`ones_like()`

`permute()`

`range_like()`

`rank`

`real`

`realize`

`reshape()`

`shape`

`storage`

`to()`

`transpose()`

`type`

`zeros()`

`zeros_like()`

`contextvar_context()`

`default_device()`

`default_dtype()`

`defaults()`

`driver_tensor_type()`