Multi-Scale Fusion for Object Representation

## Abstract

Abstract Representing images or videos as object-level feature vectors, rather than pixel-level feature maps, facilitates advanced visual tasks.
Object-Centric Learning (OCL) primarily achieves this by reconstructing the input under the guidance of Variational Autoencoder (VAE) intermediate representation to drive so-called slots to aggregate as much object information as possible.
However, existing VAE guidance does not explicitly address that objects can vary in pixel sizes while models typically excel at specific pattern scales.
We propose Multi-Scale Fusion (MSF) to enhance VAE guidance for OCL training.
To ensure objects of all sizes fall within VAE’s comfort zone, we adopt the image pyramid , which produces intermediate representations at multiple scales;
To foster scale-invariance/variance in object super-pixels, we devise inter / intra-scale fusion , which augments low-quality object super-pixels of one scale with corresponding high-quality super-pixels from another scale.
On standard OCL benchmarks, our technique improves mainstream methods, including state-of-the-art diffusion-based ones.
The source code is available in the supplemental material.

## 1 Introduction

According to vision cognition research, humans perceive a visual scene as objects and relations among them for higher-level cognition such as understanding, reasoning, prediction, planning and decision-making (Bar, ; Cavanagh, ; Palmeri & Gauthier, ). In computer vision, Object-Centric Learning (OCL) is a promising way to achieving similar effects – Images or video frames are represented as sparse object-level feature vectors, known as slots, rather than dense (super-)pixel-level feature maps under weak or self-supervision (Greff et al., ; Burgess et al., ). Meanwhile, segmentation masks of objects and the background are generated as byproducts, intuitively reflecting the corresponding object representation quality of these slots.

Object-level representation learning is highly influenced by textures. Early OCL methods, such as the mixture-based (Locatello et al., ; Kipf et al., ; Elsayed et al., ), which directly reconstruct the input pixels as supervision, often struggle with objects that have complex textures. To address this issue, mainstream OCL methods, such as transformer-based (Singh et al., ; ), foundation-based (Seitzer et al., ; Zadaianchuk et al., ) and diffusion-based (Jiang et al., ; Wu et al., ), leverage well-learnt intermediate representation for guided reconstruction, so as to drive slots to aggregate as much object-level information as possible.

Objects can appear at different scales in images or videos due to variations in imaging distance and their actual sizes. At the same time, encoders/decoders usually perform optimally at specific pattern scales, thus ”divide-and-rule” is necessary like in object detection and instance/panoptic segmentation (Zou et al., ; Minaee et al., ). Mainstream OCL methods, however, do not explicitly provide such multi-scale guidance to object representation. This is a long-overlooked bottleneck that limits mainstream OCL performance.

Figure: Figure 1: Multi-scale fusion is necessary in VAE guidance to OCL training. Upper right: simplified architecture of OCL with VAE guidance. Upper left: single-scale VAE encoding/decoding only represent patterns of some certain scale in high quality/confidence. Lower left and right: by resizing the input into different sizes, patterns of different scales all fall within the VAE encoder/decoder’s comfort-zone. For instance, in scale 1, the low quality super-pixels of objects 2 and 3 can be augmented by their corresponding high quality super-pixels in scales 2 and 3, respectively.
Refer to caption: x1.png

Suppose there are three objects of different sizes in the input image or video frame. As shown in Fig. 1 upper left, current single-scale VAE encoding/decoding are likely only good at some specific scale of patterns, and only represent object 1 in high quality or confidence, leaving the other two being represented in low quality/confidence. Thus the intermediate representation of such single-scale VAE could not provide good guidance to OCL training on objects 2 and 3. But, as shown in Fig. 1 lower left and right, if we resize the input into three scales, we can ensure all the objects fall within the comfort-zone of the VAE encoder/decoder. Moreover, as shown in Fig. 1 lower left center, for scale 1, the low-quality super-pixels of object 2 and 3 can be augmented by their corresponding representations in scale 2 and 3, respectively. This is our motivation.

We propose Multi-Scale Fusion (MSF) upon VAE intermediate representation, to guide OCL of both the transformer-based classics and diffusion-based state-of-the-arts.
(i) We adopt the image pyramid technique, which resizes input images or video frames into different scales, to ensure objects of various sizes always fall within VAE encoder/decoder’s comfort zones.
(ii) We devise inter/intra-scale quantized fusion, which quantize VAE intermediate representation of different scales with shared/specified codebooks, to foster scale-invariance/variance in object representation.
(iii) Our technique augments VAE intermediate discrete representation with better object separability and, in turn, provides better guidance for OCL training.

## 2 Related Work

VAE & OCL. Pretrained VAE models (Im Im et al., ; Van Den Oord et al., ), like dVAE or VQ-VAE, are often used to provide well-learnt intermediate representations that highlight object separability in the input’s feature maps by suppressing texture redundancies for OCL. With such guidance, transformer-based OCL methods (Singh et al., ; ), like SLATE and STEVE, decode slots, which are extracted by SlotAttention (Locatello et al., ) from input images or video frames, into the input via a transformer decoder. Similarly, diffusion-based methods (Jiang et al., ; Wu et al., ), like SlotDiffusion, decode slots via a diffusion model. These architectures drive slots to aggregate as much object information as possible, forming good object representation. Our work is conducted upon these two lines of work. And foundation-based methods (Seitzer et al., ; Zadaianchuk et al., ), like DINOSAUR, are also included for complete comparison.

Channel Grouping. Grouping features along the channel dimension helps to learn expressive representations, making it widely adopted in CNNs (Zhang et al., ) and ViTs (Gu et al., ). Grouping can be performed directly on feature map channels (Krizhevsky et al., ; Huang et al., ; Chen et al., ), or indirectly on convolution weights (Zhao et al., ; ). This is also explored in OCL setting. SysBinder (Singh et al., ) groups slots’ queries to aggregate different object information, achieving emerging attributes under extra supervision. The most recent GDR (Zhao et al., ) and OGDR (Zhao et al., ) group the VAE codebook from feature level into combinable attribute level, achieving better generalizability and convergence in object representing. Our work also groups it but for scale-invariance and -variance.

Multi-Scale. Objects can exist at multiple scales due to variations in type and distance. Visual pattern processors like CNN (Zhang et al., ) and ViT (Gu et al., ) typically have their comfort zones as the scale distribution of objects in training data is always nonuniform. In computer vision tasks, like object detection (Zou et al., ) and instance/panoptic segmentation (Minaee et al., ), the multi-scale issue is significant, leading to the wide adoption of “divide-and-rule”. Multi-scale training using the image pyramid (Adelson et al., ) makes object scale distribution more uniform. Multi-scale designs like feature pyramid network (Lin et al., ) augment feature representations of different scales with one another, which are usually heavy and implicit. We address the multi-scale issue explicitly in the OCL setting for the first time.

