nir-rs 0.4.4

Pure-Rust implementation of the Neuromorphic Intermediate Representation (NIR) — the standard interchange format for spiking neural networks.
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

// SPDX-License-Identifier: MIT OR Apache-2.0

//! Feature-gated Serde coverage for finite, debug-oriented graph exports.

#![cfg(feature = "serde")]

use nir_rs::nodes::{Input, Lif, Output};
use nir_rs::{MetadataValue, NirError, NirGraph, NirNode, Tensor};

fn input(shape: Vec<usize>) -> NirNode {
    NirNode::Input(Input {
        shape,
        metadata: Default::default(),
    })
}

fn output(shape: Vec<usize>) -> NirNode {
    NirNode::Output(Output {
        shape,
        metadata: Default::default(),
    })
}

fn lif() -> NirNode {
    NirNode::Lif(Lif {
        tau: Tensor::from_f64(vec![2], vec![10.0, 12.0]).unwrap(),
        r: Tensor::from_f64(vec![2], vec![1.0, 1.5]).unwrap(),
        v_leak: Tensor::from_f64(vec![2], vec![0.0, 0.0]).unwrap(),
        v_threshold: Tensor::from_f64(vec![2], vec![1.0, 1.25]).unwrap(),
        v_reset: Some(Tensor::from_f64(vec![2], vec![0.0, 0.0]).unwrap()),
        metadata: Default::default(),
    })
}

fn finite_nested_graph() -> NirGraph {
    let mut inner = NirGraph::new();
    inner.insert_node("inner_input", input(vec![2])).unwrap();
    inner.insert_node("inner_output", output(vec![2])).unwrap();
    inner.add_edge("inner_input", "inner_output");

    let mut graph = NirGraph::new();
    graph.version = Some("1.0.8".into());
    graph
        .metadata
        .insert("purpose".into(), MetadataValue::String("debug-only".into()));
    graph.insert_node("input", input(vec![2])).unwrap();
    graph.insert_node("lif", lif()).unwrap();
    graph
        .insert_node("subgraph", NirNode::Graph(Box::new(inner)))
        .unwrap();
    graph.insert_node("output", output(vec![2])).unwrap();
    graph.add_edge("input", "lif");
    graph.add_edge("lif", "subgraph");
    graph.add_edge("subgraph", "output");
    graph
}

#[test]
fn finite_graph_round_trips_through_debug_json() {
    let graph = finite_nested_graph();
    let json = serde_json::to_string_pretty(&graph).unwrap();
    let decoded: NirGraph = serde_json::from_str(&json).unwrap();

    assert_eq!(decoded, graph);
    decoded.validate_structure().unwrap();
}

#[test]
fn representation_uses_wire_tags_and_shape_plus_typed_data() {
    let value = serde_json::to_value(finite_nested_graph()).unwrap();

    assert_eq!(value["nodes"]["lif"]["type"], "LIF");
    assert_eq!(
        value["nodes"]["lif"]["tau"]["shape"],
        serde_json::json!([2])
    );
    assert_eq!(
        value["nodes"]["lif"]["tau"]["data"],
        serde_json::json!({"F64": [10.0, 12.0]})
    );
    assert_eq!(value["nodes"]["subgraph"]["type"], "NIRGraph");
    assert_eq!(
        value["nodes"]["subgraph"]["nodes"]["inner_input"]["type"],
        "Input"
    );
}

#[test]
fn nested_serde_graph_roundtrip_validates() {
    // Verifies that nested graphs survive serde JSON round-tripping and validate
    // structural integrity cleanly. Deep nesting guarantees up to MAX_NESTING_DEPTH
    // are exercised directly in `src/graph.rs` to remain independent of format-specific
    // deserializer recursion limits.
    let mut graph = NirGraph::default();
    graph.insert_node("leaf", input(vec![1])).unwrap();
    for i in (0..16).rev() {
        let mut outer = NirGraph::default();
        outer
            .insert_node(format!("n{i}"), NirNode::Graph(Box::new(graph)))
            .unwrap();
        graph = outer;
    }

    let json = serde_json::to_string(&graph).unwrap();
    let decoded: NirGraph = serde_json::from_str(&json).unwrap();
    decoded.validate_structure().unwrap();
}

#[test]
fn serde_nested_invalid_graph_keeps_path_context() {
    let mut inner = NirGraph::default();
    inner.insert_node("i", input(vec![1])).unwrap();
    inner.add_edge("i", "ghost");

    let mut graph = inner;
    for i in (0..16).rev() {
        let mut outer = NirGraph::default();
        outer
            .insert_node(format!("n{i}"), NirNode::Graph(Box::new(graph)))
            .unwrap();
        graph = outer;
    }

    let json = serde_json::to_string(&graph).unwrap();
    let decoded: NirGraph = serde_json::from_str(&json).unwrap();
    match decoded.validate_structure() {
        Err(NirError::InvalidGraph(msg)) => {
            assert!(msg.contains("n0"), "{msg}");
            assert!(msg.contains("n15"), "{msg}");
            assert!(msg.contains("ghost"), "{msg}");
        }
        other => panic!("expected InvalidGraph, got {other:?}"),
    }
}

#[test]
fn malformed_tensor_cannot_bypass_shape_invariant() {
    let malformed = serde_json::json!({
        "shape": [2],
        "data": {"F64": [1.0]}
    });
    let err = serde_json::from_value::<Tensor>(malformed).unwrap_err();
    assert!(err.to_string().contains("shape product 2"));
    assert!(err.to_string().contains("data len 1"));
}