Skip to content

Specification explanation of 24 node configuration

[!NOTE] For the latest implementation status, please refer to Functional Implementation Status (Remaining Functionality).

Creation date: 2026-01-12

overview

We will explain the system specifications of a 24-node full brain configuration in distributed brain simulation. This configuration is suitable for small to medium-scale distributed brain experiments, and realizes a complete brain function simulation with each role appropriately placed.

System configuration overview

  • Total number of nodes: 24 nodes
  • Architecture: Hierarchical distributed architecture
  • Communication protocol: Zenoh-based asynchronous communication
  • Consensus Algorithm: Distributed consensus-based decision making

Implementation Note: See docs/implementation/ARTIFACT_MANIFESTS.md for model artifact specifications.

Architecture Overview

Hierarchical structure

The 24 node configuration consists of the following 7 tiers:

  1. Input Layer: Sensor data collection and initial processing
  2. Processing Layer: Data encoding and inference
  3. Decision Layer: Task control and behavior generation
  4. Memory Layer: Vector retrieval and storage management
  5. Learning Layer: Model update and learning
  6. Aggregation Layer: Result aggregation and federated learning
  7. Management Layer: Monitoring, Authentication, Log Management

Node distribution specifications

Role Number of nodes Main functions Communication pattern
PFC node (Prefrontal Cortex) 1 High-level decision making, Q-PFC feedback control Consensus-based
Observation node (Sensing) 3 Sensor data collection, multimodal input processing Broadcast
Encoders 4 Data encoding, feature extraction Pipeline
Inference node (Inference/LM) 5 Language model inference, predictive calculation Request/Response
Decision making/action node (Planner/Controller) 2 Task control, action plan generation Consensus-based
Memory node (Vector DB/Retriever) 7 Vector retrieval, long-term memory management, episodic memory, semantic memory Query-based
Learning node (Trainer/Updater) 1 Model update, gradient calculation Batch processing
Aggregator/Federator node (Aggregator/Federator) 2 Result aggregation, federated learning coordination Aggregate communication
Administration/Utilities (Monitoring/Auth/Ethics) 3 System monitoring, authentication, ethics monitoring, log collection Control communications

system configuration diagram

Node ↔ RANK mapping (implementation reference: evospikenet/node_types.py)

Correspondence table between Rank and nodes based on implementation definition (Rank 0 to 23, total 24 nodes). The documentation certifies this implementation as correct.

  • RANK 0: Prefrontal Cortex (PFC) — Execution control node (pfc)
  • RANK 1: Primary Visual Cortex (V1) — Visual node
  • RANK 2: Secondary Visual Cortex (V2) — Visual Node
  • RANK 3: Visual Area V4 — Visual Node
  • RANK 4: Inferior Temporal Cortex (IT) / Language processing — Language/visual coupling node
  • RANK 5: Primary Auditory Cortex (A1) — auditory node
  • RANK 6: Secondary Auditory Cortex (A2) — auditory node
  • RANK 7: Dorsal Stream 1 — Visual/motion coordination node
  • RANK 8: Dorsal Stream 2 — Visual/motion coordination node
  • RANK 9: Dorsal Stream 3 — Visual/motion coordination node
  • RANK 10: Primary Motor Cortex (M1) — Motor node
  • RANK 11: Premotor Cortex — Motor Node
  • RANK 12: Cerebellum — Movement/Coordination Node
  • RANK 13: Superior Temporal Gyrus 1 (STG1) — Auditory/Language Node
  • RANK 14: Superior Temporal Gyrus 2 (STG2) — Auditory/Language Node
  • RANK 15: Superior Temporal Gyrus 3 (STG3) — Auditory/Language Node
  • RANK 16: Superior Parietal Lobule — Spatial processing node
  • RANK 17: Occipitoparietal Junction — Spatial processing node
  • RANK 18: Broca's Area — Speech generation/utterance planning node
  • RANK 19: Wernicke's Area — Language Understanding Node
  • RANK 20: Memory Node (hippocampal-like) — Memory/episode storage
  • RANK 21: Memory Node (hippocampal-like) — Memory/Semantic Memory
  • RANK 22: Decision / Additional Executive Node — Additional decision-making node
  • RANK 23: Decision / Additional Executive Node — Additional decision-making node

Note: The above mapping directly reflects the constant definitions (RANK_*, NODE_TYPE_DEFINITIONS) in evospikenet/node_types.py. Node allocation and activation in a real environment depends on the NodeDiscovery service and configuration files.