## 3 Proposed Method

We propose Multi-Scale Fusion (MSF), to explicitly address the multi-scale issue in VAE intermediate representation, and thereby to guide Object-Centric Learning (OCL) better. Our technique is applicable to both transformer-based OCL (Singh et al., ; ) classics and diffusion-based OCL (Wu et al., ) state-of-the-arts, which are our basis methods.
Note that two types of methods use dVAE (Im Im et al., ) and VQ-VAE (Van Den Oord et al., ) respectively, but we unify them with VQ-VAE like that in OGDR (Zhao et al., ).

### 3.1 Background: OCL with VAE Guidance

Assume there is an input image or video frame $\bm{T}\in\mathbb{R}^{h_{0}\times w_{0}\times c_{0}}$, where typically $h_{0}=w_{0}=128$ and $c_{0}=3$.

Initially, the primary encoder encodes the input into a feature map. $\bm{\phi}_{\mathrm{e}}:\bm{T}\rightarrow\bm{F}$, where $\bm{F}\in\mathbb{R}^{h\times w\times c}$, and $\bm{\phi}_{e}$ is a CNN (He et al., ) or ViT (Caron et al., ) module. Typically, $h=w=32$ and $c=256$.

Then, the Slot Attention (SA) (Locatello et al., ) is used to aggregate the dense feature map $\bm{F}$ into sparse object-level feature vectors, i.e., slots $\bm{S}\in\mathbb{R}^{s\times c}$, along with the byproduct, i.e., segmentation masks $\bm{M}\in\mathbb{R}^{s\times h\times w}$, under query vectors $\bm{S}_{0}$. $\bm{\phi}_{\mathrm{sa}}:(\bm{S}_{0},\bm{F})\rightarrow(\bm{S},\bm{M})$, which is basically an iterative Query-Key-Value attention (Bahdanau et al., ) mechanism with $\bm{S}_{0}$ as the query and $\bm{F}$ as the key and value. Typically, $s$ is a predefined number, usually the maximum number of objects plus the background in an image or video sample of a dataset.

Meanwhile, pretrained VAE (Im Im et al., ; Van Den Oord et al., ) converts $\bm{T}$ into continuous intermediate representation. $\bm{\phi}_{\mathrm{e}}^{\mathrm{v}}:\bm{T}\rightarrow\bm{Z}$, where $\bm{Z}\in\mathbb{R}^{h\times w\times c}$ and typically $h=w=32$ and $c=256$. This continuous representation is quantized into discrete representation by matching continuous representation with codebook and selecting matched codes to form discrete representation. $f_{\mathrm{q}}=f_{\mathrm{m}}\circ f_{\mathrm{s}}:(\bm{Z},\bm{C})\rightarrow(
\bm{P},\bm{I},\bm{X})$, where codebook $\bm{C}\in\mathbb{R}^{m\times c}$, matching probabilities $\bm{P}\in\mathbb{R}^{h\times w\times m}$, matched indexes $\bm{I}\in\mathbb{R}^{h\times w}$ and discrete representation $\bm{X}\in\mathbb{R}^{h\times w\times c}$. The matching $f_{\mathrm{m}}$ and selection $f_{\mathrm{s}}$ are implemented as below, respectively

$$ $\bm{P}=\mathrm{softmax}_{m}(-||\bm{Z}-\bm{C}||_{2}),\quad\bm{I}=\mathrm{argmax }_{m}(\bm{P})$ (1) $$

$$ $\bm{X}=\mathrm{select}_{m}(\bm{C},\bm{I})$ (2) $$

where each super-pixel $\bm{P}^{(i,j,:)}\in\mathbb{R}^{m}$ means the matching probabilities of the $m$ template features in $C$. So the index of the maximum element in $\bm{P}^{(i,j,:)}$, i.e., $\bm{I}^{(i,j)}$ is the index of the most matched code, which can quantize $\bm{Z}^{(i,j,:)}$ into $\bm{X}^{(i,j,:)}:=\bm{C}^{(\bm{I}^{(i,j)},:)}$.

Lastly, with $\bm{S}$ as the condition, the primary decoder reconstructs the input guided by VAE discrete intermediate representation conditioned on $\bm{S}$, which drives every slot to aggregate as much object information as possible. $\bm{\phi}_{\mathrm{d}}:(\bm{X},\bm{S})\rightarrow\bm{X}^{\prime}$, where $\bm{X}^{\prime}\in\mathbb{R}^{h\times w\times c}$. For transformer-based OCL, a transformer decoder (Vaswani et al., ) with internal masking performs the reconstruction as classification. For diffusion-based OCL, a diffusion model, typically a conditional UNet (Rombach et al., ), carries out the reconstruction as regression of the noise added to $\bm{X}$.

For VAE pretraining, there is also VAE decoding from discrete representation to the input $\bm{\phi}_{\mathrm{d}}^{\mathrm{v}}:\bm{X}\rightarrow\bm{T}^{\prime}$, where $\bm{T}^{\prime}\in\mathbb{R}^{h_{0}\times w_{0}\times c_{0}}$. And the supervision signal comes from Mean-Squared Error (MSE) between $\bm{T}$ and $\bm{T}^{\prime}$.
For OCL training, the pretrained VAE module is frozen, and no VAE decoding occurs. Remaining parts are trained under the supervision signal of either Cross Entropy (CE) between $\bm{X}$ and $\bm{X}^{\prime}$, or Mean-Squared Error (MSE) between the ground-truth noise added to $\bm{X}$ and the reconstructed noise.

### 3.2 Naive Multi-Scale Training

In images or videos, there can be objects of different pattern sizes due to their original sizes and distances to the imaging point; On the other hand, however, models processing them usually have their best-at scales of visual patterns because of the non-uniform object size distribution of their training data.
An effective solution is image pyramid (Adelson et al., ), which resizes the input into different sizes for parallel processing via the model. During training, these naive multi-scale representations make the pattern scale distribution more uniform; during testing, this ensures different size objects fall within the model’s comfort zone.

Assume the input image or video frame is $\bm{T}_{1}:=\bm{T}$, and is down-sampled with typical bi-linear interpolation into $\bm{T}_{n}\in\mathbb{R}^{\frac{h_{0}}{2^{n-1}}\times\frac{w_{0}}{2^{n-1}}
\times c_{0}}$, where $n=1...N$ means different spatial scales and we use $N=3$.

