Struct GraphNeuralNetwork 

pub struct GraphNeuralNetwork {
    pub config: GnnConfig,
    pub nodes: Vec<NodeFeatures>,
    pub adjacency: Vec<Vec<(GnnNodeId, f64)>>,
    pub trained_iterations: u64,
}

Message-passing Graph Neural Network.

Supports dynamic node/edge addition/removal, configurable aggregation strategies, and multi-layer propagation.

Fields

config: GnnConfig

GNN configuration (layers, aggregation, iterations).

nodes: Vec<NodeFeatures>

Node feature vectors; index matches the logical node id.

adjacency: Vec<Vec<(GnnNodeId, f64)>>

Adjacency list: adjacency[node_idx] = list of (neighbour_id, weight).

trained_iterations: u64

Cumulative message-passing iterations executed so far.

Implementations

impl GraphNeuralNetwork

pub fn new(config: GnnConfig) -> Self

Create a new, empty graph neural network with the given configuration.

pub fn add_node(&mut self, features: Vec<f64>) -> GnnNodeId

Append a new node with the provided feature vector.

Returns the GnnNodeId assigned to the new node.

pub fn add_edge( &mut self, from: GnnNodeId, to: GnnNodeId, weight: f64, ) -> Result<(), GnnError>

Add an undirected edge between from and to with the given weight.

Both directions are stored so that neighbour aggregation works transparently for undirected graphs.

Errors

Returns GnnError::NodeNotFound if either node id is out of bounds.

pub fn remove_node(&mut self, id: GnnNodeId) -> bool

Remove the node with the given id together with all edges incident to it.

Returns true if the node existed, false otherwise.

Note: Removing a node renumbers all nodes with higher indices; any previously obtained GnnNodeIds for those nodes become stale.

pub fn forward(&self) -> Vec<Vec<f64>>

Run num_iterations rounds of message passing and return the final node embeddings.

Each iteration:

1. Every node aggregates its neighbours’ current feature vectors using the configured GnnAggregation.
2. The aggregated vector is passed through every GnnLayer in order.

Returns one embedding Vec<f64> per node in node-index order.

pub fn aggregate_neighbors( &self, node_id: GnnNodeId, features: &[Vec<f64>], ) -> Vec<f64>

Aggregate the feature vectors of node_id’s neighbours according to the configured aggregation strategy.

Falls back to the node’s own features when it has no neighbours.

pub fn apply_layer(input: &[f64], layer: &GnnLayer) -> Vec<f64>

Apply a single layer (linear transform + bias + activation) to input.

layer.weights must be [output_dim × input_dim]. Rows shorter than input are zero-padded; inputs longer than any row are silently ignored for that row (safe defaults for heterogeneous graphs).

pub fn node_embedding(&self, id: GnnNodeId) -> Result<Vec<f64>, GnnError>

Compute the embedding for a single node.

Errors

• GnnError::EmptyGraph if the graph has no nodes.
• GnnError::NodeNotFound if id is out of range.

pub fn graph_embedding(&self) -> Vec<f64>

Compute the graph-level embedding as the element-wise mean of all node embeddings.

Returns an empty vector if the graph has no nodes or if the node embeddings are empty.

pub fn num_nodes(&self) -> usize

Number of nodes in the graph.

pub fn num_edges(&self) -> usize

Number of directed edges (2 per undirected edge).

pub fn stats(&self) -> GnnStats

Return a statistics snapshot for the current graph state.