Skip to main content

/

Docs

Log in

Mojo struct

Symbol

Represents a symbolic value within a Graph.

A Symbol can represent the output of a node, the arguments of a Graph (as seen from within its body), and more generally any symbolic value available within the Graph. Other nodes receive Symbol values as inputs to form a computation graph.

A Symbol may also refer to an existing input or output of a node, and you can change them, such as by swapping a new Symbol.

Conceptually, a Symbol is the equivalent of a variable in Mojo. A Symbol can also be thought of as the end of an edge in the dataflow graph (the other end being one use of that symbol).

Similar to a regular variable, a Symbol has a data type.

Note: All the methods in this type are documented as "Creates foo". This is a shorthand notation for "Adds a node representing an op that returns foo".

Fields​

  • ​handle (Value): A handle to this Symbol's internal representation.

Implemented traits​

AnyType, CollectionElement, Copyable, Formattable, Movable, Stringable

Methods​

__getitem__​

__getitem__(self: Self, i: Variant[Symbol, Int], axis: Int = 0, keep_dims: Bool = 0) -> Self

Symbolic slicing - indexes a value by a single index.

Uses the mo.slice op.

Args:

  • ​i (Variant[Symbol, Int]): The index value.
  • ​axis (Int): The axis to index at.
  • ​keep_dims (Bool): Returns a tensor with the same rank as the input if set.

Returns:

The slicing result.

__getitem__(self: Self, *s: SymbolicSlice, *, out_dims: List[Dim, 0]) -> Self

Range-based slicing.

Uses the mo.slice op. Slicing along multiple dimensions is supported.

Args:

  • ​*s (SymbolicSlice): The slice values. The ith SymbolicSlice in the variadic list represents the begin:end:step triple for axis i.
  • ​out_dims (List[Dim, 0]): The expected output dimensions returned by slicing. These will be assert at graph execution time to be correct.

Returns:

The slicing result.

__getitem__(self: Self, *slices: Slice, *, out_dims: List[Dim, 0] = List()) -> Self

Shorthand for symbolic slicing with Int ranges.

Args:

  • ​*slices (Slice): The slice values for each dimension respectively. If fewer than rank() slices are provided, the remaining dimensions will be trivially sliced. In other words s[:, :2] is equivalent to s[:, :2, :, :] for a tensor of rank 4. Currently indexing and slicing may not be mixed.
  • ​out_dims (List[Dim, 0]): The expected output dimensions returned by slicing. These will be assert at graph execution time to be correct.

Returns:

The slicing result.

Raises:

An exception if out_dims is empty and can't be calculated at graph build time.

__neg__​

__neg__(self: Self) -> Self

Numerical negative, element-wise.

Returns:

The operation result.

__add__​

__add__(self: Self, rhs: Self) -> Self

Element-wise addition.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__add__(self: Self, rhs: Int) -> Self

Element-wise addition by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__add__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise addition by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__sub__​

__sub__(self: Self, rhs: Self) -> Self

Element-wise subtraction.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__sub__(self: Self, rhs: Int) -> Self

Element-wise subtraction by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__sub__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise subtraction by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__mul__​

__mul__(self: Self, rhs: Self) -> Self

Element-wise multiplication.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__mul__(self: Self, rhs: Int) -> Self

Element-wise multiplication by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__mul__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise multiplication by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__matmul__​

__matmul__(self: Self, rhs: Self) -> Self

Matrix multiplication.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__truediv__​

__truediv__(self: Self, rhs: Self) -> Self

Element-wise division.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__truediv__(self: Self, rhs: Int) -> Self

Element-wise division by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__truediv__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise division by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__pow__​

__pow__(self: Self, rhs: Self) -> Self

Element-wise raise to power.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__pow__(self: Self, rhs: Int) -> Self

Element-wise raise to power by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__pow__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise raise to power by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__radd__​

__radd__(self: Self, rhs: Self) -> Self

Element-wise addition.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__radd__(self: Self, rhs: Int) -> Self

Element-wise addition by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__radd__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise addition by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__rsub__​

__rsub__(self: Self, rhs: Self) -> Self

Element-wise subtraction.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__rsub__(self: Self, rhs: Int) -> Self

Element-wise subtraction by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__rsub__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise subtraction by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__rmul__​

__rmul__(self: Self, rhs: Self) -> Self

Element-wise multiplication.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__rmul__(self: Self, rhs: Int) -> Self

Element-wise multiplication by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__rmul__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise multiplication by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__rtruediv__​

__rtruediv__(self: Self, rhs: Self) -> Self

Element-wise division.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__rtruediv__(self: Self, rhs: Int) -> Self

Element-wise division by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__rtruediv__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise division by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

__rpow__​

