lmm 0.1.0

A language agnostic framework for emulating reality.
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

use lmm::field::Field;
use lmm::operator::{FourierOperator, NeuralOperator};
use lmm::tensor::Tensor;
use lmm::traits::Learnable;

fn make_field(data: Vec<f64>) -> Field {
    let n = data.len();
    Field::new(vec![n], Tensor::new(vec![n], data).unwrap()).unwrap()
}

#[test]
fn test_identity_kernel() {
    let mut weights = vec![0.0; 5];
    weights[2] = 1.0;
    let op = NeuralOperator {
        kernel_weights: weights,
    };
    let input = make_field(vec![1.0, 2.0, 3.0, 4.0, 5.0]);
    let out = op.transform(&input).unwrap();
    for (a, b) in out.values.data.iter().zip(input.values.data.iter()) {
        assert!(
            (a - b).abs() < 1e-10,
            "Identity kernel mismatch: {} vs {}",
            a,
            b
        );
    }
}

#[test]
fn test_zero_kernel_gives_zero() {
    let op = NeuralOperator {
        kernel_weights: vec![0.0, 0.0, 0.0],
    };
    let input = make_field(vec![1.0, 2.0, 3.0, 4.0, 5.0]);
    let out = op.transform(&input).unwrap();
    assert!(out.values.data.iter().all(|&v| v == 0.0));
}

#[test]
fn test_scale_kernel() {
    let op = NeuralOperator {
        kernel_weights: vec![0.5],
    };
    let input = make_field(vec![2.0, 4.0, 6.0]);
    let out = op.transform(&input).unwrap();
    assert_eq!(out.values.data, vec![1.0, 2.0, 3.0]);
}

#[test]
fn test_learnable_update() {
    let mut op = NeuralOperator {
        kernel_weights: vec![1.0, 0.0, 1.0],
    };
    let grad = Tensor::new(vec![3], vec![0.1, 0.2, 0.3]).unwrap();
    op.update(&grad, 1.0).unwrap();
    assert!((op.kernel_weights[0] - 0.9).abs() < 1e-10);
    assert!((op.kernel_weights[1] - (-0.2)).abs() < 1e-10);
    assert!((op.kernel_weights[2] - 0.7).abs() < 1e-10);
}

#[test]
fn test_learnable_wrong_size_error() {
    let mut op = NeuralOperator {
        kernel_weights: vec![1.0, 0.0],
    };
    let grad = Tensor::new(vec![3], vec![0.1, 0.2, 0.3]).unwrap();
    assert!(op.update(&grad, 1.0).is_err());
}

#[test]
fn test_gradient_descent_reduces_error() {
    let target = make_field(vec![1.0, 2.0, 3.0, 4.0, 5.0]);
    let input = make_field(vec![2.0, 4.0, 6.0, 8.0, 10.0]);
    let mut op = NeuralOperator {
        kernel_weights: vec![1.0],
    };
    let initial_out = op.transform(&input).unwrap();
    let initial_err: f64 = initial_out
        .values
        .data
        .iter()
        .zip(target.values.data.iter())
        .map(|(a, b)| (a - b).powi(2))
        .sum();
    for _ in 0..5 {
        let grads = op.gradient_wrt_kernel(&input, &target).unwrap();
        let grad_tensor = Tensor::new(vec![grads.len()], grads).unwrap();
        op.update(&grad_tensor, 0.01).unwrap();
    }
    let final_out = op.transform(&input).unwrap();
    let final_err: f64 = final_out
        .values
        .data
        .iter()
        .zip(target.values.data.iter())
        .map(|(a, b)| (a - b).powi(2))
        .sum();
    assert!(
        final_err < initial_err,
        "Error should decrease after gradient steps: {final_err:.4} vs {initial_err:.4}"
    );
}

#[test]
fn test_fourier_operator_round_trip() {
    let data = vec![1.0, 0.0, -1.0, 0.0, 1.0, 0.0, -1.0, 0.0];
    let n_modes = data.len();
    let op = FourierOperator {
        spectral_weights: vec![1.0; n_modes],
    };
    let input = make_field(data.clone());
    let out = op.transform(&input).unwrap();
    assert_eq!(out.values.data.len(), data.len());
}

#[test]
fn test_empty_kernel_error() {
    let op = NeuralOperator {
        kernel_weights: vec![],
    };
    let input = make_field(vec![1.0, 2.0, 3.0]);
    assert!(op.transform(&input).is_err());
}