Sentence Compression via DC Programming Approach

TL;DR

This paper introduces a novel sentence compression model combining probability and parse tree models, formulated as an ILP, and solves it efficiently using a DC programming approach with guarantees of syntax correctness and meaning preservation.

Contribution

The paper presents a new ILP-based sentence compression model and a DC programming approach with a parallel-branch-and-bound framework for optimal solutions.

Findings

Model guarantees syntax correctness and meaning retention.

Proposed algorithm achieves high-quality compression.

Numerical results show effective performance.

Abstract

Sentence compression is an important problem in natural language processing. In this paper, we firstly establish a new sentence compression model based on the probability model and the parse tree model. Our sentence compression model is equivalent to an integer linear program (ILP) which can both guarantee the syntax correctness of the compression and save the main meaning. We propose using a DC (Difference of convex) programming approach (DCA) for finding local optimal solution of our model. Combing DCA with a parallel-branch-and-bound framework, we can find global optimal solution. Numerical results demonstrate the good quality of our sentence compression model and the excellent performance of our proposed solution algorithm.

Tables

Table 1. Table 1: Compression results

Corpus+Model	Solver	$50\%$ compression rate		$70\%$ compression rate		$90\%$ compression rate
		F-score (%)	Time (s)	F-score (%)	Time (s)	F-score (%)	Time (s)
Treebank+P	Gurobi	56.5	0.099	72.1	0.099	79.4	0.081
	PDCABB	59.1	0.194	76.2	0.152	80.0	0.122
Treebank+H	Gurobi	79.0	0.064	82.6	0.070	81.3	0.065
	PDCABB	79.9	0.096	82.7	0.171	82.1	0.121
Clarke+P	Gurobi	70.6	0.087	80.2	0.087	80.0	0.071
	PDCABB	81.4	0.132	80.0	0.128	81.2	0.087
Clarke+H	Gurobi	77.8	0.046	85.5	0.052	82.4	0.041
	PDCABB	79.9	0.081	85.2	0.116	82.3	0.082

Equations

$$f(\alpha ,\beta ,\gamma )$$

$$\sum _{i=1}^n{\alpha }_i=1.$$

$${\delta }_k-{\alpha }_k-\sum _{i=0}^{k-2}\sum _{j=1}^{k-1}{\gamma }_{ijk}=0,\forall k\in \left[\left[1,n\right]\right].$$

$${\delta }_j-\sum _{i=0}^{j-1}\sum _{k=j+1}^n{\gamma }_{ijk}-\sum _{i=0}^{j-1}{\beta }_{ij}=0,\forall j\in \left[\left[1,n\right]\right].$$

$${\delta }_i-\sum _{j=i+1}^{n-1}\sum _{k=j+1}^n{\gamma }_{ijk}-\sum _{j=i+1}^n{\beta }_{ij}-\sum _{h=0}^{i-1}{\beta }_{hi}=0,\forall i\in \left[\left[1,n\right]\right].$$

$$\sum _{i=1}^{n-1}\sum _{j=i+1}^n{\beta }_{ij}=1.$$

$$\underline{l}\le \sum _{i=1}^n{\delta }_i\le \bar{l}.$$

$$\sum _{j\in I_i}{\delta }_j\ge {\delta }_i,{\delta }_i\ge {\delta }_j,\forall j\in I_i.$$

$$\max \{f(\alpha ,\beta ,\gamma ):(\text{ref}cons:1)-(\text{ref}cons:7),(\alpha ,\beta ,\gamma ,\delta )\in \{0,1{\}}^{\frac{n^3+3n^2+14n}{6}}\}.$$

$$\min \{f(x):=c^{\top }x:x\in S\}$$

$$\min \{f(x):x\in K\},$$

$$\{0,1{\}}^n\equiv \{x:p(x)\le 0\}.$$

$$\min \{F_t(x):=f(x)+tp(x):x\in K\}.$$

$$F_{\mu }=({\mu }^2+1)\times \frac{P\times R}{{\mu }^2\times P+R}$$

$$P=\frac{A}{A+C},R=\frac{A}{A+B}$$

Full text

1 Introduction

The recent years have been known by the quick evolution of the artificial intelligence (AI) technologies, and the sentence compression problems attracted the attention of researchers due to the necessity of dealing with a huge amount of natural language information in a very short response time. The general idea of sentence compression is to make a summary with shorter sentences containing the most important information while maintaining grammatical rules. Nowadays, there are various technologies involving sentence compression as: text summarization, search engine and question answering etc. Sentence compression will be a key technology in future human-AI interaction systems.

