auto-diff 0.3.2

A neural network library 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

use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput, BenchmarkId};
use std::iter;

use auto_diff::tensor::gen_tensor::*;

extern crate ndarray;
extern crate ndarray_linalg;
extern crate openblas_src; // or another backend of your choice

//use ndarray;

fn single_add_benchmark(c: &mut Criterion) {
    let m1 = GenTensor::<f64>::fill(1., &vec![10,10]);
    c.bench_function("single add", |b| b.iter(|| {
        let m3 = m1.add(&m1);
    }));
}

fn tensor_dim_benchmark(c: &mut Criterion) {
    let ss = vec![10, 20, 30, 50, 70, 128];

    let mut group = c.benchmark_group("tensor_dim");
    for size in ss.iter() {
        let m1 = GenTensor::<f64>::fill(1., &vec![*size, *size]);
        group.bench_with_input(BenchmarkId::new("add", size*size), size, |b, &size| {
            b.iter(|| {
                let m_result = m1.add(&m1);
            });
        });
        group.bench_with_input(BenchmarkId::new("mul", size*size), size, |b, &size| {
            b.iter(|| {
                let m_result = m1.mul(&m1);
            });
        });
        let md = &ndarray::Array2::<f64>::zeros(((*size) as usize, (*size) as usize));
        group.bench_with_input(BenchmarkId::new("mul_ndarray", size*size), size, |b, &size| {
            b.iter(|| {
                let m_result = md * md;
            });
        });
    }
    group.finish();

}

criterion_group!(benches, single_add_benchmark, tensor_dim_benchmark);
criterion_main!(benches);