tensorplay.export API

Infer dynamic shape markers from representative input sets.

A range restriction attached to one input dimension.

name ties the constraint to a named Dim shared across inputs (equalities are implied). root/scale/offset describe a derived dimension whose size equals scale * root_size + offset. Constraints without a name come from dim hints or static entries.

A validated mutable mapping from graph targets to replacement callables.

Entries are keyed by graph target (callable or method name). Removing a key preserves the op from rewriting; materialize returns a plain dict for consumers that require one.

clear() → None.  Remove all items from D.

classmethod fromkeys(iterable, value=None, /)

Create a new dictionary with keys from iterable and values set to value.

materialize() → dict[Any, Callable[[...], Any]][source]

Return a plain dict of effective entries, resolving defaults.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

remove(target: Any) → Callable[[...], Any][source]

Preserve target by deleting its decomposition entry.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

A named symbolic dimension with an optional finite range.

Ties several input sites to one shared dimension size.

sites lists every (input placeholder name, dim index) pair whose runtime sizes must stay equal; name is the symbolic dimension they implement when the tie comes from a shared Dim, else None.

A validated graph together with its state and example bindings.

buffers() → Iterator[Any][source]

Iterate over the captured module’s buffers.

static call_exported(program: ExportedProgram) → Callable[[...], Any][source]

Return a callable executing the flat contract on user arguments.

property code: str

Python source of the captured graph’s generated forward.

classmethod deserialize(artifact: Any, state_dict: Any = None, constants: Any = None, example_inputs: Any = None) → ExportedProgram[source]

Rebuild a program from serialize() artifacts.

invalidate_unlifted() → None[source]

Drop the cached unlifted module so the next call rebuilds it.

module() → GraphModule[source]

Return a self-contained module with lifted state folded back in.

The returned module takes only the user arguments: state placeholders are rewritten into attribute reads on a fresh module that owns the parameter, buffer, and constant values. The result is cached; pass rebind to drop state changes made through this program view.

parameters() → Iterator[Any][source]

Iterate over the captured module’s parameters.

run_decompositions(decomp_table: Any = None) → ExportedProgram[source]

Return a copied program after applying registered graph rewrites.

Entries map a graph target (a callable, a method name, or a target string) to a builder invoked as builder(graph, node); the builder creates the replacement nodes and returns the value users should consume. Nodes whose target has no entry are left untouched.

serialize(opset_version: Any = None, pickle_protocol: int = 4) → Any[source]

Return serialized program artifacts (JSON program + example inputs).

property state_dict: dict[str, Any]

Tensor values of the lifted parameters and persistent buffers.

property tensor_constants: dict[str, Any]

Lifted non-parameter, non-buffer tensor values.

Describe lifted state, user values, mutations, and graph outputs.

property assertion_dep_token: Mapping[int, str] | None

Position of the assertion dependency token output, if present.

clone() → ExportGraphSignature[source]

Deep copy: specs and argument records are duplicated, not shared.

get_param_to_buffer() → Mapping[str, str][source]

Map parameter targets to the buffer targets holding their gradients.

Gradients are declared as GRADIENT_TO_PARAMETER outputs; a gradient for a parameter whose optimizer state lives in a buffer binds the two targets under the parameter’s FQN.

get_replace_hook(replace_inputs: bool = False)[source]

Build a rename hook suitable for graph rewriting passes.

is_buffer(name: str) → bool[source]

Whether name is a placeholder carrying a lifted buffer.

is_param(name: str) → bool[source]

Whether name is a placeholder carrying a lifted parameter.

replace_all_uses(old: str, new: str) → None[source]

Rename a graph value across every input and output spec.

Adapt one flattened argument layout into another layout.

Compact signature retained for callers that build signatures directly.

Associate shape specifications with tensor objects by identity.

Executable module view retaining the captured root module hierarchy.

Role a packaged weight plays in the captured program.

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()

Returns self, the complex conjugate of any int.

denominator

the denominator of a rational number in lowest terms

classmethod from_bytes(bytes, byteorder='big', *, signed=False)

imag

the imaginary part of a complex number

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

numerator

the numerator of a rational number in lowest terms

real

the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)