There are various models proposed for sentence compression. The paper of Jing [3] could be one of the first works addressed on this topic with many rewriting operations as deletion, reordering, substitution, and insertion. This approach is realized based on multiple knowledge resources (such as WordNet and parallel corpora) to find the pats that can not be removed if they are detected to be grammatically necessary by using some simple rules. Later, Knight and Marcu investigated discriminative models[4]. They proposed a decision-tree model to find the intended words through a tree rewriting process, and a noisy-channel model to construct a compressed sentence from some scrambled words based on the probability of mistakes. MacDonald [12] presented a sentence compression model using a discriminative large margin algorithm. He ranks each candidate compression using a scoring function based on the Ziff-Davis corpus using a Viterbi-like algorithm. The model has a rich feature set defined over compression bigrams including parts of speech, parse trees, and dependency information, without using a synchronous grammar. Clarke and Lapata [1] reformulated McDonald’s model in the context of integer linear programming (ILP) and extended with constraints ensuring that the compressed output is grammatically and semantically well formed. The corresponding ILP model is solving in using the branch-and-bound algorithm.

In this paper, we will propose a new sentence compression model to both guarantee the grammatical rules and preserve main meaning. The main contributions in this work are: (1) Taking advantages of Parse tree model and Probability model, we hybridize them to build a new model that can be formulated as an ILP. Using the Parse tree model, we can extract the sentence truck, then fix the corresponding integer variables in the Probability model to derive a simplified ILP with improved quality of the compressed result. (2) We propose to use a DC programming approach called PDCABB (an hybrid algorithm combing DCA with a parallel branch-and-bound framework) developed by Niu in [17] for solving our sentence compression model. This approach can often provide a high quality optimal solution in a very short time.

The paper is organized as follows: The Section 2 is dedicated to establish hybrid sentence compression model. In Section 3, we will present DC programming approach for solving ILP. The numerical simulations and the experimental setup will be reported in Section 4. Some conclusions and future works will be discussed in the last section.

2 Hybrid Sentence Compression Model

Our sentence compression model is based on an Integer Linear Programming (ILP) probability model [1], and a parsing tree model. In this section, we will give a brief introduction of the two models, and propose our new hybrid model.

2.1 ILP Probability Model

Let x = $\{x_{1},x_{2},\ldots,x_{n}\}$ be a sentence with $n\geq 2$ words.111Punctuation is also deemed as word. We add $x_{0}$=‘start’ as the start token and $x_{n+1}$=‘end’ as the end token.

The sentence compression is to choose a subset of words in x for maximizing its probability to be a sentence under some restrictions to the allowable trigram combinations. This probability model can be described as an ILP as follows:

Decision variables: We introduce the binary decision variables $\delta_{i}$, $i\in\left[\!\left[1,n\right]\!\right]$222$\left[\!\left[m,n\right]\!\right]$ with $m\leq n$ stands for the set of integers between $m$ and $n$. for each word $x_{i}$ as: $\delta_{i}=1$ if $x_{i}$ is in a compression and [math] otherwise. In order to take context information into consideration, we introduce the context variables $(\alpha,\beta,\gamma)$ such that: $\forall i\in\left[\!\left[1,n\right]\!\right]$, we set $\alpha_{i}=1$ if $x_{i}$ starts a compression and [math] otherwise; $\forall i\in\left[\!\left[0,n-1\right]\!\right],j\in\left[\!\left[i+1,n\right]\!\right]$, we set $\beta_{ij}=1$ if the sequence $x_{i}$, $x_{j}$ ends a compression and [math] otherwise; and $\forall i\in\left[\!\left[0,n-2\right]\!\right],j\in\left[\!\left[i+1,n-1\right]\!\right],k\in\left[\!\left[j+1,n\right]\!\right]$, we set $\gamma_{ijk}=1$ if sequence $x_{i}$, $x_{j}$, $x_{k}$ is in a compression and [math] otherwise. There are totally $\frac{n^{3}+3n^{2}+14n}{6}$ binary variables for $(\delta,\alpha,\beta,\gamma)$.

Objective function: The objective function is to maximize the probability of the compression computed by:

[TABLE]

