OrderNet: Ordering by Example

TL;DR

OrderNet is a neural architecture designed to infer the correct order of unordered sequences from training data, demonstrating superior generalization in tasks like TSP and sentence reconstruction.

Contribution

It introduces a permutation-equivariant neural network architecture capable of inferring sequence order from data, outperforming previous methods in generalization.

Findings

Outperforms previous supervised techniques in TSP sequence length generalization

Successfully reconstructs sentence order from scrambled words

Demonstrates permutation equivariance in neural network design

Abstract

In this paper we introduce a new neural architecture for sorting unordered sequences where the correct sequence order is not easily defined but must rather be inferred from training data. We refer to this architecture as OrderNet and describe how it was constructed to be naturally permutation equivariant while still allowing for rich interactions of elements of the input set. We evaluate the capabilities of our architecture by training it to approximate solutions for the Traveling Salesman Problem and find that it outperforms previously studied supervised techniques in its ability to generalize to longer sequences than it was trained with. We further demonstrate the capability by reconstructing the order of sentences with scrambled word order.

Tables

Table 1. Table 1 : Hyperparameters used in experiments

Hyperparameter	TSP Experiment	Word Order Experiment
Encoder Blocks	4	8
Encoder Layer-1 Depth	128	256
Encoder Layer-2 Depth	16	32
Encoder Pooling	MaxPool	AvgPool
Decoder Blocks	4	8
Decoder Block Depth	16	32
Parameters	73K	1.4M

Table 2. Table 2 : WikiText-103 samples with actual and predicted word order. Incorrect predictions are highlighted in light-red.

Actual Word Order	Predicted Word Order
<unk> pike as miranda frost	miranda frost as <unk> pike
while deangelo gets annoyed with	while deangelo gets annoyed with
the tna x division championship	the tna x division championship
federal bureau of investigation agents	federal bureau of investigation agents
as the japanese regrouped west	as the japanese regrouped west
meridian has nine historic districts	historic meridian has nine districts
when drummer lombardo left slayer	when drummer lombardo left slayer
the spores are 7 –	the spores are 7 –
highland park houses a jimmie	jimmie houses a highland park
route 29 follows main street	main street follows route 29

Equations

$$P(Y|X)=\prod _{t}P(y_t|y_1,\dots ,y_{t-1},X)$$

$$Z_{ij}=[x_i{x}_j]$$

$$x_i^{\prime }$$

$$y_t^{\prime }$$

$$y_0^{\prime }$$

$$S_{it}$$

Full text

1 Introduction

In this paper we examine the problem of ordering sets with neural networks. We use ordering to mean any function that takes as input an unordered set and outputs the elements of the input in a specific order.

Using this definition, we can break ordering into three non-comprehensive categories:

Easy: If an ordering is fully specified by a well-defined comparison operator $\leq$ between input elements, the problem is easy. This is just the traditional task of sorting a list, and there are a plethora of sorting algorithms that can easily determine the correct order.

Example: Given a list of numbers, sort them from smallest to largest. 2. 2.

Harder: If an ordering is fully specified by a comparison of input elements but we have incomplete knowledge, the problem is harder.

Example: Given a list of facial images, sort them from the youngest person to the oldest person. 3. 3.

Hardest: If an ordering is only determined by considering every element of the input, the problem is hard. These are combinatorial optimization problems, but the goal we are optimizing for might be probabilistic in nature, e.g. What is the most probable order for the input?

Example: Take an example sentence and scramble the order of the words, e.g. [“example”, “is”, “This”, “an”, “.”]. Can we reconstruct the original sentence, “This is an example.”?

The easy category of ordering problems never benefits from the application of machine learning. The harder category likely can benefit from machine learning, but it is probably more fruitful to use machine learning to infer an intermediate value that can be sorted using an ordinary sort algorithm.

We are interested in solving the hardest case: Given training pairs $(X,Y)$ where each $X$ is an unordered input and each $Y$ is the observed ordering of the input, we wish to build a model $P(Y|X)$ that allows us to autoregessively predict the most probable ordering.

