xnn 0.2.0

A lightweight ML framework with GPU-first architecture
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

//! Math operation tests.

mod abs;
mod acos;
mod acosh;
mod add;
mod and;
mod asin;
mod asinh;
mod atan;
mod atanh;
mod ceil;
mod clamp;
mod cos;
mod cosh;
mod div;
mod eq;
mod exp;
mod floor;
mod ge;
mod gt;
mod le;
mod log;
mod log2;
mod lt;
mod max;
mod min;
mod mul;
mod ne;
mod neg;
mod not;
mod or;
mod pow;
mod rcp;
mod rem;
mod round;
mod rsqr;
mod rsqrt;
mod select;
mod sign;
mod sin;
mod sinh;
mod sqr;
mod sqrt;
mod sub;
mod tan;
mod tanh;

/// Generates a binary arithmetic op test for float types.
macro_rules! test_arithmetic_op_float {
    ($name:ident, $method:ident, $T:ty, $a:expr, $b:expr, $c:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let (c_shape, c_data) = $c;
            let a = Tensor::<$T>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<$T>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let c = Tensor::<$T>::from_shape_slice(&ctx, c_shape, c_data).unwrap();
            let result = a.$method(&b).unwrap();
            crate::assert_tensor_relative_eq(&result, &c);
        }
    };
}

/// Generates a binary arithmetic op test for integer types.
macro_rules! test_arithmetic_op_integer {
    ($name:ident, $method:ident, $T:ty, $a:expr, $b:expr, $c:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let (c_shape, c_data) = $c;
            let a = Tensor::<$T>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<$T>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let c = Tensor::<$T>::from_shape_slice(&ctx, c_shape, c_data).unwrap();
            let result = a.$method(&b).unwrap();
            crate::assert_tensor_eq(&result, &c);
        }
    };
}

/// Generates a binary comparison op test.
macro_rules! test_comparison_op {
    ($name:ident, $method:ident, $T:ty, $a:expr, $b:expr, $c:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let (c_shape, c_data) = $c;
            let a = Tensor::<$T>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<$T>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let c = Tensor::<bool>::from_shape_slice(&ctx, c_shape, c_data).unwrap();
            let result = a.$method(&b).unwrap();
            crate::assert_tensor_eq(&result, &c);
        }
    };
}

/// Generates a binary logical op test.
macro_rules! test_logical_op {
    ($name:ident, $method:ident, $a:expr, $b:expr, $c:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let (c_shape, c_data) = $c;
            let a = Tensor::<bool>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<bool>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let c = Tensor::<bool>::from_shape_slice(&ctx, c_shape, c_data).unwrap();
            let result = a.$method(&b).unwrap();
            crate::assert_tensor_eq(&result, &c);
        }
    };
}

/// Generates a unary float op test.
macro_rules! test_unary_op_float {
    ($name:ident, $method:ident, $a:expr, $b:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let a = Tensor::<f32>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<f32>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let result = a.$method().unwrap();
            crate::assert_tensor_relative_eq(&result, &b);
        }
    };
}

/// Generates a unary integer op test.
macro_rules! test_unary_op_integer {
    ($name:ident, $method:ident, $T:ty, $a:expr, $b:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let a = Tensor::<$T>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<$T>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let result = a.$method().unwrap();
            crate::assert_tensor_eq(&result, &b);
        }
    };
}

/// Generates a unary rounding op test.
macro_rules! test_unary_rounding_op {
    ($name:ident, $method:ident, $a:expr, $b:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let a = Tensor::<f32>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<f32>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let result = a.$method().unwrap();
            crate::assert_tensor_relative_eq(&result, &b);
        }
    };
}

/// Generates a unary logical op test.
macro_rules! test_unary_logical_op {
    ($name:ident, $method:ident, $a:expr, $b:expr) => {
        #[test]
        fn $name() {
            use xnn::{Context, Tensor};
            let ctx = Context::try_default().unwrap();
            let (a_shape, a_data) = $a;
            let (b_shape, b_data) = $b;
            let a = Tensor::<bool>::from_shape_slice(&ctx, a_shape, a_data).unwrap();
            let b = Tensor::<bool>::from_shape_slice(&ctx, b_shape, b_data).unwrap();
            let result = a.$method().unwrap();
            crate::assert_tensor_eq(&result, &b);
        }
    };
}

pub(crate) use test_arithmetic_op_float;
pub(crate) use test_arithmetic_op_integer;
pub(crate) use test_comparison_op;
pub(crate) use test_logical_op;
pub(crate) use test_unary_logical_op;
pub(crate) use test_unary_op_float;
pub(crate) use test_unary_op_integer;
pub(crate) use test_unary_rounding_op;