tensorlogic-scirs-backend 0.1.0

SciRS2-powered tensor execution backend for TensorLogic
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

//! Unit tests for SciRS2 backend.

use tensorlogic_infer::{ElemOp, ReduceOp, TlExecutor};

use crate::Scirs2Exec;

#[test]
fn test_scirs2_tensor_creation() {
    let tensor = Scirs2Exec::from_vec(vec![1.0, 2.0, 3.0, 4.0], vec![2, 2]).expect("unwrap");
    assert_eq!(tensor.shape(), &[2, 2]);
    assert_eq!(tensor.len(), 4);
}

#[test]
fn test_scirs2_elem_ops() {
    let mut exec = Scirs2Exec::new();
    let tensor = Scirs2Exec::from_vec(vec![-1.0, 0.0, 1.0, 2.0], vec![4]).expect("unwrap");

    let relu = exec.elem_op(ElemOp::Relu, &tensor).expect("unwrap");
    assert_eq!(relu[[0]], 0.0);
    assert_eq!(relu[[1]], 0.0);
    assert_eq!(relu[[2]], 1.0);
    assert_eq!(relu[[3]], 2.0);

    let one_minus = exec.elem_op(ElemOp::OneMinus, &tensor).expect("unwrap");
    assert_eq!(one_minus[[0]], 2.0);
    assert_eq!(one_minus[[1]], 1.0);
    assert_eq!(one_minus[[2]], 0.0);
    assert_eq!(one_minus[[3]], -1.0);
}

#[test]
fn test_scirs2_binary_ops() {
    let mut exec = Scirs2Exec::new();
    let a = Scirs2Exec::from_vec(vec![1.0, 2.0, 3.0, 4.0], vec![2, 2]).expect("unwrap");
    let b = Scirs2Exec::from_vec(vec![2.0, 2.0, 2.0, 2.0], vec![2, 2]).expect("unwrap");

    let mult = exec
        .elem_op_binary(ElemOp::Multiply, &a, &b)
        .expect("unwrap");
    assert_eq!(mult[[0, 0]], 2.0);
    assert_eq!(mult[[0, 1]], 4.0);
    assert_eq!(mult[[1, 0]], 6.0);
    assert_eq!(mult[[1, 1]], 8.0);

    let sub = exec
        .elem_op_binary(ElemOp::Subtract, &a, &b)
        .expect("unwrap");
    assert_eq!(sub[[0, 0]], -1.0);
    assert_eq!(sub[[0, 1]], 0.0);
    assert_eq!(sub[[1, 0]], 1.0);
    assert_eq!(sub[[1, 1]], 2.0);
}

#[test]
fn test_scirs2_reduce_ops() {
    let mut exec = Scirs2Exec::new();
    let tensor =
        Scirs2Exec::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], vec![2, 3]).expect("unwrap");

    let sum_axis0 = exec.reduce(ReduceOp::Sum, &tensor, &[0]).expect("unwrap");
    assert_eq!(sum_axis0.shape(), &[3]);

    let sum_axis1 = exec.reduce(ReduceOp::Sum, &tensor, &[1]).expect("unwrap");
    assert_eq!(sum_axis1.shape(), &[2]);

    let max_axis0 = exec.reduce(ReduceOp::Max, &tensor, &[0]).expect("unwrap");
    assert_eq!(max_axis0.shape(), &[3]);
}

#[test]
fn test_scirs2_einsum_matmul() {
    let mut exec = Scirs2Exec::new();

    let a = Scirs2Exec::from_vec(vec![1.0, 2.0, 3.0, 4.0], vec![2, 2]).expect("unwrap");
    let b = Scirs2Exec::from_vec(vec![5.0, 6.0, 7.0, 8.0], vec![2, 2]).expect("unwrap");

    let result = exec.einsum("ij,jk->ik", &[a, b]).expect("unwrap");
    assert_eq!(result.shape(), &[2, 2]);
}

#[test]
fn test_backward_pass_basic() {
    use tensorlogic_infer::TlAutodiff;
    use tensorlogic_ir::{EinsumGraph, EinsumNode, OpType};

    let mut exec = Scirs2Exec::new();

    // Create a simple graph: unary operation (ReLU)
    let mut graph = EinsumGraph::new();
    graph.tensors.push("input[a]".to_string());
    graph.tensors.push("output[a]".to_string());
    graph.nodes.push(EinsumNode {
        op: OpType::ElemUnary {
            op: "relu".to_string(),
        },
        inputs: vec![0],
        outputs: vec![1],
        metadata: None,
    });
    graph.outputs.push(1);

    // Add input tensor
    let input = Scirs2Exec::from_vec(vec![-1.0, 2.0, -3.0, 4.0], vec![4]).expect("unwrap");
    exec.add_tensor("input[a]".to_string(), input);

    // Forward pass
    let output = exec.forward(&graph).expect("unwrap");
    assert_eq!(output.shape(), &[4]);

    // Backward pass with ones gradient
    let loss_grad = Scirs2Exec::ones(vec![4]);
    let tape = exec.backward(&graph, &loss_grad).expect("unwrap");

    // Should have gradients
    assert!(!tape.is_empty());
}

#[test]
fn test_backward_pass_binary() {
    use tensorlogic_infer::TlAutodiff;
    use tensorlogic_ir::{EinsumGraph, EinsumNode, OpType};

    let mut exec = Scirs2Exec::new();

    // Create a graph: binary operation (subtract)
    let mut graph = EinsumGraph::new();
    graph.tensors.push("a[i]".to_string());
    graph.tensors.push("b[i]".to_string());
    graph.tensors.push("output[i]".to_string());
    graph.nodes.push(EinsumNode {
        op: OpType::ElemBinary {
            op: "subtract".to_string(),
        },
        inputs: vec![0, 1],
        outputs: vec![2],
        metadata: None,
    });
    graph.outputs.push(2);

    // Add input tensors
    let a = Scirs2Exec::from_vec(vec![5.0, 6.0], vec![2]).expect("unwrap");
    let b = Scirs2Exec::from_vec(vec![3.0, 2.0], vec![2]).expect("unwrap");
    exec.add_tensor("a[i]".to_string(), a);
    exec.add_tensor("b[i]".to_string(), b);

    // Forward pass
    let output = exec.forward(&graph).expect("unwrap");
    assert_eq!(output.shape(), &[2]);

    // Backward pass
    let loss_grad = Scirs2Exec::ones(vec![2]);
    let tape = exec.backward(&graph, &loss_grad).expect("unwrap");

    // Should have gradients for both inputs
    assert!(!tape.is_empty());
}