__rpow__(self: Self, rhs: Self) -> Self

Element-wise raise to power.

Args:

  • ​rhs (Self): The right hand side operand.

Returns:

The operation result.

__rpow__(self: Self, rhs: Int) -> Self

Element-wise raise to power by an Int literal.

Args:

  • ​rhs (Int): The right hand side operand.

Returns:

The operation result.

__rpow__(self: Self, rhs: SIMD[float64, 1]) -> Self

Element-wise raise to power by a Float64.

Args:

  • ​rhs (SIMD[float64, 1]): The right hand side operand.

Returns:

The operation result.

graph​

graph(self: Self) -> Graph

Returns the Graph owning this Symbol.

Returns:

The parent Graph.

type​

type(self: Self) -> Type

Returns this Symbol's type.

Returns:

The Symbol's type.

tensor_type​

tensor_type(self: Self) -> TensorType

Returns this Symbol's type, as TensorType.

Implicitly asserts that the type is indeed TensorType, and raises an error otherwise.

Returns:

The tensor type of this Symbol.

shape​

shape(self: Self) -> List[Dim, 0]

Returns this Symbol's tensor shape, as List[Dim].

Implicitly asserts that the type is indeed TensorType, and raises an error otherwise.

Returns:

The tensor shape of this Symbol.

__str__​

__str__(self: Self) -> String

Returns a String representation of this Symbol.

The representation uses an internal MLIR Assembly format, and typically shows the node that outputs this Symbol. Its structure is subject to change without notice, and should not be used for serialization. For debugging purposes only.

Returns:

A textual representation of this Symbol.

format_to​

format_to(self: Self, inout writer: Formatter)

Formats this symbol to the provided formatter.

Args:

  • ​writer (Formatter): The formatter to write to.

rebind​

rebind(self: Self, *dims: Dim) -> Self

rebind(self: Self, dims: List[Dim, 0]) -> Self

reshape​

reshape(self: Self) -> Self

reshape(self: Self, *dims: Int) -> Self

Reshapes this Symbol.

Uses the mo.reshape op. Requires the symbol to be a TensorType.

Args:

  • ​*dims (Int): The new dimensions.

Returns:

A new Symbol that has the given shape.

reshape(self: Self, *dims: Dim) -> Self

Reshapes this Symbol.

Uses the mo.reshape op. Requires the symbol to be a TensorType.

Args:

  • ​*dims (Dim): The new dimensions.

Returns:

A new Symbol that has the given shape.

reshape(self: Self, *dims: Variant[Symbol, Int]) -> Self

Reshapes this Symbol.

Uses the mo.reshape op. Requires the symbol to be a TensorType.

Args:

  • ​*dims (Variant[Symbol, Int]): The new dimensions.

Returns:

A new Symbol that has the given shape.

swapaxes​

swapaxes(self: Self, axis1: Int, axis2: Int) -> Self

Interchanges two axes of this Symbol.

Uses the mo.transpose op. Negative values are allowed, and represent the axis number counting from the last.

Args:

  • ​axis1 (Int): One of the axes to swap.
  • ​axis2 (Int): The other axis.

Returns:

A new transposed Symbol.

broadcast_to​

broadcast_to(self: Self, *dims: Dim) -> Self

Broadcasts this Symbol to the specified dims.

Uses the mo.broadcast_to op. Requires the symbol to be a TensorType.

Args:

  • ​*dims (Dim): The target dimensions.

Returns:

A new Symbol that is broadcast to the given shape.

broadcast_to(self: Self, shape: List[Dim, 0], location: Optional[_SourceLocation] = #kgen.none) -> Self

Broadcasts this Symbol to the specified shape.

Uses the mo.broadcast_to op. Requires the symbol to be a TensorType.

Args:

  • ​shape (List[Dim, 0]): The target shape.
  • ​location (Optional[_SourceLocation]): An optional location for a more specific error message.

Returns:

A new Symbol that is broadcast to the given shape.

print​

print(self: Self, label: String = "debug_tensor")

Prints this Symbol's value at runtime.

This uses mo.debug.tensor.print to enable printing the runtime value that this Symbol represents, at grpah execution time.

Args:

  • ​label (String): A label to accompany the printout.

insert_transformation​

insert_transformation(self: Self, transform: fn(Symbol) raises -> Symbol)

Inserts nodes in between this Symbol and all its current uses.

This enables inserting ops in between this Symbol and all its uses, for example to modify an existing Graph.

Note: The function is called exactly once, even if self has no uses.

Args:

  • ​transform (fn(Symbol) raises -> Symbol): A function that creates a unary subgraph (single input, single output) and returns the result of the final node. The function will be called with this Symbol, and its return value will replace all of its uses.

Was this page helpful?