Base_JSON/prefixW/json/W05/W05-0407.json

{
    "paper_id": "W05-0407",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T04:45:44.350513Z"
    },
    "title": "Engineering of Syntactic Features for Shallow Semantic Parsing",
    "authors": [
        {
            "first": "Alessandro",
            "middle": [],
            "last": "Moschitti",
            "suffix": "",
            "affiliation": {},
            "email": ""
        },
        {
            "first": "Bonaventura",
            "middle": [],
            "last": "Coppola",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Trento",
                "location": {
                    "settlement": "Povo-Trento",
                    "country": "Italy"
                }
            },
            "email": "coppolab@itc.it"
        },
        {
            "first": "Daniele",
            "middle": [],
            "last": "Pighin",
            "suffix": "",
            "affiliation": {},
            "email": ""
        },
        {
            "first": "Roberto",
            "middle": [],
            "last": "Basili",
            "suffix": "",
            "affiliation": {},
            "email": ""
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "Recent natural language learning research has shown that structural kernels can be effectively used to induce accurate models of linguistic phenomena. In this paper, we show that the above properties hold on a novel task related to predicate argument classification. A tree kernel for selecting the subtrees which encodes argument structures is applied. Experiments with Support Vector Machines on large data sets (i.e. the PropBank collection) show that such kernel improves the recognition of argument boundaries.",
    "pdf_parse": {
        "paper_id": "W05-0407",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "Recent natural language learning research has shown that structural kernels can be effectively used to induce accurate models of linguistic phenomena. In this paper, we show that the above properties hold on a novel task related to predicate argument classification. A tree kernel for selecting the subtrees which encodes argument structures is applied. Experiments with Support Vector Machines on large data sets (i.e. the PropBank collection) show that such kernel improves the recognition of argument boundaries.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "The design of features for natural language processing tasks is, in general, a critical problem. The inherent complexity of linguistic phenomena, often characterized by structured data, makes difficult to find effective linear feature representations for the target learning models.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "In many cases, the traditional feature selection techniques (Kohavi and Sommerfield, 1995) are not so useful since the critical problem relates to feature generation rather than selection. For example, the design of features for a natural language syntactic parse-tree re-ranking problem (Collins, 2000) cannot be carried out without a deep knowledge about automatic syntactic parsing. The modeling of syntactic/semantic based features should take into account linguistic aspects to detect the interesting con-text, e.g. the ancestor nodes or the semantic dependencies (Toutanova et al., 2004) .",
                "cite_spans": [
                    {
                        "start": 60,
                        "end": 90,
                        "text": "(Kohavi and Sommerfield, 1995)",
                        "ref_id": "BIBREF10"
                    },
                    {
                        "start": 288,
                        "end": 303,
                        "text": "(Collins, 2000)",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 569,
                        "end": 593,
                        "text": "(Toutanova et al., 2004)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "A viable alternative has been proposed in (Collins and Duffy, 2002) , where convolution kernels were used to implicitly define a tree substructure space. The selection of the relevant structural features was left to the voted perceptron learning algorithm. Another interesting model for parsing re-ranking based on tree kernel is presented in (Taskar et al., 2004) . The good results show that tree kernels are very promising for automatic feature engineering, especially when the available knowledge about the phenomenon is limited.",
                "cite_spans": [
                    {
                        "start": 42,
                        "end": 67,
                        "text": "(Collins and Duffy, 2002)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 343,
                        "end": 364,
                        "text": "(Taskar et al., 2004)",
                        "ref_id": "BIBREF15"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Along the same line, automatic learning tasks that rely on syntactic information may take advantage of a tree kernel approach. One of such tasks is the automatic boundary detection of predicate arguments of the kind defined in PropBank (Kingsbury and Palmer, 2002) . For this purpose, given a predicate p in a sentence s, we can define the notion of predicate argument spanning trees (P AST s) as those syntactic subtrees of s which exactly cover all and only the p's arguments (see Section 4.1). The set of nonspanning trees can be then associated with all the remaining subtrees of s.",
                "cite_spans": [
                    {
                        "start": 236,
                        "end": 264,
                        "text": "(Kingsbury and Palmer, 2002)",
                        "ref_id": "BIBREF9"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "An automatic classifier which recognizes the spanning trees can potentially be used to detect the predicate argument boundaries. Unfortunately, the application of such classifier to all possible sentence subtrees would require an exponential execution time. As a consequence, we can use it only to decide for a reduced set of subtrees associated with a corresponding set of candidate boundaries. Notice how these can be detected by previous approaches (e.g. (Pradhan et al., 2004) ) in which a traditional boundary classifier (tbc) labels the parse-tree nodes as potential arguments (PA). Such classifiers, generally, are not sensitive to the overall argument structure. On the contrary, a P AST classifier (past c ) can consider the overall argument structure encoded in the associated subtree. This is induced by the PA subsets.",
                "cite_spans": [
                    {
                        "start": 452,
                        "end": 480,
                        "text": "(e.g. (Pradhan et al., 2004)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "The feature design for the P AST representation is not simple. Tree kernels are a viable alternative that allows the learning algorithm to measure the similarity between two P AST s in term of all possible tree substructures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "In this paper, we designed and experimented a boundary classifier for predicate argument labeling based on two phases: (1) a first annotation of potential arguments by using a high recall tbc and (2) a P AST classification step aiming to select the correct substructures associated with potential arguments. Both classifiers are based on Support Vector Machines learning. The past c uses the tree kernel function defined in (Collins and Duffy, 2002) . The results show that the P AST classification can be learned with high accuracy (the f-measure is about 89%) and the impact on the overall boundary detection accuracy is good.",
                "cite_spans": [
                    {
                        "start": 424,
                        "end": 449,
                        "text": "(Collins and Duffy, 2002)",
                        "ref_id": "BIBREF0"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "In the remainder of this paper, Section 2 introduces the Semantic Role Labeling problem along with the boundary detection subtask. Section 3 defines the SVMs using the linear kernel and the parse tree kernel for boundary detection. Section 4 describes our boundary detection algorithm. Section 5 shows the preliminary comparative results between the traditional and the two-step boundary detection. Finally, Section 7 summarizes the conclusions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "One of the largest resources of manually annotated predicate argument structures has been developed in the PropBank (PB) project. The PB corpus contains 300,000 words annotated with predicative information on top of the Penn Treebank 2 Wall Street Journal texts. For any given predicate, the expected arguments are labeled sequentially from Arg0 to Arg9, ArgA and ArgM. Figure 1 shows an example of the PB predicate annotation of the sentence: John rented a room in Boston.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 370,
                        "end": 378,
                        "text": "Figure 1",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Automated Semantic Role Labeling",
                "sec_num": "2"
            },
            {
                "text": "Predicates in PB are only embodied by verbs whereas most of the times Arg0 is the subject, Arg1 is the direct object and ArgM indicates locations, as in our example. Several machine learning approaches for automatic predicate argument extraction have been developed, e.g. (Gildea and Jurasfky, 2002; Gildea and Palmer, 2002; Gildea and Hockenmaier, 2003; Pradhan et al., 2004) . Their common characteristic is the adoption of feature spaces that model predicateargument structures in a flat feature representation. In the next section, we present the common parse tree-based approach to this problem.",
                "cite_spans": [
                    {
                        "start": 272,
                        "end": 299,
                        "text": "(Gildea and Jurasfky, 2002;",
                        "ref_id": "BIBREF6"
                    },
                    {
                        "start": 300,
                        "end": 324,
                        "text": "Gildea and Palmer, 2002;",
                        "ref_id": "BIBREF7"
                    },
                    {
                        "start": 325,
                        "end": 354,
                        "text": "Gildea and Hockenmaier, 2003;",
                        "ref_id": "BIBREF4"
                    },
                    {
                        "start": 355,
                        "end": 376,
                        "text": "Pradhan et al., 2004)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Automated Semantic Role Labeling",
                "sec_num": "2"
            },
            {
                "text": "Given a sentence in natural language, all the predicates associated with the verbs have to be identified along with their arguments. This problem is usually divided in two subtasks: (a) the detection of the target argument boundaries, i.e. the span of its words in the sentence, and (b) the classification of the argument type, e.g. Arg0 or ArgM in PropBank or Agent and Goal in FrameNet.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "The standard approach to learn both the detection and the classification of predicate arguments is summarized by the following steps:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "1. Given a sentence from the training-set, generate a full syntactic parse-tree;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "2. let P and A be the set of predicates and the set of parse-tree nodes (i.e. the potential arguments), respectively;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "3. for each pair < p, a >\u2208 P \u00d7 A:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "\u2022 extract the feature representation set, F p,a ;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "\u2022 if the subtree rooted in a covers exactly the words of one argument of p, put F p,a in T + (positive examples), otherwise put it in T \u2212 (negative examples).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "For instance, in Figure 1 , for each combination of the predicate rent with the nodes N, S, VP, V, NP, PP, D or IN the instances F rent,a are generated. In case the node a exactly covers \"John\", \"a room\" or \"in Boston\", it will be a positive instance otherwise it will be a negative one, e.g. F rent,IN .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 17,
                        "end": 25,
                        "text": "Figure 1",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "The T + and T \u2212 sets are used to train the boundary classifier. To train the multi-class classifier T + can be reorganized as positive T + arg i and negative T \u2212 arg i examples for each argument i. In this way, an individual ONE-vs-ALL classifier for each argument i can be trained. We adopted this solution, according to (Pradhan et al., 2004) , since it is simple and effective. In the classification phase, given an unseen sentence, all its F p,a are generated and classified by each individual classifier C i . The argument associated with the maximum among the scores provided by the individual classifiers is eventually selected.",
                "cite_spans": [
                    {
                        "start": 322,
                        "end": 344,
                        "text": "(Pradhan et al., 2004)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Predicate Argument Extraction",
                "sec_num": "2.1"
            },
            {
                "text": "The discovery of relevant features is, as usual, a complex task. However, there is a common consensus on the set of basic features. These standard features, firstly proposed in (Gildea and Jurasfky, 2002) , refer to unstructured information derived from parse trees, i.e. Phrase Type, Predicate Word, Head Word, Governing Category, Position and Voice. For example, the Phrase Type indicates the syntactic type of the phrase labeled as a predicate argument, e.g. NP for Arg1 in Figure 1 . The Parse Tree Path contains the path in the parse tree between the predicate and the argument phrase, expressed as a sequence of nonterminal labels linked by direction (up or down) symbols, e.g. V \u2191 VP \u2193 NP for Arg1 in Figure 1 . The Predicate Word is the surface form of the verbal predicate, e.g. rent for all arguments.",
                "cite_spans": [
                    {
                        "start": 177,
                        "end": 204,
                        "text": "(Gildea and Jurasfky, 2002)",
                        "ref_id": "BIBREF6"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 477,
                        "end": 485,
                        "text": "Figure 1",
                        "ref_id": "FIGREF1"
                    },
                    {
                        "start": 708,
                        "end": 716,
                        "text": "Figure 1",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Standard feature space",
                "sec_num": "2.2"
            },
            {
                "text": "In the next section we describe the SVM approach and the basic kernel theory for the predicate argument classification.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Standard feature space",
                "sec_num": "2.2"
            },
            {
                "text": "Given a vector space in n and a set of positive and negative points, SVMs classify vectors according to a separating hyperplane, H( x) = w \u00d7 x + b = 0, where w \u2208 n and b \u2208 are learned by applying the Structural Risk Minimization principle (Vapnik, 1995) .",
                "cite_spans": [
                    {
                        "start": 239,
                        "end": 253,
                        "text": "(Vapnik, 1995)",
                        "ref_id": "BIBREF17"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "To apply the SVM algorithm to Predicate Argument Classification, we need a function \u03c6 : F \u2192 n to map our features space F = {f 1 , .., f |F | } and our predicate/argument pair representation, F p,a = F z , into n , such that:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "F z \u2192 \u03c6(F z ) = (\u03c6 1 (F z ), .., \u03c6 n (F z ))",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "From the kernel theory we have that:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "H( x) = i=1..l \u03b1 i x i \u2022 x + b = i=1..l \u03b1 i x i \u2022 x + b = i=1..l \u03b1 i \u03c6(F i ) \u2022 \u03c6(F z ) + b.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "where, F i \u2200i \u2208 {1, .., l} are the training instances and the product",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "K(F i , F z ) =<\u03c6(F i ) \u2022 \u03c6(F z )>",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "is the kernel function associated with the mapping \u03c6.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "The simplest mapping that we can apply is \u03c6(F z ) = z = (z 1 , ..., z n ) where z i = 1 if f i \u2208 F z and z i = 0 otherwise, i.e. the characteristic vector of the set F z with respect to F. If we choose the scalar product as a kernel function we obtain the lin-",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "ear kernel K L (F x , F z ) = x \u2022 z.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "An interesting property is that we do not need to evaluate the \u03c6 function to compute the above vector. Only the K( x, z) values are in fact required. This allows us to derive efficient classifiers in a huge (possible infinite) feature space, provided that the kernel is processed in an efficient way. This property is also exploited to design convolution kernel like those based on tree structures.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Learning predicate structures via Support Vector Machines",
                "sec_num": "3"
            },
            {
                "text": "The main idea of the tree kernels is the modeling of a K T (T 1 , T 2 ) function which computes the number of common substructures between two trees T 1 and T 2 .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "Given the set of substructures (fragments) {f 1 , f 2 , ..} = F extracted from all the trees of the training set, we define the indicator function I i (n) which is equal 1 if the target f i is rooted at node n and 0 otherwise. It follows that:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "EQUATION",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [
                    {
                        "start": 0,
                        "end": 8,
                        "text": "EQUATION",
                        "ref_id": "EQREF",
                        "raw_str": "K T (T 1 , T 2 ) = n 1 \u2208N T 1 n 2 \u2208N T 2 \u2206(n 1 , n 2 )",
                        "eq_num": "(1)"
                    }
                ],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "where N T 1 and N T 2 are the sets of the T 1 's and T 2 's nodes, respectively and \u2206(n 1 , n 2 ) =",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "|F | i=1 I i (n 1 )I i (n 2 )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": ". This latter is equal to the number of common fragments rooted at the n 1 and n 2 nodes. We can compute \u2206 as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "1. if the productions at n 1 and n 2 are different then \u2206(n 1 , n 2 ) = 0;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "2. if the productions at n 1 and n 2 are the same, and n 1 and n 2 have only leaf children (i.e. they are pre-terminals symbols) then \u2206(n 1 , n 2 ) = 1;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "3. if the productions at n 1 and n 2 are the same, and n 1 and n 2 are not pre-terminals then",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "\u2206(n 1 , n 2 ) = nc(n 1 ) j=1 (1 + \u2206(c j n 1 , c j n 2 )) (2)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "where nc(n 1 ) is the number of the children of n 1 and c j n is the j-th child of the node n. Note that, as the productions are the same, nc(n 1 ) = nc(n 2 ).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "The above kernel has the drawback of assigning higher weights to larger structures 1 . In order to overcome this problem we scale the relative importance of the tree fragments imposing a parameter \u03bb in conditions 2 and 3 as follows:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "\u2206(n x , n z ) = \u03bb and \u2206(n x , n z ) = \u03bb nc(nx) j=1 (1 + \u2206(c j n 1 , c j n 2 )).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "1 In order to approach this problem and to map similarity scores in the [0,1] range, a normalization in the kernel space, i.e. K",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "T (T 1 , T 2 ) = K T (T 1 ,T 2 ) \u221a K T (T 1 ,T 1 )\u00d7K T (T 2 ,T 2 )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": ". is always applied",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The tree kernel function",
                "sec_num": "3.1"
            },
            {
                "text": "Section 2 has shown that traditional argument boundary classifiers rely only on features extracted from the current potential argument node. In order to take into account a complete argument structure information, the classifier should select a set of parse-tree nodes and consider them as potential arguments of the target predicate. The number of all possible subsets is exponential in the number of the parse-tree nodes of the sentence, thus, we need to cut the search space. For such purpose, a traditional boundary classifier can be applied to select the set of potential arguments PA. The reduced number of PA subsets can be associated with sentence subtrees which in turn can be classified by using tree kernel functions. These measure if a subtree is compatible or not with the subtree of a correct predicate argument structure.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Boundary detection via argument spanning",
                "sec_num": "4"
            },
            {
                "text": "We consider the predicate argument structures annotated in PropBank along with the corresponding TreeBank data as our object space. Given the target predicate p in a sentence parse tree T and a subset s = {n 1 , .., n k } of the T's nodes, N T , we define as the spanning tree root r the lowest common ancestor of n 1 , .., n k . The node spanning tree (N ST ), p s is the subtree rooted in r, from which the nodes that are neither ancestors nor descendants of any n i are removed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "Since predicate arguments are associated with tree nodes, we can define the predicate argu- ment spanning tree (P AST ) of a predicate argument set, {a 1 , .., a n }, as the N ST over such nodes, i.e. p {a 1 ,..,a n } . A P AST corresponds to the minimal subparse tree whose leaves are all and only the word sequence compounding the arguments. For example, Figure 2 shows the parse tree of the sentence \"John took the book and read its title\". took {ARG 0 ,ARG 1 } and read {ARG 0 ,ARG 1 } are two P AST structures associated with the two predicates took and read, respectively. All the other N ST s are not valid P AST s.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 357,
                        "end": 365,
                        "text": "Figure 2",
                        "ref_id": "FIGREF2"
                    }
                ],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "Notice that, labeling p s , \u2200s \u2286 N T with a P AST classifier (past c ) corresponds to solve the boundary problem. The critical points for the application of this strategy are: (1) how to design suitable features for the P AST characterization. This new problem requires a careful linguistic investigation about the significant properties of the argument spanning trees and (2) how to deal with the exponential number of N ST s.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "For the first problem, the use of tree kernels over the P AST s can be an alternative to the manual features design as the learning machine, (e.g. SVMs) can select the most relevant features from a high dimensional feature space. In other words, we can use Eq. 1 to estimate the similarity between two P AST s avoiding to define explicit features. The same idea has been successfully applied to the parse-tree reranking task (Taskar et al., 2004; Collins and Duffy, 2002) and predicate argument classification (Moschitti, 2004) .",
                "cite_spans": [
                    {
                        "start": 425,
                        "end": 446,
                        "text": "(Taskar et al., 2004;",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 447,
                        "end": 471,
                        "text": "Collins and Duffy, 2002)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 510,
                        "end": 527,
                        "text": "(Moschitti, 2004)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "For the second problem, i.e. the high computational complexity, we can cut the search space by us-ing a traditional boundary classifier (tbc), e.g. (Pradhan et al., 2004) , which provides a small set of potential argument nodes. Let PA be the set of nodes located by tbc as arguments. We may consider the set P of the N ST s associated with any subset of PA, i.e. P = {p s : s \u2286 PA}. However, also the classification of P may be computationally problematic since theoretically there are |P| = 2 |PA| members.",
                "cite_spans": [
                    {
                        "start": 148,
                        "end": 170,
                        "text": "(Pradhan et al., 2004)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "In order to have a very efficient procedure, we applied past c to only the PA sets associated with incorrect P AST s. A way to detect such incorrect N ST s is to look for a node pair <n 1 , n 2 >\u2208 PA \u00d7 PA of overlapping nodes, i.e. n 1 is ancestor of n 2 or viceversa. After we have detected such nodes, we create two node sets P A 1 = PA \u2212 {n 1 } and P A 2 = PA \u2212 {n 2 } and classify them with the past c to select the correct set of argument boundaries. This procedure can be generalized to a set of overlapping nodes O greater than 2 as reported in Appendix 1.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "Note that the algorithm selects a maximal set of non-overlapping nodes, i.e. the first that is generated. Additionally, the worst case is rather rare thus the algorithm is very fast on average.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "The Figure 3 shows a working example of the multi-stage classifier. In Frame (a), tbc labels as potential arguments (gray color) three overlapping nodes (in Arg.1). The overlap resolution algorithm proposes two solutions (Frame (b)) of which only one is correct. In fact, according to the second solution the propositional phrase \"of the book\" would incorrectly be attached to the verbal predicate, i.e. in contrast with the parse tree. The past c , applied to the two N ST s, should detect this inconsistency and provide the correct output. Note that, during the learning, we generate the non-overlapping structures in the same way to derive the positive and negative examples.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 4,
                        "end": 12,
                        "text": "Figure 3",
                        "ref_id": "FIGREF3"
                    }
                ],
                "eq_spans": [],
                "section": "The Predicate Argument Spanning Trees (P AST s)",
                "sec_num": "4.1"
            },
            {
                "text": "In the Frame (b) of Figure 3 , we show one of the possible cases which past c should deal with. The critical problem is that the two N ST s are perfectly identical, thus, it is not possible to discern between them using only their parse-tree fragments.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 20,
                        "end": 28,
                        "text": "Figure 3",
                        "ref_id": "FIGREF3"
                    }
                ],
                "eq_spans": [],
                "section": "Engineering Tree Fragment Features",
                "sec_num": "4.2"
            },
            {
                "text": "The solution to engineer novel features is to simply add the boundary information provided by the tbc to the N ST s. We mark with a progressive number the phrase type corresponding to an argument node, starting from the leftmost argument. For example, in the first N ST of Frame (c), we mark as NP-0 and NP-1 the first and second argument nodes whereas in the second N ST we have an hypothesis of three arguments on the NP, NP and PP nodes. We trasform them in NP-0, NP-1 and PP-2.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Engineering Tree Fragment Features",
                "sec_num": "4.2"
            },
            {
                "text": "This simple modification enables the tree kernel to generate features useful to distinguish between two identical parse trees associated with different argument structures. In order to verify the relevance of our model, the next section provides empirical evidence about the effectiveness of our approach.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Engineering Tree Fragment Features",
                "sec_num": "4.2"
            },
            {
                "text": "The experiments were carried out with the SVM-light-TK software available at http://ai-nlp.info.uniroma2.it/moschitti/ which encodes the tree kernels in the SVM-light software (Joachims, 1999) . For tbc, we used the linear kernel with a regularization parameter (option -c) equal to 1 and a cost-factor (option -j) of 10 to have a higher Recall. For the past c we used \u03bb = 0.4 (see (Moschitti, 2004) ).",
                "cite_spans": [
                    {
                        "start": 176,
                        "end": 192,
                        "text": "(Joachims, 1999)",
                        "ref_id": "BIBREF8"
                    },
                    {
                        "start": 382,
                        "end": 399,
                        "text": "(Moschitti, 2004)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "As referring dataset, we used the PropBank cor-pora available at www.cis.upenn.edu/\u223cace, along with the Penn TreeBank 2 (www.cis.upenn.edu/\u223ctreebank) (Marcus et al., 1993) . This corpus contains about 53,700 sentences and a fixed split between training and testing which has been used in other researches, e.g. (Pradhan et al., 2004; Gildea and Palmer, 2002) . We did not include continuation and co-referring arguments in our experiments.",
                "cite_spans": [
                    {
                        "start": 150,
                        "end": 171,
                        "text": "(Marcus et al., 1993)",
                        "ref_id": "BIBREF12"
                    },
                    {
                        "start": 311,
                        "end": 333,
                        "text": "(Pradhan et al., 2004;",
                        "ref_id": null
                    },
                    {
                        "start": 334,
                        "end": 358,
                        "text": "Gildea and Palmer, 2002)",
                        "ref_id": "BIBREF7"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "We used sections from 02 to 07 (54,443 argument nodes and 1,343,046 non-argument nodes) to train the traditional boundary classifier (tbc). Then, we applied it to classify the sections from 08 to 21 (125,443 argument nodes vs. 3,010,673 nonargument nodes). As results we obtained 2,988 N ST s containing at least an overlapping node pair out of the total 65,212 predicate structures (according to the tbc decisions). From the 2,988 overlapping structures we extracted 3,624 positive and 4,461 negative N ST s, that we used to train the past c .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "The performance was evaluated with the F 1 measure 2 over the section 23. This contains 10,406 argument nodes out of 249,879 parse tree nodes. By applying the tbc classifier we derived 235 overlapping N ST s, from which we extracted 204 P AST s and 385 incorrect predicate argument structures. On such test data, the performance of past c was very high, i.e. 87.08% in Precision and 89.22% in Recall.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "Using the past c we removed from the tbc the PA that cause overlaps. To measure the impact on the boundary identification performance, we compared it with three different boundary classification baselines:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "\u2022 tbc: overlaps are ignored and no decision is taken. This provides an upper bound for the recall as no potential argument is rejected for later labeling. Notice that, in presence of overlapping nodes, the sentence cannot be annotated correctly.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "\u2022 RN D: one among the non-overlapping structures with maximal number of arguments is randomly selected. \u2022 Heu (heuristic): one of the N ST s which contain the nodes with the lowest overlapping score is chosen. This score counts the number of overlapping node pairs in the N ST . For example, in Figure 3 .(a) we have a NP that overlaps with two nodes NP and PP, thus it is assigned a score of 2.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 295,
                        "end": 303,
                        "text": "Figure 3",
                        "ref_id": "FIGREF3"
                    }
                ],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "The third row of Table 1 shows the results of tbc, tbc + RN D, tbc + Heu and tbc + past c in the columns 2,3,4 and 5, respectively. We note that:",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 17,
                        "end": 24,
                        "text": "Table 1",
                        "ref_id": "TABREF2"
                    }
                ],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "\u2022 The tbc F 1 is slightly higher than the result obtained in (Pradhan et al., 2004) , i.e. 95.37% vs. 93.8% on same training/testing conditions, i.e. (same PropBank version, same training and testing split and same machine learning algorithm). This is explained by the fact that we did not include the continuations and the coreferring arguments that are more difficult to detect.",
                "cite_spans": [
                    {
                        "start": 61,
                        "end": 83,
                        "text": "(Pradhan et al., 2004)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "\u2022 Both RN D and Heu do not improve the tbc result. This can be explained by observing that in the 50% of the cases a correct node is removed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "\u2022 When, to select the correct node, the past c is used, the F 1 increases of 1. 49%, i.e. (96.86 vs. 95.37) . This is a very good result considering that to increase the very high baseline of tbc is hard.",
                "cite_spans": [
                    {
                        "start": 80,
                        "end": 107,
                        "text": "49%, i.e. (96.86 vs. 95.37)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "In order to give a fairer evaluation of our approach we tested the above classifiers on the overlapping structures only, i.e. we measured the past c improvement on all and only the structures that required its application. Such reduced test set contains 642 argument nodes and 15,408 non-argument nodes. The fourth row of Table 1 reports the classifier performance on such task. We note that the past c improves the other heuristics of about 20%.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 322,
                        "end": 329,
                        "text": "Table 1",
                        "ref_id": "TABREF2"
                    }
                ],
                "eq_spans": [],
                "section": "The Experiments",
                "sec_num": "5"
            },
            {
                "text": "Recently, many kernels for natural language applications have been designed. In what follows, we highlight their difference and properties.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "6"
            },
            {
                "text": "The tree kernel used in this article was proposed in (Collins and Duffy, 2002) for syntactic parsing reranking. It was experimented with the Voted Perceptron and was shown to improve the syntactic parsing. A refinement of such technique was presented in (Taskar et al., 2004) . The substructures produced by the proposed tree kernel were bound to local properties of the target parse tree and more lexical information was added to the overall kernel function.",
                "cite_spans": [
                    {
                        "start": 53,
                        "end": 78,
                        "text": "(Collins and Duffy, 2002)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 254,
                        "end": 275,
                        "text": "(Taskar et al., 2004)",
                        "ref_id": "BIBREF15"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "6"
            },
            {
                "text": "In (Zelenko et al., 2003) , two kernels over syntactic shallow parser structures were devised for the extraction of linguistic relations, e.g. personaffiliation. To measure the similarity between two nodes, the contiguous string kernel and the sparse string kernel (Lodhi et al., 2000) were used. The former can be reduced to the contiguous substring kernel whereas the latter can be transformed in the non-contiguous string kernel. The high running time complexity, caused by the general form of the fragments, limited the experiments on data-set of just 200 news items.",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 25,
                        "text": "(Zelenko et al., 2003)",
                        "ref_id": "BIBREF18"
                    },
                    {
                        "start": 265,
                        "end": 285,
                        "text": "(Lodhi et al., 2000)",
                        "ref_id": "BIBREF11"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "6"
            },
            {
                "text": "In (Cumby and Roth, 2003) , it is proposed a description language that models feature descriptors to generate different feature type. The descriptors, which are quantified logical prepositions, are instantiated by means of a concept graph which encodes the structural data. In the case of relation extraction the concept graph is associated with a syntactic shallow parse and the extracted propositional features express fragments of a such syntactic structure. The experiments over the named entity class categorization show that when the description language selects an adequate set of tree fragments the Voted Perceptron algorithm increases its classification accuracy.",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 25,
                        "text": "(Cumby and Roth, 2003)",
                        "ref_id": "BIBREF3"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "6"
            },
            {
                "text": "In (Culotta and Sorensen, 2004) a dependency tree kernel is used to detect the Named Entity classes in natural language texts. The major novelty was the combination of the contiguous and sparse kernels with the word kernel. The results show that the contiguous outperforms the sparse kernel and the bag-of-words.",
                "cite_spans": [
                    {
                        "start": 3,
                        "end": 31,
                        "text": "(Culotta and Sorensen, 2004)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Related Work",
                "sec_num": "6"
            },
            {
                "text": "The feature design for new natural language learning tasks is difficult. We can take advantage from the kernel methods to model our intuitive knowledge about the target linguistic phenomenon. In this paper we have shown that we can exploit the properties of tree kernels to engineer syntactic features for the predicate argument boundary detection task. Preliminary results on gold standard trees suggest that (1) the information related to the whole predicate argument structure is important and (2) tree kernel can be used to generate syntactic features.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions",
                "sec_num": "7"
            },
            {
                "text": "In the future, we would like to use an approach similar to the P AST classifier on parses provided by different parsing models to detect boundary and to classify semantic role more accurately .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusions",
                "sec_num": "7"
            },
            {
                "text": "F 1 assigns equal importance to Precision P and Recall R, i.e. F 1 = 2P \u00d7R P +R .",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [
            {
                "text": "We wish to thank Ana-Maria Giuglea for her help in the design and implementation of the basic Semantic Role Labeling system that we used in the experiments.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Acknowledgements",
                "sec_num": null
            },
            {
                "text": "Let O be the set of overlapping nodes of PA, and N O the set of non overlapping nodes of PA. Let subs (\u22121) ",
                "cite_spans": [
                    {
                        "start": 102,
                        "end": 106,
                        "text": "(\u22121)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Appendix 1: Generalized Boundary Selection Algorithm",
                "sec_num": null
            }
        ],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "New ranking algorithms for parsing and tagging: Kernels over discrete structures, and the voted perceptron",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [],
                        "last": "Collins",
                        "suffix": ""
                    },
                    {
                        "first": "Nigel",
                        "middle": [],
                        "last": "Duffy",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "ACL02",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Michael Collins and Nigel Duffy. 2002. New ranking algorithms for parsing and tagging: Kernels over dis- crete structures, and the voted perceptron. In ACL02.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Discriminative reranking for natural language parsing",
                "authors": [
                    {
                        "first": "Michael",
                        "middle": [],
                        "last": "Collins",
                        "suffix": ""
                    }
                ],
                "year": 2000,
                "venue": "Proceedings of ICML",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Michael Collins. 2000. Discriminative reranking for nat- ural language parsing. In Proceedings of ICML 2000.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "Dependency tree kernels for relation extraction",
                "authors": [
                    {
                        "first": "Aron",
                        "middle": [],
                        "last": "Culotta",
                        "suffix": ""
                    },
                    {
                        "first": "Jeffrey",
                        "middle": [],
                        "last": "Sorensen",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of the 42nd Meeting of the Association for Computational Linguistics (ACL'04), Main Volume",
                "volume": "",
                "issue": "",
                "pages": "423--429",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Aron Culotta and Jeffrey Sorensen. 2004. Dependency tree kernels for relation extraction. In Proceedings of the 42nd Meeting of the Association for Computational Linguistics (ACL'04), Main Volume, pages 423-429, Barcelona, Spain, July.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "Kernel methods for relational learning",
                "authors": [
                    {
                        "first": "Chad",
                        "middle": [],
                        "last": "Cumby",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Roth",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Proceedings of the Twentieth International Conference (ICML 2003)",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Chad Cumby and Dan Roth. 2003. Kernel methods for relational learning. In Proceedings of the Twentieth International Conference (ICML 2003), Washington, DC, USA.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "Identifying semantic roles using combinatory categorial grammar",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Gildea",
                        "suffix": ""
                    },
                    {
                        "first": "Julia",
                        "middle": [],
                        "last": "Hockenmaier",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Daniel Gildea and Julia Hockenmaier. 2003. Identifying semantic roles using combinatory categorial grammar.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "Proceedings of the 2003 Conference on Empirical Methods in Natural Language Processing",
                "authors": [],
                "year": null,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "In Proceedings of the 2003 Conference on Empirical Methods in Natural Language Processing, Sapporo, Japan.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "Automatic labeling of semantic roles",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Gildea",
                        "suffix": ""
                    },
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Jurasfky",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Computational Linguistic",
                "volume": "28",
                "issue": "3",
                "pages": "496--530",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Daniel Gildea and Daniel Jurasfky. 2002. Automatic la- beling of semantic roles. Computational Linguistic, 28(3):496-530.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "The necessity of parsing for predicate argument recognition",
                "authors": [
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Gildea",
                        "suffix": ""
                    },
                    {
                        "first": "Martha",
                        "middle": [],
                        "last": "Palmer",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Proceedings of the 40th Annual Conference of the Association for Computational Linguistics (ACL-02)",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Daniel Gildea and Martha Palmer. 2002. The neces- sity of parsing for predicate argument recognition. In Proceedings of the 40th Annual Conference of the Association for Computational Linguistics (ACL-02), Philadelphia, PA, USA.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Making large-scale SVM learning practical",
                "authors": [
                    {
                        "first": "T",
                        "middle": [],
                        "last": "Joachims",
                        "suffix": ""
                    }
                ],
                "year": 1999,
                "venue": "Advances in Kernel Methods -Support Vector Learning",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "T. Joachims. 1999. Making large-scale SVM learning practical. In B. Sch\u00f6lkopf, C. Burges, and A. Smola, editors, Advances in Kernel Methods -Support Vector Learning.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "From Treebank to PropBank",
                "authors": [
                    {
                        "first": "Paul",
                        "middle": [],
                        "last": "Kingsbury",
                        "suffix": ""
                    },
                    {
                        "first": "Martha",
                        "middle": [],
                        "last": "Palmer",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Proceedings of the 3rd International Conference on Language Resources and Evaluation (LREC-2002)",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Paul Kingsbury and Martha Palmer. 2002. From Tree- bank to PropBank. In Proceedings of the 3rd Interna- tional Conference on Language Resources and Evalu- ation (LREC-2002), Las Palmas, Spain.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Feature subset selection using the wrapper model: Overfitting and dynamic search space topology",
                "authors": [
                    {
                        "first": "Ron",
                        "middle": [],
                        "last": "Kohavi",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Sommerfield",
                        "suffix": ""
                    }
                ],
                "year": 1995,
                "venue": "The First International Conference on Knowledge Discovery and Data Mining",
                "volume": "",
                "issue": "",
                "pages": "192--197",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ron Kohavi and Dan Sommerfield. 1995. Feature sub- set selection using the wrapper model: Overfitting and dynamic search space topology. In The First Interna- tional Conference on Knowledge Discovery and Data Mining, pages 192-197. AAAI Press, Menlo Park, California, August. Journal version in AIJ.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "Text classification using string kernels",
                "authors": [
                    {
                        "first": "Huma",
                        "middle": [],
                        "last": "Lodhi",
                        "suffix": ""
                    },
                    {
                        "first": "Craig",
                        "middle": [],
                        "last": "Saunders",
                        "suffix": ""
                    },
                    {
                        "first": "John",
                        "middle": [],
                        "last": "Shawe-Taylor",
                        "suffix": ""
                    },
                    {
                        "first": "Nello",
                        "middle": [],
                        "last": "Cristianini",
                        "suffix": ""
                    },
                    {
                        "first": "Christopher",
                        "middle": [],
                        "last": "Watkins",
                        "suffix": ""
                    }
                ],
                "year": 2000,
                "venue": "NIPS",
                "volume": "",
                "issue": "",
                "pages": "563--569",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Huma Lodhi, Craig Saunders, John Shawe-Taylor, Nello Cristianini, and Christopher Watkins. 2000. Text clas- sification using string kernels. In NIPS, pages 563- 569.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "Building a large annotated corpus of english: The Penn Treebank",
                "authors": [
                    {
                        "first": "M",
                        "middle": [
                            "P"
                        ],
                        "last": "Marcus",
                        "suffix": ""
                    },
                    {
                        "first": "B",
                        "middle": [],
                        "last": "Santorini",
                        "suffix": ""
                    },
                    {
                        "first": "M",
                        "middle": [
                            "A"
                        ],
                        "last": "Marcinkiewicz",
                        "suffix": ""
                    }
                ],
                "year": 1993,
                "venue": "Computational Linguistics",
                "volume": "19",
                "issue": "",
                "pages": "313--330",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "M. P. Marcus, B. Santorini, and M. A. Marcinkiewicz. 1993. Building a large annotated corpus of en- glish: The Penn Treebank. Computational Linguistics, 19:313-330.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "A study on convolution kernels for shallow semantic parsing",
                "authors": [
                    {
                        "first": "Alessandro",
                        "middle": [],
                        "last": "Moschitti",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "proceedings of the 42 th Conference on Association for Computational Linguistic (ACL-2004)",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Alessandro Moschitti. 2004. A study on convolution ker- nels for shallow semantic parsing. In proceedings of the 42 th Conference on Association for Computational Linguistic (ACL-2004), Barcelona, Spain.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "Support vector learning for semantic argument classification",
                "authors": [
                    {
                        "first": "Kadri",
                        "middle": [],
                        "last": "Sameer Pradhan",
                        "suffix": ""
                    },
                    {
                        "first": "Valeri",
                        "middle": [],
                        "last": "Hacioglu",
                        "suffix": ""
                    },
                    {
                        "first": "Wayne",
                        "middle": [],
                        "last": "Krugler",
                        "suffix": ""
                    },
                    {
                        "first": "James",
                        "middle": [
                            "H"
                        ],
                        "last": "Ward",
                        "suffix": ""
                    },
                    {
                        "first": "Daniel",
                        "middle": [],
                        "last": "Martin",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Jurafsky",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "Machine Learning Journal",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Sameer Pradhan, Kadri Hacioglu, Valeri Krugler, Wayne Ward, James H. Martin, and Daniel Jurafsky. 2005. Support vector learning for semantic argument classi- fication. to appear in Machine Learning Journal.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "Association for Computational Linguistics",
                "authors": [
                    {
                        "first": "Ben",
                        "middle": [],
                        "last": "Taskar",
                        "suffix": ""
                    },
                    {
                        "first": "Dan",
                        "middle": [],
                        "last": "Klein",
                        "suffix": ""
                    },
                    {
                        "first": "Mike",
                        "middle": [],
                        "last": "Collins",
                        "suffix": ""
                    },
                    {
                        "first": "Daphne",
                        "middle": [],
                        "last": "Koller",
                        "suffix": ""
                    },
                    {
                        "first": "Christopher",
                        "middle": [],
                        "last": "Manning",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of EMNLP 2004",
                "volume": "",
                "issue": "",
                "pages": "1--8",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ben Taskar, Dan Klein, Mike Collins, Daphne Koller, and Christopher Manning. 2004. Max-margin parsing. In Dekang Lin and Dekai Wu, editors, Proceedings of EMNLP 2004, pages 1-8, Barcelona, Spain, July. As- sociation for Computational Linguistics.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "The leaf projection path view of parse trees: Exploring string kernels for hpsg parse selection",
                "authors": [
                    {
                        "first": "Kristina",
                        "middle": [],
                        "last": "Toutanova",
                        "suffix": ""
                    },
                    {
                        "first": "Penka",
                        "middle": [],
                        "last": "Markova",
                        "suffix": ""
                    },
                    {
                        "first": "Christopher",
                        "middle": [
                            "D"
                        ],
                        "last": "Manning",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "Proceedings of EMNLP",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Kristina Toutanova, Penka Markova, and Christopher D. Manning. 2004. The leaf projection path view of parse trees: Exploring string kernels for hpsg parse se- lection. In Proceedings of EMNLP 2004.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "The Nature of Statistical Learning Theory",
                "authors": [
                    {
                        "first": "V",
                        "middle": [],
                        "last": "Vapnik",
                        "suffix": ""
                    }
                ],
                "year": 1995,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "V. Vapnik. 1995. The Nature of Statistical Learning The- ory. Springer.",
                "links": null
            },
            "BIBREF18": {
                "ref_id": "b18",
                "title": "Kernel methods for relation extraction",
                "authors": [
                    {
                        "first": "D",
                        "middle": [],
                        "last": "Zelenko",
                        "suffix": ""
                    },
                    {
                        "first": "C",
                        "middle": [],
                        "last": "Aone",
                        "suffix": ""
                    },
                    {
                        "first": "A",
                        "middle": [],
                        "last": "Richardella",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Journal of Machine Learning Research",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "D. Zelenko, C. Aone, and A. Richardella. 2003. Kernel methods for relation extraction. Journal of Machine Learning Research.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF1": {
                "num": null,
                "uris": null,
                "text": "A predicate argument structure in a parse-tree representation.",
                "type_str": "figure"
            },
            "FIGREF2": {
                "num": null,
                "uris": null,
                "text": "A sentence parse tree with two predicative tree structures (P AST s)",
                "type_str": "figure"
            },
            "FIGREF3": {
                "num": null,
                "uris": null,
                "text": "Two-step boundary classifier.",
                "type_str": "figure"
            },
            "FIGREF4": {
                "num": null,
                "uris": null,
                "text": "For example, for the first N ST the fragments [NP-1 [NP][PP]], [NP [DT][NN]] and [PP [IN][NP]] are generated. They do not match anymore with the [NP-0 [NP][PP]], [NP-1 [DT][NN]] and [PP-2 [IN][NP]] fragments of the second N ST .",
                "type_str": "figure"
            },
            "TABREF2": {
                "num": null,
                "text": "Two-steps boundary classification performance using the traditional boundary classifier tbc, the random selection of non-overlapping structures (RN D), the heuristic to select the most suitable non-overlapping node set (Heu) and the predicate argument spanning tree classifier (pastc).",
                "content": "<table/>",
                "type_str": "table",
                "html": null
            }
        }
    }
}