The learning algorithm used is a variation of the Winnow update rule incorporated in SNoW (Roth, 1998; Roth and Yih, 2002), a multi-class classifier that is specifically tailored for large scale learning tasks. SNoW learns a sparse network of linear functions, in which the targets (argument border predictions or argument type predictions, in this case) are represented as linear functions over a common feature space. It incorporates several improvements over the basic Winnow multiplicative update rule. In particular, a regularization term is added, which has the effect of trying to separate the data with a thick separator (Grove and Roth, 2001; Hang et al., 2002). In the work presented here we use this regularization with a fixed parameter.

Experimental evidence has shown that SNoW activations are monotonic with the confidence in the prediction. Therefore, it can provide a good source of probability estimation. We use softmax (Bishop, 1995) over the raw activation values as conditional probabilities, and also the score of the target. Specifically, suppose the number of classes is n , and the raw activation values of class i is act i . The posterior estimation for class i is derived by the following equation. score( i )= p i = [BAR] ∑ 1 ≤j≤n e act i e act j

The score plays an important role in different places. For example, the first phase uses the scores to decide which argument candidates should be filtered out. Also, the scores output by the secondphase classifier are used in the inference procedure to reason for the best global labeling.

The first phase is to predict the argument candidates of a given sentence that correspond to the active verb. Unfortunately, it turns out that it is difficult to predict the exact arguments accurately. Therefore, the goal here is to output a superset of the correct arguments by filtering out unlikely candidates.

Specifically, we learn two classifiers, one to detect beginning argument locations and the other to detect end argument locations. Each multiclass classifier makes predictions over forty-three classes—thirty-two argument types, ten continuous argument types, and one class to detect not beginning/not end . Features used for these classifiers are: • Word feature includes the current word, two

words before and two words after. • Part-of-speech tag (POS) feature includes the

POS tags of all words in a window of size two. • Chunk feature includes the BIO tags for

chunks of all words in a window of size two. • Predicate lemma & POS tag show the lemma

form and POS tag of the active predicate. • Voice feature is the voice (active/passive) of

the current predicate. This is extracted with a

simple rule: a verb is identified as passive if it

follows a to-be verb in the same phrase chunk

and its POS tag is VBN(past participle) or it

immediately follows a noun phrase. • Position feature describes if the current word

is before or after the predicate. • Chunk pattern encodes the sequence of

chunks from the current words to the predicate. • Clause tag indicates the boundary of clauses. • Clause path feature is a path formed from a

semi-parsed tree containing only clauses and

chunks. Each clause is named with the chunk

preceding it. The clause path is the path from

predicate to target word in the semi-parse tree. • Clause position feature is the position of the

target word relative to the predicate in the

semi-parse tree containing only clauses. There

are four configurations – target word and pred-

icate share the same parent, target word parent

is an ancestor of predicate, predicate parent is

an ancestor of target word, or otherwise.

Because each argument consists of a single beginning and a single ending, these classifiers can be used to construct a set of potential arguments (by combining each predicted begin with each predicted end after it of the same type).

