Object-Centric Learning with Slot Attention

Introduction

Object-centric representations have the potential to improve sample efficiency and generalization of machine learning algorithms across a range of application domains, such as visual reasoning , modeling of structured environments , multi-agent modeling , and simulation of interacting physical systems . Obtaining object-centric representations from raw perceptual input, such as an image or a video, is challenging and often requires either supervision or task-specific architectures . As a result, the step of learning an object-centric representation is often skipped entirely. Instead, models are typically trained to operate on a structured representation of the environment that is obtained, for example, from the internal representation of a simulator or of a game engine .

To overcome this challenge, we introduce the Slot Attention module, a differentiable interface between perceptual representations (e.g., the output of a CNN) and a set of variables called slots. Using an iterative attention mechanism, Slot Attention produces a set of output vectors with permutation symmetry. Unlike capsules used in Capsule Networks , slots produced by Slot Attention do not specialize to one particular type or class of object, which could harm generalization. Instead, they act akin to object files , i.e., slots use a common representational format: each slot can store (and bind to) any object in the input. This allows Slot Attention to generalize in a systematic way to unseen compositions, more objects, and more slots.

Slot Attention is a simple and easy to implement architectural component that can be placed, for example, on top of a CNN encoder to extract object representations from an image and is trained end-to-end with a downstream task. In this paper, we consider image reconstruction and set prediction as downstream tasks to showcase the versatility of our module both in a challenging unsupervised object discovery setup and in a supervised task involving set-structured object property prediction.

Our main contributions are as follows: (i) We introduce the Slot Attention module, a simple architectural component at the interface between perceptual representations (such as the output of a CNN) and representations structured as a set. (ii) We apply a Slot Attention-based architecture to unsupervised object discovery, where it matches or outperforms relevant state-of-the-art approaches , while being more memory efficient and significantly faster to train. (iii) We demonstrate that the Slot Attention module can be used for supervised object property prediction, where the attention mechanism learns to highlight individual objects without receiving direct supervision on object segmentation.

Methods

In this section, we introduce the Slot Attention module (Figure 1(a); Section 2.1) and demonstrate how it can be integrated into an architecture for unsupervised object discovery (Figure 1(c); Section 2.2) and into a set prediction architecture (Figure 1(c); Section 2.3).

The Slot Attention module (Figure 1(a)) maps from a set of $N$ input feature vectors to a set of $K$ output vectors that we refer to as slots. Each vector in this output set can, for example, describe an object or an entity in the input. The overall module is described in Algorithm 1 in pseudo-codeAn implementation of Slot Attention is available at: https://github.com/google-research/google-research/tree/master/slot_attention..

Slot Attention uses an iterative attention mechanism to map from its inputs to the slots. Slots are initialized at random and thereafter refined at each iteration $t=1\ldots T$ to bind to a particular part (or grouping) of the input features. Randomly sampling initial slot representations from a common distribution allows Slot Attention to generalize to a different number of slots at test time.

At each iteration, slots compete for explaining parts of the input via a softmax-based attention mechanism and update their representation using a recurrent update function. The final representation in each slot can be used in downstream tasks such as unsupervised object discovery (Figure 1(c)) or supervised set prediction (Figure 1(c)).

Slot Attention uses dot-product attention with attention coefficients that are normalized over the slots, i.e., the queries of the attention mechanism. This choice of normalization introduces competition between the slots for explaining parts of the input.

We further follow the common practice of setting the softmax temperature to a fixed value of $\sqrt{D}$ :

In other words, the normalization ensures that attention coefficients sum to one for each individual input feature vector, which prevents the attention mechanism from ignoring parts of the input. To aggregate the input values to their assigned slots, we use a weighted mean as follows:

The weighted mean helps improve stability of the attention mechanism (compared to using a weighted sum) as in our case the attention coefficients are normalized over the slots. In practice we further add a small offset $\epsilon$ to the attention coefficients to avoid numerical instability.

The aggregated updates are finally used to update the slots via a learned recurrent function, for which we use a Gated Recurrent Unit (GRU) with $D_{\texttt{slots}}$ hidden units. We found that transforming the GRU output with an (optional) multi-layer perceptron (MLP) with ReLU activation and a residual connection can help improve performance. Both the GRU and the residual MLP are applied independently on each slot with shared parameters. We apply layer normalization (LayerNorm) both to the inputs of the module and to the slot features at the beginning of each iteration and before applying the residual MLP. While this is not strictly necessary, we found that it helps speed up training convergence. The overall time-complexity of the module is $\mathcal{O}\left(T\cdot D\cdot N\cdot K\right)$.

We identify two key properties of Slot Attention: (1) permutation invariance with respect to the input (i.e., the output is independent of permutations applied to the input and hence suitable for sets) and (2) permutation equivariance with respect to the order of the slots (i.e., permuting the order of the slots after their initialization is equivalent to permuting the output of the module). More formally:

The proof is in the supplementary material. The permutation equivariance property is important to ensure that slots learn a common representational format and that each slot can bind to any object in the input.

2 Object Discovery

Set-structured hidden representations are an attractive choice for learning about objects in an unsupervised fashion: each set element can capture the properties of an object in a scene, without assuming a particular order in which objects are described. Since Slot Attention transforms input representations into a set of vectors, it can be used as part of the encoder in an autoencoder architecture for unsupervised object discovery. The autoencoder is tasked to encode an image into a set of hidden representations (i.e., slots) that, taken together, can be decoded back into the image space to reconstruct the original input. The slots thereby act as a representational bottleneck and the architecture of the decoder (or decoding process) is typically chosen such that each slot decodes only a region or part of the image . These regions/parts are then combined to arrive at the full reconstructed image.

