Collective Cognition and Sensing in Robotic Swarms via an Emergent Group-Mind

Abstract

Algorithms for robotic swarms often involve programming each robot with simple rules that cause complex group behavior to emerge out of many individual interactions. We study an algorithm with emergent behavior that transforms a robotic swarm into a single unified computational meta-entity that can be programmed at runtime. In particular, a swarm-spanning artificial neural network emerges as wireless neural links between robots self-organize. The resulting artificial group-mind is trained to differentiate between spatially heterogeneous light patterns it observes by using the swarm’s distributed light sensors like cells in a retina. It then orchestrates different coordinated heterogeneous swarm responses depending on which pattern it observes. Experiments on real robot swarms containing up to 316 robots demonstrate that this enables collective decision making based on distributed sensor data, and facilitates human-swarm interaction.

Appendix: High-level Pseudo Code

Each robot in the swarm runs identical code. Two different “main” procedures are presented. The first is for situations in which the output behavior of the swarm does not involve movement or other actions that will break the group mind’s network connectivity (Algorithm 2). The second is for situations in which the output behavior is expected to break connectivity, and so the group mind must organize an orderly dissolution back to a non-group-mind swarm (Algorithm 3). In addition to the main thread, each robot runs a separate message broadcast thread at approximately 2 Hz (Algorithm 4), and has a callback function to receive incoming messages (Algorithm 5), respectively. Global data is accessible across all threads and functions.

The start-up procedure appears in Algorithm 1 and corresponds to the steps in Fig. 2 between “Local ID Agreement” and “Data Upload.” Each robot uses a state machine that is initialized to state $\mathrm {NOT\_YET\_TRAINING}$ (line 1). A Boolean value $done\_training$ is also used to track when training has resulted in an acceptable level of accuracy (on this robot). The battery charge is used to seed a pseudo-random number generator so that different pseudo-random number sequences will be generated on each robot with high probability. A distributed algorithm is used to ensure that neighboring robots have unique randomly determined IDs (line 4). Light sensors are calibrated (line 5). Neighbors are discovered and outgoing wireless links to their neurons are created and initialized with random weights (line 6). Data is uploaded to the swarm from a human user via visual light projection following a predefined procedure (line 7). State $\mathrm {TRAIN}$ indicates the start-up phase has ended (line 8).

The main thread for non-movement cases appears in Algorithm 2. All signals sent along neural connections are tagged with the number of training iterations this robot has completed. The function $\mathrm {out\_of\_sync}()$ returns $\mathbf {true}$ whenever this robot has gotten too many training iterations ahead of its neighbors (100 in our experiments). The backpropogation training algorithm is run one iteration at a time (line 4) — but only if the training error needs improvement and this robot is not out-of-sync with its neighbors (line 3). A robot stops training once its local error has fallen below $5\%$ (lines 5–6). This robot uses the subroutine $\mathrm {use\_group\_mind}(\mathrm {sample\_light()})$ to both provide its current light sensor reading to the group mind, and to learn the group mind’s prediction of the overall swarm behavior $\tau$ that should be performed (line 7). The single robot behavior $behaviour$ this robot performs as part of $\tau$ is also returned, and determined within $\mathrm {use\_group\_mind}(\mathrm {sample\_light()})$ by querying a local look-up table with the value of $\tau$. The look-up table is populated with the local mapping from $\tau$ to $behaviour$ during the data upload portion of the start-up phase.

The main thread used in cases involving movement appears in Algorithm 3. Differences vs. Algorithm 2 (no movement) appear on lines 3 and 8–15. Movement destroys the group mind; thus, movement should only start once the group-mind is highly certain it has calculated the correct response behavior. This is facilitated by adding state $\mathrm {CONSIDER}$ to the state machine, and also by defining one of the behaviors to be “continue training.” In practice, the swarm is trained to continue training in response to a neutral gray light pattern, which is then displayed during the training phase. $\mathrm {CONSIDER}$ can only be accessed once a robot believes the desired behavior is no longer “continue training” (lines 9–12). The function $\mathrm {consideration\_time\_exhausted()}$ is used to ensure a robot remains continuously in state $\mathrm {CONSIDER}$ for a predetermined amount of time before switching to state $\mathrm {ACT}$ to perform the prescribed behavior (lines 11–14). This adds robustness to erroneous outputs from partially trained models.

Algorithm 4 depicts the message broadcast thread. Function $\mathrm {get\_neural\_data()}$ retrieves the neural network data that resides on this robot’s portion of the group mind (line 3). For each training example as well as the real-time environmental sensor input, this includes both the forward neural signals and backpropogation messages (including training iteration number and, for each backpropogation message, the destination ID). Neural data is broadcast, along with this robot’s state and ID (line 4). In practice, due to the Kilobots’ small message payload size (9 bytes), we must divide each batch of neural network data across multiple messages (not shown). If there is movement behavior such that state $\mathrm {ACT}$ is used, then the robot sends this state, its ID, and the swarm behavior class $\tau$ output of the neural network vs. real-time environmental data (lines 5–6). To save space we omit the other message passing details necessary to run the standard distributed algorithms that we employ as subroutines during the start-up phase (represented by lines 7–8).

The receive message callback function appears in Algorithm 5. Normal training data is received on lines 2–5. If a neighbor has decided to act (e.g., move) then this robot will join it (lines 6–9); making sure to perform its own prescribed behavior $behaviour$ relevant to the overall swarm behavior $\tau$ (line 9). The function $\mathrm {modify\_behaviour}(behaviour,sender\_behaviour,sender\_distance)$ is used to modify the specific output behavior of this robot during the $\mathrm {ACT}$ phase, as a function of interaction with neighboring robots (lines 10–14). This enables more complex swarm behaviors to emerge out of the interactions between robots. For example, the smiley faces in our experiments are created as randomly searching robots stop moving in the vicinity of attracting robots. Lines 15–16 represent other message processing that is used for the distributed subroutines within the start-up phase.