Struct kn_graph::graph::Graph

pub struct Graph { /* private fields */ }

The core graph datastructure.

This is a Directed Acyclic Graph (DAG) with values and their creating operations as nodes, and input operands as edges. The data structure is append-only, values cannot be removed and so will never become invalid.

This type implements Index<Value> trait, so you can use graph[value] to get information about the given value.

// create a new graph
let mut graph = Graph::new();

// define the inputs
let x = graph.input(shape![Size::BATCH, 4, 8, 8]);

// define constants
let w_data = vec![0.5; 4 * 4 * 3 * 3];
let w = graph.constant(shape![4, 4, 3, 3], w_data);
let b_data = vec![0.5; 4];
let b = graph.constant(shape![4, 1, 1], b_data);

// build operation graph
let y0 = graph.conv(x, w, 1, 1, 1, 1);
let y = graph.add(y0, b);

graph.output(y);

println!("{}", graph);

Results in the following output:

Graph {
  check: 1504812640,
  input_shapes: [Shape(B x 4 x 8 x 8)],
  output_shapes: [Shape(B x 4 x 8 x 8)],
  inputs: [Value(0)],
  outputs: [Value(6)],
  values: [
    Value(0) = ValueInfo { shape: Shape(B x 4 x 8 x 8), operation: Input { index: 0 }, debug_id: "", non_output_uses: 1 },
    Value(1) = ValueInfo { shape: Shape(4 x 4 x 3 x 3), operation: Constant { data: [..; 144] }, debug_id: "", non_output_uses: 1 },
    Value(2) = ValueInfo { shape: Shape(4 x 1 x 1), operation: Constant { data: [0.5, 0.5, 0.5, 0.5] }, debug_id: "", non_output_uses: 1 },
    Value(3) = ValueInfo { shape: Shape(B x 4 x 8 x 8), operation: Conv { input: Value(0), filter: Value(1), details: ConvDetails { batch_size: Size(B), input_channels: 4, output_channels: 4, input_h: 8, input_w: 8, kernel_h: 3, kernel_w: 3, stride_y: 1, stride_x: 1, padding_y: 1, padding_x: 1, output_h: 8, output_w: 8 } }, debug_id: "", non_output_uses: 1 },
    Value(4) = ValueInfo { shape: Shape(1 x 4 x 1 x 1), operation: View { input: Value(2) }, debug_id: "", non_output_uses: 1 },
    Value(5) = ValueInfo { shape: Shape(B x 4 x 8 x 8), operation: Broadcast { input: Value(4) }, debug_id: "", non_output_uses: 1 },
    Value(6) = ValueInfo { shape: Shape(B x 4 x 8 x 8), operation: Binary { left: Value(3), right: Value(5), op: Add }, debug_id: "", non_output_uses: 0 },
  ],
}

Implementations

impl Graph

pub fn new() -> Self

pub fn values(&self) -> impl Iterator<Item = Value>

Iterate over the values in this graph, in topological order, which means that nodes will only be visited after all of their inputs have been visited.

pub fn inputs(&self) -> &[Value]

pub fn input_shapes(&self) -> Vec<Shape>

pub fn outputs(&self) -> &[Value]

pub fn output_shapes(&self) -> Vec<Shape>

pub fn outputs_mut(&mut self) -> &mut Vec<Value>

pub fn is_hidden(&self, value: Value) -> bool

pub fn is_hidden_with_uses(&self, value: Value, users: usize) -> bool

pub fn is_const(&self, value: Value) -> bool

pub fn as_const(&self, value: Value) -> Option<Tensor>

Try to evaluate value as a constant.

pub fn is_const_filled_with(&self, value: Value, f: f32) -> bool

Returns whether value is effectively a constant with every element equal to f.

pub fn as_single_const(&self, value: Value) -> Option<f32>

Returns Some(f) if value is effectively a constant with every element equal to f.

pub fn take_new_values(&mut self) -> Vec<Value>

Return all newly crated values since the last call to take_new_values.

pub fn set_debug_id(&mut self, value: Value, id: String)

Equivalent to self[value].debug_id = id, but that would not work since there is intentionally no implementation of IndexMut for Graph.

pub fn input(&mut self, shape: Shape) -> Value

Declare a new input value.

pub fn scalar(&mut self, value: f32) -> Value

pub fn constant(&mut self, shape: Shape, data: Vec<f32>) -> Value

Declare a new constant.

pub fn constant_tensor(&mut self, tensor: Tensor) -> Value

pub fn view(&mut self, input: Value, new_shape: Shape) -> Value