Encoder Our encoder consists of two components: (i) a CNN backbone augmented with positional embeddings, followed by (ii) a Slot Attention module. The output of Slot Attention is a set of slots, that represent a grouping of the scene (e.g. in terms of objects).

Decoder Each slot is decoded individually with the help of a spatial broadcast decoder , as used in IODINE : slot representations are broadcasted onto a 2D grid (per slot) and augmented with position embeddings. Each such grid is decoded using a CNN (with parameters shared across the slots) to produce an output of size $W\times H\times 4$, where $W$ and $H$ are width and height of the image, respectively. The output channels encode RGB color channels and an (unnormalized) alpha mask. We subsequently normalize the alpha masks across slots using a Softmax and use them as mixture weights to combine the individual reconstructions into a single RGB image.

3 Set Prediction

Set representations are commonly used in tasks across many data modalities ranging from point cloud prediction , classifying multiple objects in an image , or generation of molecules with desired properties . In the example considered in this paper, we are given an input image and a set of prediction targets, each describing an object in the scene. The key challenge in predicting sets is that there are $K!$ possible equivalent representations for a set of $K$ elements, as the order of the targets is arbitrary. This inductive bias needs to be explicitly modeled in the architecture to avoid discontinuities in the learning process, e.g. when two semantically specialized slots swap their content throughout training . The output order of Slot Attention is random and independent of the input order, which addresses this issue. Therefore, Slot Attention can be used to turn a distributed representation of an input scene into a set representation where each object can be separately classified with a standard classifier as shown in Figure 1(c).

Encoder We use the same encoder architecture as in the object discovery setting (Section 2.2), namely a CNN backbone augmented with positional embeddings, followed by Slot Attention, to arrive at a set of slot representations.

Classifier For each slot, we apply a MLP with parameters shared between slots. As the order of both predictions and labels is arbitrary, we match them using the Hungarian algorithm . We leave the exploration of other matching algorithms for future work.

Related Work

Our object discovery architecture is closely related to a line of recent work on compositional generative scene models that represent a scene in terms of a collection of latent variables with the same representational format. Closest to our approach is the IODINE model, which uses iterative variational inference to infer a set of latent variables, each describing an object in an image. In each inference iteration, IODINE performs a decoding step followed by a comparison in pixel space and a subsequent encoding step. Related models such as MONet and GENESIS similarly use multiple encode-decode steps. Our model instead replaces this procedure with a single encoding step using iterated attention, which improves computational efficiency. Further, this allows our architecture to infer object representations and attention masks even in the absence of a decoder, opening up extensions beyond auto-encoding, such as contrastive representation learning for object discovery or direct optimization of a downstream task like control or planning. Our attention-based routing procedure could also be employed in conjunction with patch-based decoders, used in architectures such as AIR , SQAIR , and related approaches , as an alternative to the typically employed autoregressive encoder . Our approach is orthogonal to methods using adversarial training or contrastive learning for object discovery: utilizing Slot Attention in such a setting is an interesting avenue for future work.

Neural networks for sets A range of recent methods explore set encoding , generation , and set-to-set mappings . Graph neural networks and in particular the self-attention mechanism of the Transformer model are frequently used to transform sets of elements with constant cardinality (i.e., number of set elements). Slot Attention addresses the problem of mapping from one set to another set of different cardinality while respecting permutation symmetry of both the input and the output set. The Deep Set Prediction Network (DSPN) respects permutation symmetry by running an inner gradient descent loop for each example, which requires many steps for convergence and careful tuning of several loss hyperparmeters. Instead, Slot Attention directly maps from set to set using only a few attention iterations and a single task-specific loss function. In concurrent work, both the DETR and the TSPN model propose to use a Transformer for conditional set generation. Most related approaches, including DiffPool , Set Transformers , DSPN , and DETR use a learned per-element initialization (i.e., separate parameters for each set element), which prevents these approaches from generalizing to more set elements at test time.

Iterative routing Our iterative attention mechanism shares similarlities with iterative routing mechanisms typically employed in variants of Capsule Networks . The closest such variant is inverted dot-product attention routing which similarly uses a dot product attention mechanism to obtain assignment coefficients between representations. Their method (in line with other capsule models) however does not have permutation symmetry as each input-output pair is assigned a separately parameterized transformation. The low-level details in how the attention mechanism is normalized and how updates are aggregated, and the considered applications also differ significantly between the two approaches.

Interacting memory models Slot Attention can be seen as a variant of interacting memory models , which utilize a set of slots and their pairwise interactions to reason about elements in the input (e.g. objects in a video). Common components of these models are (i) a recurrent update function that acts independently on individual slots and (ii) an interaction function that introduces communication between slots. Typically, slots in these models are fully symmetric with shared recurrent update functions and interaction functions for all slots, with the exception of the RIM model , which uses a separate set of parameters for each slot. Notably, RMC and RIM introduce an attention mechanism to aggregate information from inputs to slots. In Slot Attention, the attention-based assignment from inputs to slots is normalized over the slots (as opposed to solely over the inputs), which introduces competition between the slots to perform a clustering of the input. Further, we do not consider temporal data in this work and instead use the recurrent update function to iteratively refine predictions for a single, static input.

