autograd 1.1.1

Tensors and differentiable operations in Rust
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

extern crate autograd as ag;
extern crate ndarray;

#[test]
fn scalar_add() {
    ag::with(|g| {
        let z: ag::Tensor<f64> = 3. + g.ones(&[3]) + 2.;
        assert_eq!(z.eval(&[]), Ok(ndarray::arr1(&[6., 6., 6.]).into_dyn()));
    });
}

#[test]
fn scalar_sub() {
    ag::with(|g| {
        let ref z: ag::Tensor<f64> = 3. - g.ones(&[3]) - 2.;
        assert_eq!(z.eval(&[]), Ok(ndarray::arr1(&[0., 0., 0.]).into_dyn()));
    });
}

#[test]
fn scalar_mul() {
    ag::with(|g| {
        let ref z: ag::Tensor<f64> = 3. * g.ones(&[3]) * 2.;
        assert_eq!(z.eval(&[]), Ok(ndarray::arr1(&[6., 6., 6.]).into_dyn()));
    });
}

#[test]
fn scalar_div() {
    ag::with(|g| {
        let z: ag::Tensor<f64> = 3. / g.ones(&[3]) / 2.;
        assert_eq!(z.eval(&[]), Ok(ndarray::arr1(&[1.5, 1.5, 1.5]).into_dyn()));
    });
}

#[test]
fn slice() {
    ag::with(|g| {
        let ref a: ag::Tensor<f32> = g.zeros(&[4, 4]);
        let ref b = g.slice(a, &[0, 0], &[-1, 2]); // numpy equivalent is a[:, 0:2]
        assert_eq!(b.eval(&[]).unwrap().shape(), &[4, 2]);
    });
}

#[test]
fn slice_negative() {
    ag::with(|g| {
        let ref a: ag::Tensor<f32> = g.zeros(&[4, 4]);
        let ref b = g.slice(a, &[0, 0], &[-2, 2]); // numpy equivalent is a[:-1, :2]
        assert_eq!(b.eval(&[]).unwrap().shape(), &[3, 2]);

        let ref b = g.slice(a, &[0, 0], &[-3, 2]); // numpy equivalent is a[:-1, :2]
        assert_eq!(b.eval(&[]).unwrap().shape(), &[2, 2]);
    });
}