Multi-scale VAE encoding is $\bm{\phi}_{\mathrm{e}}^{\mathrm{v}}:\bm{T}_{n}\rightarrow\bm{Z}_{n}$, where $\bm{Z}_{n}\in\mathbb{R}^{\frac{h}{2^{n-1}}\times\frac{w}{2^{n-1}}\times c}$ and typically $h=w=32$ and $c=256$.

Multi-scale VAE quantization is $f_{\mathrm{q}}=f_{\mathrm{m}}\circ f_{\mathrm{s}}:(\bm{Z}_{n},\bm{C})
\rightarrow(\bm{P}_{n},\bm{I}_{n},\bm{X}_{n})$, where $\bm{P}_{n}\in\mathbb{R}^{\frac{h}{2^{n-1}}\times\frac{w}{2^{n-1}}\times m}$, $\bm{I}_{n}\in\mathbb{R}^{\frac{h}{2^{n-1}}\times\frac{w}{2^{n-1}}}$ and $\bm{X}_{n}\in\mathbb{R}^{\frac{h}{2^{n-1}}\times\frac{w}{2^{n-1}}\times c}$. Here codebook $\bm{C}$ is shared over all $N$ scales of representation so as to facilitate scale-invariant pattern learning that differentiates among different object types. But this strong inductive bias can lose scale-variant information that differentiates among different object instances of the same type; Besides, no information exchange among the scales is a kind of information waste – The object pattern that is well represented in one scale should augment its poorly represented patterns in the other scales. We will address this in the next subsection.

Multi-scale VAE decoding is $\bm{\phi}_{\mathrm{d}}^{\mathrm{v}}:\bm{X}_{n}\rightarrow\bm{T}_{n}^{\prime}$, where $\bm{T}_{n}^{\prime}\in\mathbb{R}^{\frac{h_{0}}{2^{n-1}}\times\frac{w_{0}}{2^{n
-1}}\times c}$.

During VAE pretraining, there are $N$ sets of reconstruction and quantization losses, each of which is defined identically to those in the former subsection.
During OCL training, only scale $n=1$ is used as guidance, thus the supervision is no different from that in the former section. Although multi-scale guidance can be used, it is always harmful in practice. This can be attributed to that scales $n>1$ have too large down sampling and lose too much information to guide object-level information aggregation.

By following such recipe, hopefully at least one of the $N$ scales of representation provides high-quality representation to an arbitrary size object.

Note: The original VQ-VAE has only $n=1$ scale, which is a special case of our method.

### 3.3 Inter/Intra-Scale Quantized Fusion

Based on the naive multi-scale quantization, we further devise inter/intra-scale fusion among those multi-scale representations. Inter-scale fusion utilizes scale-invariance to augment poorly represented features in some scales with the well-represented features in another scale; Intra-scale fusion augments the aforementioned scale-invariant features with the scale-variant features in the same scale. We refer to scale-invariance as patterns that differentiate among different object types, and scale-variance as patterns that distinguish among different object instances of the same type.

Firstly, we project VAE continuous intermediate representation of a certain scale $\bm{Z}_{n}$ into two copies, $\bm{Z}_{n}^{\mathrm{si}}$ for scale-invariance and $\bm{Z}_{n}^{\mathrm{sv}}$ for scale-variance, respectively.
These two copies will ultimately be combined back after quantized fusion, thus we employ the invertible project-up-project-down design proposed in Zhao et al. () to maintain the inductive biases added in between.

$$ $\bm{Z}_{n}^{\mathrm{si}},\bm{Z}_{n}^{\mathrm{sv}}=\mathrm{chunk}_{c,2}(\bm{Z}_ {n}\cdot\mathrm{pinv}(W))$ (3) $$

where $\mathrm{pinv}(W)$ is pseudo-inverse of the project-down matrix in Eq. 5 for project-up here; $\mathrm{chunk}_{c,2}(\cdot)$ splits the tensor into two along the channel dimension.

Secondly, for the scale-variant continuous representation, we conduct quantization by a codebook specific to the current scale. $f_{\mathrm{q}}=f_{\mathrm{m}}\circ f_{\mathrm{s}}:(\bm{Z}_{n}^{\mathrm{sv}},
\bm{C}_{n}^{\mathrm{sv}})\rightarrow(\bm{P}_{n}^{\mathrm{sv}},\bm{I}_{n}^{
\mathrm{sv}},\bm{X}_{n}^{\mathrm{sv}})$. These non-sharing codebooks allow for scale-variant representation learning.

Meanwhile, for the scale-invariant continuous representation, we conduct inter-scale fusion over scale-invariant quantized representations of all scales. $f_{\mathrm{rf}}:\{(\bm{Z}_{n}^{\mathrm{si}},\bm{C}^{\mathrm{si}})\}\rightarrow
\{(\dot{\bm{P}}_{n}^{\mathrm{si}},\dot{\bm{I}}_{n}^{\mathrm{si}},\dot{\bm{X}}_
{n}^{\mathrm{si}})\}$, where $n=1...N$. The shared codebook enforces scale-invariant representation learning.

Now that all scales $\{\bm{X}_{n}^{\mathrm{si}}\}$ consist of codes in a shared codebook $\bm{C}^{\mathrm{si}}$ with corresponding matching probabilities $\{\bm{P}_{n}^{\mathrm{si}}\}$, for the same (super-)pixel region under $N$ scales, the matching probabilities indicate how confident the model is about the representation quality. We utilize this to augment the low-confidence/quality representation in some scales with the high-confidence/quality representation in another scale, as below.
Take scales $n-1$, $n$ and $n+1$ as an example:

