ModularGeneral

ModularGeneral#

class braintools.conn.ModularGeneral(intra_conn, inter_conn=None, inter_conn_pair=None, module_ratios=None, **kwargs)#

Modular network using Connectivity instances for both intra and inter-module patterns.

This class creates a modular network structure where:

Intra-module connectivity is defined by a sequence of Connectivity instances
Inter-module connectivity is defined by either a single PointConnectivity instance or a dict mapping (pre_mod, post_mod) tuples to PointConnectivity instances

Parameters:

intra_conn (Sequence[PointConnectivity]) – Sequence of connectivity instances for generating connections within each module. The length of the sequence determines the number of modules.
inter_conn (PointConnectivity | None) – Default connectivity instance for inter-module connections. Applied to all module pairs not specified in inter_conn_pair. If None and a pair is not in inter_conn_pair, that pair is skipped.
inter_conn_pair (Dict[tuple[int, int], PointConnectivity] | None) – Dict mapping (pre_module_id, post_module_id) tuples to PointConnectivity instances for specific inter-module connections. Overrides inter_conn for specified pairs.
module_ratios (Sequence[int | float] | None) –
Ratios or sizes for the first n_modules-1 modules. Length must be n_modules-1. Each element can be:
- int: Fixed size for that module
- float: Proportion of total size (e.g., 0.3 means 30% of total)
The last module gets the remaining neurons. If None, modules are evenly divided.

Examples

>>> from braintools.conn import Random, ModularGeneral, SmallWorld
>>> import brainunit as u

>>> # Different connectivity per module with uniform inter-module connectivity
>>> intra_list = [
...     Random(prob=0.3, weight=1.0 * u.nS),
...     Random(prob=0.5, weight=1.5 * u.nS),
...     SmallWorld(k=6, p=0.3, weight=2.0 * u.nS)
... ]
>>> inter = Random(prob=0.01, weight=0.1 * u.nS)
>>> mod = ModularGeneral(intra_conn=intra_list, inter_conn=inter)
>>> result = mod(pre_size=900, post_size=900)

>>> # Different inter-module connectivity for specific module pairs
>>> default_inter = Random(prob=0.01, weight=0.1 * u.nS)
>>> specific_inter = {
...     (0, 1): Random(prob=0.05, weight=0.2 * u.nS),
...     (1, 2): Random(prob=0.03, weight=0.15 * u.nS),
... }
>>> mod = ModularGeneral(
...     intra_conn=intra_list,
...     inter_conn=default_inter,
...     inter_conn_pair=specific_inter
... )
>>> result = mod(pre_size=900, post_size=900)

>>> # Custom module sizes with fixed sizes
>>> mod = ModularGeneral(
...     intra_conn=intra_list,
...     inter_conn=inter,
...     module_ratios=[200, 300]  # Last module gets remaining 400
... )
>>> result = mod(pre_size=900, post_size=900)

>>> # Custom module sizes with ratios
>>> mod = ModularGeneral(
...     intra_conn=intra_list,
...     inter_conn=inter,
...     module_ratios=[0.2, 0.3]  # 20%, 30%, and remaining 50%
... )
>>> result = mod(pre_size=900, post_size=900)

>>> # Mixed fixed and ratio sizes
>>> mod = ModularGeneral(
...     intra_conn=intra_list,
...     inter_conn=inter,
...     module_ratios=[100, 0.5]  # 100 neurons, 50% of total, and remainder
... )
>>> result = mod(pre_size=900, post_size=900)

generate(**kwargs)[source]#

Generate modular network with custom intra-module connectivity.

Return type:: ConnectionResult

ModularGeneral

Contents

ModularGeneral#