Exact structured inference with neural network scoring functions is computationally challenging but several methods have been proposed for approximating inference. One approach is to perform gradient descent with respect to the output structure directly (Belanger and McCallum, 2016). Another approach, proposed recently, is to train a neural network (an inference network) to perform inference (Tu and Gimpel, 2018). In this paper, we compare these two families of inference methods on three sequence labeling datasets. We choose sequence labeling because it permits us to use exact inference as a benchmark in terms of speed, accuracy, and search error. Across datasets, we demonstrate that inference networks achieve a better speed/accuracy/search error trade-off than gradient descent, while also being faster than exact inference at similar accuracy levels. We find further benefit by combining inference networks and gradient descent, using the former to provide a warm start for the latter. 1 1 Introduction Structured prediction models commonly involve complex inference problems for which finding exact solutions is intractable (Cooper, 1990). There are generally two ways to address this difficulty. One is to restrict the model family to those for which inference is feasible. For example, state-of-the-art methods for sequence labeling use structured energies that decompose into label-pair potentials and then use rich neural network architectures to define the potentials (Collobert et al., 2011; Lample et al., 2016; Ma and Hovy, 2016, inter alia ). Exact dynamic programming algorithms like the Viterbi algorithm can be used for inference. The second approach is to retain computationally-intractable scoring functions but then use approximate methods for inference. For example, some researchers relax the structured output space from a discrete space to a continuous one and then use gradient descent to maximize the score function with respect to the output (Belanger and McCallum, 2016). Another approach is to train a neural network (an inference network) to output a structure in the relaxed space that has high score under the structured scoring function (Tu and Gimpel, 2018). This idea was proposed as an alternative to gradient descent in the context of structured prediction energy networks (Belanger and McCallum, 2016). In this paper, we empirically compare exact inference, gradient descent, and inference networks for three sequence labeling tasks. We train conditional random fields (CRFs) for sequence labeling with neural networks used to define the potentials. We choose a scoring function that permits exact inference via Viterbi so that we can benchmark the approximate methods in terms of search error in addition to speed and accuracy. We consider three families of neural network architectures to serve as inference networks: convolutional neural networks (CNNs), recurrent neural networks (RNNs), and sequence-to-sequence models with attention (seq2seq; Sutskever et al., 2014; Bahdanau et al., 2015). We also use multi-task learning while training inference networks, combining the structured scoring function with a local cross entropy loss. Our empirical findings can be summarized as follows. Gradient descent works reasonably well for tasks with small label sets and primarily local structure, like part-of-speech tagging. However, gradient descent struggles on tasks with long-distance dependencies, even with small label set sizes. For tasks with large label set sizes, inference networks and Viterbi perform comparably, with Viterbi taking much longer. In this regime, it is difficult for gradient descent to find a good solution, even with many iterations. In comparing inference network architectures, (1) CNNs are the best choice for tasks with primarily local structure, like part-of-speech tagging; (2) RNNs can handle longer-distance dependencies while still offering high decoding speeds; and (3) seq2seq networks consistently work better than RNNs, but are also the most computationally expensive. We also compare search error between gradient descent and inference networks and measure correlations with input likelihood. We find that inference networks achieve lower search error on instances with higher likelihood (under a pretrained language model), while for gradient descent the correlation between search error and likelihood is closer to zero. This shows the impact of the use of dataset-based learning of inference networks, i.e., they are more effective at amortizing inference for more common inputs. Finally, we experiment with two refinements of inference networks. The first fine-tunes the inference network parameters for a single test example to minimize the energy of its output. The second uses an inference network to provide a warm start for gradient descent. Both lead to reductions in search error and higher accuracies for certain tasks, with the warm start method leading to a better speed/accuracy trade-off. For sequence labeling tasks, given an input sequence x = h x 1 , x 2 , ..., x | x | i , we wish to output a sequence y = h y 1 , y 2 , ..., y | x | i  Y ( x ) . Here Y ( x ) is the structured output space for x . Each label y t is represented as an L -dimensional one-hot vector where L is the number of labels. Conditional random fields (CRFs; Lafferty et al., 2001) form one popular class of methods for structured prediction, especially for sequence labeling. We define our structured energy function to be similar to those often used in CRFs for sequence labeling: E  ( x , y ) =  X t LX i =1 y t,i (cid:16) u  i f ( x , t ) (cid:17) + X t y  t  1 Wy t ! where y t,i is the i th entry of the vector y t . one-hot vector, but this energy is generalized to be able to use both discrete labels and continuous relaxations of the label space, which we will introduce below. Also, we use f ( x , t )  R d to denote the input feature vector for position t , u i  R d is a label-specific parameter vector used for modeling the local scoring function, and W  RL  L is a parameter matrix learned to model label transitions. For the feature vectors we use a bidirectional long short-term memory (BLSTM; Hochreiter and Schmidhuber, 1997), so this forms a BLSTM-CRF (Lample et al., 2016; Ma and Hovy, 2016). For training, we use the standard conditional log-likelihood objective for CRFs, using the forward and backward dynamic programming algorithms to compute gradients. For a given input x at test time, prediction is done by choosing the output with the lowest energy: argmin y Y ( x ) E  ( x , y ) The Viterbi algorithm can be used to solve this problem exactly for the energy defined above. For our experimental comparison, we consider two CRF variants. The first is the basic model described above, which we refer to as BLSTM-CRF. Below we describe three additional techniques that we add to the basic model. We will refer to the CRF with these three techniques as BLSTM-CRF+. Using these two models permits us to assess the impact of model complexity and performance level on the inference method comparison. Word Embedding Fine-Tuning. We used pretrained, fixed word embeddings when using the BLSTM-CRF model, but for the more complex BLSTM-CRF+ model, we fine-tune the pretrained word embeddings during training. Character-Based Embeddings. Character-based word embeddings provide consistent improvements in sequence labeling (Lample et al., 2016; Ma and Hovy, 2016). In addition to pretrained word embeddings, we produce a character-based embedding for each word using a character convolutional network like that of Ma and Hovy (2016). The filter size is 3 characters and the character embedding dimensionality is 30. We use max pooling over the character sequence in the word and the resulting embedding is concatenated with the word embedding before being passed to the BLSTM. Dropout. We also add dropout during training (Hinton et al., 2012). Dropout is applied before the character embeddings are fed into the CNNs, at the final word embedding layer before the input to the BLSTM, and after the BLSTM. The dropout rate is 0.5 for all experiments. To use gradient descent (GD) for structured inference, researchers typically relax the output space from a discrete, combinatorial space to a continuous one and then use gradient descent to solve the following optimization problem: where YR is the relaxed continuous output space. For sequence labeling, YR ( x ) consists of length| x | sequences of probability distributions over output labels. To obtain a discrete labeling for evaluation, the most probable label at each position is returned. There are multiple settings in which gradient descent has been used for structured inference, e.g., image generation (Johnson et al., 2016), structured prediction energy networks (Belanger and McCallum, 2016), and machine translation (Hoang et al., 2017). Gradient descent has the advantage of simplicity. Standard autodifferentiation toolkits can be used to compute gradients of the energy with respect to the output once the output space has been relaxed. However, one challenge is maintaining constraints on the variables being optimized. Therefore, we actually perform gradient descent in an even more relaxed output space YR  ( x ) which consists of length| x | sequences of vectors, where each vector y t  RL . When computing the energy, we use a softmax transformation on each y t , solving the following optimization problem with gradient descent: argmin y Y R  ( x ) E  ( x , softmax( y )) (1) where the softmax operation above is applied independently to each vector y t in the output structure y . Tu and Gimpel (2018) define an inference network (infnet) A  : X  YR and train it with the goal that where YR is the relaxed continuous output space as defined in Section 3. For sequence labeling, for example, an inference network A  takes a sequence x as input and outputs a distribution over labels for each position in x . Below we will consider three families of neural network architectures for A  . For training the inference network parameters  , Tu and Gimpel (2018) explored stabilization and regularization terms and found that a local cross entropy loss consistently worked well for sequence labeling. We use this local cross entropy loss in this paper, so we perform learning by solving the following: argmin  X h x , y i E  ( x , A  ( x ))+  token ( y , A  ( x )) where the sum is over h x , y i pairs in the training set. The token-level loss is defined:  token ( y , A ( x )) = | y | X t =1 CE( y t , A ( x ) t ) (2) where y t is the L -dimensional one-hot label vector at position t in y , A ( x ) t is the inference net-work's output distribution at position t , and CE stands for cross entropy. We will give more details on how  token is defined for different inference network families below. It is also the loss used in our non-structured baseline models. We now describe options for inference network architectures for sequence labeling. For each, we optionally include the modeling improvements described in Section 2.1. When doing so, we append + to the setting's name to indicate this (e.g., infnet+). CNNs are frequently used in NLP to extract features based on symbol subsequences, whether words or characters (Collobert et al., 2011; Kalchbrenner et al., 2014; Kim, 2014; Kim et al., 2016; Zhang et al., 2015). CNNs use filters that are applied to symbol sequences and are typically followed by some sort of pooling operation. We apply filters over a fixed-size window centered on the word being labeled and do not use pooling. The feature maps f n ( x , t ) for (2 n + 1) gram filters are defined: f n ( x , t ) = g ( W n [ v x t  n ; ... ; v x t + n ] + b n ) where g is a nonlinearity, v x t is the embedding of word x t , and W n and b n are filter parameters. We consider two CNN configurations: one uses n = 0 and n = 1 and the other uses n = 0 and n = 2 . For each, we concatenate the two feature maps and use them as input to the softmax layer over outputs. In each case, we use H filters for each feature map. For sequence labeling, it is common to use a BLSTM that runs over the input sequence and produces a softmax distribution over labels at each position in the sequence. We use this BLSTM tagger as our RNN inference network architecture. The parameter H refers to the size of the hidden vectors in the forward and backward LSTMs, so the full dimensionality passed to the softmax layer is 2 H . Sequence-to-sequence (seq2seq; Sutskever et al. 2014) models have been successfully used for many sequential modeling tasks. It is common to augment models with an attention mechanism that focuses on particular positions of the input sequence while generating the output sequence (Bahdanau et al., 2015). Since sequence labeling tasks have equal input and output sequence lengths and a strong connection between corresponding entries in the sequences, Goyal et al. (2018) used fixed attention that deterministically attends to the i th input when decoding the i th output, and hence does not learn any attention parameters. It is shown as follows: P ( y t | y <t , x ) = softmax( W s [ h t , s t ]) where s t is the hidden vector at position t from a BLSTM run over x , h t is the decoder hidden vector at position t , and W s is a parameter matrix. The concatenation of the two hidden vectors is used to produce the distribution over labels. When using this inference network, we redefine the local loss to the standard training criterion for seq2seq models, namely the sum of the log losses for each output conditioned on the previous outputs in the sequence. We always use the previous predicted label as input (as used in scheduled sampling, Bengio et al., 2015) during training because it works better for our tasks. In our experiments, the forward and backward encoder LSTMs use hidden dimension H , as does the LSTM decoder. Thus the model becomes similar to the BLSTM tagger except with conditioning on previous labeling decisions in a left-to-right manner. We also experimented with the use of beam search for both the seq2seq baseline and inference networks and did not find much difference in the results. Also, as alternatives to the deterministic position-based attention described above, we experimented with learned local attention ( Luong et al., 2015) and global attention, but they did not work better on our tasks. To further improve the performance of an inference network for a particular test instance x , we propose two novel approaches that leverage the strengths of inference networks to provide effective starting points and then use instance-level fine-tuning in two different ways. For each test example x , we initialize an instance-specific inference network A  ( x ) using the trained inference network parameters, then run gradient descent on the following loss: This procedure fine-tunes the inference network parameters for a single test example to minimize the energy of its output. For each test example, the process is repeated, with a new instance-specific inference network being initialized from the trained inference network parameters. Given a test example x , we initialize y  YR  ( x ) using the inference network and then use gradient descent by solving Eq. 1 described in Section 3 to update y . However, the inference network output is in YR ( x ) while gradient descent works with the more relaxed space YR  ( x ) . We perform experiments on three tasks: Twitter part-of-speech tagging (POS), named entity recognition (NER), and CCG supersense tagging (CCG). POS. We use the annotated data from Gimpel et al. (2011) and Owoputi et al. (2013) which contains 25 POS tags. For training, we combine the 1000-tweet OCT 27T RAIN set and the 327-tweet OCT 27D EV set. For validation, we use the 500-tweet OCT 27T EST set and for testing we use the 547-tweet DAILY 547 test set. We use the 100-dimensional skip-gram embeddings from Tu et al. (2017) which were trained on a dataset of 56 million English tweets using word2vec (Mikolov et al., 2013). The evaluation metric is tagging accuracy. NER. We use the CoNLL 2003 English data (Tjong Kim Sang and De Meulder, 2003). There are four entity types: PER, LOC, ORG, and MISC. There is a strong local dependency between neighboring labels because this is a labeled segmentation task. We use the BIOES tagging scheme, so there are 17 labels. We use 100-dimensional pretrained GloVe (Pennington et al., 2014) embeddings. The task is evaluated with micro-averaged F1 score using the conlleval script. CCG. We use the standard splits from CCG-bank ( Hockenmaier and Steedman, 2002). We only keep sentences with length less than 50 in the original training data when training the CRF. The training data contains 1,284 unique labels, but because the label distribution has a long tail, we use only the 400 most frequent labels, replacing the others by a special tag  . The percentages of  in train/development/test are 0.25/0.23/0.23 % . When the gold standard tag is  , the prediction is always evaluated as incorrect. We use the same GloVe embeddings as in NER. Because of the compositional nature of supertags, this task has more non-local dependencies. The task is evaluated with per-token accuracy. For the optimization problems mentioned below, we use stochastic gradient descent with momen-tum as the optimizer. Full details of hyperparame-ter tuning are in the appendix. Local Baselines. We consider local (non-structured) baselines that use the same architectures as the inference networks but train using only the local loss  token . Structured Baselines. We train the BLSTM-CRF and BLSTM-CRF+ models with the standard conditional log-likelihood objective. We tune hyperparameters on the development sets. Gradient Descent for Inference. We use gradient descent for structured inference by solving Eq. 1. We randomly initialize y  YR  ( x ) and, for N iterations, we compute the gradient of the energy with respect to y , then update y using gradient descent with momentum, which we found to generally work better than constant step size. We tune N and the learning rate via instance-specific oracle tuning, i.e., we choose them separately for each input to maximize performance (accuracy or F1 score) on that input. Even with this oracle tuning, we find that gradient descent struggles to compete with the other methods. Inference Networks. To train the inference networks, we first train the BLSTM-CRF or BLSTM-CRF+ model with the standard conditional log-likelihood objective. The hidden sizes H are tuned in that step. We then fix the energy function and train the inference network A  using the combined loss from Section 4. For instance-tailored inference networks and when using inference networks as a warm start for gradient descent, we tune the number of epochs N and the learning rate on the development set, and report the performance on the test set, using the same values of N and the learning rate for all test examples. This first section of results uses the simpler BLSTM-CRF modeling configuration. In Section 7 below we present results with the stronger BLSTM-CRF+ configuration and also apply the same modeling improvements to the baselines and inference networks. Table 1 shows test results for all tasks and architectures. The inference networks use the same architectures as the corresponding local baselines, but their parameters are trained with both the local loss and the BLSTM-CRF energy, leading to consistent improvements. CNN inference networks work well for POS, but struggle on NER and CCG compared to other architectures. BLSTMs work well, but are outperformed slightly by seq2seq models across all three tasks. Using the Viterbi algorithm for exact inference yields the best performance for NER but is not best for the other two tasks. It may be surprising that an inference network trained to mimic Viterbi would outperform Viterbi in terms of accuracy, which we find for the CNN for POS tagging and the seq2seq inference network for CCG. We suspect this occurs for two reasons. One is due to the addition of the local loss in the inference network objective; the inference networks may be benefiting from this multi-task training. Edunov et al. (2018) similarly found benefit from a combination of token-level and sequence-level losses. The other potential reason is beneficial inductive bias with the inference network architecture. For POS tagging, the CNN architecture is clearly well-suited to this task given the strong performance of the local CNN baseline. Nonetheless, the CNN inference network is able to improve upon both the CNN baseline and Viterbi. Hidden Sizes. For the test results in Table 1, we did limited tuning of H for the inference networks based on the development sets. Figure 1 shows the impact of H on performance. Across H values, the inference networks outperform the baselines. For NER and CCG, seq2seq outperforms the BLSTM which in turn outperforms the CNN. Tasks and Window Sizes. Table 2 shows that CNNs with smaller windows are better for POS, while larger windows are better for NER and CCG. This suggests that POS has more local dependencies among labels than NER and CCG. Asymptotically, Viterbi takes O ( nL 2 ) time, where n is the sequence length. The BLSTM and our deterministic-attention seq2seq models have time complexity O ( nL ) . CNNs also have complexity O ( nL ) but are more easily parallelizable. Table 3 shows test-time inference speeds for inference networks, gradient descent, and Viterbi for the BLSTM-CRF model. We use GPUs and a minibatch size of 10 for all methods. CNNs are 1-2 orders of magnitude faster than the others. BLSTMs work almost as well as seq2seq models and are 2-4 times faster in our experiments. Viterbi is actually faster than seq2seq when L is small, but for CCG, which has L = 400 , it is 4-5 times slower. Gradient descent is slower than the others because it generally needs many iterations (20-50) for competitive performance. We can view inference networks as approximate search algorithms and assess characteristics that affect search error. To do so, we train two LSTM language models (one on word sequences and one on gold label sequences) on the Twitter POS data. We also compute the difference in the BLSTM-CRF energies between the inference network output y inf and the Viterbi output y vit as the search error: E  ( x , y inf )  E  ( x , y vit ) . We compute the same search error for gradient descent. For the BLSTM inference network, Spearman's  between the word sequence perplexity and search error is 0.282; for the label sequence perplexity, it is 0.195. For gradient descent inference, Spearman's  between the word sequence perplexity and search error is 0.122; for the label sequence perplexity, it is 0.064. These positive correlations mean that for frequent sequences, inference networks and gradient descent exhibit less search error. We also note that the correlations are higher for the inference network than for gradient descent, showing the impact of amortization during learning of the inference network parameters. That is, since we are learning to do inference from a dataset, we would expect search error to be smaller for more frequent sequences, and we do indeed see this correlation. We now compare inference methods when using the improved modeling techniques described in Section 2.1 (i.e., the setting we called BLSTM-CRF+). We use these improved techniques for all models, including the CRF, the local baselines, gradient descent, and the inference networks. When training inference networks, both the inference network architectures and the structured energies use the techniques from Section 2.1. So, when referring to inference networks in this section, we use the name infnet+. The results are shown in Table 4. With a more powerful local architecture, structured prediction is less helpful overall, but inference networks still POS NER CCG local baseline 91.3 90.5 94.1 infnet+ 91.3 90.8 94.2 gradient descent 90.8 89.8 90.4 Viterbi 90.9 91.6 94.3 Table 4: Test results with BLSTM-CRF+. POS. As in the BLSTM-CRF setting, the local CNN baseline and the CNN inference network outperform Viterbi. This is likely because the CRFs use BLSTMs as feature networks, but our results show that CNN baselines are consistently better than BLSTM baselines on this task. As in the BLSTM-CRF setting, gradient descent works quite well on this task, comparable to Viterbi, though it is still much slower. NER. We see slightly higher BLSTM-CRF+ results than several previous state-of-the-art results (cf. 90.94; Lample et al., 2016 and 91.37; Ma and Hovy, 2016). The stronger BLSTM-CRF+ configuration also helps the inference networks, improving performance from 90.5 to 90.8 for the seq2seq architecture over the local baseline. Though gradient descent reached high accuracies for POS tagging, it does not perform well on NER, possibly due to the greater amount of non-local information in the task. While we see strong performance with infnet+, it still lags behind Viterbi in F1. We consider additional experiments in which we increase the number of layers in the inference networks. We use a 2-layer BLSTM as the inference network and also use weight annealing of the local loss hyper-parameter  , setting it to  = e  0 . 01 t where t is the epoch number. Without this annealing, the 2-layer inference network was difficult to train. The weight annealing was helpful for encouraging the inference network to focus more on the non-local information in the energy function rather than the token-level loss. As shown in Table 5, these changes yield an improvement of 0.4 in F1. CCG. Our BLSTM-CRF+ reaches an accuracy of 94.3%, which is comparable to several recent results (93.53, Xu et al., 2016; 94.3, Lewis et al., 2016; and 94.50, Vaswani et al., 2016). The local baseline, the BLSTM inference network, and Viterbi are all extremely close in accuracy. Gradient descent struggles here, likely due to the large number of candidate output labels. Table 6 compares inference methods in terms of both accuracy and energies reached during inference. For each number N of gradient descent iterations in the table, we tune the learning rate per-sentence and report the average accuracy/F1 with that fixed number of iterations. We also report the average energy reached. For inference networks, we report energies both for the output directly and when we discretize the output (i.e., choose the most probable label at each position). Gradient Descent Across Tasks. The number of gradient descent iterations required for competitive performance varies by task. For POS, 20 iterations are sufficient to reach accuracy and energy close to Viterbi. For NER, roughly 40 iterations are needed for gradient descent to reach its highest F1 score, and for its energy to become very close to that of the Viterbi outputs. However, its F1 score is much lower than Viterbi. For CCG, gradient descent requires far more iterations, presumably due to the larger number of labels in the task. Even with 1000 iterations, the accuracy is 4% lower than Viterbi and the inference networks. Unlike POS and NER, the inference network reaches much lower energies than gradient descent on CCG, suggesting that the inference network may not suffer from the same challenges of searching high-dimensional label spaces as those faced by gradient descent. Inference Networks Across Tasks. For POS, the inference network does not have lower energy than gradient descent with  20 iterations, but it does have higher accuracy. This may be due in part to our use of multi-task learning for inference networks. The discretization of the inference network outputs increases the energy on average for this task, whereas it decreases the energy for the other two tasks. For NER, the inference network reaches a similar energy as gradient descent, especially when discretizing the output, but is considerably better in F1. The CCG tasks shows the largest difference between gradient descent and the inference network, as the latter is much better in both accuracy and energy. Instance Tailoring and Warm Starting. Across tasks, instance tailoring and warm starting lead to lower energies than infnet+. The improvements in energy are sometimes joined by improvements in accuracy, notably for NER where the gains range from 0.4 to 0.7 in F1. Warm starting gradient descent yields the lowest energies (other than Viterbi), showing promise for the use of gradient descent as a local search method starting from inference network output. Wall Clock Time Comparison. Figure 2 shows the speed/accuracy trade-off for the inference methods, using wall clock time for test set inference as the speed metric. On this task, Viterbi is time-consuming because of the larger label set size. The inference network has comparable accuracy to Viterbi but is much faster. Gradient descent needs much more time to get close to the others but plateaus before actually reaching similar accuracy. Instance-tailoring and warm starting reside between infnet+ and Viterbi, with warm starting being significantly faster because it does not require updating inference network parameters. The most closely related prior work is that of Tu and Gimpel (2018), who experimented with RNN inference networks for sequence labeling. We compared three architectural families, showed the relationship between optimal architectures and downstream tasks, compared inference networks to gradient descent, and proposed novel variations. We focused in this paper on sequence labeling, in which CRFs with neural network potentials have emerged as a state-of-the-art approach (Lample et al., 2016; Ma and Hovy, 2016; Strubell et al., 2017; Yang et al., 2018). Our results suggest that inference networks can provide a feasible way to speed up test-time inference over Viterbi without much loss in performance. The benefits of inference networks may be coming in part from multi-task training; Edunov et al. (2018) similarly found benefit from combining token-level and sequence-level losses. We focused on structured prediction in this paper, but inference networks are useful in other settings as well. For example, it is common to use a particular type of inference network to approximate posterior inference in neural approaches to latent-variable probabilistic modeling, such as variational autoencoders (Kingma and Welling, 2013) and, more closely related to this paper, variational sequential labelers (Chen et al., 2018). In such settings, Kim et al. (2018) have found benefit with instance-specific updating of inference network parameters, which is related to our instance-level fine-tuning. There are also connections between structured inference networks and amortized structured inference (Srikumar et al., 2012) as well as methods for neural knowledge distillation and model compression (Hinton et al., 2015; Ba and Caruana, 2014; Kim and Rush, 2016). Gradient descent is used for inference in several settings, e.g., structured prediction energy networks (Belanger and McCallum, 2016), image generation applications (Mordvintsev et al., 2015; Gatys et al., 2015), finding adversarial examples (Goodfellow et al., 2015), learning paragraph embeddings (Le and Mikolov, 2014), and machine translation (Hoang et al., 2017). Gradient descent has started to be replaced by inference networks in some of these settings, such as image transformation (Johnson et al., 2016; Li and Wand, 2016). Our results provide more evidence that gradient descent can be replaced by inference networks or improved through combination with them. We compared several methods for approximate inference in neural structured prediction, finding that inference networks achieve a better speed/accuracy/search error trade-off than gradient descent. We also proposed instance-level inference network fine-tuning and using inference networks to initialize gradient descent, finding further reductions in search error and improvements in performance metrics for certain tasks. We would like to thank Ke Li for suggesting experiments that combine inference networks and gradient descent, the anonymous reviewers for their feedback, and NVIDIA for donating GPUs used in this research.
abstain abstain abstain method method objective result abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method method method objective abstain abstain abstain abstain abstain method result abstain method abstain abstain abstain abstain abstain abstain abstain method method method method abstain abstain method abstain method abstain method abstain method abstain abstain method abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain abstain other method method abstain abstain abstain abstain abstain abstain method other method method method abstain method abstain abstain abstain abstain abstain abstain method method method abstain abstain method method method abstain abstain abstain abstain abstain method abstain method method method method abstain abstain method abstain abstain method method abstain abstain method method method abstain abstain method abstain abstain method abstain abstain method abstain method method abstain method abstain method method method abstain method abstain method method abstain result abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result result abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other objective method abstain other method method abstain other other other abstain result objective other