Sequence-to-sequence models [1] (seq2seq) have become ubiquitous in many areas of deep learning including language translation, and one might initially think they may be a good fit for modeling $P(Y|X)$ in ordering problems. Indeed, one could think of ordering as the task of translating an unordered set into an ordered sequence, but there are two aspects which make seq2seq inappropriate:

The outputs of the model are indices which reference elements of the input. If a fixed output dictionary is used, as is usually the case in seq2seq models, the model would not be able to generalize to longer sequence lengths. 2. 2.

The input does not have a known ordering, and thus there is a large equivalence class. Since seq2seq models are not naturally permutation equivariant, the model would need to learn the ordering for each of $n!$ permutations.

The first problem has been addressed previously using Pointer Networks [2], which combine an LSTM [3] seq2seq model with an attention mechanism, inspired by [4], such that the output sequence can learn to point at elements of the input sequence. We draw heavy inspiration from that work; however, it leaves the problem of the large equivalence class of the input set unaddressed. In a follow up work Vinyals et al [5] address the second problem of permutation equivariance by encoding the input set into a memory block which is addressed with a content-based attention mechanism.

In this paper we present a new neural architecture for ordering unordered sets where the order is inferred from data. We refer to this model as OrderNet, and we demonstrate its capabilities by applying it to the Traveling Salesman Problem (TSP) in Section 3.1. We show that it is more capable of generalizing to longer sequences than existing techniques and uses fewer than half the parameters. In Section 3.2 we apply OrderNet to reconstruct the word order of randomly shuffled Wikipedia text.

Main Contributions

The main contributions of this paper are as follows:

• •

An encoder for sets which is more expressive than some previously studied methods.

• •

A convolutional decoder for set2seq problems that maintains permutation equivariance.

• •

A generic end-to-end model for learning to reconstruct the order of a sequence.

2 Model

Notation

Input elements are indexed with the symbol $i$ with values we represent as A,B,C,… We use alpha characters to emphasize that the input is an unordered set. Output sequence elements are indexed with the symbol $t$ with values $0,1,2,...$. We use $[a\;\;b]$ to denote vector concatenation of $a$ with $b$, and we often drop indices representing the feature dimension of a vector.

Problem Formulation

Given training data which consists of example pairs $(X,Y)$, where each $X$ is an unordered set of vectors $x_{i}\in\mathbb{R}^{d}$ , and each $Y$ is a target sequences of indices $y_{t}\in\mathbb{N}$ representing the order of $X$, we desire to model the conditional probability $P(Y|X)$. In the case of the Traveling Salesman Problem, which we visit in Section 3.1, each $X$ would be a set of cities to be visited (2-dimensional random points in the interval $[0,1]$), and each corresponding $Y$ would be the sequence of indices which result in the shortest possible path that visits each city exactly once.

Much as in the case of seq2seq modeling, we can decompose this probability without loss of generality using the chain rule:

[TABLE]

Formulating the probability using the chain rule allows us to construct our model autoregressively. We must only model the probability of a single timestep conditioned on the input set and the previously predicted output.

We formulate our model as an encoder-decoder: First, the input is passed through an encoder which allows the model to capture context for each element of the input. Second, the encoded representation of the input set is passed to a decoder which models the conditional probability.

Our method differs from typical seq2seq approaches in two important ways:

The encoder output size is not fixed. Each element of the input set is encoded to capture context. The encoder output is fixed-size for each element. The encoding is constructed to be permutation equivariant. 2. 2.

The decoder output is a softmax probability distribution over input elements, similar to [2].

Permutation Equivariance

Ordering functions must be equivariant to permutations. In the case of the TSP, if the first two cities are swapped in the input, then the values $1$ and $2$ must be exchanged in the output. We could learn this equivariance from data; however, there are $n!$ permutations for each input set, so doing so would be grossly inefficient with model parameters, and generalization would most likely suffer. Instead we choose to construct each component of our model with permutation equivariance in mind.

2.1 Input Set Encoder

The first component of OrderNet is an encoder which captures context for each input set element. The goal of the encoder is to map each element $x\in X$ into a representation which will make decoding the set into the correct order easier.

