graph.GraphModule

class graph.GraphModule(input_nodes: SetList[GraphNode], output_nodes: SetList[GraphNode], name: str, computational_module: Any)[source]

Bases: GraphModuleBase

Describe a module of computation in a graph

GraphModule acts as a base class for all modules of computation that exist in a computational graph in Rockpool. It minimally holds a set of input nodes input_nodes and output nodes output_nodes that it is connected to, and which are then connected onward to other GraphModule s in the graph.

You should subclass GraphModule to make graph modules that define some specific computation. e.g. a set of weights; a set of spiking neurons with some characteristics. Specific subclasses of GraphModule can be converted between each other as part of the device mapping process. e.g. a set of generic LIF neurons can be converted to a HW specific graph module that defines the configuration of some neurons on a device.

Specific subclasses of GraphModule should ideally be “units” of computation, as in the examples above. The exception is GraphHolder, which is deigned to encapsulate entire graphs or subgraphs.

See also

For an overview of computational graphs in Rockpool, see Computational graphs in Rockpool.

Attributes overview

`input_nodes`	The input nodes attached to this module
`output_nodes`	The output nodes attached to this module
`name`	An arbitrary name attached to this specific `GraphModule`
`computational_module`	The computational module that acts as the source for this graph module

Methods overview

`__init__`(input_nodes, output_nodes, name, ...)
`add_input`(node)	Add a `GraphNode` as an input source to this module, and connect it
`add_output`(node)	Add a `GraphNode` as an output of this module, and connect it
`clear_inputs`()	Remove all `GraphNode` s as inputs of this module
`clear_outputs`()	Remove all `GraphNode` s as outputs of this module
`remove_input`(node)	Remove a `GraphNode` as an input of this module, and disconnect it
`remove_output`(node)	Remove a `GraphNode` as an output of this module, and disconnect it

__init__(input_nodes: SetList[GraphNode], output_nodes: SetList[GraphNode], name: str, computational_module: Any) → None

classmethod _convert_from(mod: GraphModuleBase) → GraphModuleBase[source]

Convert another GraphModule to a GraphModule of this specific subclass

You should override this method in your subclass, to include conversion rules from other graph module classes to your specific subclass.

If you do not provide conversion rules to your specific subclass then it will not be possible to map other GraphModule subclasses to your subclass.

Parameters:: mod (GraphModule) – A GraphModule or GraphModule subclass object to convert to an object of the specific subclass.
Returns:: A converted GraphModule subclass object, of the specific subclass on which this method was called.
Return type:: GraphModule

classmethod _factory(size_in: int, size_out: int, name: str | None = None, computational_module: Any | None = None, *args, **kwargs) → GraphModuleBase

Build a new GraphModule or GraphModule subclass, with new input and output GraphNode s created automatically

Use this factory method to construct a new GraphModule from scratch, which needs new input and output GraphNode s created automatically. This helper method will be inherited by new GraphModule subclasses, and will act as factory methods also for your custom GraphModule subclass.

Parameters:

size_in (int) – The number of input GraphNode s to create and attach
size_out (int) – The number of output GraphNode s to create and attach
name (str, optional) – An arbitrary name to attach to this GraphModule, defaults to None
computational_module (Optional[Module], optional) – A rockpool computational module that forms the “generator” of this graph module, defaults to None

Returns:

The newly constructed GraphModule or GraphModule subclass

Return type:

GraphModuleBase

add_input(node: GraphNode) → None[source]

Add a GraphNode as an input source to this module, and connect it

The new node will be appended after the last current input node. The node will be connected with this GraphModule as a sink.

Parameters:: node (GraphNode) – The node to add as an input source

add_output(node: GraphNode) → None[source]

Add a GraphNode as an output of this module, and connect it

The new node will be appended after the last current output node. The node will be connected with this GraphModule as a source.

Parameters:: node (GraphNode) – The node to add as an output

clear_inputs() → None: Remove all GraphNode s as inputs of this module

clear_outputs() → None: Remove all GraphNode s as outputs of this module

computational_module: Any

The computational module that acts as the source for this graph module

Type:: Module

input_nodes: SetList[GraphNode]

The input nodes attached to this module

Type:: SetList[GraphNode]

name: str

An arbitrary name attached to this specific GraphModule

Type:: str

output_nodes: SetList[GraphNode]

The output nodes attached to this module

Type:: SetList[GraphNode]

remove_input(node: GraphNode) → None[source]

Remove a GraphNode as an input of this module, and disconnect it

The node will be disconnected from this GraphModule as a sink, and will be removed from the module.

Parameters:: node (GraphNode) – The node to remove. If this node exists as an input to the module, it will be removed.

remove_output(node: GraphNode) → None[source]

Remove a GraphNode as an output of this module, and disconnect it

The node will be disconnected from this GraphModule as a source, and will be removed from the module.

Parameters:: node (GraphNode) – The node to remove. If this node exists as an output to the module, it will be removed.