C OORDINATION A MONG N EURAL M ODULES T HROUGH A S HARED G LOBAL W ORKSPACE
A BSTRACT
Deep learning has seen a movement away from representing examples with a monolithic hidden state towards a richly structured state.
For example, Transformers segment by position, and object-centric architectures decompose images into entities.
In all these architectures, interactions between different elements are modeled via pairwise interactions: Transformers make use of self-attention to incorporate information from other positions and object-centric architectures make use of graph neural networks to model interactions among entities.
We consider how to improve on pairwise interactions in terms of global coordination and a coherent, integrated representation that can be used for downstream tasks.
In cognitive science, a global workspace architecture has been proposed in which functionally specialized components share information through a common, bandwidth-limited communication channel.
We explore the use of such a communication channel in the context of deep learning for modeling the structure of complex environments.
The proposed method includes a shared workspace through which communication among different specialist modules takes place but due to limits on the communication bandwidth, specialist modules must compete for access.
We show that capacity limitations have a rational basis in that (1) they encourage specialization and compositionality and (2) they facilitate the synchronization of otherwise independent specialists.
I NTRODUCTION
[Figure]
Deep Learning has seen a movement towards more structured models with cleaner separation between different pieces of information often handled by different components.
The induced structure, and separation of knowledge has improved generalization, model-size scaling, and long-range dependencies (Berner et al., 2019;
Vinyals et al., 2019; Brown et al., 2020).
This opens up questions about how to achieve coherence and coordination between different components in such architectures.
Looking back to the 1980s, the focus in AI was much less on learning and more on constructing articulated, multi-component architectures and examining how intelligence might emerge from interactions among this collection of simple, functionally specialized components (Fodor, 1983; Braitenberg, 1986; Minsky, 1988; Brooks, 1991).
Each of these specialist modules is on the scale of a typical component of a computer program, like a subroutine that implements a narrow, prespeciﬁed function from certain input contents to certain output contents.
Through appropriate communication and coordination, a set of specialists can achieve complex, dynamic, and ﬂexible behavior patterns.
As a concrete illustration, consider the task of driving a car in terms of specialists.
One specialist might monitor the position of the car with respect to lines on the road, and another specialist might adjust the steering direction based on the perceptual data.
In addition, there might be specialists which provide alerts when certain events occur, such as loud sounds, reaching a critical intersection on a route, or coming into close proximity to the car in front.
To execute the task of driving the car properly, all these specialists need to interact coherently and broadcast their individual information to each other.
Arguably, modern ML and AI has yet to develop broad architectural frameworks for learning both the specialist modules and how they should interact , while the classical view lacks an articulate story about how learning could take place successfully in such frameworks.
In this article, we revisit this classical view with modern machine learning tools based on end-to-end learning and differentiable memory and attention mechanisms.
Inspired by the Global Workspace Theory (Baars, 1993; Dehaene et al., 1998; Shanahan and Baars, 2005; Shanahan, 2006; 2010; 2012; Dehaene et al., 2017) from cognitive neuroscience, we argue that more ﬂexibility and generalization emerge through an architecture of specialists if their training encourages them to communicate effectively with one another via the bottleneck of a shared workspace (Figure. 1).
Distributed specialist modules.
From a computational perspective, articulated multi-component architectures composed of sparsely interacting specialist modules show desirable scaling properties (e.g., more specialists can seamlessly be added), increased robustness (the system can tolerate the removal of or changes in individual specialists), and efﬁciency (information is processed predominantly locally, reducing the cost of communication between specialists).
However, modularization also requires mechanisms to establish sharing of compatible representations across specialists, a form of shared internal language.
While portions of a task might be solved by independent specialists, synchronization is critical particularly when there are statistical, functional, or causal dependencies among the specialists.
Coherence through a shared workspace.
In cognitive neuroscience, the Global Workspace Theory (GWT) (Baars, 1993; Dehaene et al., 2017) suggests an architecture allowing specialist modules to interact.
The key claim of GWT is the existence of a shared representation—sometimes called a blackboard, sometimes a workspace—that can be modiﬁed by any specialist and that is broadcast to all specialists, along with the notion that write access is limited to maintain coherence.
Our interpretation of this restriction on write access is that it stems from an assumption on the form of the joint distribution between high-level concepts.
In this paper, we explore a communication and coordination scheme similar to the one proposed by GWT for modern neural network architectures like Transformers (Vaswani et al., 2017; Dehghani et al., 2018; Parmar et al., 2018;
Radford et al., 2019; Brown et al., 2020) and attention-based modular architectures (Goyal et al., 2019; Rahaman et al., 2020;
Mittal et al., 2020a; Goyal et al., 2020; Madan et al., 2021).
In terms of our driving example, the workspace could be used to override default behaviors by giving high priority to specialist modules which provide alerts of various sorts (loud sounds, presence of a child on the street), allowing specialists which respond to such alerts to take control of behavior over default driving routines.
This scenario implies that prioritization of signals in a shared workspace is critical.
A shared communication channel necessitates common representations.
For a multitude of specialist modules to cooperate, a common language is necessary (Baars, 1997).
For example, in the driving scenario, alerts may come from auditory or visual processing specialists, but regardless of the source, a signal for danger must be placed in the workspace to override default behavior, whether that behavior is controlled by a radio-tuning specialist or a steering specialist.
Although specialist modules can be pre-wired to have compatible communication interfaces, we will model an architecture in which an ensemble of specialist modules is trained in coordination , which should lead to a shared language (Colagrosso and Mozer, 2005).
Internally, individual specialists can use whatever form of representations that serves them, but their inputs and outputs require alignment with other specialists in order to synchronize.
For example, an unusual event such as a rough thud under the wheels might not have been previously experienced, but the mere signalling of novelty
[Figure]
o m pu t a t i o n
[Figure]
o
[Figure]
pu t a t
i
[Figure]
n
[Figure]
C o m pu t a t i o n
[Figure]
S h a r e d W o r k s p a c e } }
[Figure]
t a t i o n
[Figure]
( 1 ), specialists compete for write access to the shared workspace, resulting in a subset of them being activated (in blue), and only the activated specialists perform the write operation on the workspace.
In the second step ( 2 ), the contents of the shared workspace are broadcast to all the specialists.
could override default specialists.
Without a global communication channel, specialists would have to learn to communicate through pairwise interactions, which might limit coordination of behavior in novel situations: global communication ensures exchangeability of knowledge to achieve systematic generalization.
S YNCHRONIZING NEURAL MODULES THROUGH A SHARED WORKSPACE
We investigate a neural architecture reminiscent of the GW model, where a number of sparsely communicating specialist modules interact via a shared working memory.
In particular, we extend the Transformer (Vaswani et al., 2017), attention and slot-based modular architectures (Goyal et al., 2019) by adding a shared workspace and allowing modules (each representing an entity) to compete for write access in each computational stage.
Key-value attention.
Key-value attention deﬁnes the backbone of updates to the hidden states in the proposed model.
This form of attention is widely used in self-attention models and performs well on a wide array of tasks (Bahdanau et al., 2014; Vaswani et al., 2017; Santoro et al., 2018).
Key-value attention selects an input value based on the match of a query vector to a key vector associated with each value.
To allow differentiability and thus easier learnability, selection is soft and computes a convex combination of all the values.
Such a mechanism makes it possible to change on-the-ﬂy both the source of input and how the shared workspace is updated.
It also makes the outputs of the specialists and the elements of the memory permutation invariant: they should be considered as an unordered set of elements to be selected by an attention mechanism from the contents of specialists.
More precisely, soft attention uses the product of a query (represented as a matrix Q of dimensionality
N r × d , with N r queries, and d the dimension of each query) with a set of N o objects each associated with a key as a row in matrix K T ( N o × d ).
After normalization with a softmax the resulting convex weights are used to combine the values V i (row i of matrix V ): where the softmax is applied to each row of its argument matrix, yielding a set of convex weights.
For our experiments, we use multihead dot product attention.
Neural modules with pairwise interactions.
Our approach to synchronizing neural modules is highly general and mostly agnostic to the task, domain, or speciﬁc choice of architecture, with the only requirement being that the model consists of multiple specialist modules which either operate independently or have sparse interactions requiring to only match pairs of modules at a time.
Our goal is to explore how introducing a shared workspace can help these modules to become better synchronized and coordinated.
We show the utility of the shared workspace for synchronization in (a)
Transformers (Vaswani et al., 2017), in which all interactions between positions are performed via attention, and (b) slot-based architectures like Recurrent Independent Mechanisms or RIMs (Goyal et al., 2019) in which all pairwise interactions between modules are performed via attention.
In the context of slot-based architectures, each slot’s content is associated with a specialist module, whereas in Transformers different entities each associated with a different position acts as a specialist module (Figure 2).
Both Transformers and RIMs utilize a self-attention mechanism for sharing information between modules, typically implemented in a pairwise manner, i.e., each specialist attends to every other specialist.
Instead, we facilitate information sharing among specialist modules through a limited capacity shared workspace .
In this framework at each computational stage, different specialists compete for write access to the common workspace.
The contents of the workspace, in turn, are broadcast to all specialist modules simultaneously.
Notation.
The input is processed through a sequence of computational stages indexed by t , and at each stage, n s entities are operated on (i.e., n s different modules in slot-based architectures like
RIMs or n s different positions in the case of Transformers).
Each of these n s specialist modules has a distinct internal n h -dimensional state h kt , for k ∈ { 1 , ..., n s } .
The specialist modules communicate with each other via a shared workspace divided into n m memory slots , each consisting of a vector of n l elements, denoted M =
[ m 1 ; . . .
m
j ; . . .
m n m ] .
The shared workspace is updated across different computational stages i.e., different time-steps in recurrent architecture and different layers in the case of Transformers.
At each computational stage t , different specialists compete for writing in the shared workspace, but all specialists can read from the current state of the workspace.
In the case of an autoregressive task, we can restrict the information sharing to previous positions and keep a separate version of the workspace for each position.
2. S PECIFICS OF THE S HARED W ORKSPACE .
Step 1: Process Input to obtain an entity representation for each specialist.
The ﬁrst step is external to the proposed method, and involves processing the input to form the initial representation vector for each of the different specialists.
Different common deep learning architectures can be used to form the representation of different specialists.
For example, Transformers start with a matrix n s × n h whose rows are initialized as the n h -dimensional embeddings of the input at each position of the sequence.
Slot-Based Recurrent architectures like RIMs consist of a single-layer recurrent structure where the hidden state h t at computational stage t is decomposed into the substates of the n s specialists, h kt for k = 1 , ...n s .
In the proposed scheme, within each computational stage, the updates of the hidden state of different specialists follow a two-step process.
First, specialists compete and write to a shared workspace.
Second, information from the workspace gets broadcast to all the specialists, as detailed next.
Step 2: Writing Information in the shared workspace.
The specialists compete to write into the shared workspace, whose contents need to be updated in the context of new information received from different specialists.
This step ensures that only the critically important signals make it to the shared workspace, therefore preventing the workspace from being cluttered.
Let matrix R represent the combined state of all the specialists (i.e. h kt ∀ k ∈ { 1 , . . .
, n s } as the rows of R ).
In order to implement the competition between specialists to write into the workspace, we use a key-query-value attention mechanism.
In this case, the query is a function of the state of the current workspace memory content, represented by matrix M (with one row per slot of the memory), i.e (cid:101) Q = M (cid:102) W q .
Keys and values are a function of the information from the specialists i.e., a function of R .
We apply dot product attention to get the updated memory matrix: M ← [Equation]
The use of a regular softmax to write into M leads to a standard soft competition among different specialists to write in the shared workspace.
One can also use a top- k softmax (Ke et al., 2018) to select a ﬁxed number of specialists allowed to write in the shared workspace: based on the pre-softmax values, a ﬁxed number of k specialists which have the highest values are selected, and get access to write in the shared workspace.
Selection with a top- k softmax is a hybrid between hard and soft selection.
We denote the set of thus selected specialists as F t .
We note that we can apply the attention mechanism multiple times to distill information from different specialists into the shared workspace.
Here, the contents of the shared workspace are updated in the gated way as proposed in RMC (Santoro et al., 2018).
We ask the reader to refer to appendix section C for more details.
Step 3: Broadcast of information from the shared workspace.
Each specialist then updates its state using the information broadcast from the shared workspace.
We again utilize an attention mechanism to perform this consolidation.
All the specialists create queries (cid:98) q k = h kt (cid:99) W q , which are matched with the keys (cid:98) κ j = ( m j (cid:99) W e ) T ∀ k ∈ { 1 , . .
. , n s } , j ∈ { 1 , . .
. , n m } from the updated memory slots, forming attention weights s k,j = softmax (cid:16) (cid:98) q k (cid:98) κ j √ d e (cid:17) .
The memory slot values generated by each slot of the shared workspace and the attention weights are then used to update the state of all the specialists: h kt ← h kt + (cid:80) j s k,j (cid:98) v j where (cid:98) v j = m j (cid:99) W v ∀ k ∈ { 1 , . .
. , n s } .
After receiving the broadcast information from the workspace, each specialist update their state by applying some dynamics function i.e., one step update of LSTM or GRU units in the case of recurrent architectures, and a feedforward layer in the case of Transformers.
This yields the new value h kt +1 for the k -th specialist, from which we start the next stage ( t + 1 ).
Replacing pairwise interactions among neural modules with interaction facilitated by the shared workspace allows for the following:
Higher-order (HO) interaction among neural modules.
The two-step write-read process ﬁrst allows each memory slot to store a ‘ﬁltered summary’ of the current input where the ‘ﬁlter’ is determined by the previous state of that slot (‘Query’ for the write step).
Neural modules then summarize the information contained in these slots and update their state.
Hence unlike pairwise interaction, messages passed among neural modules in the shared workspace setting also include HO interaction terms; those consisting of more than 2 modules at a time.
Naturally, HO interaction require that messages passed among neural modules lie in the same representation space, which is precisely what we aim to achieve by allowing message passing only via a singular global channel.
Dynamic ﬁltering due to persistence of memory.
With a shared workspace (SW), contents of the memory slot play a key role in ﬁltering and summarizing the information contained in the input at a given time step.
Persistence of memory throughout an episode 1) would allow the memory layer to summarize and ﬁlter information based on what it has seen thus far 2) should ideally lead to better generalization as the model is able to dynamically modify its ﬁltering machinery for a particular input.
In contrast, “inducing points” in Set Transformers (Lee et al., 2019) are ﬁxed after training and hence the bottleneck cannot adjust itself on the ﬂy for any new input.
We present comparisons on several tasks in section 4.
They show the importance of these two properties by comparing performance of SW with a) 2 × Self-Attention (to simulate HO interaction without global communication) b) a version without memory persistence, in Appendix D.
Computational Complexity of using shared workspace for synchronizing different specialists.
To encourage a coherent global coordination, Transformers and slot-based recurrent architectures rely on pairwise interactions captured via an attention mechanism.
Unfortunately, such attention mechanisms scale quadratically with the number of specialists.
Here, we propose a method which uses a shared workspace to create global coherence between different specialists and in the process, replaces the pairwise interactions of conventional dot-product attention.
The computational complexity of the proposed method is thus linear in the number of specialists.
In our experimentation, the number of memory slots is practically constant, which suggests a very favourable scaling behavior, and certainly much less than quadratic.
As a point of reference, what would correspond to the number of slots in human working memory (Baars, 1993) is indeed very small (less than 10 slots).
R ELATED W ORK
This work taps into a line of reasoning put forward by historical works, such as Minsky (1988);
Braitenberg (1986); Fodor (1983), wherein it is argued that in order to be able to deal with a wide spectrum of conditions and tasks, an intelligent system should be comprised of many interacting specialized modules or programs, rather than a single “one-size-ﬁts-all” entity.
While modular architectures have been the subject of a number of research directions, (Jacobs et al., 1991; Bottou and Gallinari, 1991; Ronco et al., 1997; Reed and De Freitas, 2015; Andreas et al., 2016; Rosenbaum et al., 2017; Fernando et al., 2017; Shazeer et al., 2017; Rosenbaum et al., 2019; Goyal and Bengio, , we focus here on a mechanism for achieving coherence and synchronization between specialist modules via a global workspace shared between all specialists.
Prior works have explored incorporating slot-based memory in the context of recurrent neural networks (Graves et al., 2014; 2016;
Santoro et al., 2018).
In the context of transformers, Burtsev and
Sapunov (2020) introduce memory tokens that are processed in addition to sequence tokens, whereas
Dai et al.
(Transformer-XL) propose to partition a long sequence to smaller segments and use the activations of the previous segment in memory while processing the current segment.
Building on the latter, Rae et al.
(2019) propose to store activations from prior segments in a compressed memory.
However, these methods do not restrict memory writes to be sparse and competitive.
Recent advances in this direction include the global neuronal workspace (GNW) model (Dehaene and Changeux, 2011), which identiﬁes the global workspace with a large network of excitatory pyramidal neurons with long-range axonal processes connecting prefrontal and parietal cortices.
Further, deploying a shared workspace to establish coherence between different specialists as opposed to using all-pair communication has an added beneﬁt, in that it allows us to tackle the O ( n 2 ) complexity of selfattention.
This makes our work related to previous work on reducing the computational complexity of dot product attention in Transformers.
Lee et al.
(2019) introduce the ISAB module, which maps between sets and comprises two dot-product attention layers.
In the ﬁrst layer, a set of trainable parameters are used as queries and the elements of the input set as keys; in the second layer, the output of the ﬁrst layer is used as keys and the input set as queries.
However, unlike in this work, the intermediate states (corresponding to the output of the ﬁrst layer) are not maintained across layers.
Concurrent to our work, (Jaegle et al., 2021) also introduced the idea of using a latent bottleneck for addressing quadratic complexity by learning a bottleneck but there are important differences.
For example.
in Perceiver the latent bottleneck iteratively queries the information about different positions, and does not maintain the representation of the different specialists.
More precisely, in our proposed method different specialists write information in the workspace and then information gets read from the shared workspace.
In Perceiver, the latent bottleneck iteratively reads information from the set of positions.
We also show the applicability of the proposed idea both for slot based models and Transformers.
The proposed model can also be seen as integrating out different ideas popular in modular architectures (Andreas et al., 2016;
Goyal et al., 2019), memory networks (Graves et al., 2014;
Santoro et al., 2018) and mixture of experts (Jacobs et al., 1991), and hence combining some of their beneﬁts in a uniﬁed architecture.
The proposed model is factored as a set of specialists (incorporating modularity).
The proposed model achieves coordination among different specialists via the use of a shared workspace (in the Neural Turing machines, there is only a single specialist i.e., without any modularity).
Multiple experts can be active at the same time (generally not the case with a mixture of experts).
E XPERIMENTS
Here we brieﬂy outline the tasks on which we applied the idea of the shared workspace and direct the reader to the appendix for some more experiments (Appendix G), full details on each task and details on hyperparameter settings for the model.
The experiments have the following goals: (a)
Demonstrate that the use of the shared workspace can improve results on a wide array of challenging benchmark tasks, with the goal of demonstrating the practical utility and breadth of the technique.
(b) Show that the shared workspace addresses coherence between different specialists by achieving improved performance without requiring all pairwise interactions.
Finally, to show wide applicability of our model, we integrate SW in TIMs (Lamb et al., 2021), SCOFF (Goyal et al., 2020) and BRIMs (Mittal et al., 2020b) and show improvements over the default communication method used in each.
Making sense of the visual input.
Using a shared workspace introduces a bottleneck in sharing of information between specialists.
Since the size of the workspace is limited and generally much lower than the number of specialists, there is a limit to the amount of information that can be exchanged among specialists.
We hypothesize that mediating communication through a limited capacity workspace should encourage the model to look at relevant information that is important for the downstream objective.
We test this hypothesis on a set of visually challenging benchmarks.
For our experiments, we use either Transformers or RIMs as a backbone.
We consider variants of Transformers based on different subsets of important properties.
Transformers [TR]: Self-attention based multi-layer architecture (Vaswani et al., 2017) with shared parameters across layers.
Set transformer [ISAB]: Transformers where self attention is replaced by ISAB module (Lee et al., 2019).
Sparse
Here, we compare the performance of the Transformers with shared workspace to other Transformer baselines.
Here, we plot the test accuracy for each model.
[Table] Transformers [STR]: Transformers with sparse factorizations of the attention matrix (Child et al., 2019).
High Capacity Transformers [TR+HC]:
Same as TR but with different parameters across layers.
Transformers with Shared Workspace with soft-competition [TR+SSW]: Transformers with different positions competing with each other to write in shared workspace using soft-competition.
Transformers with Shared Workspace with top- k competition [TR+HSW]: Transformers with different positions competing with each other to write in shared workspace using top- k competition.
For a more detailed description of all the tasks described below, we ask the reader to appendix section E.
Detecting Equilateral Triangles .
We ﬁrst use a simple toy task to test our hypothesis where the model should detect equilateral triangles in images (Ahmad and Omohundro, 2009).
Each image is of size 64 × 64 and contains 3 randomly placed clusters of points.
For equilateral triangles, the midpoints of these clusters are equidistant from each other.
This is a binary classiﬁcation task where the model has to predict whether the three given clusters form an equilateral triangle or not.
To feed an image into a Transformer, we follow the same methodology as used in vision Transformers (Dosovitskiy et al., 2020).
We ﬁrst divide an image into equal sized 4 × 4 patches and treat each patch as a different input position of the Transformer.
To solve this task correctly, the model only needs to attend to relevant information i.e., to patches that contain the cluster of points.
Therefore, using a limited capacity shared workspace should be useful here.
Our results (presented in Figure 3) conﬁrm this hypothesis.
We can see that Transformers with shared workspace attention converge much faster and reach higher accuracy as compared to the baseline Transformer .
Our method also outperforms Set Transformer by a signiﬁcant margin.
Multi MNIST Generation.
In this task, we train an Image Transformer (Parmar et al., 2018) (pixelby-pixel, raster-order generative model) for next-pixel prediction on the “MultiMNIST dataset” where each image consists of 4 independently sampled MNIST digits stacked horizontally to form one image (see Figure 10 for demonstration).
The main aim of this task is to observe the inductive biases that allow for specialization of mechanisms in TIMs (Lamb et al., 2021).
Each image in the MultiMNIST dataset can be broken down into different sets of independent spatial components.
Since the digits which make up the image are independently selected, the joint distribution of pixel intensities in any one of the four sections of the image is statistically independent of the pixel intensities in any other section of the image.
Moreover each section of the image can be further broken down into independent spatial components: one that pertains to the background and one that pertains to the foreground.
One can expect that architectures that are made up of sparsely interacting different mechanisms to naturally capture this statistical independence by dividing labour among different mechanisms.
While, for monolithic architectures, a major portion of their training time will be spent in learning these statistical independencies from scratch.
We ﬁnd that replacing the pairwise communication in TIMs with a shared workspace (TIMs + SW) leads to better and more interpretable division of labor among specialists as shown in Figure 5.
From the ﬁgure, It is clear that the TIMs model is unable to divide labour among specialists with mechanism 2 being activation for all the pixels in the image.
On the other hand, we can see that TIMs + SW is able to divide labor among specialists with each mechanism focusing on a different aspect of the image.
We can see that mechanism 2 gets activated for the digits which are present towards the centre of each of thecolumns while mechanisms 3 and 4 cover the background of the digits, with mechanism 3 covering the area between adjacent digits and mechanism 4 covering the area above and below the digits.
Thus, we can see that using a shared workspace aids the division of labor among different specialists.
We also ﬁnd that TIMs + SW results in the least cross-entropy loss in the test set when compared to TIMs and Image Transformers (Parmar et al., 2018).
Results shown in appendix Table 5.
[Figure]
CATER: Object Tracking.
Cater is a spatiotemporal reasoning video dataset introduced in
Girdhar and Ramanan (2019).
Each video contains 3D objects organized in a 6 × 6 grid.
Each object affords certain actions that can be performed on them.
These actions result in movement of the concerned objects and change in their positions.
Some of these actions include: rotate , pick-place , slide , contain .
Throughout the duration of the video, a number of these actions are performed to get the ﬁnal state of the grid.
Note that only a single object undergoes an action, at any instant.
The task that we focus on here is called localization .
In this task, the goal is to predict the location of the target object in the ﬁnal frame.
In this case the target object is called a snitch.
The snitch as well as the other objects move across the 6 × 6 grid.
In some scenarios, the snitch may be covered by other objects hence hiding it from the view.
In such cases, tracking the movement of the snitch across frames becomes essential.
Therefore, capturing long-range temporal dependencies is essential to solve this task.
The information exchange limit enforced by the limited capacity of the shared workspace should be useful here as well.
For CATER, in some frames the snitch is not visible as it is covered by other objects.
Therefore, ideally the model only needs to attend to frames in which the snitch is visible.
Additionally, if the snitch is visible throughout the video in all frames, then to accurately predict the ﬁnal position of the snitch, the model only needs to attend to the ﬁnal frame of the video and can completely ignore the initial frames.
The results for this task are presented in Table 1.
We also experimented with both soft competition TR+SSW and hard competition TR+HSW, with only k = 5 specialists writing into the shared workspace.
We can see that models with a shared workspace outperform those with pairwise multihead attention thus conﬁrming our hypothesis about the beneﬁts of a shared workspace for this task.
As shown in Table 1 proposed method convincingly outperforms the Set Transformer.
Relational Reasoning : Sort-of-CLEVR.
In relational reasoning, the model is tasked with answering questions about certain properties of various objects and their relations with other objects.
The model is presented with an image and a question for that image.
This task has a clear sparse structure as in order to answer the questions correctly, it needs to only reason about a speciﬁc subset of objects that the question mentions.
For this task, we use the Sort-of-CLEVR dataset (Santoro et al., 2017).
Each image in Sort-of-CLEVR is of size 75 × 75 and contains 6 randomly placed geometrical shapes of 6 possible colors and 2 possible shapes.
Each image comes with 10 relational questions and 10 non- relational questions.
Non-relational questions only consider properties of individual objects.
On the other hand, relational questions consider relations among multiple objects.
For more details about the question see appendix Figure 8.
The input to the model consists of the image and the corresponding question.
We ﬁrst obtain a sequence of equal-sized patches for the image as in vision Transformers
(Dosovitskiy et al., 2020).
We concatenate the resulting patch sequence with the representation of the question and pass the combined sequence through the Transformer.
Sort-of-CLEVR has a ﬁnite number of possible answers, hence this task is setup as a classiﬁcation task.
[Table]
We also analyse the effect of varying number of slots in the shared workspace.
This also shows that by increasing the number of slots performance decreases hence validating claims regarding bandwidth limited communication channel via shared workspace.
We present the results for this task in Figure 4.
We observe that the Transformers with the shared workspace converge faster and outperform the baselines for relational as well as non-relational questions .
The superior performance with shared memory can be attributed to the inherent sparsity of this task.
For instance, in non-relational questions, the model only needs to attend to a single object referenced in the question to answer it correctly, while relational questions only consider a small subset of objects in the image, thus sparsity is helpful for both these types of questions.
Therefore, the limited capacity of the shared workspace forces the model to attend to only relevant information.
Shared Workspace for Physical Reasoning.
In this task, we consider a set of bouncing balls and the model is tasked with predicting the trajectory of the balls at each step.
In order to solve this task, a coherent picture of where and which objects will collide needs to be established by the learner.
We use the bouncing-ball dataset from Van Steenkiste et al.
We train the model for next-step prediction.
We compare the proposed approach against SCOFF (Goyal et al., 2020).
The results of our comparison are shown in Table 2.
We use the ARI and MSE metric for comparison.
ARI measures how well the different balls are segregated into different slots, higher ARI means better segregation.
We can see that using a shared workspace results in higher ARI as compared to pairwise communication in SCOFF.
Thus, using a shared workspace results in better division of labor among specialists.
We also compare the proposed method against other baselines in appendix section F.1.
Shared Workspace for Atari Video Games.
We start by training RIMs, RIMs + shared workspace (SW) on three "source" games (Pong, River Raid, and Seaquest) and test if the learned features transfer to a different subset of randomly selected "target" games (Alien, Asterix, Boxing, Centipede,
Gopher, Hero, James Bond, Krull, Robotank, Road Runner, Star Gunner, and Wizard of Wor).
We take a sufﬁcient number of specialists in RIMs (10).
We train on source games for 10M steps, and then ﬁne-tune on transfer games for 10M more steps.
We choose these games as they were also used in the original RIMs paper (Goyal et al., 2019).
Using a suite of 36 game pairs, we ﬁnd that RIMs + SW outperforms RIMs on both game A (a median performance ratio of 1.13; mean of 1.16) and game B (a median performance ratio of 1.11; mean of 1.15).
The improved performance with RIMs +
SW is due to better forward transfer (knowledge acquired for game
A facilitates the learning of game
B) and reduced backward interference (knowledge acquired for game B does not disrupt knowledge acquired for game A), presumably thanks to a more appropriate modularization of knowledge.
C ONCLUSION
Inspired by cognitive neuroscience global workspace theories, we have proposed a shared workspace model for establishing coherence among modular neural specialists while exchanging information in a systematic way.
We show that using a limited capacity shared workspace as a bottleneck for mediating communication among specialists results in better performance across a wide range of visual reasoning benchmarks as compared to the pairwise interactions typically used in self-attention schemes.
The proposed approach combines several key properties: knowledge and expertise is divided among specialists, they compete to post new contents to the workspace, and after being updated, the shared workspace is accessible to all specialists for their own updates.
E THICS S TATEMENT
The authors do not foresee any negative social impacts of this work, but of course the accumulation of improvements in ML could be misused as it may give more power to nefarious agents.
R EPRODUCIBILITY S TATEMENT
We use Algorithms 1 and 2 for our experiments, we will be releasing the code after the review process.
We also provide our code in the supplementary material.
B H YPERPARAMETERS
Table 3 lists the different hyper-parameters.
Parameters in RIMs+SW:
RIMs with shared workspace has three set of parameters:
• Parameters corresponding to Input attention Parameters for the attention for the k -th specialist θ k
=
( W qk , W e , W v ) corresponding to query, keys, and values respectively.
Each specialist has different query parameters but share the same keys and values (which are function of the input).
In the table it corresponds to the inp keys, inp values, inp heads respectively.
• Writing in a shared workspace: Parameters corresponding to the writing in the memory.
Here, we follow the similar mechanisms as in RMC(Santoro et al., 2018), where shared
Notation: Consider h l as the output of the l th transformer layer.
Let sequence length of original input be T and embedding dimension of transformer be D .
Let the transformer be composed of n b mechanisms and memory be denoted as a matrix M with row wise compartmentalized memories, where m i refers to the state of slot i (total number of slots is n m ).
Consider h kl
=
h l [: , ( k − 1) D/n b : kD/n b ] to be the hidden state of mechanism indexed k at layer l .
Initialization: Convert the raw input X ∈ R T × vocab _ size to h 0 = positional
_ encoding + Embedding ( X ) where h 0 ∈ R T × D .
Initialize memory matrix M which remains common for all layers in the transformer. layer
• W c ∈ R D/n b ×• c k =
h kl − 1 W ck ∀ k ∈ { 1 , . . .
, n b } • c = softmax ( concat ( c 1 , .., c n b )) , c ∈ R T × n b • For each time step t in the original sequence of length T , we use the soft score c to select the top n sel mechanisms which would self
attend and write to the memory
Hence generating set F t which stores the indices of n sel mechanisms for position t ∈ { 1 , 2 , ..., T } .
Also construct c ∗ k ∈ R T × D/n b where c ∗ k
[ t, :] =
(cid:40)
c [ t ][ k ] k ∈ F t , 0 k / ∈ F t ,
Step 2:
Selected mechanisms self-attend and update their hidden state • residual k = h kl −• ¯
h kl =
c ∗ k (cid:12) SelfAttention ( h kl − 1 ) + residual k ∀ k ∈ { 1 , . .
. , n b } Step 3: Selected mechanisms write on the shared workspace • Memory matrix M was last modiﬁed by mechanisms of layer l −• Let a k = c ∗ k (cid:12) ¯ h kl and a = concat ( a 1 , .., a n b ) .
Absorb the ﬁrst dimension (corresponding to position in the sequence) in the batch dimension by reshaping a .
Perform the same steps as in algorithm 1.
• (cid:101) Q = M (cid:102) W q • R =
[ M ; A ] where A = aW v • M ← softmax (cid:16) (cid:101) Q ( R (cid:102) W e ) T √ d e (cid:17) R (cid:102) W v Step 4: Broadcast of information from the shared workspace • Reshape the new memory to bring back the sequence dimension.
Perform the same steps as in algorithm 1.
• (cid:98) q k =
¯
h kl (cid:99) W q ∀ k ∈ { 1 , . . . , n b } • s k,j = softmax (cid:16) (cid:98) q k (cid:98) κ j √ d e (cid:17) where (cid:98) κ j = ( m j (cid:99) W e ) T ∀ k ∈ { 1 , . . . , n b } , j ∈ { 1 , . . . , n m } • h
kl
=
¯
h kl
+ (cid:80) j s k,j (cid:98) v j where (cid:98) v j
= m j (cid:99) W v ∀ k ∈ { 1 , . .
. , n b }
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table] [Figure] [Table] [Figure]
[Table] [Table] [Table]
[Table]
[Figure]
[Table] [Table]
[Table]
[Table]
[Table] [Table]
[Table]
[Table]
workspace is seen as a Matrix with row wise compartmentalized memories (i.e slots) i.e (cid:102) W q , (cid:102) W e , (cid:102) W v .
In the table it corresponds to number of memory slots, number of memory heads, size of attention head, key size and number of mlp layers in attention.
These are the same hyper-paramter as in RMC (Santoro et al., 2018).
We tried two different set of hyper-parameters (a) where we only have a single slot and (b) where we have 4 slots.
• Broadcast of Information from the shared workspace :
In this process, the information in the workspace gets broadcasted to all the specialists such that each specialist produces a query, and the keys and values are a function of the memory state.
Each specialist gets information from the memory according to its query, and this information is used to update the state of each specialist in a residual fashion.
This corresponds to the parameters of (cid:99) W v , (cid:99) W q , (cid:99) W e in the table i.e memory attention heads
memory attention keys
and memory attention values.
We did not do any hyper-parameter search for these hyper-parameters
Resources Used:
• For vision tasks like Sort-of-clever, Equilateral triangle, CIFAR classiﬁcation, it takes about 6 hours to run 200 epochs on V100 (32G) GPU.
• It takes about 2 days to train the proposed model on bouncing ball task for 100 epochs on V100 (32G) GPU.
We did not do any hyper-parameter search speciﬁc to a particular dataset (i.e 4Balls or 678Balls or Curtain Task).
We ran the proposed model for different number of memory slots (i.e 2/4/8) for all the different datasets.
• For Starcraft task, it takes about 5 days to train on V100 (16G) GPU with batch size of 4.
C I MPLEMENTATION D ETAILS
Writing Information in the shared workspace .
While writing information to the shared workspace, we update the workspace using a gating mechanism as proposed in Santoro et al.
The gating mechanism consists of input and forget gates.
Let M t − 1 and M t be the previous and updated memory matrix respectively.
Let M be the result of the attention mechanism as described in stepof section 2.1.
Let X 1 ...n s be the input to n s specialists.
The gating mechanism can be formulated as follows.
[Equation]
Here, I and F indicate the input and forget gates respectively.
Note that W 1 is shared across all n s specialists.
D P ROPERTIES OF S HARED W ORKSPACE
In section 2, we claim that higher-order interaction terms and effects due to persistence of memory are key contributors to Shared Workspace performance.
We support those claims here:
Shared Workspace vs repeated self attention Higher-order interaction can be simulated by repeating the self-attention step multiple times at the same layer/time-step.
However, due to the absence of a global communication channel, there is no constraint that the messages passed among the neural modules should lie in the same representation space.
We modify a standard transformer where we repeat the self-attention step two times in every layer.
We expect that 2 × Self Attention will perform worse than SW.
We also run a model where both self-attention as well as shared workspace is used by the transformer to update its state.
Persistence of Memory To check whether persistence is crucial for our model to perform well, we run a model where we re-initialize the shared workspace at every layer.
Again we expect that removing memory persistence should result in a drop in performance and speed of convergence.
We run these models on sort-of-clevr dataset and present the results in ﬁgure
We note that removing persistence of memory results in signiﬁcantly slower convergence.
Replacing
SW with 2 × SA results in a signiﬁcant drop in performance.
[Figure]
A demonstration of this task can be found in ﬁgure 6.
We use images of size 64 × 64 for this task.
Our training dataset consists of 50000 examples and we evaluate on 10000 examples.
We follow the same setup as vision transformers Dosovitskiy et al.
(2020) for this task.
We divide the image into patches of size 4 × 4 , this sequence of patches is fed as input to a 4-layered transformer along with the CLS token which is used for classiﬁcation.
We set hidden dim to 256 and ffn dim to 512.
For the proposed model (TR+SSW, TR+HSW), We use a query and key size of 32, and value size of 64.
We use 4 heads during reading from and writing into the shared workspace which consist ofmemory slots.
For the baseline models (TR, TR + HC, STR), we use query, key and value size ofand 4 heads.
For training, we use a batch size of 64.
We train the model for 200 epochs using Adam optimizer with a learning rate of 0.0001.
We anneal the learning rate using cosine annealing.
[Equation]
[Figure]
Figure 8 shows a sample from this dataset.
The images in this dataset are of size 75 × 75 .
Each question is encoded into 11 bits.
The ﬁrst 6 bits indicate color, the next 2 bits indicate question type (relational or non-relational), and the remaining 3 bits indicate question subtype (according to ﬁgure 8).
We use a 4-layered transformer for this task with hidden dim set to 256 and ffn dim set to 512.
For the proposed model (TR+SSW, TR+HSW), We use a query and key size of 32, and value size of 64.
We use 4 heads during reading from and writing into the shared workspace which consists of 8 memory slots.
For the baseline models (TR, TR + HC, STR), we use query, key and value size of 64 and 4 heads.
We encode the 11 bit question into a 256 dimensional vector representation and concatenate it with the sequence of 15 × 15 sized patched obtained from the image.
We use the representation corresponding to the CLS token for classiﬁcation.
We train the model using cross-entropy loss.
We use a batch size of 64 and train the model for 100 epochs.
We use Adam optimizer with a learning rate of 0.0001 for training.
E. CATER: O BJECT T RACKING
Each CATER video consists of about 300 frames of size 224 × 224 .
We ﬁrst sample frames at a sampling rate of 6 which results in 50 frames.
From these 50 frames, we stack 5 consecutive frames together and pass each stack through a 18 layered resnet.
The corresponding sequence of 10 frames is passed as input to the transformer.
This task is setup as a classiﬁcation task where we have to predict which cell in the 6 × 6 grid contains the snitch in the ﬁnal frame.
We use a 6-layered transformer with hidden dim set to 512 and ffn dim set to 2048.
For the proposed model (TR+SSW, TR+HSW),
We use a query and key size of 32, and value size of 64.
We use 8 heads during reading from and writing into the shared workspace which consists of 8 memory slots.
For the baseline models (TR,
TR + HC, STR), we use query, key and value size of 64 and 8 heads.
F
RIM S T ASKS
F.
[Figure]
OUNCING
[Figure]
ALL
[Figure]
ror comparison of the proposed method, LSTM,
RIMs and RMC baseline.
Given 10 frames of ground truth, the model predicts the rollout over the next 35 steps.
Here, we present the BCE for the 30th frame and 45th frame.
The proposed SW extension performs better than other baselines in accurately predicting the dynamics, with an increasing advantage as the number of unrolled steps (30 vs 45) and balls ((a) vs (b)) increases .
Results are an average over 5 random seeds.
The dataset consists of 50,000 training examples and 10,000 test examples showing ∼ 50 frames of either 4 solid balls bouncing in a conﬁned square geometry ( 4Balls ), 6-8 balls bouncing in a conﬁned geometry ( 678Balls ), 3 balls bouncing in a conﬁned geometry with an occluded region ( Curtain ), or balls of different colors ( Colored 4Balls ) and ( Colored 678Balls ).
We train baselines as well as the proposed shared workspace extension (e.g.,
RIMs + SW).
As shown in Fig.
9, we study the performance of the proposed model compared with
LSTM, RIMs and RMC.
The ﬁrst 10 frames of ground truth are fed in and then the system is rolled out for the next 35 time steps.
During the rollout phase, the proposed method performs better than the baselines in accurately predicting the dynamics of the balls as reﬂected by cross entropy (CE).
We trained baselines as well as proposed model for about 100 epochs.
We use the same architecture for encoder as well as decoder as in (Van Steenkiste et al., 2018).
Hyper-parameters speciﬁc to the proposed architecture are listed in Tab. 3.
G I NTEGRATING SW WITH MORE ARCHITECTURES G. TIM S
TIMs was proposed by Lamb et al.
A transformer network is divided into ‘independent mechanisms’ which update their state via sharing information between positions and sharing information between mechanisms.
The information sharing step between mechanisms can be replaced by SW to create TIMs+SW.
G.1. M ULTI MNIST G ENERATION
In this task, we train an Image Transformer Parmar et al.
(2018) (pixel-by-pixel, raster-order generative model) for next pixel prediction task on the “MultiMNIST dataset”
[Table]
Each 32 × 32 image in this dataset is made up of four randomly selected (and augmented)
MNIST digits (resized to 32 × 8 ) placed side-by-side as shown in ﬁgure 10.
The digits themselves are selected independently of one-another.
The main aim of creating such a task is to observe the working of independent mechanisms in architectures such as TIMs (Lamb et al., 2021).
Each image in the MultiMNIST dataset can be broken down into different sets of independent spatial components.
Since the digits which make up the image are independently selected, the joint distribution of pixel intensities in any one of the four sections of the image is statistically independent of the pixel intensities in any other section of the image.
Moreover each section of the image can be further broken down into independent spatial components: one that pertains to the background and one that pertains to the foreground.
It is expected that a monolithic architecture (having a single computational unit) would have to devote a signiﬁcant portion of its training to learn the statistical independence between the different constituents of the image.
On the other hand, architectures made up of sparsely interacting independent mechanisms have a natural way of capturing such statistical independence.
A division of labour where each mechanism is focused on the generation of a distinct independent constituent of the image should allow for better generalization on the test set.
Once the generation of a constituent is completed, the task can be handed over to some other mechanism based on current position in the image.
For this experiment we train a standard transformer with shared parameters across all layers (denoted by TR), TIMs (Lamb et al., 2021) with 4 mechanisms, and a modiﬁed version of TIMs with 4 mechanisms where the pair-wise communication between the mechanisms is replaced by communication via a shared workspace (denoted by TIMs+SW).
Training.
We follow the minGPT Image Transformer setup Karpathy (2020) for our experiments.
All three of the conﬁgurations have 8 layers, 8 heads for multi-headed attention and use the exact same parameter initialization and base architecture.
We train all three of the models for 20 epochs.
In the TR model, all of the 8 monolithic layers share the same set of parameters.
In TIMs and
TIMs+SW, the ﬁrst two layers are the standard monolithic layers having shared parameters.
The middle four layers in both of these architectures are modular layers with four mechanisms.
These four
[Table]
layers share the same set of parameters.
In the case of TIMs+SW, the four mechanisms in these layers communicate via a shared workspace (having 2 memory slots).
This shared workspace is common for all four middles layers and is absent in TIMs where the mechanisms communicate via pair-wise competition as proposed in the original paper.
TIMs and TIMs+SW architectures are concluded by two more monolithic layers which again share the same parameters.
For all three models to have comparable number of parameters, we chose the transformer embedding dimension to be 256 for TR model, 192 for TIMs model and 160 for TIMs+SW model.
In TIMs and
TIMs+SW, the embedding dimension is divided equally among the four specialists.
Each memory slot in the shared workspace of the TIMs+SW model has a 160 dimensional embedding and the model uses four heads to perform read and write operations on the shared workspace.
Total number of parameters for all three architectures lie between 1M and 1.8M.
Results.
We observe the best cross-entropy loss in 20 epochs on the test set of the MultiMNIST dataset for the next pixel prediction task in the table 5.
We further plot the sixth layer “mechanism activation score” of TIMs and TIMs+SW while generating the ﬁrst four images of the test set in the best epoch (shown in ﬁgure 5).
G.1. U SING W ORKSPACE FOR LANGUAGE M ODELLING
We train our models on the WikiText-103 dataset by posing a language modeling problem.
The dataset is divided into train, test and validation sets which are composed out of 28,475, 60 andarticles respectively.
The total number of tokens in the train set is more than 103 million, hence the name of the dataset.
This dataset retains numbers, punctuation and case.
Training.
We train our models for 15 epochs for the next word prediction task on the WikiTextdataset and report the perplexity on the validation set.
We show the results using TIMs (Lamb et al., 2021) with 4 mechanisms and TIMs+SW with 4 mechanisms (where we replace the pairwise communication in TIMs with communication via a shared workspace like in the MultiMNIST experiment).
We modify the FAIRSEQ Ott et al.
(2019) transformer language model class for all of our experiments.
For TIMs+SW, we train and test two different variants: TIMs+SSW uses soft attention to generate the activation scores of competing independent mechanisms whereas TIMs+HSW uses top-k attention with k=2.
Since in this test, our aim is to compare the performance of the two models for the language modeling task, the architectures are only made up of a transformer decoder.
In both of the models, there aretransformer decoder layers divided into 3 sets.
The ﬁrst 2 layers are standard monolithic decoder layers which share the same parameters.
The next 4 layers are modular layers (TIMs layers or
TIMs+SW layers depending on the model choice).
These layers also share the same parameters among themselves.
The last 2 layers are again standard monolothic decoder layers, both sharing the same parameters.
The inputs to the network are 1024 dimensional word embeddings, input to a transformer layer of dimension 1024 and feed forward dimension of 2048 .
Both of the networks have 8 attention heads with head dimension of 128.
The total transformer layer size of 8 × 128 = 1024 is equally divided among the four mechanisms.
In the case of TIMs, these mechanisms (in layers 3,4,5) interact via pair-wise communication, whereas in TIMs+SSW and TIMs+HSW, these mechanisms interact via a shared workspace.
The shared workspace hasmemory slots, each 1024 dimensional, having 4 attention heads for reading and writing.
[Table]
per gpu
[Table]
size multiple
[Table]
Transformer layer
[Table]
Mechanisms
[Table] [Table]
warmup updates
Starting Warmup lr
[Table]
TIMs+SSW
Number [Table] memory slots
Size [Table] memory slots
Memory Attention Heads
Gate Style ’unit’
Number of MLP layers in Attention top-k competition
False
TIMs+HSW
Number of memory slots
Size of memory slots
Memory Attention Heads
Gate Style ’unit’
Number of MLP layers in Attention top
[Table]
True, k=
Results.
We plot the perplexity (per epoch) on the validation set.
All models have comparable number of parameters (within a 10% difference).
We note that TIMs performs poorly on this dataset but adding shared workspace improves the performance consistently.
We also note that sparsity indeed helps as TIMs+HSW performed the best.
[Figure]