user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: FSPool: Learning Set Representations with Featurewise Sort Pooling

Paper content:
Traditional set prediction models can struggle with simple datasets due to an issue we call the responsibility problem.
We introduce a pooling method for sets of feature vectors based on sorting features across elements of the set.
This can be used to construct a permutation-equivariant auto-encoder that avoids this responsibility problem.
On a toy dataset of polygons and a set version of MNIST, we show that such an auto-encoder produces considerably better reconstructions and representations.
Replacing the pooling function in existing set encoders with FSPool improves accuracy and convergence speed on a variety of datasets.
Consider the following task: you have a dataset wherein each datapoint is a set of 2-d points that form the vertices of a regular polygon, and the goal is to learn an auto-encoder on this dataset.
The only variable is the rotation of this polygon around the origin, with the number of points, size, and centre of it fixed.
Because the inputs and outputs are sets, this problem has some unique challenges.
Encoder: This turns the set of points into a latent space.
The order of the elements in the set is irrelevant, so the feature vector the encoder produces should be invariant to permutations of the elements in the set.
While there has been recent progress on learning such functions (Zaheer et al., 2017; Qi et al., 2017) , they compress a set of any size down to a single feature vector in one step.
This can be a significant bottleneck in what these functions can represent efficiently, particularly when relations between elements of the set need to be modeled (Murphy et al., 2019; Zhang et al., 2019b) .
Decoder: This turns the latent space back into a set.
The elements in the target set have an arbitrary order, so a standard reconstruction loss cannot be used naïvely -the decoder would have to somehow output the elements in the same arbitrary order.
Methods like those in Achlioptas et al. (2018) therefore use an assignment mechanism to match up elements (section 2), after which a usual reconstruction loss can be computed.
Surprisingly, their model is still unable to solve the polygon reconstruction task with close-to-zero reconstruction error, despite the apparent simplicity of the dataset.
In this paper, we introduce a set pooling method for neural networks that addresses both the encoding bottleneck issue and the decoding failure issue.
We make the following contributions:
1. We identify the responsibility problem (section 3).
This is a fundamental issue with existing set prediction models that has not been considered in the literature before, explaining why these models struggle to model even the simple polygon dataset.
2. We introduce FSPOOL: a differentiable, sorting-based pooling method for variable-size sets (section 4).
By using our pooling in the encoder of a set auto-encoder and inverting the sorting in the decoder, we can train it with the usual MSE loss for reconstruction without the need for an assignment-based loss.
This avoids the responsibility problem.
3. We show that our auto-encoder can learn polygon reconstructions with close-to-zero error, which is not possible with existing set auto-encoders (subsection 6.1).
This benefit transfers over to a set version of MNIST, where the quality of reconstruction and learned representation is improved (subsection 6.2).
In further classification experiments on CLEVR (subsection 6.3) and several graph classification datasets (subsection 6.4), using FSPool in a set encoder improves over many non-trivial baselines.
Lastly, we show that combining FSPool with Relation Networks significantly improves over standard Relation Networks in a model that heavily relies on the quality of the representation (subsection 6.5).
In this paper, we identified the responsibility problem with existing approaches for predicting sets and introduced FSPool, which provides a way around this issue in auto-encoders.
In experiments on two datasets of point clouds, we showed that this results in much better reconstructions.
We believe that this is an important step towards set prediction tasks with more complex set elements.
However, because our decoder uses information from the encoder, it is not easily possible to turn it into a generative set model, which is the main limitation of our approach.
Still, we find that using the auto-encoder to obtain better representations and pre-trained weights can be beneficial by itself.
Our insights about the responsibility problem have already been successfully used to create a model without the limitations of our auto-encoder (Zhang et al., 2019a) .
In classification experiments, we also showed that simply replacing the pooling function in an existing model with FSPool can give us better results and faster convergence.
We showed that FSPool consistently learns better set representations at a relatively small computational cost, leading to improved results in the downstream task.
Our model thus has immediate applications in various types of set models that have traditionally used sum or max pooling.
It would be useful to theoretically characterise what types of relations are more easily expressed by FSPool through an analysis like in Murphy et al. (2019) .
This may result in further insights into how to learn better set representations efficiently.

assistant: text: Sort in encoder and undo sorting in decoder to avoid responsibility problem in set auto-encoders