Although this phase identifies typed arguments (i.e. labeled with argument types), the second phase will re-score each phrase using phrase-based classifiers – therefore, the goal of the first phase is simply to identify non-typed phrase candidates. In this all, without verb) on the training and the development set, respectively. Because these are the only candidates passed to the second phase, the final system performance is upper-bounded by 88 . 65% . task, we achieves 98 . 96% and 88 . 65% recall (over-

The second phase of our system assigns the final argument classes to (a subset) of the argument candidates supplied from the first phase. Again, the SNoW learning architecture is used to train a multiclass classifier to label each argument to one of the argument types, plus a special class— no argument (null). Training examples are created from the argument candidates supplied from the first phase using the following features: • Predicate lemma & POS tag, voice, position,

clause Path, clause position, chunk pattern

Same features as those in the first phase. • Word & POS tag from the argument, includ-

ing the first,last,and head 1 word and tag. • Named entity feature tells if the target argu-

ment is, embeds, overlaps, or is embedded in a

named entity with its type. • Chunk tells if the target argument is, embeds,

overlaps, or is embedded in a chunk with its

type. • Lengths of the target argument, in the numbers

of words and chunks separately. • Verb class feature is the class of the active

predicate described in PropBank Frames. • Phrase type uses simple heuristics to identify

the target argument as VP, PP, or NP. • Sub-categorization describes the phrase

structure around the predicate. We separate

the clause where the predicate is in into three

parts—the predicate chunk, segments before

and after the predicate, and use the sequence

of phrase types of these three segments. • Baseline features identified not in the main

verb chunk as AM-NEG and modal verb in the

main verb chunk as AM-MOD. • Clause coverage describes how much of the

local clause (from the predicate) is covered by

the target argument. • Chunk pattern length feature counts the num-

ber of patterns in the argument. • Conjunctions join every pair of the above fea-

tures as new features. • Boundary words & POS tag include two

words/tags before and after the target argu-

ment. • Bigrams are pairs of words/tags in the window

from two words before the target to the first

word of the target, and also from the last word

to two words after the argument. • Sparse collocation picks one word/tag from

the two words before the argument, the first

word/tag, the last word/tag of the argument,

and one word/tag from the two words after the

argument to join as features.

Although the predictions of the second-phase classifier can be used directly, the labels of arguments in a sentence often violate some constraints. Therefore, we rely on the inference procedure to make the final predictions.

Formally, the argument classifier attempts to assign labels to a set of arguments, S 1: M , indexed from 1 to M Each argument S i . can take any label from a set of argument labels, P , and the indexed set of If we assume that the classifier returns a score, score( S i = c i ) , corresponding to the likelihood of seeing label c i for argument S i , then, given a sentence, the unaltered inference task is solved by maximizing the overall score of the arguments, arguments can take a set of labels, c 1: M ∈P M . ĉ 1: M = argmax score( S 1: M = c 1: M )

c 1: M ∈P M

= argmax ∑ M score( S i = c i ) . (1)

c 1: M ∈P M i =1

In the presence of global constraints derived from linguistic information and structural considerations, our system seeks for a legitimate labeling that maximizes the score. Specifically, it can be viewed as the solution space is limited through the use of a filter function, F , that eliminates many argument labelings from consideration. It is interesting to contrast this with previous work that filters individual phrases (see (Carreras and M àrquez, 2003)). Here, 1. Arguments cannot cover the predicate except

those that contain only the verb or the verb and

the following word. 2. Arguments cannot overlap with the clauses

(they can be embedded in one another). 3. If a predicate is outside a clause, its arguments

cannot be embedded in that clause. 4. No overlapping or embedding arguments. 5. No duplicate argument classes for A0–A5,V. 6. Exactly one V argument per verb. 7. If there is C-V, then there should be a sequence

of consecutive V, A1, and C-V pattern. For ex-

ample, when split is the verb in “split it up”,

the A1 argument is “it” and C-V argument is

“up”. 8. If there is an R-XXX argument, then there has

to be an XXX argument. That is, if an ar-

gument is a reference to some other argument

XXX, then this referenced argument must exist

in the sentence. 9. If there is a C-XXX argument, then there has

to be an XXX argument; in addition, the C-

XXX argument must occur after XXX. This is

stricter than the previous rule because the order

of appearance also needs to be considered. 10. Given the predicate, some argument classes

are illegal (e.g. predicate ’stalk’ can take only

A0 or A1). This linguistic information can be

found in PropBank Frames . We reformulate the constraints as linear we are concerned with global constraints as well as constraints on the arguments. Therefore, the final labeling becomes ĉ 1: M = argmax M∑ score( S i = c i ) (2)

c 1: M ∈F ( P M ) i =1 The filter function used considers the following constraints: (in)equalities by introducing indicator variables. The optimization problem (Eq. 2) is solved using ILP.

As discussed previously, a collection of potential arguments is not necessarily a valid semantic labeling since it must satisfy all of the constraints. In this context, inference is the process of finding the best (according to Equation 1) valid semantic labels that satisfy all of the specified constraints. We take a similar approach that has been previously used for entity/relation recognition (Roth and Yih, 2004), and model this inference procedure as solving an ILP.

An integer linear program (ILP) is basically the sameas a linear program . The cost function and the (in)equality constraints are all linear in terms of the variables. The only difference in an ILP is the variables can only take integers as their values. In our inference problem, the variables are in fact binary. A general binary integer programming problem can be stated as follows.

Given a cost vector p ∈< d , a set of variables, z = ( z 1 ,...,z d ) and cost matrices C 1 ∈< t 1 × < d , C 2 ∈< t 2 ×< d , where t 1 and t 2 are the numbers of inequality and equality constraints and d is the number of binary variables. The ILP solution z ∗ is the vector that maximizes the cost function, z ∗ = argmax p · z , z ∈{ 0 , 1 } d subject to Cz 1 ≥ b 1 , and Cz 2 = b 2 ,

To solve the problem of Equation 2 in this setting, ∑ we first reformulate the original cost function M i =1 score( S i = c i ) asa linear function over several binary variables, and then represent the filter function F using linear inequalities and equalities.

We set up a bijection from the semantic labeling to the variable set z . Thisisdonebysetting z toaset c ] be the indicator variable that represents whether or not the argument type c is assigned to S i , and let p ic = score( S i = c ) . Equation 1 can then be written as an ILP cost function as where b 1 , b 2 ∈< d , and for all z∈ z , z∈{ 0 , 1 } . of indicator variables. Specifically, let z ic = [ S i = ∑∑ M |P| argmax p ic z ic , z ∈{ 0 , 1 } d i =1 c =1 subject to ∑ |P| z ic =1 ∀z ic ∈ z , c =1 which means that each argument can take only one type. Note that this new constraint comes from the variable transformation, and is not one of the constraints used in the filter function F .

Constraints 1 through 3 can be evaluated on a perargument basis – the sake of efficiency, arguments that violate these constraints are eliminated even before given the second-phase classifier. Next, we show how to transform the constraints in the filter function into the form of linear (in)equalities over z , and use them in this ILP setting. Constraint 4: No overlapping or embedding If arguments S j 1 ,...,S j k occupy the same word ina sentence, then this constraint restricts only one arguments to be assigned to an argument type. In other words, k− 1 arguments will be the special class null, which means the argument candidate is not a legitimate argument. If the special class null is represented by the symbol φ , then for every set of such arguments, the following linear equality represents this constraint. k∑ z jφ i = k− 1 i =1 Constraint 5: No duplicate argument classes Within the same sentence, several types of arguments cannot appear more than once. For example, a predicate can only take one A0. This constraint can be represented using the following inequality. M∑ z i A0 ≤ 1 i =1 Constraint 6: Exactly one V argument For each verb, there is one and has to be one V argument, which represents the active verb. Similarly, this constraint can be represented by the following equality. ∑ M z i V =1 i =1 Constraint 7: V–A1–C-V pattern This constraint is only useful when there are three consecutive candidate arguments in a sentence. Suppose C-V, then S j 1 and S j 2 have to be V and A1, respectively. This if-then constraint can be represented by the following two linear inequalities. arguments S j 1 ,S j 2 ,S j 3 are consecutive. If S j 3 is z j 3 C-V ≥z j 1 V , and z j 3 C-V ≥z j 2 A1 Constraint 8: R-XXX arguments Suppose the referenced argument type is A0 and the reference type is R-A0. The linear inequalities that represent this constraint are: ∑ M ∀m∈{ 1 ,...,M} : z i A0 ≥z m R-A0 i =1

If there are γ reference argument pairs, then the total number of inequalities needed is γM . Constraint 9: C-XXX arguments This constraint is similar to the reference argument constraints. The difference is that the continued argument XXX has to occur before C-XXX. Assume that the argument pair is A0 and C-A0, and arguinequalities that represent this constraint are: ment S j i appears before S j k if i≤ k . The linear ∑ j− 1 ∀m∈{ 2 ,...,M} : z j i A0 ≥z m R-A0 i =1 Constraint 10: Illegal argument types Given a specific verb, some argument types should never occur. For example, most verbs don’t have arguments A5. This constraint is represented by summing all the corresponding indicator variables to be 0. ∑ M z i A5 =0 i =1

Using ILP to solve this inference problem enjoys several advantages. Linear constraints are very general, and are able to represent many types of constraints. Previous approaches usually rely on dynamic programming to resolve non overlapping/embedding constraints (i.e., Constraint 4) when the data is sequential, but are unable to handle other constraints. The ILP approach is flexible enough to handle constraints regardless of the structure of the data. Although solving an ILP problem is NP-hard, with the help of todays commercial numerical packages, this problem can usually be solved very fast in practice. For instance, it only takes about 10 minutes to solve the inference problem for 4305 sentences on a Pentium-III 800 MHz machine in our experiments. Note that ordinary search methods (e.g., beam search) are not necessarily faster than solving an ILP problem and do not guarantee the optimal solution.