where $P\left(x_{i}|\text{start}\right)$ stands for the probability of a sentence starting with $x_{i}$, $P\left(x_{k}|x_{i},x_{j}\right)$ denotes the probability that $x_{i},x_{j},x_{k}$ successively occurs in a sentence, and $P\left(\text{end}|x_{i},x_{j}\right)$ means the probability that $x_{i},x_{j}$ ends a sentence. The probability $P\left(x_{i}|\text{start}\right)$ is computed by bigram model, and the others are computed by trigram model based on some corpora.

Constraints: The following sequential constraints will be introduced to restrict the possible trigram combinations:

Constraint 1 Exactly one word can begin a sentence.

[TABLE]

Constraint 2 If a word is included in a compression, it must either start the sentence, or be preceded by two other words, or be preceded by the ‘start’ token and one other word.

[TABLE]

Constraint 3 If a word is included in a compression, it must either be preceded by one word and followed by another, or be preceded by one word and end the sentence.

[TABLE]

Constraint 4 If a word is in a compression, it must either be followed by two words, or be followed by one word and end the sentence.

[TABLE]

Constraint 5 Exactly one word pair can end the sentence.

[TABLE]

Constraint 6 The length of a compression should be bounded.

[TABLE]

with given lower and upper bounds of the compression $\underline{l}$ and $\bar{l}$.

Constraint 7 The introducing term for preposition phrase (PP) or subordinate clause (SBAR) must be included in the compression if any word of the phrase is included. Otherwise, the phrase should be entirely removed. Let us denote $I_{i}=\{j:x_{j}\in\text{PP/SBAR},j\neq i\}$ the index set of the words included in PP/SBAR leading by the introducing term $x_{i}$, then

[TABLE]

ILP probability model: The optimization model for sentence compression is summarized as a binary linear program as:

[TABLE]

with $O(n^{3})$ binary variables and $O(n)$ linear constraints.

The advantage of this model is that its solution will provide a compression with maximal probability based on the trigram model. However, there is no information about syntactic structures of the target sentence, so it is possible to generate ungrammatical sentences. In order to overcome this disadvantage, we propose to combine it with the parse tree model presented below.

2.2 Parse Tree Model

A parse tree is an ordered, rooted tree which reflects the syntax of the input language based on some grammar rules (e.g. using CFG syntax-free grammar). For constructing a parse tree in practice, we can use a nature language processing toolkit NLTK [18] in Python. Based on NLTK, we have developed a CFG grammar generator which helps to generate automatically a CFG grammar based on a target sentence. A recursive descent parser can help to build a parse tree.

For example, the sentence “The man saw the dog with the telescope.” can be parsed as in Figure 1. It is observed that a higher level node in the parse tree indicates more important sentence components (e.g., the sentence S consists of a noun phrase NP, a verb phrase VP, and a symbol SYM), whereas a lower node tends to carry more semantic contents (e.g., the proposition phrase PP is consists of a preposition ‘with’, and a noun phrase ‘the telescope’). Therefore, a parse tree presents the clear structure of a sentence in a logical way.

Sentence compression can be also considered as finding a subtree which remains grammatically correct and containing main meaning of the original sentence. Therefore, we can propose a procedure to delete some nodes in the parse tree. For instance, the sentence above can be compressed as “The man saw the dog.” by deleting the node PP.

2.3 New Hybrid Model: ILP-Parse Tree Model

Our proposed model for sentence compression, called ILP-Parse Tree Model (ILP-PT), is based on the combination of the two models described above. The ILP model will provide some candidates for compression with maximal probability, while the parse tree model helps to guarantee the grammar rules and keep the main meaning of the sentence. This combination is described as follows:

Step 1 (Build ILP probability model): Building the ILP model as in formulation (8) for the target sentence.

Step 2 (Parse Sentence): Building a parse tree as described in subsection 2.2.

Step 3 (Fix variables for sentence trunk): Identifying the sentence trunk in the parse tree and fixing the corresponding integer variables to be $1$ in ILP model. This step helps to extract the sentence trunk by keeping the main meaning of the original sentence while reducing the number of binary decision variables.

More precisely, we will introduce for each node $N_{i}$ of the parse tree a label $s_{N_{i}}$ taking the values in $\left\{0,1,2\right\}$. A value [math] represents the deletion of the node; $1$ represents the reservation of the node; whereas $2$ indicates that the node can either be deleted or be reserved. We set these labels as compression rules for each CFG grammar to support any sentence type of any language.