Mixtures of experts Expert models are related to our slot-based approach, but do not fully share parameters between individual experts. This results in the specialization of individual experts to, e.g., different tasks or object types. In Slot Attention, slots use a common representational format and each slot can bind to any part of the input.

Soft clustering Our routing procedure is related to soft k-means clustering (where slots corresponds to cluster centroids) with two key differences: We use a dot product similarity with learned linear projections and we use a parameterized, learnable update function. Variants of soft k-means clustering with learnable, cluster-specific parameters have been introduced in the computer vision and speech recognition communities , but they differ from our approach in that they do not use a recurrent, multi-step update, and do not respect permutation symmetry (cluster centers act as a fixed, ordered dictionary after training). The inducing point mechanism of the Set Transformer and the image-to-slot attention mechanism in DETR can be seen as extensions of these ordered, single-step approaches using multiple attention heads (i.e., multiple similarity functions) for each cluster assignment.

Recurrent attention Our method is related to recurrent attention models used in image modeling and scene decomposition , and for set prediction . Recurrent models for set prediction have also been considered in this context without using attention mechanisms . This line of work frequently uses permutation-invariant loss functions , but relies on inferring one slot, representation, or label per time step in an auto-regressive manner, whereas Slot Attention updates all slots simultaneously at each step, hence fully respecting permutation symmetry.

Experiments

The goal of this section is to evaluate the Slot Attention module on two object-centric tasks—one being supervised and the other one being unsupervised—as described in Sections 2.2 and 2.3. We compare against specialized state-of-the-art methods for each respective task. We provide further details on experiments and implementation, and additional qualitative results and ablation studies in the supplementary material.

Baselines In the unsupervised object discovery experiments, we compare against two recent state-of-the-art models: IODINE and MONet . For supervised object property prediction, we compare against Deep Set Prediction Networks (DSPN) . DSPN is the only set prediction model that respects permutation symmetry that we are aware of, other than our proposed model. In both tasks, we further compare against a simple MLP-based baseline that we term Slot MLP. This model replaces Slot Attention with an MLP that maps from the CNN feature maps (resized and flattened) to the (now ordered) slot representation. For the MONet, IODINE, and DSPN baselines, we compare with the published numbers in as we use the same experimental setup.

Datasets For the object discovery experiments, we use the following three multi-object datasets : CLEVR (with masks), Multi-dSprites, and Tetrominoes. CLEVR (with masks) is a version of the CLEVR dataset with segmentation mask annotations. Similar to IODINE , we only use the first 70K samples from the CLEVR (with masks) dataset for training and we crop images to highlight objects in the center. For Multi-dSprites and Tetrominoes, we use the first 60K samples. As in , we evaluate on 320 test examples for object discovery. For set prediction, we use the original CLEVR dataset which contains a training-validation split of 70K and 15K images of rendered objects respectively. Each image can contain between three and ten objects and has property annotations for each object (position, shape, material, color, and size). In some experiments, we filter the CLEVR dataset to contain only scenes with at maximum 6 objects; we call this dataset CLEVR6 and we refer to the original full dataset as CLEVR10 for clarity.

Training The training setup is unsupervised: the learning signal is provided by the (mean squared) image reconstruction error. We train the model using the Adam optimizer with a learning rate of $4\times 10^{-4}$ and a batch size of 64 (using a single GPU). We further make use of learning rate warmup to prevent early saturation of the attention mechanism and an exponential decay schedule in the learning rate, which we found to reduce variance. At training time, we use $T=3$ iterations of Slot Attention. We use the same training setting across all datasets, apart from the number of slots $K$: we use $K=7$ slots for CLEVR6, $K=6$ slots for Multi-dSprites (max. 5 objects per scene), and $K=4$ for Tetrominoes (3 objects per scene). Even though the number of slots in Slot Attention can be set to a different value for each input example, we use the same value $K$ for all examples in the training set to allow for easier batching.

Metrics In line with previous works , we compare the alpha masks produced by the decoder (for each individual object slot) with the ground truth segmentation (excluding the background) using the Adjusted Rand Index (ARI) score . ARI is a score to measure clustering similarity, ranging from 0 (random) to 1 (perfect match). To compute the ARI score, we use the implementation provided by Kabra et al. .

Results Quantitative results are summarized in Table 2 and Figure 2. In general, we observe that our model compares favorably against two recent state-of-the-art baselines: IODINE and MONet . We also compare against a simple MLP-based baseline (Slot MLP) which performs better than chance, but due to its ordered representation is unable to model the compositional nature of this task. We note a failure mode of our model: In rare cases it can get stuck in a suboptimal solution on the Tetrominoes dataset, where it segments the image into stripes. This leads to a significantly higher reconstruction error on the training set, and hence such an outlier can easily be identified at training time. We excluded a single such outlier (1 out of 5 seeds) from the final score in Table 2. We expect that careful tuning of the training hyperparameters particularly for this dataset could alleviate this issue, but we opted for a single setting shared across all datasets for simplicity.

Compared to IODINE , Slot Attention is significantly more efficient in terms of both memory consumption and runtime. On CLEVR6, we can use a batch size of up to 64 on a single V100 GPU with 16GB of RAM as opposed to 4 in using the same type of hardware. Similarly, when using 8 V100 GPUs in parallel, model training on CLEVR6 takes approximately 24hrs for Slot Attention as opposed to approximately 7 days for IODINE .

