constensor-core 0.1.1

Experimental ML framework featuring a graph-based JIT compiler.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#[cfg(feature = "cuda")]
use constensor_core::Cuda;
use constensor_core::{CompiledGraph, Cpu, Graph, GraphTensor, R1, R2, R3};

macro_rules! test_for_device_cast {
    ($dev:ty, $name:ident) => {
        mod $name {
            use super::*;

            // Test casting a 1D tensor from f32 to f64
            #[test]
            fn cast_f32_to_f64_1d() {
                let mut graph = Graph::empty();
                let _x = GraphTensor::<R1<4>, f32, $dev>::fill(&mut graph, 1.5);
                let compiled: CompiledGraph<R1<4>, f32, $dev> = graph.compile().unwrap();
                let tensor = compiled.run().unwrap();
                let casted = tensor.cast::<f64>().unwrap();
                let data = casted.data().unwrap().into_owned();
                assert_eq!(data, vec![1.5_f64; 4]);
            }

            // Test casting a 2D tensor from f64 to f32
            #[test]
            fn cast_f64_to_f32_2d() {
                let mut graph = Graph::empty();
                let _x = GraphTensor::<R2<2, 3>, f64, $dev>::fill(&mut graph, 2.75);
                let compiled: CompiledGraph<R2<2, 3>, f64, $dev> = graph.compile().unwrap();
                let tensor = compiled.run().unwrap();
                let casted = tensor.cast::<f32>().unwrap();
                let data = casted.data().unwrap().into_owned();
                assert_eq!(data, vec![vec![2.75_f32; 3]; 2]);
            }

            // Test casting a 3D tensor from i32 to f32
            #[test]
            fn cast_i32_to_f32_3d() {
                let mut graph = Graph::empty();
                let _x = GraphTensor::<R3<1, 2, 3>, i32, $dev>::fill(&mut graph, 7);
                let compiled: CompiledGraph<R3<1, 2, 3>, i32, $dev> = graph.compile().unwrap();
                let tensor = compiled.run().unwrap();
                let casted = tensor.cast::<f32>().unwrap();
                let data = casted.data().unwrap().into_owned();
                let expected = vec![vec![vec![7.0_f32; 3]; 2]; 1];
                assert_eq!(data, expected);
            }

            // Test casting from f32 to i32 truncates toward zero
            #[test]
            fn cast_f32_to_i32_truncate() {
                let mut graph = Graph::empty();
                let _x = GraphTensor::<R1<3>, f32, $dev>::fill(&mut graph, 1.9);
                let compiled: CompiledGraph<R1<3>, f32, $dev> = graph.compile().unwrap();
                let tensor = compiled.run().unwrap();
                let casted = tensor.cast::<i32>().unwrap();
                let data = casted.data().unwrap().into_owned();
                assert_eq!(data, vec![1_i32; 3]);
            }
        }
    };
}

test_for_device_cast!(Cpu, cpu_tests_cast);
#[cfg(feature = "cuda")]
test_for_device_cast!(Cuda<0>, cuda_tests_cast);