For the word $x_{i}$, we go through all its parent nodes till the root S. If the traversal path contains [math], then $\delta_{i}=0$; else if the traversal path contains only $1$, then $\delta_{i}=1$; otherwise $\delta_{i}$ will be further determined by solving the ILP model. The sentence truck is composed by the words $x_{i}$ whose $\delta_{i}$ are fixed to $1$. Using this method, we can extract the sentence trunk and reduce the number of binary variables in ILP model.

Step 4 (Solve ILP): Applying an ILP solution algorithm to solve the simplified ILP model derived in Step 3 and generate a compression. In the next section, we will introduce a DC programming approach for solving ILP.

3 DC Programming approach for solving ILP

Solving an ILP is in general NP-hard. A classical and most frequently used method is branch-and-bound algorithm as in [1]. Gurobi [2] is currently one of the best ILP solvers, which is an efficient implementation of branch-and-bound combing various techniques such as presolve, cutting planes, heuristics and parallelism etc.

In this section, we will present a Difference of Convex (DC) programming approach, called DCA-Branch-and-Bound (DCABB), for solving this model. DCABB is initially designed for solving mixed-integer linear programming (MILP) proposed in [13], and extended for solving mixed-integer nonlinear programming [14, 15] with various applications including scheduling [8], network optimization [20], cryptography [10] and finance [9, 19] etc. This algorithm is based on continuous representation techniques for integer set, exact penalty theorem, DCA and Branch-and-Bound algorithms. Recently, the author developed a parallel branch-and-bound framework (called PDCABB) [17] in order to use the power of multiple CPU and GPU for improving the performance of DCABB.

The ILP model can be stated in standard matrix form as:

[TABLE]

where $S=\{x\in\{0,1\}^{n}:Ax=b\}$, $c\in\mathbb{R}^{n}$, $b\in\mathbb{R}^{m}$ and $A\in\mathbb{R}^{m\times n}$. Let us denote $K$ the linear relaxation of $S$ defined by $K=\{x\in[0,1]^{n}:Ax=b\}$. Thus, we have the relationship between $S$ and $K$ as $S=K\cap\{0,1\}^{n}.$

The linear relaxation of ($P$) denoted by $R(P)$ is

[TABLE]

whose optimal value denoted by $l(P)$ is a lower bound of ($P$).

The continuous representation technique for integer set $\{0,1\}^{n}$ consists of finding a continuous DC function333A function $f:\mathbb{R}^{n}\to\mathbb{R}$ is called DC if there exist two convex functions $g$ and $h$ (called DC components) such that $f=g-h$. $p:\mathbb{R}^{n}\to\mathbb{R}$ such that

[TABLE]

We often use the following functions for $p$ with their DC components:

function type expression of $p$ DC components of $p$

piecewise linear $\sum_{i=1}^{n}\min\{x_{i},1-x_{i}\}$ $g(x)=0$, $h(x)=-p(x)$

quadratic $\sum_{i=1}^{n}x_{i}(1-x_{i})$

trigonometric $\sum_{i=1}^{n}\sin^{2}(\pi x_{i})$ $g(x)=\pi^{2}\|x\|^{2}$, $h(x)=g(x)-p(x)$

Based on the exact penalty theorem [6, 11], there exists a large enough parameter $t\geq 0$ such that the problem ($P$) is equivalent to the problem ($P^{t}$):

[TABLE]

The objective function $F_{t}:\mathbb{R}^{n}\to\mathbb{R}$ in ($P^{t}$) is also DC with DC components $g_{t}$ and $h_{t}$ defined as $g_{t}(x)=tg(x),h_{t}(x)=th(x)-f(x)$ where $g$ and $h$ are DC components of $p$. Thus the problem ($P^{t}$) is a DC program which can be solved by DCA described in Algorithm 1.

The symbol $\partial h(x^{i})$ denotes the subdifferential of $h$ at $x^{i}$ which is fundamental in convex analysis. The subdifferential generalizes the derivative in the sense that $h$ is differentiable at $x^{i}$ if and only if $\partial h(x^{i})$ reduces to the singleton $\{\nabla h(x^{i})\}$.

Concerning on the choice of the penalty parameter $t$, we suggest using the following two methods: the first method is to take arbitrarily a large value for $t$; the second one is to increase $t$ by some ways in iterations of DCA (e.g., [14, 19]). Note that a smaller parameter $t$ yields a better DC decomposition [16].