In Figure 2, we investigate to what degree our model generalizes when using more Slot Attention iterations at test time, while being trained with a fixed number of $T=3$ iterations. We further evaluate generalization to more objects (CLEVR10) compared to the training set (CLEVR6). We observe that segmentation scores significantly improve beyond the numbers reported in Table 2 when using more iterations. This improvement is stronger when testing on CLEVR10 scenes with more objects. For this experiment, we increase the number of slots from $K=7$ (training) to $K=11$ at test time. Overall, segmentation performance remains strong even when testing on scenes that contain more objects than seen during training.

We visualize discovered object segmentations in Figure 3 for all three datasets. The model learns to keep slots empty (only capturing the background) if there are more slots than objects. We find that Slot Attention typically spreads the uniform background across all slots instead of capturing it in just a single slot, which is likely an artifact of the attention mechanism that does not harm object disentanglement or reconstruction quality. We further visualize how the attention mechanism segments the scene over the individual attention iterations, and we inspect scene reconstructions from each individual iteration (the model has been trained to reconstruct only after the final iteration). It can be seen that the attention mechanism learns to specialize on the extraction of individual objects already at the second iteration, whereas the attention map of the first iteration still maps parts of multiple objects into a single slot.

To evaluate whether Slot Attention can perform segmentation without relying on color cues, we further run experiments on a binarized version of multi-dSprites with white objects on black background, and on a greyscale version of CLEVR6. We use the binarized multi-dSprites dataset from Kabra et al. , for which Slot Attention achieves $69.4\pm 0.9\%$ ARI using $K=4$ slots, compared to $64.8\pm 17.2\%$ for IODINE and $68.5\pm 1.7\%$ for R-NEM , as reported in . Slot Attention performs competitively in decomposing scenes into objects based on shape cues only. We visualize discovered object segmentations for the Slot Attention model trained on greyscale CLEVR6 in Figure 4, which Slot Attention handles without issue despite the lack of object color as a distinguishing feature.

As our object discovery architecture uses the same decoder and reconstruction loss as IODINE , we expect it to similarly struggle with scenes containing more complicated backgrounds and textures. Utilizing different perceptual or contrastive losses could help overcome this limitation. We discuss further limitations and future work in Section 5 and in the supplementary material.

Summary Slot Attention is highly competitive with prior approaches on unsupervised scene decomposition, both in terms of quality of object segmentation and in terms of training speed and memory efficiency. At test time, Slot Attention can be used without a decoder to obtain object-centric representations from an unseen scene.

2 Set Prediction

Training We train our model using the same hyperparameters as in Section 4.1 except we use a batch size of $512$ and striding in the encoder. On CLEVR10, we use $K=10$ object slots to be in line with . The Slot Attention model is trained using a single NVIDIA Tesla V100 GPU with 16GB of RAM.

Metrics Following Zhang et al. , we compute the Average Precision (AP) as commonly used in object detection . A prediction (object properties and position) is considered correct if there is a matching object with exactly the same properties (shape, material, color, and size) within a certain distance threshold ($\infty$ means we do not enforce any threshold). The predicted position coordinates are scaled to $$. We zero-pad the targets and predict an additional indicator score in$$ corresponding to the presence probability of an object (1 means there is an object) which we then use as prediction confidence to compute the AP.

Results In Figure 5 (left) we report results in terms of Average Precision for supervised object property prediction on CLEVR10 (using $T=3$ for Slot Attention at both train and test time). We compare to both the DSPN results of and the Slot MLP baseline. Overall, we observe that our approach matches or outperforms the DSPN baseline. The performance of our method degrades gracefully at more challenging distance thresholds (for the object position feature) maintaining a reasonably small variance. Note that the DSPN baseline uses a significantly deeper ResNet 34 image encoder. In Figure 5 (center) we observe that increasing the number of attention iterations at test time generally improves performance. Slot Attention can naturally handle more objects at test time by changing the number of slots. In Figure 5 (right) we observe that the AP degrades gracefully if we train a model on CLEVR6 (with $K=6$ slots) and test it with more objects.

Intuitively, to solve this set prediction task each slot should attend to a different object. In Figure 6, we visualize the attention maps of each slot for two CLEVR images. In general, we observe that the attention maps naturally segment the objects. We remark that the method is only trained to predict the property of the objects, without any segmentation mask. Quantitatively, we can evaluate the Adjusted Rand Index (ARI) scores of the attention masks. On CLEVR10 (with masks), the attention masks produced by Slot Attention achieve an ARI of $78.0\%\pm 2.9$ (to compute the ARI we downscale the input image to $32\times 32$). Note that the masks evaluated in Table 2 are not the attention maps but are predicted by the object discovery decoder.

Summary Slot Attention learns a representation of objects for set-structured property prediction tasks and achieves results competitive with a prior state-of-the-art approach while being significantly easier to implement and tune. Further, the attention masks naturally segment the scene, which can be valuable for debugging and interpreting the predictions of the model.

Conclusion

We have presented the Slot Attention module, a versatile architectural component that learns object-centric abstract representations from low-level perceptual input. The iterative attention mechanism used in Slot Attention allows our model to learn a grouping strategy to decompose input features into a set of slot representations. In experiments on unsupervised visual scene decomposition and supervised object property prediction we have shown that Slot Attention is highly competitive with prior related approaches, while being more efficient in terms of memory consumption and computation.