View an existing value as a new shape.

pub fn broadcast(&mut self, input: Value, new_shape: Shape) -> Value

Broadcast the input towards new_shape. Additional unit axes are are inserted at the front and unit axes are repeated as necessary.

pub fn repeat_unary(&mut self, input: Value, axis: usize, count: Size) -> Value

pub fn flatten(&mut self, input: Value, start_axis: usize) -> Value

View a value with a flattened shape. All axis starting from start_axis inclusive are flattened into a single axis.

pub fn permute(&mut self, input: Value, permutation: Vec<usize>) -> Value

Change the order of axis in the shape.

pub fn slice(&mut self, input: Value, axis: usize, range: SliceRange) -> Value

Slice a value along an axis.

pub fn index(&mut self, input: Value, axis: usize, index: usize) -> Value

Index along a given axis. Similar to slice with a 1-sized interval except that the the resulting value doesn’t have the extra axis.

pub fn flip(&mut self, input: Value, axis: usize) -> Value

Flip the given axis.

pub fn repeat(&mut self, input: Value, axis: usize, count: Size) -> Value

Repeat input along a given axis, count times. This starts by emitting the entire tensor before repeating elements, similar to torch.repeat or numpy.tile.

pub fn repeat_interleave( &mut self, input: Value, axis: usize, count: Size ) -> Value

Repeat elements of input along a given axis, count times. This starts by repeat each element before going to the next one, similar to torch.repeat_interleave or numpy.repeat.

pub fn gather(&mut self, input: Value, axis: usize, indices: Value) -> Value

Index input along the given axis with indices given by indices.

The output shape is the input shape with axis replaced by the shape of indices.

pub fn concat( &mut self, inputs: Vec<Value>, axis: usize, base_shape: Option<Shape> ) -> Value

Concatenate inputs along axis. base_shape can be provided to allow the result shape to be inferred in case inputs is empty.

pub fn conv( &mut self, input: Value, filter: Value, stride_y: usize, stride_x: usize, padding_y: usize, padding_x: usize ) -> Value

Apply 2D convolution.

pub fn linear(&mut self, input: Value, weight: Value) -> Value

Apply a linear transformation. Input shape [b, Ci] and weight shape [Co, Ci] result in an output with shape [b, Co].

pub fn mat_mul(&mut self, left: Value, right: Value) -> Value

General matrix multiply, with broadcasting.

• The last two axes should have shapes [n, p] and [p, m] and will result in an output shape [n, m]
• The preceding axes are broadcast together and reappear in the output as-is.

pub fn batched_mat_mul(&mut self, left: Value, right: Value) -> Value

Batched matrix multiply, without any automatic broadcasting. Inputs must have shapes [b, m, n], [b, n, p] and the result has shape [b, m, p].

pub fn softmax(&mut self, input: Value, axis: usize) -> Value

pub fn layernorm(&mut self, input: Value, axis: usize, eps: f32) -> Value

pub fn reduce(&mut self, input: Value, axes: Vec<usize>, op: ReduceOp) -> Value

Reduce input along the given axes. The result shape is the same as the input shape but without the reduces axes.

pub fn sigmoid(&mut self, input: Value) -> Value

Elementwise sigmoid.

pub fn relu(&mut self, input: Value) -> Value

Elementwise relu.

pub fn clamp(&mut self, input: Value, min: f32, max: f32) -> Value

Elementwise clamp.

pub fn add(&mut self, left: Value, right: Value) -> Value

pub fn sub(&mut self, left: Value, right: Value) -> Value

pub fn mul(&mut self, left: Value, right: Value) -> Value

pub fn pow(&mut self, left: Value, right: Value) -> Value

pub fn unary(&mut self, op: UnaryOp, input: Value) -> Value

pub fn binary(&mut self, op: BinaryOp, left: Value, right: Value) -> Value

Compute elementwise binary operation. Both inputs must have the same rank (or right must have rank 0), the right shape is broadcasted to the left shape.

pub fn call(&mut self, graph: &Graph, inputs: &[Value]) -> Vec<Value>

Computes the operations described by graph on the given inputs.

This can be used to cleanly compose multiple graphs together.

pub fn output(&mut self, value: Value)

Register an existing value as an output

pub fn output_all(&mut self, values: &[Value])

Register multiple values as output at once, in order.

Trait Implementations

impl Clone for Graph

fn clone(&self) -> Graph

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Graph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Graph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Index<Value> for Graph

type Output = ValueInfo

The returned type after indexing.

fn index(&self, value: Value) -> &Self::Output

Performs the indexing (container[index]) operation.