Concerning on the numerical results given by DCA, it is often observed that DCA provides an integer solution which is also an upper bound solution for the problem ($P$). Therefore, DCA is often proposed for upper bound algorithm in nonconvex optimization. More details about DCA and its convergence theorem can be found in [7, 5]. Combing DCA with a parallel-branch-and-bound algorithm (PDCABB) proposed in [17], we can globally solve ILP. The PDCABB algorithm is described in Algorithm 2. More details about this algorithm as the convergence theorem, branching strategies, parallel node selection strategies will be discussed in full-length paper.

4 Experimental Results

In this section, we present our experimental results for assessing the performance of the sentence compression model described above.

Our sentence compression model is implemented in Python as a Natural Language Processing package, called ‘NLPTOOL’ (actually supporting multi-language tokenization, tagging, parsing, automatic CFG grammar generation, and sentence compression), which implants NLTK 3.2.5[18] for creating parsing trees and Gurobi 7.5.2[2] for solving the linear relaxation problems $R(P_{i})$ and the convex optimization subproblems in Step 2 of DCA. The PDCABB algorithm is implemented in C++ and invoked in python. The parallel computing part in PDCABB is realized by OpenMP.

4.1 F-score evaluation

We use a statistical approach called F-score to evaluate the similarity between the compression computed by our algorithm and a standard compression provided by human. F-score is defined by :

[TABLE]

where $P$ and $R$ represent for precision rate and recall rate as:

[TABLE]

in which $A$ denotes for the number of words both in the compressed result and the standard result; $B$ is the number of words in the standard result but not in the compressed result; and $C$ counts the number of words in the compressed result but not in the standard result. The parameter $\mu$, called preference parameter, stands for the preference between precision rate and recall rate for evaluating the quality of the results. $F_{\mu}$ is a strictly monotonic function defined on $[0,+\infty[$ with $\displaystyle\lim_{\mu\to 0}F_{\mu}=P$ and $\displaystyle\lim_{\mu\to+\infty}F_{\mu}=R$. In our tests, we will use $F_{1}$ as F-score. Clearly, a bigger F-score indicates a better compression.

4.2 Numerical Results

Table 1 illustrates the compression result of $100$ sentences obtained by two ILP compression models: our new hybrid model (H) v.s. the probability model (P). Penn Treebank corpus (Treebank) provided in NLTK and CLwritten corpus (Clarke) provided in [1] are used for sentence compression. We applied Kneser-Ney Smoothing for computing trigram probabilities. The compression rates 444The compression rate is computed by the length of compression over the length of original sentence. are given by $50\%$, $70\%$ and $90\%$. We compare the average solution time and the average F-score for these models solved by Gurobi and PDCABB. The experiments are performed on a laptop equipped with $2$ Intel i$5$-$6200$U $2.30$GHz CPU ($4$ cores) and $8$ GB RAM.

It can be observed that our hybrid model often provides better F-scores in average for all compression rates, while the computing time for both Gurobi and PDCABB are all very short within less than 0.2 seconds. We can also see that Gurobi and PDCABB provided different solutions since F-scores are different. This is due to the fact that branch-and-bound algorithm find only approximate global solutions when the gap between upper and lower bounds is small enough. Even both of the solvers provide global optimal solutions, these solutions could be also different since the global optimal solution for ILP could be not unique. However, the reliability of our judgment can be still guaranteed since these two algorithms provided very similar F-score results.

The box-plots given in Figure 2 demonstrates the variations of F-scores for different models with different corpora. We observed that our hybrid model (Treebank+H and Clarke+H) provided better F-scores in average and is more stable in variation, while the quality of the compressions given by probability model is worse and varies a lot. Moreover, the choice of corpora will affect the compression quality since the trigram probability depends on corpora. Therefore, in order to provide more reliable compressions, we have to choose the most related corpora to compute the trigram probabilities.

5 Conclusion and Perspectives

We have proposed a hybrid sentence compression model ILP-PT based on the probability model and the parse tree model to guarantee the syntax correctness of the compressed sentence and save the main meaning. We use a DC programming approach PDCABB to solve our sentence compression model. Experimental results show that our new model and the solution algorithm can produce high quality compressed results within a short compression time.

Concerning on future works, we are very interested in designing a suitable recurrent neural network for sentence compression. With deep learning method, it is possible to classify automatically the sentence types and fundamental structures, it is also possible to distinguish the fixed collocation in a sentence and make these variables be remained or be deleted together. Researches in these directions will be reported subsequently.