A natural next step is to apply Slot Attention to video data or to other data modalities, e.g. for clustering of nodes in graphs, on top of a point cloud processing backbone or for textual or speech data. It is also promising to investigate other downstream tasks, such as reward prediction, visual reasoning, control, or planning.

Broader Impact

The Slot Attention module allows to learn object-centric representations from perceptual input. As such, it is a general module that can be used in a wide range of domains and applications. In our paper, we only consider artificially generated datasets under well-controlled settings where slots are expected to specialize to objects. However, the specialization of our model is implicit and fully driven by the downstream task. We remark that as a concrete measure to assess whether the module specialized in unwanted ways, one can visualize the attention masks to understand how the input features are distributed across the slots (see Figure 6). While more work is required to properly address the usefulness of the attention coefficients in explaining the overall predictions of the network (especially if the input features are not human interpretable), we argue that they may serve as a step towards more transparent and interpretable predictions.

Acknowledgments and Disclosure of Funding

We would like to thank Nal Kalchbrenner for general advise and feedback on the paper, Mostafa Dehghani, Klaus Greff, Bernhard Schölkopf, Klaus-Robert Müller, Adam Kosiorek, and Peter Battaglia for helpful discussions, and Rishabh Kabra for advise regarding the DeepMind Multi-Object Datasets.

References

Appendix A Limitations

We highlight several limitations of the Slot Attention module that could potentially be addressed in future work:

Background treatment The background of a scene receives no special treatment in Slot Attention as all slots use the same representational format. Providing special treatment for backgrounds (e.g., by assigning a separate background slot) is interesting for future work.

Translation symmetry The positional encoding used in our experiments is absolute and hence our module is not equivariant to translations. Using a patch-based object extraction process as in or an attention mechanism with relative positional encoding are promising extensions.

Type of clustering Slot Attention does not know about objects per-se: segmentation is solely driven by the downstream task, i.e., Slot Attention does not distinguish between clustering objects, colors, or simply spatial regions, but relies on the downstream task to drive the specialization to objects.

Communication between slots In Slot Attention, slots only communicate via the softmax attention over the input keys, which is normalized across slots. This choice of normalization establishes competition between the slots for explaining parts of the input, which can drive specialization of slots to objects. In some scenarios it can make sense to introduce a more explicit form of communication between slots, e.g. via slot-to-slot message passing in the form of a graph neural network as in or self-attention . This can be beneficial for modeling systems of objects that interact dynamically or for set generation conditioned on a single vector (as opposed to an image or a set of vectors) .

Appendix B Model Ablations

In this section, we investigate the importance of individual components and modeling choices in the Slot Attention module and compare our default choice to a variety of reasonable alternatives. For simplicity, we report all results on a smaller validation set consisting of $500$ validation images for property prediction (instead of 15K) and on $320$ training images for object discovery. In the unsupervised case, results on the training set and on held-out validation examples are nearly identical.

Value aggregation In Figure 7, we show the effect of taking a weighted sum as opposed to a weighted average in Line 8 of Algorithm 1. The average stabilizes training and yields significantly higher ARI and Average Precision scores (especially at the more strict distance thresholds). We can obtain a similar effect by replacing the weighted mean with a weighted sum followed by layer normalization (LayerNorm) .

Position embedding In Figure 8, we observe that the position embedding is not necessary for predicting categorical object properties. However, the performance in predicting the object position clearly decreases if we remove the position embedding. Similarly, the ARI score in unsupervised object discovery is significantly lower when not adding positional information to the CNN feature maps before the Slot Attention module.

Slot initialization In Figure 9, we show the effect of learning a separate set of Gaussian mean and variance parameters for the initialization of each slot compared to the default setting of using a shared set of parameters for all slots. We observe that a per-slot parameterization can increase performance slightly for the supervised task, but decreases performance on the unsupervised task, compared to the default shared parameterization. We remark that when learning a separate set of parameters for each slot, adding additional slots at test time is not possible without re-training.

Attention normalization axis In Figure 10, we highlight the role of the softmax axis in the attention mechanism, i.e., over which dimension the normalization is performed. Taking the softmax over the slot axis induces competition among the slots for explaining parts of the input. When we take the softmax over the input axis insteadIn this case we aggregate using a weighted sum, as the attention coefficients are normalized over the inputs. (as done in regular self-attention), the attention coefficients for each slot will be independent of all other slots, and hence slots have no means of exchanging information, which significantly harms performance on both tasks.

Recurrent update function In Figure 11, we highlight the role of the GRU in learning the update function for the slots as opposed to simply taking the output of Line 8 as the next value for the slots. We observe that the learned update function yields a noticable improvement.

Attention iterations In Figure 12, we show the impact of the number of attention iterations while training. We observe a clear benefit in having more than a single attention iteration. Having more than 3 attention iterations significantly slows down training convergence, which results in lower performance when trained for the same number of steps. This can likely be mitigated by instead decoding and applying a loss at every attention iteration as opposed to only the last one. We note that at test time, using more than 3 attention iterations (even when trained with only 3 iterations) generally improves performance.

Layer normalization In Figure 13, we show that applying layer normalization (LayerNorm) to the inputs and to the slot representations at each iteration in the Slot Attention module improves predictive performance. For set prediction, it particularly improves its ability to predict position accurately, likely because it leads to faster convergence at training time.