graph TD
    subgraph "Input Layer"
        S1[Sensing Node 1]
        S2[Sensing Node 2]
        S3[Sensing Node 3]
        S4[Sensing Node 4]
    end

    subgraph "Processing Layer"
        E1[Encoder Node 1]
        E2[Encoder Node 2]
        E3[Encoder Node 3]
        E4[Encoder Node 4]
        I1[Inference Node 1]
        I2[Inference Node 2]
        I3[Inference Node 3]
        I4[Inference Node 4]
        I5[Inference Node 5]
        I6[Inference Node 6]
    end

    subgraph "Decision Layer"
        P1[Planner Node 1]
        P2[Planner Node 2]
    end

    subgraph "Memory Layer"
        M1[Memory Node 1]
        M2[Memory Node 2]
        M3[Memory Node 3]
    end

    subgraph "Learning Layer"
        T1[Trainer Node]
    end

    subgraph "Aggregation Layer"
        A1[Aggregator Node 1]
        A2[Aggregator Node 2]
    end

    subgraph "Management Layer"
        Mon[Monitoring Node]
        Auth[Auth Node]
    end

    S1 --> E1
    S2 --> E2
    S3 --> E3
    S4 --> E4

    E1 --> I1
    E2 --> I2
    E3 --> I3
    E4 --> I4

    I1 --> P1
    I2 --> P1
    I3 --> P2
    I4 --> P2
    I5 --> P1
    I6 --> P2

    P1 --> M1
    P2 --> M2

    M1 --> T1
    M2 --> T1
    M3 --> T1

    T1 --> A1
    A1 --> A2

    A2 --> Mon
    Mon --> Auth

Detailed specifications of each layer

Input Layer (observation layer)

Purpose: Sensor data collection and initial processing from external environment

Node specifications: - Number: 4 nodes - Features: - Multimodal sensor data collection (visual, auditory, tactile, etc.) - Real-time data filtering - Outlier detection and removal - Communication: Data distribution using broadcast method

Processing Layer

Purpose: Data encoding, inference processing, and advanced spatial cognition/generation.

Node specifications: - Encoder Nodes: 4 nodes - Function: data encoding, feature extraction - Algorithm: TAS-Encoding, Spike Encoding - Inference Nodes: 6 nodes - Features: Language model inference, predictive calculation - Model: Transformer-based LLM

Feature 13: Advanced Spatial Processing Node (Spatial Processing - Rank 12-15) ✅ New implementation completed

Advanced spatial recognition and generation system implemented in EvoSpikeNet's distributed brain system (completed on 2026-02-17). These nodes simulate the visual processing pathways of the biological brain.

Implementation file: spatial_processing.py (891 lines)

Node Rank Brain Region Role Output Delay State
SpatialWhereNode 12 Dorsal parietal lobe Spatial position/distance/depth recognition Spatial coordinates, depth map <50ms ✅ Implementation
SpatialWhatNode 13 Visual cortex/temporal cortex Object recognition, scene understanding Class probability, attributes <30ms ✅ Implementation
SpatialIntegrationNode 14 Occipito-Parietal Junction What-Where Integration Integrated Representation, World State <50ms ✅ Implementation
SpatialAttentionControlNode 15 Fronto-orbital area Attention control, Saccade planning Attention map, target location <30ms ✅ Implementation

Major components: - ✅ CoordinateTransformer: Coordinate system transformation (Egocentric ↔ Allocentric) - ✅ DepthEstimationNetwork: Monocular depth estimation (CNN 3500+ lines) - ✅ SpatialCoordinateEncoder: 3D coordinate → spike expression conversion - ✅ DistributedSpatialCortex: Rank 12-15 Integrated System

Test statistics (tests/integration/test_distributed_brain_simulation.py): - Spatial Integration Test: 5+ cases - E2E pipeline testing: 2+ cases - Performance profiling: 3+ cases - Pass rate: 100% (17+ total tests)

Performance results: - Where path latency: ~47ms (target <50ms) ✅ - What Path Latency: ~28ms (Target <30ms) ✅ - Integrated path latency: ~48ms (target <50ms) ✅ - Attention control: ~25ms (target <30ms) ✅

Detailed specifications: DISTRIBUTED_BRAIN_SPATIAL_NODES.md (v2.0)