- 1.
Given any super-pixel $\bm{z}_{n}^{\mathrm{si}}:=\bm{Z}_{n}^{\mathrm{si},(i,j,:)}\in\mathbb{R}^{c}$ in any scale $n$, find the corresponding region/super-pixel(s) in other scales, and mean them along all spatial dimensions as voting. For scale $n-1$, we choose $\bm{Z}_{n-1}^{\mathrm{si},(2i:2i+2,2j:2j+2,:)}\in\mathbb{R}^{2\times 2\times c}$ and mean it into a vector $\bm{z}_{n-1}^{\mathrm{si}}\in\mathbb{R}^{c}$; For scale $n+1$, we choose $\bm{z}_{n+1}^{\mathrm{si}}:=\bm{Z}_{n+1}^{\mathrm{si},(\lfloor\frac{i}{2}
\rfloor,\lfloor\frac{j}{2}\rfloor,:)}\in\mathbb{R}^{c}$.
- 2.
Match $\{\bm{z}_{n-1}^{\mathrm{si}},\bm{z}_{n}^{\mathrm{si}},\bm{z}_{n+1}^{\mathrm{si
}}\}$ respectively with codebook $\bm{C}^{\mathrm{si}}$ as in Eq. 1, then we have corresponding matching probabilities $\{\bm{p}_{n-1}^{\mathrm{si}},\bm{p}_{n}^{\mathrm{si}},\bm{p}_{n+1}^{\mathrm{si
}}\}\in\{\mathbb{R}^{m}\}$. These probabilities can be taken as the super-pixel quality of the same region in scales $\{n-1,n,n+1\}$.
- 3.
Select the most matched code with the highest probability among all scales as the quantization $\dot{\bm{X}}_{n}^{\mathrm{si},(i,j,:)}$ of the super-pixel $\bm{Z}_{n}^{\mathrm{si},(i,j,:)}$. Specifically, for scales $\{n-1,n,n+1\}$, the most matched code index is
$\dot{\bm{I}}_{n}^{\mathrm{si},(i,j)}=\mathrm{argmax}_{m}(\mathrm{max}_{n}(\{
\bm{p}_{n-1}^{\mathrm{si}},\bm{p}_{n}^{\mathrm{si}},\bm{p}_{n+1}^{\mathrm{si}}
\}))$
(4)
with which we can determine $\dot{\bm{X}}_{n}^{\mathrm{si},(i,j,:)}$ as in Eq. 2.

Lastly, for each scale $n$, conduct the intra-scale fusion between the fused scale-invariant representation and scale-variant representation. $f_{\mathrm{af}}:(\dot{\bm{X}}_{n}^{\mathrm{si}},\bm{X}_{n}^{\mathrm{sv}})
\rightarrow\bm{X}_{n}$. This combines the augmented scale-invariant and scale-variant copies back into the final discrete intermediate representation. Note that this projection follow the aforementioned invertible project-up-project-down design.

$$ $\bm{X}_{n}=\mathrm{concat}_{c}(\dot{\bm{X}}_{n}^{\mathrm{si}},\bm{X}_{n}^{ \mathrm{sv}})\cdot W$ (5) $$

where $\mathrm{concat}_{c}(\cdot)$ is channel concatenation; project-down matrix $W\in\mathbb{R}^{2c\times c}$ is trainable.

The above processes can be parallelized using PyTorch, as shown in Algo. 1 pseudo code.

### 3.4 Resource Consumption Analysis

Here we list our hyper-parameters and estimate the computation and memory consumption. We focus on the VAE part as our modifications to the basis methods only affect this part.

Codebook-related parameters. The basis methods use a codebook of size $(m,c)=4096\times 256$, which amounts to $1.048$M. We use (1) invertiable projection to project the continuous representation into two copies (and project them back), up to $c\times 2c=2^{17}$; (2) four groups of codebooks of size $(m^{0.5},c)=(64,256)$, one shared for $N=3$ scale-invariant scales, three specifically for $N=3$ scale-variant scales, up to $m^{0.5}\times c\times(1+N)=2^{16}$. Thus our codebook-related parameters are $0.196$M – we have $81.25\%$ fewer codebook parameters than the basis methods.

Computation and memory consumption. The exact calculation relates with the VAE encoder/decoder layers, like Conv2d, GroupNorm, Mish, etc., thus has too many details. But due to the $O(n^{2})$ complexity nature of convolution layers, we can quickly get the estimation in ratio. Denote the computation of the original VAE as unit, then our $N=3$ scales’ computations would be $1$, $\frac{1}{4}$ and $\frac{1}{16}$, since the latter two has $2\times$ and $4\times$ down sampling rates. Thus in VAE pretraining, our technique requires roughly $31.25\%$ more computation. The memory consumption increase is similar.

However, for OCL training, heavy modules, like the primary encoder, SlotAttention and primary decoder, are added. Thus the parameter decrease and resource consumption inscrease are all negligible. Besides, no hyper-parameters in our technique requires extra tuning.

Figure: Figure 2: Qualitative results of OCL unsupervised segmentation. The last row is our MSF.
Refer to caption: x2.png

## 4 Experiments

We experiment the following points: (i) Our technique MSF augments performance of mainstream OCL methods that are either transformer-based or diffusion-based. (ii) MSF fuses multi-scale information into VAE discrete representation and guides OCL better. (iii) How the composing designs of MSF contribute to its effectiveness. Results are mostly averaged over three random seeds.

### 4.1 OCL Performance