Without loss of generality, any such representation can be decomposed as a function $\mathrm{Encoding}(x_{i})=f(x_{i},X)$, and the encoding will be permutation equivariant so long as the function’s dependence on the set $X$ is invariant to permutations.

For our encoder we limit our consideration to functions of the form $f(x_{i},X)=\operatorname{pool}_{j}\phi(x_{i},x_{j})$, where $\operatorname{pool}$ is either max pooling or average pooling, and we use a two-layer MLP for $\phi$. This construction has several benefits:

• •

Pooling over all $j$ ensures permutation equivariance.

• •

Using a two-layer MLP allows $\phi$ to approximate any arbitrary function, limited only by the width of the layers [6].

• •

By representing the encoding as a function of all pairs of input elements we gain expressive capacity.

We refer to this sequence of operations as the OrderNet encoder block, and we construct the encoder by applying several layers of encoder blocks in sequence. The input of each block is concatenated with its output so that the final representation contains all information available from previous encoding layers, including the original input. We conjecture that multiple layers allow for a much richer representation. Roughly speaking, the first layer allows for pairwise interactions, the second layer allows for pairwise interactions of pairs, so on and so forth. Each additional layer allows for more interactions between the various subsets of the input.

Although the use of pooling operators for encoding sets has been studied extensively in other papers, it is typically applied to functions of input elements [7] [8], not functions of pairs of elements. Our encoder is more expressive since we allow each input element to interact with every other element of the input set before pooling. It is also worth noting that the way we have constructed the encoder bears some resemblance to self-attention mechanisms studied extensively in some language translation models [9].

Encoder Implementation

The input to OrderNet is represented as a matrix $X_{id}$ where $i$ indexes the element of the set, and $d$ indexes the feature dimension of the vector elements of the set. In order to perform our encoding operation where each element interacts with every other element, we must first expand and concatenate the input $X_{id}$ with a transposed version of itself to form a 3D tensor $Z\in\mathbb{R}^{|X|\times|X|\times 2d}$, where

[TABLE]

To implement the two-layer MLP we apply a sequence of $1\times 1$ convolution, ReLU [10], and batch normalization [11], repeated once. Following the two-layer MLP, the tensor is pooled over the $j$ dimension yielding an encoding of $X_{id}$ which captures the context of the set. The encoder block is depicted in Figure 1 (a). It should be noted that the $1\times 1$ filter size of the convolutions is chosen specifically to preserve permutation equivariance as using a larger filter size would allow the network to learn dependencies between adjacent elements of the input. We set the diagonal elements to zero before pooling with the motivation of preventing the self-interaction of elements from dominating the encoding.

2.2 Fully Convolutional Decoder

Taking inspiration from previously developed fully convolutional encoder-decoder models [12], the OrderNet decoder is fully convolutional, avoiding recurrent networks and allowing for training to happen for each timestep in parallel. The inputs to the decoder are elements of the input set as represented by the output of the encoder module. The decoder is autoregressive: we make predictions for each timestep $t$ that depend on the prediction from timestep $t-1$ [13].

We define $x^{\prime}_{i}$ to be the encoder representation of element $i$ from the input set with feature depth $d^{\prime}$ and refer to these as the source elements. We define $y^{\prime}_{t}$ to be the encoder representation of the previously decoded output for timestep $t-1$ and refer to these as target elements. By expanding and concatenating the source and target elements, we can define a 3D source-target tensor $S_{it}$, where $i$ indexes the elements of the input set and $t$ indexes the output timestep. $S\in\mathbb{R}^{|X|\times|X|\times 2d^{\prime}}$, where

[TABLE]

An illustration of the source-target tensor is provided in Figure 2. We build our decoder from layers of convolutions, non-linearities (ReLU), batch normalizations, and max pooling. We construct the decoder with the following in mind:

• •

Causal padding is necessary to prevent the layers from seeing into the future (see Figure 3).

• •

To preserve permutation equivariance, the filter size must be $1$ in the source-dimension to prevent input elements from interacting.

• •

