Struct GraphTensor

pub struct GraphTensor<S: Shape, T: DType, D: Dev> { /* private fields */ }

A tensor representing an intermediary result of a graph. Performing operations on this tensor will not cause any computations.

Implementations

impl<const B: usize, const M: usize, const K: usize, T: DType, D: Dev> GraphTensor<R3<B, M, K>, T, D>

pub fn matmul<const N: usize>( self, rhs: GraphTensor<R3<B, K, N>, T, D>, ) -> GraphTensor<R3<B, M, N>, T, D>

pub fn matmul_axpby<const N: usize>( self, rhs: GraphTensor<R3<B, K, N>, T, D>, out: GraphTensor<R3<B, M, N>, T, D>, alpha: T, beta: T, ) -> GraphTensor<R3<B, M, N>, T, D>

out = out * alpha + beta * lhs * rhs

Examples found in repository

examples/matmul/main.rs (line 19)

fn bench<T: DType, const B: usize, const M: usize, const K: usize, const N: usize>(
    type_name: &str,
    alpha: T,
    beta: T,
) {
    // Number of times to run the matmul for averaging
    let iterations = 1;
    let mut total = std::time::Duration::new(0, 0);

    let mut graph = Graph::empty();
    let a = GraphTensor::<R3<B, M, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(1.));
    // Strided matmuls works on all devices.
    let b = GraphTensor::<R3<B, N, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.)).t();
    // let b = GraphTensor::<R3<B, K, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.));
    let o = GraphTensor::<R3<B, M, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(3.));
    let _c = a.matmul_axpby(b, o, alpha, beta);

    graph.optimize();
    let compiled: CompiledGraph<R3<B, M, N>, T, BestDevice<0>> = graph.compile().unwrap();

    for _ in 0..iterations {
        let start = Instant::now();

        let tensor = std::hint::black_box(compiled.run().unwrap());
        dbg!(tensor.data().unwrap());

        total += start.elapsed();
    }

    let avg = total / (iterations as u32);
    println!("Average execution time for {type_name} over {iterations} iterations: {avg:?}");
}

impl<S: Shape, T: DType, D: Dev> GraphTensor<S, T, D>

pub fn fill(graph: &mut Graph<T>, v: T) -> Self

Create a tensor filled with some value.

Examples found in repository

examples/hello_world/main.rs (line 6)

fn main() {
    let mut graph: Graph<f32> = Graph::empty();
    let _arange = GraphTensor::<R1<10>, f32, Cpu>::arange(&mut graph, 0., 1.);
    let a = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 1.0);
    let b = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 2.0);
    let c = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 3.0);
    let d = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 4.0);
    let res = a * b + c;
    let _out = res + d;

    graph.optimize();

    graph.visualize("graph.png").unwrap();

    let compiled: constensor_core::CompiledGraph<R2<3, 4>, f32, Cpu> = graph.compile().unwrap();
    let res = compiled.run().unwrap();

    let tensor: Tensor<R2<3, 4>, f32, Cpu> = res;

    assert_eq!(tensor.data().unwrap().to_vec(), vec![vec![9.0; 4]; 3],);
}

examples/matmul/main.rs (line 14)

fn bench<T: DType, const B: usize, const M: usize, const K: usize, const N: usize>(
    type_name: &str,
    alpha: T,
    beta: T,
) {
    // Number of times to run the matmul for averaging
    let iterations = 1;
    let mut total = std::time::Duration::new(0, 0);

    let mut graph = Graph::empty();
    let a = GraphTensor::<R3<B, M, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(1.));
    // Strided matmuls works on all devices.
    let b = GraphTensor::<R3<B, N, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.)).t();
    // let b = GraphTensor::<R3<B, K, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.));
    let o = GraphTensor::<R3<B, M, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(3.));
    let _c = a.matmul_axpby(b, o, alpha, beta);

    graph.optimize();
    let compiled: CompiledGraph<R3<B, M, N>, T, BestDevice<0>> = graph.compile().unwrap();

    for _ in 0..iterations {
        let start = Instant::now();

        let tensor = std::hint::black_box(compiled.run().unwrap());
        dbg!(tensor.data().unwrap());

        total += start.elapsed();
    }

    let avg = total / (iterations as u32);
    println!("Average execution time for {type_name} over {iterations} iterations: {avg:?}");
}

pub fn zeros(graph: &mut Graph<T>) -> Self

Create a tensor filled with zeros.

pub fn ones(graph: &mut Graph<T>) -> Self

Create a tensor filled with ones.

pub fn sqrt(self) -> GraphTensor<S, T, D>

Elementwise unary square root.

pub fn rand(graph: &mut Graph<T>) -> Self

Create a tensor filled with uniform random values in [0,1).

pub fn randn(graph: &mut Graph<T>, mean: T, std: T) -> Self

Create a tensor filled with normally distributed random values (mean, std).

