redstone-ml 0.0.0

High-performance Machine Learning, Auto-Differentiation and Tensor Algebra crate for 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
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

use redstone_ml::*;

#[test]
fn test_broadcast() {
    let tensor = NdArray::new([1, 2, 3]);
    let tensor = tensor.broadcast_to(&[3, 3]);
    assert_eq!(tensor.shape(), [3, 3]);
    assert_eq!(tensor, NdArray::new([[1, 2, 3], [1, 2, 3], [1, 2, 3]]));
}

#[test]
fn test_broadcast_scalar_to_higher_dims() {
    let tensor = NdArray::new([42]);
    let tensor = tensor.broadcast_to(&[2, 3]);
    assert_eq!(tensor.shape(), [2, 3]);
    assert_eq!(tensor, NdArray::new([[42, 42, 42], [42, 42, 42]]));
}

#[test]
fn test_broadcast_matrix_to_higher_dims() {
    let tensor = NdArray::new([[1, 2], [3, 4]]);
    let tensor = tensor.broadcast_to(&[3, 2, 2]);
    assert_eq!(tensor.shape(), [3, 2, 2]);
    assert_eq!(tensor, NdArray::new([[[1, 2], [3, 4]], [[1, 2], [3, 4]], [[1, 2], [3, 4]]]));
}

#[test]
#[should_panic]
fn test_broadcast_incompatible_shapes1() {
    let tensor = NdArray::new([1, 2, 3]);
    tensor.broadcast_to(&[3, 5]);
}

#[test]
#[should_panic]
fn test_broadcast_incompatible_shapes2() {
    let tensor: NdArray<f32> = NdArray::ones([3, 3]);
    tensor.broadcast_to(&[1, 3]);
}

#[test]
#[should_panic]
fn test_broadcast_incompatible_shapes3() {
    let tensor: NdArray<bool> = NdArray::ones([1, 1, 3]);
    tensor.broadcast_to(&[1, 3]);
}


#[test]
fn test_broadcast_identity() {
    let tensor = NdArray::new([1, 2, 3]);
    let tensor = tensor.broadcast_to(&[3]);
    assert_eq!(tensor.shape(), [3]);
    assert_eq!(tensor, NdArray::new([1, 2, 3]));
}

#[test]
fn test_broadcast_unchanged() {
    let tensor = NdArray::new([1, 2, 3]);
    let tensor = tensor.broadcast_to(&[1, 3]);
    assert_eq!(tensor.shape(), [1, 3]);
    assert_eq!(tensor, NdArray::new([[1, 2, 3]]));
}

#[test]
fn test_broadcast_high_dims() {
    let tensor = NdArray::new([[1], [2], [3]]);
    let tensor = tensor.broadcast_to(&[3, 3, 3]);
    assert_eq!(tensor.shape(), [3, 3, 3]);
    assert_eq!(tensor, NdArray::new(
        [[[1, 1, 1], [2, 2, 2], [3, 3, 3]],
            [[1, 1, 1], [2, 2, 2], [3, 3, 3]],
            [[1, 1, 1], [2, 2, 2], [3, 3, 3]]]
    )
    );
}

#[test]
fn test_broadcast_single_dimensional_expansion() {
    let tensor = NdArray::new([1, 2, 3]);
    let tensor = tensor.broadcast_to(&[3, 1, 3]);
    assert_eq!(tensor.shape(), [3, 1, 3]);
    assert_eq!(tensor, NdArray::new([[[1, 2, 3]], [[1, 2, 3]], [[1, 2, 3]]]));
}