Feedforward network In Figure 14, we show that the residual MLP after the GRU is optional and may slow down convergence in property prediction, but may slightly improve performance on object discovery.

Softmax temperature In Figure 15, we show the effect of the softmax temperature. The scaling of $\sqrt{D}$ clearly improves the performance on both tasks.

Offset for numerical stability In Figure 16, we show that adding a small offset to the attention maps (for numerical stability) as in Algorithm 1 compared to the alternative of adding an offset to the denominator in the weighted mean does not significantly change the result in either task.

Learning rate schedules In Figure 17 and 18, we show the effect of our decay and warmup schedules. While we observe a clear benefit from the decay schedule, the warmup seem to be mostly useful in the object discovery setting, where it helps avoid failure cases of getting stuck in a suboptimal solution (e.g., clustering the image into stripes as opposed to objects).

Number of training slots In Figure 19, we show the effect of training with a larger number of slots than necessary. We train both the object discovery and property prediction methods on CLEVR6 with the number of slots we used in our CLEVR10 experiments (note that for object discovery we use an additional slot to be consistent with the baselines). We observe that knowing the precise number of objects in the dataset is generally not required. Training with more slots may even help in the property prediction experiments and is slightly harmful in the object discovery. Overall, this indicates that the model is rather robust to the number of slots (given enough slots to model each object independently). Using a (rough) upper bound to the number of objects in the dataset seem to be a reasonable selection strategy for the number of slots.

Soft k-means Slot Attention can be seen as a generalized version of the soft k-means algorithm . We can reduce Slot Attention to a version of soft k-means with a dot-product scoring function (as opposed to the negative Euclidean distance) by simultaneously replacing the GRU update, all LayerNorm functions and the key/query/value projections with the identity function. Specifically, instead of the GRU update, we simply take the output of Line 8 in Algorithm 1 as the next value for the slots. With these ablations, the model achieves $75.5\pm 3.8\%$ ARI on CLEVR6, compared to $98.8\pm 0.3\%$ for the full version of Slot Attention.

Appendix C Further Experimental Results

Experiments on a single V100 GPU with 16GB of RAM with 500k steps and a batch size of 64 ran for approximately 7.5hrs for Tetrominoes, 24hrs for multi-dSprites, and 5 days, 13hrs for CLEVR6 (wall-clock time).

Qualitative results

In Figure 20, we show qualitative segmentation results for a Slot Attention model trained on the object discovery task. This model is trained on CLEVR6 but uses $K=11$ instead of the default setting of $K=7$ slots during both training and testing, while all other settings remain unchanged. In this particular experiment, we trained 5 models using this setting with 5 different random seeds for model parameter initialization. Out of these 5 models, we found that a single model learned the solution of placing the background into a separate slot (which is the one we visualize). The typical solution that a Slot Attention-based model finds (for most random seeds) is to distribute the background equally over all slots, which is the solution we highlight in the main paper. In Figure 20 (bottom two rows), we further show how the model generalizes to scenes with more objects (up to 10) despite being trained on CLEVR6, i.e., on scenes containing a maximum of 6 objects.

C.2 Set Prediction

Experiments on a single V100 GPU with 16GB of RAM with 150k steps and a batch size of 512 ran for approximately 2 days and 3hrs for CLEVR (wall-clock time).

Qualitative results

In Table 1, we show the predictions and attention coefficients of a Slot Attention model on several challenging test examples for the supervised property prediction task. The model was trained with default settings ($T=3$ attention iterations) and the images are selected by hand to highlight especially difficult cases (e.g., multiple identical objects or many partially overlapping objects in one scene). Overall, we can see that the property prediction typically becomes more accurate with more iterations, although the accuracy of the position prediction may decrease. This is not surprising as we only apply the loss at $t=3$, and generalization to more time steps at test time is not guaranteed. We note that one could alternatively apply the loss at every iteration during training, which has the potential to improve accuracy, but would increase computational cost. We observe that the model appears to handle multiple copies of the same object well (top). On very crowded scenes (middle and bottom), we note that the slots have a harder time segmenting the scene, which can lead to errors in the prediction. However, more iterations seem to sharpen the segmentation which in turns improves predictions.

Numerical results

To facilitate comparison with our method, we report the results of Figure 5 of the main paper (left subfigure) in numerical form in Table 2 as well as the performance of DSPN with 10 iterations (as opposed to 30). We note that our approach has generally higher average $AP$ compared to DSPN and lower variance. We remark that the published implementation of DSPN uses a significantly deeper image encoder than our model: ResNet 34 vs. a CNN with 4 layers. Further, we use the same scale for all properties (each coordinate in the prediction vector is in $$), while in DSPN the object-coordinates are rescaled to$$ and every other property is in $$.

Results partitioned by number of objects

Here, we break down the results from Table 2 for the Slot Attention model into separate bins that measure the AP score solely for images with a certain fixed number of objects. This is different from Figure 5 (right subfigure) in the main paper, where we test generalization to more objects at test time. We can observe that the rate of mistakes increases with the number of objects in the scene.

To analyse to what degree this can be addressed by increasing the number of iterations that are used in the Slot Attention module, we run the same experiment where we increase the number of iterations at test time from 3 to 5 iterations for a model trained with 3 iterations. We can see that increasing the number of iterations significantly improves results for difficult scenes with many objects, whereas this has little effect for scenes with only a small number of objects.

Step-wise loss & coordinate scaling