To evaluate the quality of the learnt object representation, we measure unsupervised segmentation accuracy using OCL’s byproduct segmentation masks. Like others, the metrics are ARI (Adjusted Rand Index) (^1^11https://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_rand_score.html), ARIfg (foreground), mIoU (mean Intersection-over-Union) (^2^22https://scikit-learn.org/stable/modules/generated/sklearn.metrics.jaccard_score.html) and mBO (mean Best Overlap) (Caron et al., ).
The datasets being used are either synthetic images, i.e., ClevrTex (^3^33https://www.robots.ox.ac.uk/~vgg/data/clevrtex/); or real-world images, i.e., COCO (^4^44https://cocodataset.org/#panoptic-2020) and VOC (^5^55http://host.robots.ox.ac.uk/pascal/VOC/voc2012/index.html); or synthetic videos, i.e., MOVi-C/D/E (^6^66https://github.com/google-research/kubric/tree/main/challenges/movi).

To evaluate how much performance our MSF can boost existing OCL methods, we use SLATE (Singh et al., ) and STEVE (Singh et al., ) to represent transformer-based classics, for images and videos respectively; use SlotDiffusion (Wu et al., ) to represent diffusion-based state-of-the-arts for images. We also include DINOSAUR (Seitzer et al., ) as a foundation-based representative. Similar improvers SysBinder (Singh et al., ) and OGDR (Zhao et al., ) are compared here too. We use DINO (Caron et al., ) as the primary encoder to make sure MSF is effective on very strong baselines.

Details about dataset processing, model architectures and training schemes are in the appendix.

As shown in Tab. 2, 2 and 4, MSF is beneficial to both transformer-based classics and diffusion-based state-of-the-arts. On complex synthetic dataset ClevrTex, MSF improves SLATE significantly, up to 12% in ARIfg. On challenging real-world dataset COCO, MSF still manages to improve SLATE by 6% in ARIfg. MSF even boosts SlotDiffusion, which is state-of-the-art, by 3% in ARI on VOC.
Compared with other improvers, i.e., SysBinder@$g$2 and OGDR@$g$2,
our MSF also beats or at least ties them on SLATE, while beats them consistently on STEVE.
On SlotDiffusion, our MSF beats the strong competitor OGDR@$g$2, and defeats DINOSUAR.

**Table 1: Transformer-based image OCL performance on synthetic and real-world datasets.**
|  | ARI | ARIfg | mIoU | mBO |
| --- | --- | --- | --- | --- |
|  | ClevrTex |  |  |  |
| SLATEr | 20.56 | 68.14 | 34.11 | 34.57 |
| +SysBind@2 | 23.27 | 71.27 | 35.63 | 36.62 |
| +OGDR@$g$2 | 34.46 | 73.38 | 37.42 | 36.69 |
| +MSF | 32.70 | 80.70 | 40.61 | 41.48 |
|  | COCO |  |  |  |
| SLATEr | 24.18 | 24.54 | 21.37 | 21.76 |
| +SysBind@2 | 25.71 | 24.97 | 21.46 | 22.01 |
| +OGDR@$g$2 | 30.37 | 29.95 | 23.47 | 22.98 |
| +MSF | 30.95 | 30.47 | 23.33 | 23.85 |
|  | VOC |  |  |  |
| SLATEr | 11.64 | 15.65 | 15.64 | 14.99 |
| +SysBind@2 | 11.75 | 16.04 | 15.73 | 15.01 |
| +OGDR@$g$2 | 13.20 | 17.49 | 16.46 | 16.65 |
| +MSF | 12.17 | 16.54 | 16.74 | 16.69 |

**Table 3: Diffusion-based image OCL on synthetic and real-world datasets. * Subscript “r” and “c” stand for random and condition query initialization, respectively.**
|  | ARI | ARIfg | mIoU | mBO |
| --- | --- | --- | --- | --- |
|  | ClevrTex |  |  |  |
| SlotDiffuzr | 64.21 | 26.50 | 31.51 | 32.44 |
| +OGDR@$g$2 | 69.21 | 37.83 | 34.74 | 34.03 |
| +MSF | 71.47 | 38.08 | 35.06 | 35.67 |
| DINOSAUR | 60.74 | 45.75 | 30.48 | 32.56 |
|  | COCO |  |  |  |
| SlotDiffuzr | 36.54 | 35.67 | 22.08 | 22.75 |
| +OGDR@$g$2 | 37.68 | 36.33 | 22.73 | 22.25 |
| +MSF | 37.63 | 36.99 | 22.32 | 22.87 |
| DINOSAUR | 33.24 | 33.35 | 22.01 | 21.93 |
|  | VOC |  |  |  |
| SlotDiffuzr | 16.97 | 14.33 | 15.71 | 16.02 |
| +OGDR@$g$2 | 18.20 | 15.59 | 16.11 | 17.04 |
| +MSF | 19.40 | 15.69 | 16.37 | 16.76 |
| DINOSAUR | 16.00 | 18.48 | 15.94 | 16.37 |

Therefore, our MSF is a general and effective improver to both transformer-based and diffusion-based OCL methods.

By the way, our MSF boosts OCL performance on COCO and VOC less than on other datasets. We attribute this to those object sizes are often out of the coverage of scales 1~3. Namely, many humans, trees and grass lands in those real-world images take up the whole scene, and either down sampling 4$\times$ (scale 1) or 16$\times$ (scale 3) cannot produce scale-invariant patterns for inter-scale fusion.

### 4.2 VAE Guidance

To investigate how MSF fuses multi-scale information into VAE guidance, we adopt the object separability analysis in (Stanic et al., ; Lowe et al., ). Intuitively, better object separability in VAE guidance contributes to better OCL performance.
Given the number of objects in current image or video frame, we conduct clustering on the VAE guidance; Then we can calculate the inter/intra-cluster distances for quantitative results;
Similarly, we also visualize the object separability separately of the scale-invariant representation $\{\dot{\bm{X}}_{n}^{\mathrm{si}}\}$ and scale-variant representation $\{\bm{X}_{n}^{\mathrm{sv}}\}$, as well as the representation before inter-scale fusion $\{\bm{X}_{n}^{\mathrm{si}}\}$ and the representation after intra-scale fusion $\{\bm{X}_{n}\}$, i.e., VAE guidance.
The visualization scheme follows (Stanic et al., ) and (Lowe et al., ), and the coloring scheme follows (Caron et al., ).

As shown in Fig. 3 and Tab. 4, with our MSF, good object separability can be observed both qualitatively and quantitatively in all scales $n=1...3$; By contrast, the object separability of the basis methods is consistently worse. Generally, as shown in Fig. 3, (i) image pyramid and shared codebook quantization equips $\{\bm{X}_{n}^{\mathrm{si}}\}$ with naive scale invariance; (ii) inter-scale fusion augments $\{\bm{X}_{n}^{\mathrm{si}}\}$ by one another and yields $\{\dot{\bm{X}}_{n}^{\mathrm{si}}\}$, where different sized objects are all well represented; (iii) non-shared codebook quantization enables $\{\bm{X}_{n}^{\mathrm{si}}\}$ to preserve scale-variance, i.e., more details; (iv) intra-scale fusion combines the scale-invariance of $\{\dot{\bm{X}}_{n}^{\mathrm{si}}\}$ and the scale variance of $\{\bm{X}_{n}^{\mathrm{sv}}\}$ together, and yields our $\{\bm{X}_{n}\}$, which provides better guidance to OCL compared with the naive VAE intermediate representation $\{\bm{X}\}$ of those basis methods.

Figure: Figure 3: Qualitative object separability of VAE guidance with our MSF. Take the upper left as an example. Super-pixels of the circled cube in scale 2 is represented in high-quality by VAE encoder, thus can augment the corresponding super-pixels in scale 1, via inter-scale fusion. Accordingly, the scale-invariant representations $\{\dot{\bm{X}}_{n}^{\mathrm{si}}\}$ are obtained. This can combine with the corresponding scale-variant super-pixels $\{\bm{X}_{n}^{\mathrm{sv}}\}$ in the same scale, producing representations $\{\bm{X}_{n}\}$ with good object separability, via intra-scale fusion. Note: quality values are not drawn.
Refer to caption: x3.png

### 4.3 Ablation Study

We use SLATE on ClevrTex as an example to evaluate how different designs contribute to our MSF. We use ARI+ARIfg as the metrics because ARI is primarily dominated by background segmentation performance while ARIfg only measures the foreground. We employ naive CNN (Kipf et al., ) as the primary encoder to reduce experiment time.

Inter/intra-scale fusion: with vs without. As shown in Tab. 5 upper left, both types of fusion are crucial to performance. Yet using inter-scale fusion alone can be even worse than disabling both, meaning that inter-scale fusion enforces scale-invariance at the cost of losing too much information, wheras intra-scale fusion can recover it. Therefore, enabling both types of fusion is the best setting.

Scale-invariant/variant codebook: shared vs specified. Firstly, using different codebooks as the scale-invariant codebook is meaningless because the corresponding matching probabilities for the same super-pixel cannot be compared. As shown in Tab. 5 upper right, sharing one codebook over different scales for the scale-variance is harmful to the performance. Hence different sets of codes are necessary to foster diverse patterns that are different among the scales.

Number of scales: 2, 3 or 4. As shown in Tab. 5 lower left, the default number of scales $N=3$ is the best setting. By contrast, $N=2$ includes too less explicit scales; As for $N=4$, its last scale, i.e., scale 4, down samples too much and loses too much spatial information to support the inter-scale fusion of our MSF technique.

Number of guidance: 1 or 2. After MSF in VAE, we have three augmented scales. But as shown in Tab. 5 lower right, using the augmented scale 1 as VAE guidance is the best choice, compared with either using both augmented scale 1 and 2, or using augmented scale 2 solely. This is because the augmented scale 1 representation has the largest resolution, i.e., the most spatial details, and also multiple scales of information. Although the other two scales are also multi-scale fused, the information incompleteness due to their low resolution is harmful to guide OCL training.

**Table 5: Ablation study of SLATE+MSF on ClevrTex using naive CNN as the primary encoder. (Upper left) effects of inter-scale fusion and intra-scale fusion; (Upper right) effects of specified or shared codebooks for scale-variance; (Lower left) effects of number of scales being used in VAE pretraining; (Lower right) effects of number of VAE guidance being used for OCL training.**
| inter-scale fuz | intra-scale fuz | ARI+ARIfg |
| --- | --- | --- |
| ✓ | ✓ | 100.71 |
| ✓ |  | 90.85 |
|  | ✓ | 95.64 |
|  |  | 91.03 |

## 5 Conclusion

We propose a technique named MSF to improve existing OCL methods, including both transformer-based classics and diffusion-based state-of-the-arts. Our technique is realized by integrating the naive image pyramid with our novel inter-scale quantized fusion and intra-scale quantized fusion. Our technique ensures different sizes of objects are all processed in VAE models’ comfort zone, and fosters scale-invariance and scale-variance in object representation. This is achieved at acceptable costs of extra computation and memory. We evaluate our technique via comprehensive experiments, and also interpret the multi-scale fusion processes by visualizing it. Such multi-scale fusion is also worth exploring in the primary encoder and slot attention part, or, in VAE designing for generative models, which are suggested for future work.

## Appendix A Appendix

### A.1 Model Architecture

The overall model structure is depicted in Fig. 1 upper right. It consists of a primary encoder, SlotAttention and primary decoder, as well as VAE encoder, codebook, and VAE decoder.

Primary Encoder

Unlike exiting works, which used a naive CNN or small ResNet, we use a pretrained foundation model DINO as the primary encoder on all datasets, so that we setup strong baseline to show our MSF’s effectiveness.

To save computation while maintain strong performance for all methods, we adopt the big-little design used in (Zhao et al., ), which takes small resolution 128 as input while still produce high resolution (128) feature maps. We employ the DINO v1, tiny, with a downsampling rate of 8, as presented in (Caron et al., ). We integrate this into a big-little architecture by running DINO in parallel with the previously mentioned naive CNN. The output of DINO is then projected, upsampled, and combined element-wise with the output of the CNN. The architecture is briefly represented as dino()-conv(k3s1p1)-upsample(k8) + naivecnn(). Notably, the weights of DINO are frozen, which retains its pretrained features while allowing the CNN to focus on refining high spatial details.

Hence, no spatial downsampling occurs within this module.
This part remains consistent across all experiments.

SlotAttention

We adhere to the standard design outlined in (Locatello et al., ). This design is consistent across all experiments utilizing this module.

Primary Decoder

This module can be either a transformer decoder or a diffusion model.

For transformer-based OCL, e.g., SLATE and STEVE, we follow the architecture described in (Singh et al., ), unified across all experiments involving this component.
This decoder operates on VAE intermediate feature tensors, which undergo 4x4 spatial downsampling relative to the input. SlotAttention-derived slots are provided as the conditioning input.
The input channel dimension for this module is set to 256.

For diffusion-based OCL, e.g., SlotDiffusion, we follow the architecture described in (Wu et al., ). This decoder take VAE representation with noise as input, taking slots, time step as condition, finally produce the reconstruction of the noise being added to the input.
The input channel dimension for this module is set to 4.

VAE Encoder & Decoder

The architecture of this module is in accordance with the design described in (Singh et al., ), and it is unified for all experiments incorporating this module.
The VAE encoder applies a 4x4 spatial downsampling, and the VAE decoder performs a corresponding 4x4 upsampling.

Codebook

This module distinguishes between dVAE and VQ-VAE and is utilized in both transformer-based and diffusion-based methods.

For the non-grouped codebook design, we adhere to the typical dVAE and VQ-VAE implementations as described in (Singh et al., ) and (Wu et al., ), respectively.
For the grouped codebook design used in SLATE/STEVE and SlotDiffusion, we take the OGDR as the basis, by applying with our design as mentioned in main body of this paper. Thus except what we describe in the main body, we also adopt annealing residual connection and Gumbel sampling code matching to stabilize training.

Implementation of our MSF described in Sect 3.3 is described in Code 1.

Figure: Algorithm 1 Implementation of inter/intra-scale quantized fusion in PyTorch.
[Uncaptioned image]: x4.png

This module operates on VAE intermediate feature tensors with a 4x4 spatial downsampling relative to the input.

The non-grouped codebook contains 4096 codes; Similarly, the grouped codebook contains 4096 codes combined from scale-invariant and scale-variant codebooks, for which we introduce code replacing trick, instead of utilization loss, to improve code utilization. In transformer-based models, the code dimension (VAE intermediate channel size) is 256, whereas in diffusion-based models, the code dimension is 4.

Basis Methods

For SLATE/STEVE, we primarily adhere to the original designs for transformer-based models, SLATE and STEVE. Their primary encoder, SlotAttention, decoder, and VAE conform to the respective designs mentioned earlier. SLATE is tailored for image-based OCL tasks, while STEVE extends SLATE to video-based OCL tasks by adding an additional transformer encoder block to bridge current and subsequent queries.

For SlotDiffusion, we also follow its original design for diffusion-based methods. Its primary encoder, SlotAttention, decoder, and VAE conform to the designs outlined earlier. For video-based OCL tasks, we extend SlotDiffusion by adding an extra transformer encoder block to connect current and future queries. For the diffusion decoder, we use default noise scheduler and beta values.

DINOSAUR

DINOSAUR is included as a foundational method for OCL, serving primarily as a reference. We adopt its original design but unify its primary encoder and SlotAttention with those described above.

Competitive Improvers

SysBinder is one of the competitors. This module enhances the SlotAttention module in SLATE/STEVE. We follow its original design while keeping the other components consistent with the earlier-described modules. The grouping number is set to four across all experiments that involve this module. We use group number two.

OGDR is another competitors. We use group sizes of two, and leave all the other settings identical to the original paper.

### A.2 Dataset Processing

The datasets used for image OCL include ClevrTex, COCO, and VOC, with the latter two being real-world datasets. For video OCL, the datasets are MOVi-C, D, and E, all of which are synthetic. While the processing is mostly consistent across datasets, there are a few differences.

Shared Preprocessing

To speed up experiments, we implement a dataset conversion approach: converting all datasets into the LMDB database format and storing them on an NVMe or RAM disk to reduce I/O overhead and maximize throughput.

In particular, all images or video frames, along with their segmentation masks, are center-cropped and resized to 128x128. These are then stored in the uint8 data type to save space. For images and videos, we apply the default interpolation mode, whereas for segmentation masks, we use the NEAREST-EXACT interpolation mode.

During training, for both images and videos, we use an input and output spatial resolution of 128x128. Input images and videos are normalized by subtracting 127.5 and dividing by 127.5, ensuring all pixel values fall within the range of -1 to 1. For videos, we apply random strided temporal cropping with a fixed window size of 6 to speed up training and improve generalization.

During testing, image processing remains identical to the training phase. However, for videos, we omit the random strided temporal cropping and instead use the full 24 time steps.

ClevrTex, COCO & VOC

For ClevrTex, each image can contain up to 10 objects, so we use 10 + 1 slot queries, with the extra slot representing the background.

Microsoft COCO and Pascal VOC are both real-world datasets. For COCO, we use panoptic segmentation annotations, as OCL favors panoptic segmentation over instance or semantic segmentation. However, for VOC, we rely on semantic segmentation annotations due to the absence of panoptic or instance segmentation labels.
Given that images can contain numerous objects, including very small ones, and considering the 128x128 resolution, we filter out images with more than 10 objects or objects smaller than a 16-pixel bounding box area.
As a result, we use a maximum of 10 objects (plus stuff in COCO) per image, corresponding to 11 slot queries.

MOVi-C/D/E

These datasets provide rich annotations, such as depth, optical flow, and camera intrinsic/extrinsic parameters. However, for simplicity and comparison purposes, we limit our use to segmentation masks. Additionally, we retain the bounding box annotations for all objects across all time steps, as this conditioned query initialization is crucial and widely used in video OCL.
Given that these datasets contain 10, 20, and 23 objects, respectively, we use 10+1, 20+1, and 20+1 slot queries.

### A.3 Training Scheme

In line with established practice, our training process comprises two stages. The first stage is pretraining, during which VAE modules are trained on their respective datasets to acquire robust discrete intermediate representations. In the second stage, OCL training utilizes the pretrained VAE representations to guide object-centric learning.

Pretraining VAE

Across all datasets, we conduct 30,000 training iterations, with validation every 600 iterations. This gives us roughly 50 checkpoints for each OCL model on every dataset. To optimize storage, we retain only the final 25 checkpoints. This approach is uniformly applied across datasets.

For image datasets, the batch size is set to 64, while for video datasets, it is 16, a configuration maintained across both training and validation phases. This is consistent for all datasets.
We employ 4 workers for multi-processing, applicable to both training and validation. This configuration is the same for all datasets.

We use the Adam optimizer with an initial learning rate of 2e-3, adjusting the learning rate through cosine annealing scheduling, with a linear warmup over the first 1/20 of the total steps. This configuration is standardized across all datasets.

Automatic mixed precision is utilized, leveraging the PyTorch autocast API. In tandem with this, we use PyTorch’s built-in gradient scaler to enable gradient clipping with a maximum norm of 1.0. This setting is uniform across all datasets.

Initializing Slot Queries

The query initializer provides the initial values to aggregate the dense feature map of the input into slots representing different objects and the background.

For image datasets like ClevrTex, COCO, and VOC, we use random query initialization. This method involves learning a set of Gaussian distributions and sampling from them. There are two parameters involved: the means of the Gaussian distributions, which are trainable and of dimension $c$, and the shared sigma (a scalar value), which is non-trainable and follows a cosine annealing schedule, fixed at 0 during evaluation. Both parameters are of the same dimension as the slot queries.

For video datasets such as MOVi-C/D/E, initialization takes a different approach. Prior knowledge, such as bounding boxes, is projected into vectors. The bounding boxes are normalized by the input frame dimensions and flattened into a 4-dimensional vector corresponding to the number of slots. This vector is then processed through a two-layer MLP, using GELU activation, to map the bounding boxes into the channel dimension $c$, consistent with the slot queries.

Training the OCL Model

On this stage, we load the pretrained VAE weights to guide the OCL model, where the VAE part is frozen.

For all datasets, we run 50,000 training iterations, validating every 1,000 iterations. This results in about 50 checkpoints per OCL model for each dataset. To reduce storage demands, only the last 25 checkpoints are saved. This procedure is applied across all datasets.

The batch size for image datasets is set to 32 for both training and validation. For video datasets, the batch size is 8 for training and 4 for validation, to account for the increased time steps during video validation. This setting is shared across datasets.

We utilize 4 workers for multi-process operations, consistent across both training and validation phases, and applied uniformly across datasets.

The metrics used for evaluation include ARI, mIoU, and mBO, which calculate the panoptic segmentation accuracy for both objects and background. These metrics are applied consistently across all datasets.

We use the Adam optimizer with an initial learning rate of 2e-4, following a cosine annealing schedule and a linear warmup over the first 1/20 of the total steps. This configuration is standardized across datasets.

We employ automatic mixed precision using the PyTorch autocast API. Alongside this, we use the PyTorch gradient scaler to apply gradient clipping, with a maximum norm of 1.0 for images and 0.02 for videos.

For random query initialization, we adjust the $\sigma$ value of the learned non-shared Gaussian distribution to balance exploration and exploitation. On multi-object datasets, $\sigma$ starts at 1 and decays to 0 by the end of training using cosine annealing scheduling. On single-object datasets, $\sigma$ remains at 0 throughout training. During validation and testing, this value is set to 0 to ensure deterministic performance.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: What downstream tasks could this method help with? It doesn't seem to be a SAM alternative, so what is the potential practical impact?

What would change were this applied to higher-resolution images? MSF would seem to have some promise for small objects, but those are essentially all filtered out by the pre-processing.
soundness: 3
strengths: [S1] The method seems to consistently outperform competitors for the OCL benchmarks, and is even somewhat competitive with the foundation model baseline (DINOSAUR).

[S2] The approach is well-motivated.

[S3] Figure 3 effectively demonstrates, qualitatively, how the MSF accomplishes better OCL, that is, features that are better connected to the objects themselves.
summary: The paper proposes multi-scale fusion (MSF) for object-centric learning. Specifically, MSF extracts VAE representations corresponding to the same input, downsampled to varying resolutions. The output representations are then upsampled and downsampled as necessary and then combined as a way to augment each set of features. The augmented features can then be fed as input to the general OCL decoder (along with the slot attention outputs and the matching entries from the discrete codebook). This intends to allow for better, more separable, semantically distinct representations of objects at varying scales. The quality is demonstrated with varying metrics corresponding to unsupervised segmentation on the masks that are generated as a byproduct of this OCL pipeline.
weaknesses: [W1] The impact of the work seems limited. The ideas about multi-scale representation and fusion themselves are not novel (see for example FPN in object detection literature), but the implementation and application to this task are. However, the implementation neglects potentially more impactfully redesigns of the primary encoder-decoder pipeline or the slot attention mechanism itself. 

[W2] Additionally, there are no results for any downstream tasks. Thus, while interesting, it is hard to project the impact of the work beyond this niche.

Minor: The notation and its interaction with Figure 3 is unpleasant and difficult to follow. In particular, the differences between scale-variant, scale-invariant, and representation before inter-scale fusion are quite slight and seem slightly arbitrary. 

Minor: Algorithm 1 would fit in the main paper, and help add clarity in the flow.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 2
questions: Overall the paper is good, but the results specially on COCO seems a bit incremental.
soundness: 3
strengths: 1) The overall intuition and direction of the paper is good and deal with important problems of Object-Centric Learning.
2) The multi-scale training makes a lot sense since dealing with objects is an important problem and generally has not been solved fully in the field.
3) The paper shows good analysis and shows object separability of VAE guidance in Fig3. Fig2 quantitative results also look good.
summary: This paper addresses Object-Centric Learning (OCL), which aims to capture comprehensive object information by reconstructing inputs using intermediate representations from a Variational Autoencoder (VAE). The focus is on multi-scale training, acknowledging that objects may appear at various scales in images or videos due to changes in imaging distance or intrinsic size differences. The authors propose Multi-Scale Fusion (MSF) applied to VAE representations to guide OCL for both transformer-based approaches and state-of-the-art diffusion models. The method demonstrates promising performance on datasets such as COCO, ClevrTex, and VOC.
weaknesses: 1) Results on real world datasets especially COCO in Table 1 are really incremental. It’s not really clear how much advantage is by adding MSF.
2) Analysis of varying object sizes can show results on scale understanding better than overall IoU improvement.
3) Is there any intuition as to why the value of n is 3? Can we do a similar experiment on OpenImages and see if this holds true across datasets? For Openimages, if it’s easier you can try using the smaller subset of open images curated in this paper [1].
4) Discussion on the area of unsupervised semantic segmentation and object detection using SSL methods should be added. Papers like [1,2,3] should be discussed. 
References:
1) Hyperbolic Contrastive Learning for Visual Representations beyond Objects CVPR2023
2) VideoCutLER
3) MOST: Multiple Object localization with Self-supervised Transformers for object discovery