impl<S: Shape, T: DType, D: Dev> GraphTensor<S, T, D>

pub fn graph(&self) -> RwLockReadGuard<'_, Graph<T>>

Retrieve the graph for this GraphTensor.

pub fn id(&self) -> GraphTensorId

Get the graph tensor ID.

impl<const A: usize, T: DType, D: Dev> GraphTensor<R1<A>, T, D>

pub fn arange(graph: &mut Graph<T>, start: T, stop: T) -> Self

A GraphTensor representing a vector ranging from start to stop with step computed using A.

Examples found in repository

examples/hello_world/main.rs (line 5)

fn main() {
    let mut graph: Graph<f32> = Graph::empty();
    let _arange = GraphTensor::<R1<10>, f32, Cpu>::arange(&mut graph, 0., 1.);
    let a = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 1.0);
    let b = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 2.0);
    let c = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 3.0);
    let d = GraphTensor::<R2<3, 4>, f32, Cpu>::fill(&mut graph, 4.0);
    let res = a * b + c;
    let _out = res + d;

    graph.optimize();

    graph.visualize("graph.png").unwrap();

    let compiled: constensor_core::CompiledGraph<R2<3, 4>, f32, Cpu> = graph.compile().unwrap();
    let res = compiled.run().unwrap();

    let tensor: Tensor<R2<3, 4>, f32, Cpu> = res;

    assert_eq!(tensor.data().unwrap().to_vec(), vec![vec![9.0; 4]; 3],);
}

impl<T: DType, const A: usize, const B: usize, D: Dev> GraphTensor<R2<A, B>, T, D>

pub fn t(&self) -> GraphTensor<R2<B, A>, T, D>

Return a view of this matrix with dimensions transposed (A x B -> B x A).

impl<T: DType, const A: usize, const B: usize, const C: usize, D: Dev> GraphTensor<R3<A, B, C>, T, D>

pub fn t(&self) -> GraphTensor<R3<A, C, B>, T, D>

Return a view of this tensor with last two reversed axes (A x B x C -> A x C x B).

Examples found in repository

examples/matmul/main.rs (line 16)

fn bench<T: DType, const B: usize, const M: usize, const K: usize, const N: usize>(
    type_name: &str,
    alpha: T,
    beta: T,
) {
    // Number of times to run the matmul for averaging
    let iterations = 1;
    let mut total = std::time::Duration::new(0, 0);

    let mut graph = Graph::empty();
    let a = GraphTensor::<R3<B, M, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(1.));
    // Strided matmuls works on all devices.
    let b = GraphTensor::<R3<B, N, K>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.)).t();
    // let b = GraphTensor::<R3<B, K, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(2.));
    let o = GraphTensor::<R3<B, M, N>, T, BestDevice<0>>::fill(&mut graph, T::from_f64(3.));
    let _c = a.matmul_axpby(b, o, alpha, beta);

    graph.optimize();
    let compiled: CompiledGraph<R3<B, M, N>, T, BestDevice<0>> = graph.compile().unwrap();

    for _ in 0..iterations {
        let start = Instant::now();

        let tensor = std::hint::black_box(compiled.run().unwrap());
        dbg!(tensor.data().unwrap());

        total += start.elapsed();
    }

    let avg = total / (iterations as u32);
    println!("Average execution time for {type_name} over {iterations} iterations: {avg:?}");
}

Trait Implementations

impl<S: Shape, T: DType, D: Dev> Add for GraphTensor<S, T, D>

fn add(self, rhs: Self) -> Self::Output

Add an elementwise operation to the graph.

type Output = GraphTensor<S, T, D>

The resulting type after applying the + operator.

impl<S: Clone + Shape, T: Clone + DType, D: Clone + Dev> Clone for GraphTensor<S, T, D>

fn clone(&self) -> GraphTensor<S, T, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Shape, T: DType, D: Dev> Div for GraphTensor<S, T, D>

fn div(self, rhs: Self) -> Self::Output

Add an elementwise operation to the graph.

type Output = GraphTensor<S, T, D>

The resulting type after applying the / operator.

impl<S: Shape, T: DType, D: Dev> Mul for GraphTensor<S, T, D>

fn mul(self, rhs: Self) -> Self::Output

Add an elementwise operation to the graph.

type Output = GraphTensor<S, T, D>

The resulting type after applying the * operator.

impl<S: Shape, T: DType + Neg<Output = T>, D: Dev> Neg for GraphTensor<S, T, D>

fn neg(self) -> Self::Output

Add an elementwise addition operation to the graph.

type Output = GraphTensor<S, T, D>

The resulting type after applying the - operator.

impl<S: Shape, T: DType, D: Dev> Sub for GraphTensor<S, T, D>

fn sub(self, rhs: Self) -> Self::Output

Add an elementwise operation to the graph.

type Output = GraphTensor<S, T, D>

The resulting type after applying the - operator.