We investigate a variant of our model where we apply the set prediction component and loss at every iteration of the attention mechanism, as opposed to only after the final step. A similar experiment was reported in for the DSPN model. As DSPN uses a different scale for the position coordinates of objects by default, we further compare against a version of our model where we similarly use a different scale. Using a different scale for the object location increases its weight in the loss. We observe the effect of the coordinate scale and of computing the loss at each step in Figure 23.

A scale of 1 corresponds to our default coordinate normalization of $$, whereas larger scales correspond to a$[0,\texttt{scale}]$ normalization of the coordinates (or shifted by an arbitrary constant). Overall, we observe that computing the loss at each step in Slot Attention improves the AP score at all distance thresholds as opposed to DSPN, where it is only beneficial at small distance thresholds. We conjecture that this is an optimization issue in DSPN. As expected, increasing the importance of accurately modeling position in the loss impacts the AP positively at smaller distance thresholds, but can otherwise have a negative effect on predicting other object attributes correctly.

Appendix D Permutation Invariance and Equivariance

Before giving the proof for Proposition 1, we formally define permutation invariance and equivariance.

D.2 Proof

The proof is straightforward and is reported for completeness. We rely on the fact that the sum operation is permutation invariant.

As the linear projections are applied independently per slot/input element with shared parameters, they are permutation equivariant.

Equation 1

where we indicate with e.g. $\pi_{i}(k)$ the transformation of the coordinate $k$ with the permutation matrix $\pi_{i}$. The second equality follows from the fact that the sum is permutation invariant.

Equation 2

The matrix product in the computation of the updates involves a sum over the input elements which makes the operation invariant w.r.t. permutations of the input order (i.e. $\pi_{i}$) and equivariant w.r.t. the slot order (i.e. $\pi_{s}$).

Slot update:

The slot update applies the same network to each slot with shared parameters. Therefore, it is a permutation equivariant operation w.r.t. the slot order.

Combining all steps:

As all steps in the algorithms are permutation equivariant wrt $\pi_{s}$, the overall module is permutation equivariant. On the other hand, Equation 2 is permutation invariant w.r.t. to $\pi_{i}$. Therefore, after the first iteration the algorithm becomes permutation invariant w.r.t. the input order.

Appendix E Implementation and Experimental Details

For the Slot Attention module we use a slot feature dimension of $D=D_{\texttt{slots}}=64$. The GRU has $64$-dimensional hidden state and the feedforward block is a MLP with single hidden layer of size 128 and ReLU activation followed by a linear layer.

The CNN Encoder used in our experiments is depicted in Table 3 for CLEVR and Table 4 for Tetrominoes and Multi-dSprites. For the property prediction task on CLEVR, we reduce the size of the representation by using strides in the CNN backbone. All convolutional layers use padding SAME and have a bias weight. After this backbone, we add position embeddings (Section E.2) and then flatten the spatial dimensions. After applying a layer normalization, we finally add $1\times 1$ convolutions which we implement as a shared MLP applied at each spatial location with one hidden layer of $64$ units (32 for Tetrominoes and Multi-dSprites) with ReLU non-linearity followed by a linear layer with output dimension of $64$ (32 for Tetrominoes and Multi-dSprites).

E.2 Positional Embedding

As Slot Attention is invariant with respect to the order of the input elements (i.e., it treats the input as a set of vectors, even if it is an image), position information is not directly accessible. In order to give Slot Attention access to position information, we augment input features (CNN feature maps) with positional embeddings as follows: (i) We construct a $W\times H\times 4$ tensor, where $W$ and $H$ are width and height of the CNN feature maps, with a linear gradient $$in each of the four cardinal directions. In other words, each point on the grid is associated with a 4-dimensional feature vector that encodes its distance (normalized to$$) to the borders of the feature map along each of the four cardinal directions. (ii) We project each feature vector to the same dimensionality as the image feature vectors (i.e., number of feature maps) using a learnable linear map and add the result to the CNN feature maps.

E.3 Deconvolutional Slot Decoder

For the object discovery task, our architecture is based on an auto-encoder, where we decode the respresentations produced by Slot Attention with the help of a slot-wise spatial broadcast decoder with shared parameters between slots. Each spatial broadcast decoder produces an output of size width$\times$height$\times 4$, where the first 3 output channels denote RGB channels of the reconstructed image and the last output channel denotes a predicted alpha mask, that is later used to recombine individual slot reconstructions into a single image. The overall architecture for used for CLEVR is described in Table 5 and for Tetrominoes and Multi-dSprites in Table 6.

The spatial broadcast decoder is applied independently on each slot representation with shared parameters between slots. We first copy the slot representation vector of dimension $D_{\texttt{slots}}$ onto a grid of shape width$\times$height$\times D_{\texttt{slots}}$, after which we add a positional embedding (see Section E.2). Finally, this representation is passed through several de-convolutional layers.

Slot recombination

The final output of the spatial broadcast decoder for each slot is of shape width$\times$height$\times 4$ (ignoring the slot and batch dimension). We first split the final channels into three RGB channels and an alpha mask channel. We apply a softmax activation function across slots on the alpha masks and lastly recombine all individual slot-based reconstructions into a single reconstructed image by multiplying each alpha mask with each respective reconstructed image (per slot) and lastly by performing a sum reduction on this respective output over the slot dimension to arrive at the final reconstructed image. For visualization of the reconstruction masks in a single image, we replace each individual reconstructed image (per slot) with a unique slot-specific color (see, e.g., third column in Figure 20).