---

confidence: 2
contribution: 2
initial_rating: 6
presentation: 3
questions: I am not familiar with this field, so please refer to the weakness
soundness: 3
strengths: 1. The paper is clear writing and easy to follow.
summary: This paper addresses the lack of multi-scale object representation in VAE-guided OCL problems by constructing a multi-scale VAE model. This enables the VAE-generated results to represent multi-scale objects, thereby improving performance across various tasks.
weaknesses: 1. I think the paper's novelty is very limited. Although I am not familiar with object-centric learning, I believe that constructing multi-scale VAE features has already been applied in many generative tasks[1, 2]. Therefore, the core innovation of this paper, in my opinion, does not warrant a standalone publication. Can the author tell me about the difference between MSF and other methods?

2. Since I am not familiar with this field, the Area Chair (AC) and the authors may disregard my opinion if it appears to be biased.

[1]Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction, arxiv2404.02905
[2]SPAE: Semantic Pyramid AutoEncoder for Multimodal Generation with Frozen LLMs, NeurIPS2023

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: Can the proposed method be applied to state-of-the instance segmentation models, like MaskDINO, to improve their results (~50 mask AP) on MS-COCO for instance segmentation.
soundness: 2
strengths: The MSF is straightforward and easy to understand. According to the experimental results, it works well and improves a strong basline model DINO.
OCL is an interesting and promising direction and this paper outperform previous OCL methods.
The method can be generalized to virous computer tasks and model to improve their representation of objects.
summary: This paper is motivated by Object-Centric Learning (OCL) AND introduces a multi-scale fusion scheme to vanilla VAE and improves its representation of different scales of objects. The motivation is convincing, but the technical novelty is limited and multi-scale fusion is a widely used technique in many models and computer vision tasks. Though this paper proposes some specific design modules, like multi-scale features augmentation, they are straightforward and improvements are limited according to the ablation study.
Though the technical novelty is limited, this paper investigate an interesting view, OCL, to VAE, should be benefit the comunity.
weaknesses: According to Sec. 4.1, the improvements from MSF are limited, just 1-2 points in many metrics. 
The overall presentation is not satisfactory and difficult to understand for readers not familiar with OCL.

Meta-review: This paper explores Object-Centric Learning (OCL), which seeks to capture comprehensive object information by leveraging intermediate representations from a Variational Autoencoder (VAE) to reconstruct inputs. The approach emphasizes multi-scale training, recognizing that objects in images or videos may appear at different scales due to variations in imaging distance or intrinsic size disparities.

The average score of this paper is 6.25 (8, 6, 6, 5), which is above the borderline. After carefully checking the response during rebuttal period and reading the paper, I decide to give the acceptance recommendation.

Note that the authors are required to update/revise/polish their paper according to reviewers' suggestions in the final version.

Decision: Accept (Poster)