Sentence compression reduces the length of text by removing non-essential content while preserving important facts and grammaticality. Unsupervised objective driven methods for sentence compression can be used to create customized models without the need for ground-truth training data, while allowing flexibility in the objective function(s) that are used for learning and inference. Recent unsupervised sentence compression approaches use custom objectives to guide discrete search; however, guided search is expensive at inference time. In this work, we explore the use of reinforcement learning to train effective sentence compression models that are also fast when generating predictions. In particular, we cast the task as binary sequence labelling and fine-tune a pre-trained transformer using a simple policy gradient approach. Our approach outperforms other unsupervised models while also being more efficient at inference time. In general, the information content of text is correlated with its length. However, for a given text, a shorter version may still convey the essential information while preserving grammaticality (Sid-dharthan, 2014). The definition of essential can change depending on the downstream application, thus models for text compression must be able to adapt based on information about the downstream task. Sentence compression models have been used as sub-modules of text and speech summarization (Banerjee et al., 2015; Shang et al., 2018), for headline generation (Dorr et al., 2003), subtitle generation (Vandeghinste and Pan, 2004), and summarizing emails (Zajic et al., 2008). Potential applications also include snippet generation and highlighting for social media, blog posts or search results. Given a particular text compression task, relevant evaluation metrics and auxiliary models of compression quality may not be straightforward to formulate as well-behaved differentiable objectives that can be used with standard backpropagation. In addition, ground-truth examples may be difficult to obtain because the annotation task is difficult to fully specify, and metrics which capture different facets of compression quality, such as fluency and optimal sentence length, may be negatively correlated. Even in the case where ground-truth examples are available, they are likely to represent only a subset of the possible outputs, so there is a risk of over-fitting or biasing models when relying solely upon a small amount of gold training data for optimization. Recent unsupervised sentence compression approaches leverage powerful neural language models to directly optimize objectives such as fluency and faithfulness of compressed sentences, using discrete search strategies, without relying on ground-truth examples (Niu et al., 2019; Zhou and Rush, 2019; Schumann et al., 2020). However, these search-based methods are very inefficient at inference-time because the search must navigate through a large candidate space while recomputing expensive reward functions. To allow for flexible reward specification, while also enabling efficient inference, we design a simple and effective reinforcement learning (RL) setup: our model is initialized as an unsupervised pretrained language model with an untrained binary classification head (see Figure 2), and the sentence compression task is framed as sequence labeling, with optimization via policy gradient using a suite of reward functions. Sentences are compressed in an instantaneous, one-step fashion, similar to mod-ern part-of-speech tagging or named entity recognition models. This approach simplifies the learning setup while also allowing for high throughput. According to quantitative evaluation on several summarization benchmarks, our approach shows similar or superior performance compared to search-based methods, while also being much faster at inference time. Our approach to unsupervised extractive sentence compression has the following benefits:  Unsupervised: No labelled examples are required. Fast inference: At test time, the model only performs one-step sequence labeling. Configurable: Rewards can be tailored to specific use cases. We review related work in Section 2. Section 3 formalizes the task. Section 4 gives a detailed description of the model and reward functions. Section 5 presents experimental results, and Sections 6 and 7 provide analysis and discussion of our findings. Early work on sentence compression casts the task as an optimization problem under linguistically motivated constraints (Hori and Furui, 2004; Clarke and Lapata, 2006, 2008). The objectives to be optimized include n-gram language model scores and frequency-based word relevance measures. Constraints are designed to ensure the grammaticality of compressions. Some recent work follows the discrete optimization paradigm while leveraging powerful models as objective functions in place of hand-crafted constraints, while exploring different strategies for heuristic search: Zhou and Rush (2019) use beam search to optimize a fluency and a similarity objective. Schumann et al. (2020) use a greedy hill-climbing search to optimize fluency and similarity objectives. Niu et al. (2019) use a greedy search with a look-ahead mechanism, only optimizing fluency. All of these recent approaches use large neural language models to estimate fluency. While the approach presented in whis work does not involve discrete search, we consider it complementary and orthogonal to our RL-based approach (see Section 7 for more discussion). Another commonly proposed unsupervised framework is to use autoencoders and reconstruc-tion objectives (Miao and Blunsom, 2016; Fvry and Phang, 2018; Malireddy et al., 2020). These approaches are based on the assumption that a good sentence compression is one from which the original sentence can be inferred. Wang et al. (2018) is an example of prior work using reinforcement learning for unsupervised sentence compression. They use a Deep Q-Network to optimize a reward incorporating n-gram language model probabilities and grammatical constraints. This model repeatedly deletes a token until it terminates, as opposed to our one-step approach. Zhao et al. (2018) also use RL to optimize a syntax-focused language model score. However, their policy is initialized with a supervised sentence compression model, whereas ours is fully unsupervised. Reinforcement learning has become popular in the wider field of text summarization, finding applications in both extractive and abstractive sub-tasks. One use case of RL is in supervised scenarios, where rewards are computed based on ground-truth examples, e.g., ROUGE scores, to overcome issues with cross-entropy losses (Paulus et al., 2017; Narayan et al., 2018; Dong et al., 2018). BANDITSUM (Dong et al., 2018) in particular has a very similar RL setup to ours: they train in one-step episodes where a policy predicts extractive labels 1268 and immediately receives a reward. Scialom et al. (2019) augment a ROUGE-based reward with a reward based on question answering. Bhm et al. (2019) and Stiennon et al. (2020) learn reward functions from human quality ratings of summaries. Similar to our unsupervised approach, Laban et al. (2020) use RL for unsupervised abstractive summarization, optimizing reward functions representing fluency, coverage under a length constraint, and also use a policy gradient approach. We focus on the specific task of summarizing a sentence by extracting a subset of its tokens in their original order. Given an input sentence x consisting of n tokens x = ( x 0 , x 1 , ..., x n ) , we aim to produce a sequence of binary labels y = ( y 0 , y 1 , ..., y n )  { 0 , 1 } n , where each label indicates whether the corresponding input token should be included in the compressed version of a sentence. We further assume an objective function, or reward function R ( x, y ) that measures how well applying the labels y summarizes the original sentence x . For a particular x , the goal is to find argmax y R ( x, y ) , without access to any ground-truth examples. In general, there are 2 n possibilities to shorten a sentence in this task. A fixed summary length L would reduce this to (cid:0) nL (cid:1) possibilities, peaking at L = n 2 (for even n ). We do not constrain our approach to a fixed length, but we compare it to search-based techniques that are constrained to the (cid:0) nL (cid:1) search space. We train a policy   with parameters  to produce binary labels. Given an input x , the policy   predicts a binary keep/discard probability distribution for each token index in x . We use the notation   ( | x ) to refer to the collection of these distributions for all tokens in x . We obtain the probability   ( y | x ) of a label sequence y given input sequence x as follows:   ( y | x ) = (cid:89) i   ( y i | x ) , (1) where   ( y i | x ) is the probability of a token x i being included if y i = 1 or excluded if y i = 0 . We train our model using a policy gradient technique (Sutton et al., 1999). Unlike typical sequential reinforcement learning scenarios, our   only performs one action for a given input, receiving the corresponding reward immediately, without transi-tioning through other intermediate states. Therefore, our setup is similar to a contextual multiarmed bandit problem (Langford and Zhang, 2008), where each "arm" corresponds to a particular label sequence y = ( y 0 , y 1 , ..., y n )  { 0 , 1 } n . However, in our scenario, the policy is generally allowed to access rewards for multiple possible actions via sampling, which is different from typical bandit settings where only one ( action, reward ) pair is available for each episode. The training objective is to maximize the expected reward assigned to a predicted label sequence y for a given input x , computed by the reward function R : J (  ) = E [ R ( x, y )] (3) The policy gradient theorem states that the gradient of this expectation can be expressed as follows (Sutton et al., 1999):   J (  ) =   E [ R ( x, y ) log   ( y | x )] (4) Since the above expectation is intractable for a large dataset and the corresponding action space, this gradient is estimated by sampling:   J (  ) =   r s log   ( y s | x ) , (5) where y s    ( | x ) is a sample from the current policy at a given step, consisting of binary token labels y s = ( y s 0 , y s 1 , ..., y sn ) , and r s = R ( x, y s ) . As is commonly done when using policy gradients, we subtract a baseline from the reward for variance reduction. We instantiate the baseline as r a = R ( x, y a ) , the reward given to the the most likely label sequence y a according to the current policy. The gradient becomes:   J (  ) =   ( r s  r a ) log   ( y s | x ) (6) Accordingly, we train our model by minimizing the following loss function: 1269   = ( r a  r s ) log   ( y s | x ) . Using the baseline r a allows the intuitive interpretation that a sample y s is encouraged if its reward is higher than the current policy's prediction, i.e., when factor ( r a  r s ) is negative, and discouraged otherwise. Prior work with a similar application of policy gradient (Dong et al., 2018; Laban et al., 2021) observed an advantage in sampling k times and taking the average loss over all samples rather than using a single sample. However, in our experiments, we observe that only using the sample with the maximum reward from a large number of samples works significantly better than taking the average or only sampling once. A large k improves the discovery of high-quality compressions  if we only use a single sample or a very small k , we observe a higher tendency of models to converge on simple behaviors with low reward improvements, such as only extracting the firstL tokens of a sentence. The choice of k controls a trade-off: with a higher k , we spend more time computing the rewards of samples and less on model updates, given a limited wall-time constraint for training. We determine k in an unsupervised manner using a validation set (details in Section 5.2). is initialized as a transformer encoder model with a linear classification head. In particular, we use the 6-layer DistilRoBERTa model (Sanh et al., 2019) due to its efficiency and smaller size compared to other BERT-like models, while retaining good results on the GLUE benchmark 1 . During training, the whole model is fine-tuned. For each token in the input, our model will determine whether it should be kept or filtered. Figure 2 visualizes the design. This architecture produces summaries in an instantaneous, non-autoregressive fashion, allowing for fast prediction (see Section 5.6). We do not have direct access to ground-truth training data in our setup, so we consider a suite of reward functions that may correlate with different aspects of sentence compression quality. This reward function is intended to ensure grammatically correct and well-written sentences. We use a masked language model (LM) to estimate the fluency of a compressed sentence. In particular, we compute fluency as the average logit of a token y i in the compressed sentence y . We do this without masking y i to reduce the running time during training, as masking would require to re-encode the sentence for each token. Based on our experiments, this simplification still produces good estimates of fluency. We normalize R fluency by dividing it by an empirically set constant, to keep its values in a similar range compared to the other rewards. The con-stant is an observed minimum value from a sample dataset. We argue that a masked language model is more appropriate in our setup compared to a left-to-right (causal) language model  when predicting or sampling a compressed sentence during training, the sentence is treated as a finished rather than an intermediate output, which is not captured by the auto-regressive inference of causal LMs. We confirm the advantage of a masked LM over a left-to-right LM in a comparison on a development set (Appendix A). We note the precedent for using language models to measure fluency: Zhou and Rush (2019) and Schumann et al. (2020) use language models trained on a summarization target domain, e.g., headlines. Laban et al. (2020) uses a generic causal language model to estimate fluency. Niu et al. (2019) use a masked language model to score candidate compressions. The similarity reward is intended to preserve the meaning of the source sentence in the compressed sentence. We experiment with several options to compute similarity, all using models from the sentence-transformers library 2 (Reimers and Gurevych, 2019):  Bi-Encoder Similarity : A sentence encoder f separately computes embeddings for the source and the predicted summary. We calculate the cosine similarity between both embeddings: R sim ( x, y ) = cos ( f ( x ) , f ( y )) 2 https://www.sbert.net/ 1270  Cross-Encoder Similarity : Output of a cross-encoder model f sim measuring the semantic textual similarity between both sentences: R sim ( x, y ) = f sim ( x, y )  Cross-Encoder NLI: We also test a natural language inference (NLI) model f nli to estimate how well a compressed sentence retains source information. The intuition is that the source should imply information in the output: R nli ( x, y ) = f nli ( y | x ) Based on experiments on a development dataset, the bi-encoder similarity performs best in our setup. Because our model is non-sequential, we cannot easily employ a hard constraint to control the length of compressed sentences. Instead, we impose a soft length control using Gaussian reward functions. In particular, we either use a reward function for the length (token count) in a compressed sentence R len , or one for the compression ratio between the source and prediction, in terms of token counts, R cr . We choose one of these two depending on whether a consistent length or a consistent ratio is desired, which differs for different evaluation datasets. We set the distribution means of both rewards as the desired values for word count and compression ratio. We set the standard deviations as the mean times a factor s which we set to 0.4 for both reward functions (Equations 9, 10): R len = N (  L , ( s   L ) 2 ) , (9) R cr = N (  cr , ( s   cr ) 2 ) . The final reward function is an average of the reward functions R fluency , R sim , combined with either R len or R cr : In practice, when the downstream task is known, reward functions may be designed and calibrated based upon insights and domain expertise, e.g., an optimal summary length for a specific application or different language models corresponding to different summary styles. In this work, we only use publicly available and commonly-used off-the-shelf models to construct reward functions. This section presents a detailed analysis and evaluation results for our proposed model. We name our model SCRL (Sentence Compression with Reinforcement Learning) . We make all code, model outputs and data available 3 . We use two datasets for training: Newsroom (Grusky et al., 2018) and Gigaword (Rush et al., 2015). For Newsroom, we extract the first three sentences from each article, only keeping sentences with a number of tokens between 15 and 60. Newsroom was chosen due to the large size and a variety of un-preprocessed news articles from different sources. Ground-truth summaries are not included in the training data, thus the two datasets are treated as large unlabeled text collections. We train a model for short headline-like summaries on Gigaword to evaluate it on the Gigaword test set, which comes in a specific preprocessed format 4 . Training on Gigaword allows to expose the model to the same preprocessing, for a fair evaluation. We constructed a small labelled validation dataset for model development: we automatically identified sentence-summary pairs in Newsroom, also including title-summary pairs, by extracting cases where the tokenized summary is contained in a tokenized sentence, with preserved order. We manually filter a subset of these examples based on grammaticality and informativeness and obtain 280 examples. This dataset was only used during initial development to compare the different reward function variants discussed in Section 4.3. The evaluation includes five test sets  key statistics are listed in Table 1. L src , L tgt are the token counts in source and target sentences and cr = L tgt /L src is the compression ratio. Following Schumann et al. (2020), we compare our models on Gigaword against baselines of comparable length brackets using ROUGE F1-scores 5 . For DUC2004 (Task 3 https://github.com/complementizer/ rl-sentence-compression 4 Lowercased, pre-tokenized, rare words and digits replaced with special tokens. 5 We only consider lengths similar to the ground-truth, i.e. 8-10 tokens. 1271 Testset Type Size L src L tgt cr Gigaword abs 1951 29.7 8.8 0.4 DUC2004 abs 500 32.9 11.9 0.41 Google ext 1000 27 11 0.45 Broadcast ext 1370 19.8 14.4 0.76 BNC ext 1629 27.9 19.3 0.72 Table 1: Overview of the evaluation datasets. The Type column indicates whether the ground-truth is extractive or abstractive. Size gives the number of sentences. 1), following prior work, we truncate model outputs to 75 characters and compute ROUGE recall scores. While Gigaword and DUC2004 contain abstractive ground-truth summaries, the remaining three datasets have token-level extractive ground-truth summaries. The ground-truth compressions in the Google sentence compression dataset (Fil-ippova and Altun, 2013) were automatically generated using grammatical constraints and distant supervision via headlines. The Broadcast and BNC datasets (Clarke and Lapata, 2008) contain manually created extractive sentence compressions which tend to be longer compared to the other evaluation datasets. Following previous work, we report a simple F1-score based on tokenized predicted and ground-truth summaries on the three extractive datasets, but also measure ROUGE F1 scores. We tune our approach in several phases. At first, we identify an optimal learning rate and batch size using a grid search with a fixed training duration. We compare different settings based on the average reward achieved on a unlabelled, held-out set of the training data. Next, we test different values of k (1, 5, 10, 50, 100), the number of samples per step, and pick the best k based on the average reward on the validation set. This method of hyperparameter tuning is fully unsupervised. Using learning rate 1 e  05 , batch size 4 and k = 100 identified in the previous runs, we next compare the different options for the similarity reward listed in Section 4.3 and pick the best (bi-encoder similarity) based on the F1-score on our labelled Newsroom-based validation set (see Appendix B). We initialize the encoder component of our model with the pretrained 6-layer DistilRoBERTa model (Sanh et al., 2019). The binary classifier module Name Train data Test Data Time SCRL-L8 Gigaword Gigaword 9 SCRL-L11 Newsroom DUC04, Google 9.5 SCRL-CR75 Newsroom Broadcast, BNC 10 Table 2: Overview of trained models and training time in hours. is initialized randomly. We train each model for 8,000 steps with a batch size of 4 on a Google Cloud virtual machine with one NVIDIA Tesla T4 GPU, using the AdamW optimizer (Loshchilov and Hutter, 2019). Our default reward combination contains masked-LM fluency and bi-encoder similarity combined with either R len or R cr . Table 2 gives an overview of the three models that are used in the evaluation. Note that the sample size of 100 is responsible for the long training durations. SCRL-L8 and SCRL-L11 are trained with R len whereas SCRL-CR75 is trained with R cr , with a compression ratio of 0 . 75 . This is because the ground-truth summary lengths are approximated better by a fixed length rather than a fixed ratio in the Google and DUC2004 datasets, whereas a fixed ratio describes the Broadcast and BNC datasets better. We compare our model to the greedy stochastic hill climbing approach in Schumann et al. (2020) which obtained state-of-the-art ROUGE results for unsupervised baselines on the Gigaword and DUC2004 datasets. Because this method and SCRL do not have identical objective functions, we implement the hill climbing algorithm applied to our reward functions, which we will name HC throughout this work. This allows for a clearer comparison between RL and discrete search. HC optimizes R fluency , R sim under fixed length constraints instead of using R len and R cr . Different from Schumann et al. (2020), it runs for a fixed number of 2000 steps and restarts only when the search is stuck rather than in equal intervals (details in Appendix E). We analyze the performance of HC for different budgets to understand at what point search can surpass the learned policies. We also compare against Zhou and Rush (2019), Niu et al. (2019) and the RL-based method by Wang et al. (2018) on datasets where results are available. Table 3 shows the evaluation results on all used test datasets. Results of methods apart from SCRL and HC are taken from previous works. We com-1272 Dataset Model ROUGE F1 L d L o cr o Inf. pute ROUGE scores using the implementation from Google Research 6 . On Gigaword, SCRL outperforms all baselines, except Schumann et al. (2020) with a 10 token constraint in ROUGE-2. On DUC2004, SCRL remains behind the hill climbing methods, but outperforms other unsupervised baselines. On the Google dataset, SCRL obtains state-of-the-art results among unsupervised methods. On Broadcast and BNC, SCRL and HC obtain very similar scores, which are both higher than previously reported results. Figure 3 shows ROUGE-1 scores obtained by HC at different search budgets, compared to SCRL. The hill climbing strategy approaches or outperforms the trained model at different paces, depending on the dataset. Interestingly, HC still achieves higher rewards than SCRL relatively early during its search (see Appendix F), which is inconsistent with the evaluation results. Potential reasons for this disparity are disadvantages through the hard length constraints, a mismatch between the heuristic reward functions and evaluation metrics, and beneficial biases induced through our training framework. We compare the inference-time speed of SCRL with HC using different budgets of search steps 7 . The fastest batch size for both approaches is used. The Inference Time in Table 3 shows the average number of seconds per processed sentence, with the number of search steps set to T = 2000 for HC. SCRL is roughly 4000  faster than HC with T = 7 On a Google Colab Notebook with a Tesla P-100 GPU 1273 Figure 4: Distribution of summary lengths and compression ratios. 2000 , and  200  faster when T is reduced to 100 , for example. We believe that such a speed-up with a preserved evaluation performance is a critical factor when considering real-world applications of sentence compression. The length and compression ratio of summaries produced by SCRL is distributed around the desired values, with peakier distributions than in ground-truth summaries (examples in Figure 4). HC produces exactly the desired value whenever possible, due to the enforced constraint for length or ratio. Figure 5 shows how SCRL and HC extract tokens from different relative positions within source sentences. SCRL has a higher tendency to extract early tokens. We hypothesize that this is a reliable high-reward strategy discovered during training, considering that a milder form of the lead-bias also shows in HC. Note that neither method is inherently biased in its design to prefer tokens from certain regions. Figure 6 shows how rewards and summary length develop throughout training. The rewards generally increase quickly in the first few hundred training steps and then continue to grow very slowly. Fluency starts to increase later than the other reward functions, which is likely related to our observation that it is more sensitive to small changes in a summary. Interestingly, the summary lengths develop differently depending on the length or compression setting  SCRL-L8 and SCRL-L11 start with short summaries and increase the size over time whereas SCRL-CR75 starts with long summaries before settling on a shorter certain range. Our models learn a variety of behaviors to compress sentences, such as removing articles, auxiliary verbs, relative clauses and temporal expressions. Figure 7 shows some examples. Even though our models learn to produce grammatical sentences fairly well, grammatical errors do still appear, and are more common for the models with a short output length (SCRL-8, SCRL-11). In some cases, semantic errors occur where the original meaning is changed or made unintel-ligeble. Both SCRL and HC are susceptible of semantic and grammatical errors, as can be seen in some examples in Appendix G. A type of error that is specific to SCRL is the splitting or merging of tokens resulting from its operation on Byte Pair Encoding-based subword tokens (more details in Appendix C). To demonstrate that our approach is flexible for customization, we pick a simple example of re-1274 programming model behavior using a hand-crafted reward function. We note that in some cases, the model unnecessarily keeps day references in compressed sentences, such as "Thursday" or "yester-day". We construct a simple reward function that returns zero if any day-like word from a small gazetteer appears in an output and a score of 1 otherwise. We fine-tune an existing model with this additional reward and observe that it successfully avoids including day-words that the previous model would include. Importantly, it additionally learned to remove other tokens attached to day-words, e.g. "on" in "on Monday", keeping the sentences grammatical. Table 4 shows some examples. Empirically, the new model's outputs contain words from the gazeteer in 1% of cases where they appear in the source, compared to 12% in the initial model. We argue that RL offers the following advantages over discrete search strategies for sentence compression and similar text editing or generation tasks. The necessary search and exploration is moved into the training stage, allowing fast inference independently of how efficient objectives are to compute. Furthermore, discrete search unnecessarily spends time navigating through low-quality outputs that a trained model can quickly learn to avoid. Limitations of our approach compared to the search-based approach are its lesser flexibility in terms of on-the-fly customization and a sensitivity to disparities between training data and the application domain. Furthermore, the trained models show a lower capability to optimize the selected objectives compared to search, though this does not have a negative impact on the evaluation in most cases. The fact that most of our training time is spent on estimating the quality of sampled compressions due to large sample size k , shows that our approach is somewhat similar to large-scale search strategies applied to a whole dataset, with the difference that the sampling behavior at each step changes over time and is informed by previous steps. This suggests that discrete search could support the RL training, similarly to the learning-from-search approach described by (Li et al., 2020). This work presents a simple and effective approach for learning sentence compression models based on objective functions rather than ground-truth examples. Because it is unsupervised, it is well-suited for creating customized applications even when no gold training data is available, allowing for task-specific tuning based on arbitrary sets of reward functions, which do not need to be differentiable. Importantly, our approach is very fast at inference time compared to alternative discrete search-based methods. We are interested in several future directions related to this work: 1) systematic approaches to design reward functions for summarization, 2) RL-based summarization models with length control on the fly, 3) testing our approach on other languages, and 4) the design of curricula for different reward functions as they might pose varying difficulties at different stages of the training. This work was funded by the Irish Research Council (IRC) under grant number EBPPG/2018/23, the Science Foundation Ireland (SFI) under grant number 12/RC/2289_P2 and the enterprise partner Aylien Ltd.
abstain abstain abstain objective method result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain result abstain objective objective 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 method abstain abstain abstain abstain abstain abstain method method abstain method method method method method method other method method method abstain abstain abstain abstain method method abstain method abstain method abstain abstain method abstain method method method method method abstain method method method abstain abstain abstain method other method method method method abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain result abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain result result 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 method abstain method abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain abstain method abstain result abstain objective abstain method abstain abstain abstain abstain abstain other