Communication: Zenoh PubSub (spikes/spatial/where/*, spikes/spatial/what/*, spikes/spatial/integration/*, spikes/spatial/attention/*)

Decision Layer

Purpose: Task control and action plan generation

Node specifications: - Number: 2 nodes (redundant configuration) - Features: - Task priority determination - Action plan generation - Resource allocation - Algorithm: Distributed consensus-based decision making - Communication: Consensus protocol

Memory Layer

Purpose: Vector retrieval and long-term memory management

Node specifications: - Number: 3 nodes - Features: - Vector database management - Similarity search - Long-term memory storage and retrieval - Storage: Milvus or similar vector DB - Communication: Query-based search requests

Learning Layer

Purpose: Continuously train and update models

Node specifications: - Number: 1 node - Features: - Online learning - Model parameter update - Gradient calculation and optimization - Algorithm: Federated Learning, Meta-STDP - Communication: Batch processing based

Aggregation Layer

Purpose: Aggregation of results from each node and overall coordination

Node specifications: - Number: 2 nodes (redundant configuration) - Features: - Aggregation of inference results - Coordination of federated learning - Whole system synchronization - Algorithm: Distributed aggregation algorithm - Communication: Aggregate communication protocol

Management Layer

Purpose: System-wide monitoring and management

Node specifications: - Monitoring Node: 1 node - Function: performance monitoring, anomaly detection - Auth Node: 1 node - Features: Authentication, authorization, log management - Communication: Control communication and monitoring data collection

Consensus algorithm specification

Quorum calculation

The minimum number of votes \(q\) required for consensus in the decision-making layer is calculated by the following formula:

\[ q = \lceil N \times t \rceil \]

where: - \(N\): Total number of nodes (24) - \(t\): Consensus threshold (0.67) - \(\lceil \cdot \rceil\): Ceiling function (round up)

Implementation example:```python import math required_votes = math.ceil(self.num_nodes * self.consensus_threshold)

24 * 0.67 = 16.08 → 17 (rounded up)

```

Consensus process

  1. Suggestion Phase: Planner node generates action suggestions
  2. Voting Phase: All nodes vote on the proposal
  3. Aggregation phase: Aggregator node aggregates votes
  4. Decision phase: Accept proposals beyond quorum

Resource requirements specification

Resource allocation for each node type

Node type CPU (cores) GPU (VRAM) Memory (GB) Storage (GB) Network
Sensing 2-4 - 4-8 50 1GbE
Encoder 4-8 8GB 16-32 100 10GbE
Inference 8-16 24GB 64-128 200 10GbE
Planner 4-8 4GB 16-32 100 10GbE
Memory 4-8 - 32-64 1000+ 10GbE
Trainer 16-32 48GB+ 128-256 500+ 40GbE
Aggregator 8-16 8GB 32-64 200 40GbE
Management 2-4 - 8-16 100 1GbE

Total System Requirements

Total resource estimate for 24 node configuration: - CPU: Approximately 200-300 cores - GPU: Approximately 100-150 GB VRAM - Memory: Approximately 500-1000 GB - Storage: Approximately 5-10 TB - Network: 40GbE backbone + 10GbE access

Communication specifications

Protocol layer

  1. Application Layer: Task-specific message formats
  2. Session layer: Zenoh-based Pub/Sub communication
  3. Transport layer: TCP/UDP + TLS encryption
  4. Network layer: IPv4/IPv6 compatible

Communication pattern

  • Broadcast: Sensor data distribution
  • Pipeline: Sequential processing data flow
  • Request/Response: Inference query
  • Consensus: Voting-based consensus building
  • Query: Vector search request
  • Batch: Learning data transfer
  • Aggregation: Result collection communication
  • Control: Management/monitoring communication

Security specifications

Authentication/Authorization

  • API key authentication: Inter-service communication
  • TLS 1.3: Transport layer encryption
  • RBAC (Role-Based Access Control): Node privilege management
  • Audit log: All access records

Threat Prevention

  • Input Validation: Malicious data removal
  • Rate Limit: DoS attack prevention
  • Encryption: Protect sensitive data
  • Redundancy: Avoiding single points of failure

Scalability considerations

Extensibility

  • Horizontal scaling: homogeneous nodes can be added
  • Vertical Scaling: Supports resource augmentation
  • Dynamic reconfiguration: Add/remove nodes at runtime

Performance indicators

  • Throughput: \(\text{Throughput} = \frac{\text{Total Operations}}{\text{Time}}\)
  • Average Latency: \(\text{Avg Latency} = \frac{1}{N} \sum_{i=1}^{N} \text{Latency}_i\)
  • Maximum Latency: \(\text{Max Latency} = \max(\text{Latency}_1, \dots, \text{Latency}_N)\)

Operational guidelines

Boot sequence

  1. Management Layer (Auth, Monitoring) startup
  2. Start Aggregation Layer
  3. Start Memory Layer
  4. Start Learning Layer
  5. Start Decision Layer
  6. Start Processing Layer
  7. Start Input Layer

Monitoring points

  • CPU/memory usage rate for each layer
  • Network latency and throughput
  • Consensus arrival time
  • Error rate and retry count

*This specification is based on the design as of 2025-12-21. Updates are required due to implementation changes. *