Max pooling in the source-dimension allows for the decoder to see other possible decodings without breaking permutation equivariance (as long as the pooling spans the entirety of the source-dimension).

• •

Dense connectivity has been demonstrated to improve the performance of deep networks [14], so with that in mind the input to each decoder block is concatenated with its output.

The configuration of layers used for the decoder is shown in Figure 4.

2.3 Hyperparameters

OrderNet has several hyperparameters, including the depths of the individual layers in the encoder and decoder blocks, the number of blocks, and the pooling operator used for the encoder. Although an extensive hyperparameter search was not performed, we did experiment with several options. The hyperparameters used for the experiments in Section 3 are reported in Table 1.

3 Experiments

3.1 Traveling Salesman Problem

The Traveling Salesman Problem is described as follows: Given a set of cities and a starting city, find the shortest route for a salesman to visit each city exactly once and then return to the starting city. In our case, we focus on the TSP in 2D Euclidian space, where each city is a random point in the interval $[0,1]$. This problem has been studied extensively. A brute-force solution requires calculating the path length for $n!$ permutations, which becomes impractical very quickly. In 1962 Held and Karp [15], and independently Bellman [16], developed an algorithm using dynamic programming to find the shortest path with time complexity $O(2^{n}n^{2})$. In 1976 Christofides [17] developed a heuristic-based approach which can find a solution guaranteed to be at most $1.5\times$ longer than the optimal path in $O(n^{3})$ time. More recently the idea of using machine learning to solve combinatorial optimization problems with reinforcement learning has been explored [18] [19] [20]; however, we note that the goal of OrderNet is not to find good solutions to well-defined combinatorial optimization problems but rather to infer orderings from example data. We use the TSP to study the ability of our model to infer the correct order of a set of vectors.

In our framing, the cities in the TSP problem are just $2D$ vectors with an unknown order. We use supervised learning to train our model to imitate the ordering observed in examples of exact solutions that minimize the total path length. For each number of cities in the range 5 to 20, we generated 100,000 training pairs using random city locations and the Held-Karp method of finding the order which yields the shortest path. We train the model with Adam [21] by minimizing the cross-entropy loss between the predicted and observed order. Following training for 10 epochs, we find that our model has converged and produces surprisingly good solutions. A beam search with a beam size of $5$ is used to predict the most likely path.

Figure 5 shows the average length of the proposed tours our model generates as a function of the number of cities. Not only is the model capable of reproducing high quality tours for a similar number of cities as our training data, but also our model is able to generalize and produce good solutions for tours at least 5 times longer than those on which it was trained. In the cases we studied, tours of up to 100 cities, the tours generated by our model are only slightly worse than the tours produced using the Christofides algorithm, despite our model having time complexity $O(n^{2})$ and Christofides having time complexity $O(n^{3})$.

3.2 Word Order

In this section we analyze an example problem of learning an order: Given the first 5 words of a line of Wikipedia text, lower cased and in randomized order, can we infer the correct order? To examine this problem we use the WikiText-103 dataset [22], processed to only consider the first five words of text for each line, and disregarded blank lines and section headers. The resulting dataset had $597,867$ training examples of 5-word sequences. We encode each word using pretrained GloVe [23] embeddings (50-dimensional), and feed them to OrderNet. We find that OrderNet predicts the correct word order $69.5\%$ of the time. A selection of 10 sequences is presented in Table 2. The majority of mistakes encountered represent ambiguity in the data as formulated. Without additional context it is not necessarily possible to accurately reconstruct the order of these words.

4 Conclusion

The goal of this paper was to build a neural network capable of reconstructing the order of sequences. Such a network must be permutation equivariant, which places strong constraints on the way it can be constructed. Regardless of these constraints, we were able to build an expressive neural network capable of modeling complicated interactions of input elements. The results for the Traveling Salesman Problem show that OrderNet is capable of extrapolating to sequence lengths far greater than those on which it was trained. The results for the word order problem demonstrate that OrderNet is applicable to a broad range of problems. In future work we are interested in additional applications of OrderNet, including its components. In particular the OrderNet encoder may have applications to other problems where the function being modeled must be equivariant (or invariant) to the input order.