E.4 Set Prediction Architecture

For the property prediction task, we apply a MLP on each slot (with shared parameters between slots) and train the overall network with the Huber loss following . The Huber loss takes the form of a squared error $0.5x^{2}$ for values $|x|<1$ and a linearly increasing error with slope 1 for $|x|\geq 1$. The MLP has one hidden layer with 64 units and ReLU.

The output of this MLP uses a sigmoid activation as we one-hot encode the discrete features and normalize continuous features between $$. The overall network is presented in Table 7

E.5 Slot MLP Baseline

For the Slot MLP baseline we predict the slot representation with a MLP as shown in Tables 8 and 9. This module replaces our Slot Attention module and is followed by the same decoder/classifier. Note that we resize images to $16\times 16$ before flattening them into a single feature vector to reduce the number of parameters in the MLP.

E.6 Other Hyperparameters

All shared hyperparameters common to each experiments can be found in Table 10(a). The hyperparameters specific to the object discovery and property prediction experiments can be found in Tables 10(b) and 10(c) respectively.

In both experiments, we use a learning rate warm-up and exponential decay schedules. For the learning rate warm-up, we linearly increase the learning rate from zero to the final learning rate during the first steps of training. For the decay, we decrease the learning rate by multiplying it by an exponentially decreasing decay rate:

where the decay rate governs how much we decrease the learning rate. See Table 10 for the parameters of the two schedules.

E.7 Hyperparameter Optimization

We started with an architecture and a hyperparameter setting close to that of . We tuned hyperparameters on the object discovery task based on the achieved ARI score on a small subset of training images (320) from CLEVR. We only considered $5$ values for the learning rate $[1e-4,4e-4,2e-4,4e-5,1e-5]$ and batch sizes of $$. For property prediction, we took the same learning rate as in object discovery and we computed the AP on a small subset of training images (500). We considered batch sizes of$$ (as we were able to fit larger batches onto a single GPU due to the lower memory footprint of this model).

E.8 Datasets

We use the CLEVR dataset, which consists of rendered scenes containing multiple objects. Each object has annotations for position ($x,\ y,\ z)$ coordinates in $$), color ($8$possible values), shape ($3$possible values), material, and size ($2$possible values). The number of objects varies between$3$and$10$and, similarly to , we zero-pad the targets so that their number is constant in the batch and add an extra dimension indicating whether labels correspond to true objects or padding. For this task, we use the original version of CLEVR to be consistent with and compare with their reported numbers as well as our best-effort re-implementation. We pre-process the object location to be in$$and reshape the images to a resolution of$128\times 128$. Image features (RGB values) are normalized to$$.

Object Discovery

For object discovery, we use three of the datasets provided by the Multi-Object Datasets library , available at https://github.com/deepmind/multi_object_datasets. See the aforementioned repository for a detailed description of the datasets. We use CLEVR (with masks), Multi-dSprites, and Tetrominoes. We split the TFRecords file of the CLEVR (with masks) dataset into multiple shards to allow for faster loading of the dataset from disk. We normalize all image features (RGB values) to $$. Images in Tetrominoes and Multi-dSprites are of resolution$35\times 35$and$64\times 64$, respectively. For CLEVR (with masks), we perform a center-crop with boundaries <span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">(</mo><mi>w</mi><mi>i</mi><mi>d</mi><mi>t</mi><mi>h</mi><mo stretchy="false">)</mo><mi>a</mi><mi>n</mi><mi>d</mi></mrow><annotation encoding="application/x-tex">(width) and</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mord mathnormal">i</span><span class="mord mathnormal">d</span><span class="mord mathnormal">t</span><span class="mord mathnormal">h</span><span class="mclose">)</span><span class="mord mathnormal">an</span><span class="mord mathnormal">d</span></span></span></span></span> (height), as done in , and afterwards resize the cropped images to a resolution of$128\times 128$. As done in , we filter the CLEVR (with masks) dataset to only retain scenes with a maximum number of 6 objects, and we refer to this dataset as CLEVR6, whereas the original dataset is referred to as CLEVR10.

E.9 Metrics

Following earlier work , we use the Adjusted Rand Index (ARI) score to compare the predicted alpha masks produced by our decoder against ground truth instance segmentation masks. ARI is a score that measures clustering similarity, where an ARI score of 1 corresponds to a perfect match and a score of 0 corresponds to chance level. We exclude the background label when computing the ARI score as done in . We use the implementation provided by the Multi-Object Datasets library , available at https://github.com/deepmind/multi_object_datasets. For a detailed description of the ARI score, see the aforementioned repository.

Average Precision

We consider the same setup of Zhang et al. , where the average precision is computed across all images in the validation set. As the network predicts a confidence for each detection (real objects have target 1, padding objects 0), we first sort the predictions based on their prediction confidence. For each prediction, we then check if in the corresponding ground truth image there was an object with the matching properties. A detection is considered a true positive if the discrete predicted properties (obtained with an argmax) exactly match the ground truth and the position of the predicted object is within a distance threshold of the ground truth. Otherwise, a detection is considered a false positive. We then compute the area under the smoothed precision recall curve at unique recall values as also done in . Ours is a best-effort re-implementation of the AP score as described in . The implementation provided by can be found at https://github.com/Cyanogenoid/dspn.