Base_JSON/prefixP/json/P10/P10-1014.json

{
    "paper_id": "P10-1014",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T09:22:53.448700Z"
    },
    "title": "SystemT: An Algebraic Approach to Declarative Information Extraction",
    "authors": [
        {
            "first": "Laura",
            "middle": [],
            "last": "Chiticariu",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": ""
        },
        {
            "first": "Rajasekar",
            "middle": [],
            "last": "Krishnamurthy",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": ""
        },
        {
            "first": "Yunyao",
            "middle": [],
            "last": "Li",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": "[email protected]"
        },
        {
            "first": "Sriram",
            "middle": [],
            "last": "Raghavan",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": ""
        },
        {
            "first": "Frederick",
            "middle": [
                "R"
            ],
            "last": "Reiss",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": "[email protected]"
        },
        {
            "first": "Shivakumar",
            "middle": [],
            "last": "Vaithyanathan",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "IBM Research -Almaden San Jose",
                "location": {
                    "region": "CA",
                    "country": "USA"
                }
            },
            "email": ""
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "As information extraction (IE) becomes more central to enterprise applications, rule-based IE engines have become increasingly important. In this paper, we describe SystemT, a rule-based IE system whose basic design removes the expressivity and performance limitations of current systems based on cascading grammars. SystemT uses a declarative rule language, AQL, and an optimizer that generates high-performance algebraic execution plans for AQL rules. We compare SystemT's approach against cascading grammars, both theoretically and with a thorough experimental evaluation. Our results show that SystemT can deliver result quality comparable to the state-of-theart and an order of magnitude higher annotation throughput.",
    "pdf_parse": {
        "paper_id": "P10-1014",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "As information extraction (IE) becomes more central to enterprise applications, rule-based IE engines have become increasingly important. In this paper, we describe SystemT, a rule-based IE system whose basic design removes the expressivity and performance limitations of current systems based on cascading grammars. SystemT uses a declarative rule language, AQL, and an optimizer that generates high-performance algebraic execution plans for AQL rules. We compare SystemT's approach against cascading grammars, both theoretically and with a thorough experimental evaluation. Our results show that SystemT can deliver result quality comparable to the state-of-theart and an order of magnitude higher annotation throughput.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "In recent years, enterprises have seen the emergence of important text analytics applications like compliance and data redaction. This increase, combined with the inclusion of text into traditional applications like Business Intelligence, has dramatically increased the use of information extraction (IE) within the enterprise. While the traditional requirement of extraction quality remains critical, enterprise applications also demand efficiency, transparency, customizability and maintainability. In recent years, these systemic requirements have led to renewed interest in rule-based IE systems (Doan et al., 2008; SAP, 2010; IBM, 2010; SAS, 2010) .",
                "cite_spans": [
                    {
                        "start": 600,
                        "end": 619,
                        "text": "(Doan et al., 2008;",
                        "ref_id": "BIBREF8"
                    },
                    {
                        "start": 620,
                        "end": 630,
                        "text": "SAP, 2010;",
                        "ref_id": null
                    },
                    {
                        "start": 631,
                        "end": 641,
                        "text": "IBM, 2010;",
                        "ref_id": null
                    },
                    {
                        "start": 642,
                        "end": 652,
                        "text": "SAS, 2010)",
                        "ref_id": "BIBREF21"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Until recently, rule-based IE systems (Cunningham et al., 2000; Boguraev, 2003; Drozdzynski et al., 2004) were predominantly based on the cascading grammar formalism exemplified by the Common Pattern Specification Language (CPSL) specification (Appelt and Onyshkevych, 1998) . In CPSL, the input text is viewed as a sequence of annotations, and extraction rules are written as pattern/action rules over the lexical features of these annotations. In a single phase of the grammar, a set of rules are evaluated in a left-to-right fashion over the input annotations. Multiple grammar phases are cascaded together, with the evaluation proceeding in a bottom-up fashion.",
                "cite_spans": [
                    {
                        "start": 38,
                        "end": 63,
                        "text": "(Cunningham et al., 2000;",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 64,
                        "end": 79,
                        "text": "Boguraev, 2003;",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 80,
                        "end": 105,
                        "text": "Drozdzynski et al., 2004)",
                        "ref_id": "BIBREF9"
                    },
                    {
                        "start": 244,
                        "end": 274,
                        "text": "(Appelt and Onyshkevych, 1998)",
                        "ref_id": "BIBREF0"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "As demonstrated by prior work (Grishman and Sundheim, 1996) , grammar-based IE systems can be effective in many scenarios. However, these systems suffer from two severe drawbacks. First, the expressivity of CPSL falls short when used for complex IE tasks over increasingly pervasive informal text (emails, blogs, discussion forums etc.). To address this limitation, grammar-based IE systems resort to significant amounts of userdefined code in the rules, combined with preand post-processing stages beyond the scope of CPSL (Cunningham et al., 2010) . Second, the rigid evaluation order imposed in these systems has significant performance implications.",
                "cite_spans": [
                    {
                        "start": 30,
                        "end": 59,
                        "text": "(Grishman and Sundheim, 1996)",
                        "ref_id": "BIBREF10"
                    },
                    {
                        "start": 524,
                        "end": 549,
                        "text": "(Cunningham et al., 2010)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Three decades ago, the database community faced similar expressivity and efficiency challenges in accessing structured information. The community addressed these problems by introducing a relational algebra formalism and an associated declarative query language SQL. The groundbreaking work on System R (Chamberlin et al., 1981) demonstrated how the expressivity of SQL can be efficiently realized in practice by means of a query optimizer that translates an SQL query into an optimized query execution plan.",
                "cite_spans": [
                    {
                        "start": 303,
                        "end": 328,
                        "text": "(Chamberlin et al., 1981)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Borrowing ideas from the database community, we have developed SystemT, a declarative IE system based on an algebraic framework, to address both expressivity and performance issues. In Sys-temT, extraction rules are expressed in a declarative language called AQL. At compilation time, ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Gazetteers containing first names and last names SystemT translates AQL statements into an algebraic expression called an operator graph that implements the semantics of the statements. The SystemT optimizer then picks a fast execution plan from many logically equivalent plans. Sys-temT is currently deployed in a multitude of realworld applications and commercial products 1 . We formally demonstrate the superiority of AQL and SystemT in terms of both expressivity and efficiency (Section 4). Specifically, we show that 1) the expressivity of AQL is a strict superset of CPSL grammars not using external functions and 2) the search space explored by the SystemT optimizer includes operator graphs corresponding to efficient finite state transducer implementations. Finally, we present an extensive experimental evaluation that validates that high-quality annotators can be developed with SystemT, and that their runtime performance is an order of magnitude better when compared to annotators developed with a state-of-the-art grammar-based IE system (Section 5).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Syntax:",
                "sec_num": null
            },
            {
                "text": "A cascading grammar consists of a sequence of phases, each of which consists of one or more rules. Each phase applies its rules from left to right over an input sequence of annotations and generates an output sequence of annotations that the next phase consumes. Most cascading grammar systems today adhere to the CPSL standard. Fig. 1 shows a sample CPSL grammar that identifies person names from text in two phases. The first phase, P 1 , operates over the results of the tok-1 A trial version is available at http://www.alphaworks.ibm.com/tech/systemt Rule skipped due to priority semantics CPSL Phase P 1",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 329,
                        "end": 335,
                        "text": "Fig. 1",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Grammar-based Systems and CPSL",
                "sec_num": "2"
            },
            {
                "text": "Last(P 1 R 2 ) Last(P 1 R 2 ) \u2026 Mark Scott , Howard Smith \u2026 First(P 1 R 1 ) First(P 1 R 1 ) First(P 1 R 1 ) Last(P 1 R 2 ) CPSL Phase P 2 \u2026 Mark Scott , Howard Smith \u2026 Person(P 2 R 1 ) Person (P 2 R 4 ) Person(P 2 R 4 ) Person (P 2 R 5 ) Person(P 2 R 4 ) \u2026 Mark Scott , Howard Smith \u2026 First(P 1 R 1 ) First(P 1 R 1 ) First(P 1 R 1 ) Last(P 1 R 2 ) JAPE Phase P 1 (Brill) Caps(P 1 R 3 ) Last(P 1 R 2 ) Last(P 1 R 2 ) Caps(P 1 R 3 ) Caps(P 1 R 3 ) Caps(P 1 R 3 ) \u2026 Mark Scott , Howard Smith \u2026 Person(P 2 R 1 ) Person (P 2 R 4 , P 2 R 5 ) JAPE Phase P 2 (Appelt) Person(P 2 R 1 ) Person (P 2 R 2 )",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Grammar-based Systems and CPSL",
                "sec_num": "2"
            },
            {
                "text": "Some discarded matches omitted for clarity \u2026 Tomorrow, we will meet Mark Scott, Howard Smith and \u2026 Document d 1 Figure 2 : Sample output of CPSL and JAPE enizer and gazetteer (input types Token and Lookup, respectively) to identify words that may be part of a person name. The second phase, P 2 , identifies complete names using the results of phase P 1 .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 112,
                        "end": 120,
                        "text": "Figure 2",
                        "ref_id": "FIGREF4"
                    }
                ],
                "eq_spans": [],
                "section": "Grammar-based Systems and CPSL",
                "sec_num": "2"
            },
            {
                "text": "Applying the above grammar to document d 1 (Fig. 2) , one would expect that to match \"Mark Scott\" and \"Howard Smith\" as Person. However, as shown in Fig. 2(a) , the grammar actually finds three Person annotations, instead of two. CPSL has several limitations that lead to such discrepancies: L1. Lossy sequencing. In a CPSL grammar, each phase operates on a sequence of annotations from left to right. If the input annotations to a phase may overlap with each other, the CPSL engine must drop some of them to create a nonoverlapping sequence. For instance, in phase P 1 (Fig. 2(a) ), \"Scott\" has both a Lookup and a Token annotation. The system has made an arbitrary choice to retain the Lookup annotation and discard the Token annotation. Consequently, no Caps annotations are output by phase P 1 . L2. Rigid matching priority. CPSL specifies that, for each input annotation, only one rule can actually match. When multiple rules match at the same start position, the following tie-breaker conditions are applied (in order): (a) the rule matching the most annotations in the input stream; (b) the rule with highest priority; and (c) the rule declared earlier in the grammar. This rigid matching priority can lead to mistakes. For instance, as illustrated in Fig. 2(a) , phase P 1 only identifies \"Scott\" as a First. Matching priority causes the grammar to skip the corresponding match for \"Scott\" as a Last. Consequently, phase P 2 fails to identify \"Mark Scott\" as one single Person. L3. Limited expressivity in rule patterns. It is not possible to express rules that compare annotations overlapping with each other. E.g., \"Identify ",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 43,
                        "end": 51,
                        "text": "(Fig. 2)",
                        "ref_id": "FIGREF4"
                    },
                    {
                        "start": 149,
                        "end": 158,
                        "text": "Fig. 2(a)",
                        "ref_id": "FIGREF4"
                    },
                    {
                        "start": 570,
                        "end": 580,
                        "text": "(Fig. 2(a)",
                        "ref_id": "FIGREF4"
                    },
                    {
                        "start": 1259,
                        "end": 1268,
                        "text": "Fig. 2(a)",
                        "ref_id": "FIGREF4"
                    }
                ],
                "eq_spans": [],
                "section": "Rule fired",
                "sec_num": null
            },
            {
                "text": "In order to address the above limitations, several extensions to CPSL have been proposed in JAPE, AFst and XTDL (Cunningham et al., 2000; Boguraev, 2003; Drozdzynski et al., 2004) . The extensions are summarized as below, where each solution S i corresponds to limitation L i .",
                "cite_spans": [
                    {
                        "start": 112,
                        "end": 137,
                        "text": "(Cunningham et al., 2000;",
                        "ref_id": "BIBREF5"
                    },
                    {
                        "start": 138,
                        "end": 153,
                        "text": "Boguraev, 2003;",
                        "ref_id": "BIBREF1"
                    },
                    {
                        "start": 154,
                        "end": 179,
                        "text": "Drozdzynski et al., 2004)",
                        "ref_id": "BIBREF9"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Extensions to CPSL",
                "sec_num": null
            },
            {
                "text": "\u2022 S1. Grammar rules are allowed to operate on graphs of input annotations in JAPE and AFst. \u2022 S2. JAPE introduces more matching regimes besides the CPSL's matching priority and thus allows more flexibility when multiple rules match at the same starting position. \u2022 S3. The rule part of a pattern has been expanded to allow more expressivity in JAPE, AFst and XTDL. and 'Howard Smith' in JAPE. Phase P 1 uses a matching regime (denoted by Brill) that allows multiple rules to match at the same starting position, and phase P 2 uses CPSL's matching priority, Appelt.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Extensions to CPSL",
                "sec_num": null
            },
            {
                "text": "SystemT is a declarative IE system based on an algebraic framework. In SystemT, developers write rules in a language called AQL. The system then generates a graph of operators that implement the semantics of the AQL rules. This decoupling allows for greater rule expressivity, because the rule language is not constrained by the need to compile to a finite state transducer. Likewise, the decoupled approach leads to greater flexibility in choosing an efficient execution strategy, because many possible operator graphs may exist for the same AQL annotator.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "SystemT",
                "sec_num": "3"
            },
            {
                "text": "In the rest of the section, we describe the parts of SystemT, starting with the algebraic formalism behind SystemT's operators.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "SystemT",
                "sec_num": "3"
            },
            {
                "text": "SystemT executes IE rules using graphs of operators. The formal definition of these operators takes the form of an algebra that is similar to the relational algebra, but with extensions for text processing.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Algebraic Foundation of SystemT",
                "sec_num": "3.1"
            },
            {
                "text": "The algebra operates over a simple relational data model with three data types: span, tuple, and relation. In this data model, a span is a region of text within a document identified by its \"begin\" and \"end\" positions; a tuple is a fixed-size list of spans. A relation is a multiset of tuples, where every tuple in the relation must be of the same size. Each operator in our algebra implements a single basic atomic IE operation, producing and consuming sets of tuples. Fig. 3 illustrates the regular expression extraction operator in the algebra, which performs character-level regular expression matching. Overall, the algebra contains 12 different operators, a full description of which can be found in (Reiss et al., 2008) . The following four operators are necessary to understand the examples in this paper:",
                "cite_spans": [
                    {
                        "start": 706,
                        "end": 726,
                        "text": "(Reiss et al., 2008)",
                        "ref_id": "BIBREF19"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 470,
                        "end": 476,
                        "text": "Fig. 3",
                        "ref_id": "FIGREF3"
                    }
                ],
                "eq_spans": [],
                "section": "Algebraic Foundation of SystemT",
                "sec_num": "3.1"
            },
            {
                "text": "\u2022 The Extract operator (E) performs characterlevel operations such as regular expression and dictionary matching over text, creating a tuple for each match. \u2022 The Select operator (\u03c3) takes as input a set of tuples and a predicate to apply to the tuples. It outputs all tuples that satisfy the predicate. \u2022 The Join operator (\u22b2\u22b3) takes as input two sets of tuples and a predicate to apply to pairs of tuples from the input sets. It outputs all pairs of input tuples that satisfy the predicate. \u2022 The consolidate operator (\u2126) takes as input a set of tuples and the index of a particular column in those tuples. It removes selected overlapping spans from the indicated column, according to the specified policy.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Algebraic Foundation of SystemT",
                "sec_num": "3.1"
            },
            {
                "text": "Extraction rules in SystemT are written in AQL, a declarative relational language similar in syntax to the database language SQL. We chose SQL as a basis for our language due to its expressivity and its familiarity. The expressivity of SQL, which consists of first-order logic predicates (Codd, 1990) . As SQL is the primary interface to most relational database systems, the language's syntax and semantics are common knowledge among enterprise application programmers. Similar to SQL terminology, we call a collection of AQL rules an AQL query. Fig. 4 shows portions of an AQL query. As can be seen, the basic building block of AQL is a view: A logical description of a set of tuples in terms of either the document text (denoted by a special view called Document) or the contents of other views. Every SystemT annotator consists of at least one view. The output view statement indicates that the tuples in a view are part of the final results of the annotator. Fig. 4 also illustrates three of the basic constructs that can be used to define a view.",
                "cite_spans": [
                    {
                        "start": 288,
                        "end": 300,
                        "text": "(Codd, 1990)",
                        "ref_id": "BIBREF4"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 547,
                        "end": 553,
                        "text": "Fig. 4",
                        "ref_id": "FIGREF5"
                    },
                    {
                        "start": 964,
                        "end": 970,
                        "text": "Fig. 4",
                        "ref_id": "FIGREF5"
                    }
                ],
                "eq_spans": [],
                "section": "AQL",
                "sec_num": "3.2"
            },
            {
                "text": "\u2022 The extract statement specifies basic character-level extraction primitives to be applied directly to a tuple. \u2022 The select statement is similar to the SQL select statement but it contains an additional consolidate on clause, along with an extensive collection of text-specific predicates. \u2022 The union all statement merges the outputs of one or more select or extract statements.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "AQL",
                "sec_num": "3.2"
            },
            {
                "text": "To keep rules compact, AQL also provides a shorthand sequence pattern notation similar to the syntax of CPSL. For example, the CapsLast view in Figure 4 could have been written as: Internally, SystemT translates each of these extract pattern statements into one or more select and extract statements. SystemT has built-in multilingual support including tokenization, part of speech and gazetteer matching for over 20 languages using Language-Ware (IBM, 2010). Rule developers can utilize the multilingual support via AQL without having to configure or manage any additional resources. In addition, AQL allows user-defined functions to be used in a restricted context in order to support operations such as validation (e.g. for extracted credit card numbers), or normalization (e.g., compute abbreviations of multi-token organization candidates that are useful in generating additional candidates). More details on AQL can be found in the AQL manual (SystemT, 2010).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 144,
                        "end": 152,
                        "text": "Figure 4",
                        "ref_id": "FIGREF5"
                    }
                ],
                "eq_spans": [],
                "section": "AQL",
                "sec_num": "3.2"
            },
            {
                "text": "Grammar-based IE engines place rigid restrictions on the order in which rules can be executed. Due to the semantics of the CPSL standard, systems that implement the standard must use a finite state transducer that evaluates each level of the cascade with one or more left to right passes over the entire token stream.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Optimizer and Operator Graph",
                "sec_num": "3.3"
            },
            {
                "text": "In contrast, SystemT places no explicit constraints on the order of rule evaluation, nor does it require that intermediate results of an annotator collapse to a fixed-size sequence. As shown in Fig. 5 , the SystemT engine does not execute AQL directly; instead, the SystemT optimizer compiles AQL into a graph of operators. By tying a collection of operators together by their inputs and outputs, the system can implement a wide variety of different execution strategies. Different execution strategies are associated with different evaluation costs. The optimizer chooses the execution strategy with the lowest estimated evaluation cost. Fig. 6 presents three possible execution strategies for the CapsLast rule in Fig. 4 . If the optimizer estimates that the evaluation cost of Last is much lower than that of Caps, then it can determine that Plan C has the lowest evaluation cost among the three, because Plan C only evaluates Caps in the \"left\" neighborhood for each instance of Last. More details of our algorithms for enumerating plans can be found in (Reiss et al., 2008) .",
                "cite_spans": [
                    {
                        "start": 1058,
                        "end": 1078,
                        "text": "(Reiss et al., 2008)",
                        "ref_id": "BIBREF19"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 194,
                        "end": 200,
                        "text": "Fig. 5",
                        "ref_id": "FIGREF7"
                    },
                    {
                        "start": 639,
                        "end": 645,
                        "text": "Fig. 6",
                        "ref_id": null
                    },
                    {
                        "start": 716,
                        "end": 722,
                        "text": "Fig. 4",
                        "ref_id": "FIGREF5"
                    }
                ],
                "eq_spans": [],
                "section": "Optimizer and Operator Graph",
                "sec_num": "3.3"
            },
            {
                "text": "The optimizer in SystemT chooses the best execution plan from a large number of different algebra graphs available to it. Many of these graphs implement strategies that a transducer could not express: such as evaluating rules from right to left, sharing work across different rules, or selectively skipping rule evaluations. Within this large search space, there generally exists an execution strategy that implements the rule semantics far more efficiently than the fastest transducer could. We refer the reader to (Reiss et al., 2008 ) for a detailed description of the types of plan the optimizer considers, as well as an experimental analysis of the performance benefits of different parts of this search space.",
                "cite_spans": [
                    {
                        "start": 516,
                        "end": 535,
                        "text": "(Reiss et al., 2008",
                        "ref_id": "BIBREF19"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Optimizer and Operator Graph",
                "sec_num": "3.3"
            },
            {
                "text": "Several parallel efforts have been made recently to improve the efficiency of IE tasks by optimizing low-level feature extraction (Ramakrishnan et al., 2006; Chandel et al., 2006) or by reordering operations at a macroscopic level (Ipeirotis et al., 2006; Shen et al., 2007; Jain et al., 2009) . However, to the best of our knowledge, SystemT is the only IE system in which the optimizer generates a full end-to-end plan, beginning with low-level extraction primitives and ending with the final output tuples.",
                "cite_spans": [
                    {
                        "start": 130,
                        "end": 157,
                        "text": "(Ramakrishnan et al., 2006;",
                        "ref_id": "BIBREF17"
                    },
                    {
                        "start": 158,
                        "end": 179,
                        "text": "Chandel et al., 2006)",
                        "ref_id": "BIBREF3"
                    },
                    {
                        "start": 231,
                        "end": 255,
                        "text": "(Ipeirotis et al., 2006;",
                        "ref_id": "BIBREF12"
                    },
                    {
                        "start": 256,
                        "end": 274,
                        "text": "Shen et al., 2007;",
                        "ref_id": "BIBREF22"
                    },
                    {
                        "start": 275,
                        "end": 293,
                        "text": "Jain et al., 2009)",
                        "ref_id": "BIBREF13"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Optimizer and Operator Graph",
                "sec_num": "3.3"
            },
            {
                "text": "SystemT is designed to be usable in various deployment scenarios. It can be used as a standalone system with its own development and runtime environment. Furthermore, SystemT exposes a generic Java API that enables the integration of its runtime environment with other applications. For example, a specific instantiation of this API allows SystemT annotators to be seamlessly embedded in applications using the UIMA analytics framework (UIMA, 2010).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Deployment Scenarios",
                "sec_num": "3.4"
            },
            {
                "text": "Having described both the traditional cascading grammar approach and the declarative approach ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Grammar vs. Algebra",
                "sec_num": "4"
            },
            {
                "text": "In Section 2, we described three expressivity limitations of CPSL grammars: Lossy sequencing, rigid matching priority, and limited expressivity in rule patterns. As we noted, cascading grammar systems extend the CPSL specification in various ways to provide workarounds for these limitations.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Expressivity",
                "sec_num": "4.1"
            },
            {
                "text": "In SystemT, the basic design of the AQL language eliminates these three problems without the need for any special workaround. The key design difference is that AQL views operate over sets of tuples, not sequences of tokens. The input or output tuples of a view can contain spans that overlap in arbitrary ways, so the lossy sequencing problem never occurs. The annotator will retain these overlapping spans across any number of views until a view definition explicitly removes the overlap. Likewise, the tuples that a given view produces are in no way constrained by the outputs of other, unrelated views, so the rigid matching priority problem never occurs. Finally, the select statement in AQL allows arbitrary predicates over the cross-product of its input tuple sets, eliminating the limited expressivity in rule patterns problem.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Expressivity",
                "sec_num": "4.1"
            },
            {
                "text": "Beyond eliminating the major limitations of CPSL grammars, AQL provides a number of other information extraction operations that even extended CPSL cannot express without custom code. Complex rule interactions. Consider an example document from the Enron corpus (Minkov et al., 2005) , shown in Fig. 7 , which contains a list of person names. Because the first person in the list ('Skilling') is referred to by only a last name, rule P 2 R 3 in Fig. 1 incorrectly identifies 'Skilling, Cindy' as a person. Consequently, the output of phase P 2 of the cascading grammar contains several mistakes as shown in the figure. This problem went to the Switchfoot concert at the Roxy. It was pretty fun,\u2026 The lead singer/guitarist was really good, and even though there was another guitarist (an Asian guy), he ended up playing most of the guitar parts, which was really impressive. The biggest surprise though is that I actually liked the opening bands. \u2026I especially liked the first band",
                "cite_spans": [
                    {
                        "start": 262,
                        "end": 283,
                        "text": "(Minkov et al., 2005)",
                        "ref_id": "BIBREF15"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 295,
                        "end": 301,
                        "text": "Fig. 7",
                        "ref_id": "FIGREF8"
                    },
                    {
                        "start": 445,
                        "end": 451,
                        "text": "Fig. 1",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Expressivity",
                "sec_num": "4.1"
            },
            {
                "text": "At least 4 occurrences of MusicReviewSnippet or GenericReviewSnippet At least 3 of them should be MusicReviewSnippets Review ends with one of these.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Consecutive review snippets are within 25 tokens",
                "sec_num": null
            },
            {
                "text": "Complete review is within 200 tokens",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Start with ConcertMention",
                "sec_num": null
            },
            {
                "text": "Informal Band Review Figure 8 : Extracting informal band reviews from web logs occurs because CPSL only evaluates rules over the input sequence in a strict left-to-right fashion. On the other hand, the AQL query Q 1 shown in the figure applies the following condition: \"Always discard matches to Rule P 2 R 3 if they overlap with matches to rules P 2 R 1 or P 2 R 2 \" (even if the match to Rule P 2 R 3 starts earlier). Applying this rule ensures that the person names in the list are identified correctly. Obtaining the same effect in grammar-based systems would require the use of custom code (as recommended by (Cunningham et al., 2010) ). Counting and Aggregation. Complex extraction tasks sometimes require operations such as counting and aggregation that go beyond the expressivity of regular languages, and thus can be expressed in CPSL only using external functions. One such task is that of identifying informal concert reviews embedded within blog entries. Fig. 8 describes, by example, how these reviews consist of reference to a live concert followed by several review snippets, some specific to musical performances and others that are more general review expressions. An example rule to identify informal reviews is also shown in the figure. Notice how implementing this rule requires counting the number of Mu-sicReviewSnippet and GenericReviewSnippet annotations within a region of text and aggregating this occurrence count across the two review types. While this rule can be written in AQL, it can only be approximated in CPSL grammars. Character-Level Regular Expression CPSL cannot specify character-level regular expressions that span multiple tokens. In contrast, the extract regex statement in AQL fully supports these expressions.",
                "cite_spans": [
                    {
                        "start": 614,
                        "end": 639,
                        "text": "(Cunningham et al., 2010)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 21,
                        "end": 29,
                        "text": "Figure 8",
                        "ref_id": null
                    },
                    {
                        "start": 967,
                        "end": 973,
                        "text": "Fig. 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "We have described above several cases where AQL can express concepts that can only be expressed through external functions in a cascad-ing grammar. These examples naturally raise the question of whether similar cases exist where a cascading grammar can express patterns that cannot be expressed in AQL.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "It turns out that we can make a strong statement that such examples do not exist. In the absence of an escape to arbitrary procedural code, AQL is strictly more expressive than a CPSL grammar. To state this relationship formally, we first introduce the following definitions.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "We refer to a grammar conforming to the CPSL specification as a CPSL grammar. When a CPSL grammar contains no external functions, we refer to it as a Code-free CPSL grammar. Finally, we refer to a grammar that conforms to one of the CPSL, JAPE, AFst and XTDL specifications as an expanded CPSL grammar. Ambiguous Grammar Specification An expanded CPSL grammar may be under-specified in some cases. For example, a single rule containing the disjunction operator (|) may match a given region of text in multiple ways. Consider the evaluation of Rule P 2 R 3 over the text fragment \"Scott, Howard\" from document d 1 (Fig. 1) . If \"Howard\" is identified both as Caps and First, then there are two evaluations for Rule P 2 R 3 over this text fragment. Since the system has to arbitrarily choose one evaluation, the results of the grammar can be non-deterministic (as pointed out in (Cunningham et al., 2010)). We refer to a grammar G as an ambiguous grammar specification for a document collection D if the system makes an arbitrary choice while evaluating G over D.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 613,
                        "end": 621,
                        "text": "(Fig. 1)",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "Definition 1 (UnambigEquiv) A query Q is Un-ambigEquiv to a cascading grammar G if and only if for every document collection D, where G is not an ambiguous grammar specification for D, the results of the grammar invocation and the query evaluation are identical.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "We now formally compare the expressivity of AQL and expanded CPSL grammars. The detailed proof is omitted due to space limitations.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Example Rule",
                "sec_num": null
            },
            {
                "text": "The class of extraction tasks expressible as AQL queries is a strict superset of that expressible through expanded code-free CPSL grammars. Specifically, (a) Every expanded code-free CPSL grammar can be expressed as an UnambigEquiv AQL query. (b) AQL supports information extraction operations that cannot be expressed in expanded codefree CPSL grammars.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 1",
                "sec_num": null
            },
            {
                "text": "Proof Outline: (a) A single CPSL grammar can be expressed in AQL as follows. First, each rule r in the grammar is translated into a set of AQL statements. If r does not contain the disjunct (|) operator, then it is translated into a single AQL select statement. Otherwise, a set of AQL statements are generated, one for each disjunct operator in rule r, and the results merged using union all statements. Then, a union all statement is used to combine the results of individual rules in the grammar phase. Finally, the AQL statements for multiple phases are combined in the same order as the cascading grammar specification.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 1",
                "sec_num": null
            },
            {
                "text": "The main extensions to CPSL supported by expanded CPSL grammars (listed in Sec. 2) are handled as follows. AQL queries operate on graphs on annotations just like expanded CPSL grammars. In addition, AQL supports different matching regimes through consolidation operators, span predicates through selection predicates and coreferences through join operators. (b) Example operations supported in AQL that cannot be expressed in expanded code-free CPSL grammars include (i) character-level regular expressions spanning multiple tokens, (ii) counting the number of annotations occurring within a given bounded window and (iii) deleting annotations if they overlap with other annotations starting later in the document. 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Theorem 1",
                "sec_num": null
            },
            {
                "text": "For the annotators we test in our experiments (See Section 5), the SystemT optimizer is able to choose algebraic plans that are faster than a comparable transducer-based implementation. The question arises as to whether there are other annotators for which the traditional transducer approach is superior. That is, for a given annotator, might there exist a finite state transducer that is combinatorially faster than any possible algebra graph? It turns out that this scenario is not possible, as the theorem below shows.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Performance",
                "sec_num": "4.2"
            },
            {
                "text": "A token-based finite state transducer (FST) is a nondeterministic finite state machine in which state transitions are triggered by predicates on tokens. A token-based FST is acyclic if its state graph does not contain any cycles and has exactly one \"accept\" state.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 2 (Token-Based FST)",
                "sec_num": null
            },
            {
                "text": "Thompson's algorithm is a common strategy for evaluating a token-based FST (based on (Thompson, 1968) ). This algorithm processes the input tokens from left to right, keeping track of the set of states that are currently active.",
                "cite_spans": [
                    {
                        "start": 85,
                        "end": 101,
                        "text": "(Thompson, 1968)",
                        "ref_id": "BIBREF24"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3 (Thompson's Algorithm)",
                "sec_num": null
            },
            {
                "text": "Theorem 2 For any acyclic token-based finite state transducer T , there exists an UnambigEquiv operator graph G, such that evaluating G has the same computational complexity as evaluating T with Thompson's algorithm starting from each token position in the input document.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3 (Thompson's Algorithm)",
                "sec_num": null
            },
            {
                "text": "Proof Outline: The proof constructs G by structural induction over the transducer T . The base case converts transitions out of the start state into Extract operators. The inductive case adds a Select operator to G for each of the remaining state transitions, with each selection predicate being the same as the predicate that drives the corresponding state transition. For each state transition predicate that T would evaluate when processing a given document, G performs a constant amount of work on a single tuple. 2",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Definition 3 (Thompson's Algorithm)",
                "sec_num": null
            },
            {
                "text": "In this section we present an extensive comparison study between SystemT and implementations of expanded CPSL grammar in terms of quality, runtime performance and resource requirements. Tasks We chose two tasks for our evaluation:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Experimental Evaluation",
                "sec_num": "5"
            },
            {
                "text": "\u2022 NER : named-entity recognition for Person, Organization, Location, Address, PhoneNumber, EmailAddress, URL and DateTime. \u2022 BandReview : identify informal reviews in blogs (Fig. 8 ).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 173,
                        "end": 180,
                        "text": "(Fig. 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Experimental Evaluation",
                "sec_num": "5"
            },
            {
                "text": "We chose NER primarily because named-entity recognition is a well-studied problem and standard datasets are available for evaluation. For this task we use GATE and ANNIE for comparison 3 . We chose BandReview to conduct performance evaluation for a more complex extraction task. Datasets. For quality evaluation, we use:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Experimental Evaluation",
                "sec_num": "5"
            },
            {
                "text": "\u2022 EnronMeetings (Minkov et al., 2005) : collection of emails with meeting information from the Enron corpus 4 with Person labeled data; \u2022 ACE (NIST, 2005) : collection of newswire reports and broadcast news/conversations with Person, Organization, Location labeled data 5 . Table 1 lists the datasets used for performance evaluation. The size of Finance L is purposely small because GATE takes a significant amount of time processing large documents (see Sec. 5.2). Set Up. The experiments were run on a server with two 2.4 GHz 4-core Intel Xeon CPUs and 64GB of memory. We use GATE 5.1 (build 3431) and two configurations for ANNIE: 1) the default configuration, and 2) an optimized configuration where the Ontotext Japec Transducer 6 replaces the default NE transducer for optimized performance. We refer to these configurations as ANNIE and ANNIE-Optimized, respectively.",
                "cite_spans": [
                    {
                        "start": 16,
                        "end": 37,
                        "text": "(Minkov et al., 2005)",
                        "ref_id": "BIBREF15"
                    },
                    {
                        "start": 142,
                        "end": 154,
                        "text": "(NIST, 2005)",
                        "ref_id": "BIBREF16"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 274,
                        "end": 281,
                        "text": "Table 1",
                        "ref_id": "TABREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Experimental Evaluation",
                "sec_num": "5"
            },
            {
                "text": "The goal of our quality evaluation is two-fold: to validate that annotators can be built in Sys-temT with quality comparable to those built in a grammar-based system; and to ensure a fair performance comparison between SystemT and GATE by verifying that the annotators used in the study are comparable. Table 2 shows results of our comparison study for Person annotators. We report the classical (exact) precision, recall, and F 1 measures that credit only exact matches, and corresponding partial measures that credit partial matches in a fashion similar to (NIST, 2005) . As can be seen, T-NE produced results of significantly higher quality than ANNIE on both datasets, for the same Person extraction task. In fact, on EnronMeetings, the F 1 measure of T-NE is 7.4% higher than the best published result (Minkov et al., 2005) . Similar results can be observed for Organization and Location on ACE (exact numbers omitted in interest of space).",
                "cite_spans": [
                    {
                        "start": 559,
                        "end": 571,
                        "text": "(NIST, 2005)",
                        "ref_id": "BIBREF16"
                    },
                    {
                        "start": 807,
                        "end": 828,
                        "text": "(Minkov et al., 2005)",
                        "ref_id": "BIBREF15"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 303,
                        "end": 310,
                        "text": "Table 2",
                        "ref_id": "TABREF2"
                    }
                ],
                "eq_spans": [],
                "section": "Quality Evaluation",
                "sec_num": "5.1"
            },
            {
                "text": "Clearly, considering the large gap between ANNIE's F 1 and partial F 1 measures on both datasets, ANNIE's quality can be improved via dataset-specific tuning as demonstrated in (Maynard et al., 2003) . However, dataset-specific tuning for ANNIE is beyond the scope of this paper. Based on the experimental results above and our previous formal comparison in Sec. 4, we believe it is reasonable to conclude that annotators can be built in SystemT of quality at least comparable to those built in a grammar-based system.",
                "cite_spans": [
                    {
                        "start": 177,
                        "end": 199,
                        "text": "(Maynard et al., 2003)",
                        "ref_id": "BIBREF14"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Quality Evaluation",
                "sec_num": "5.1"
            },
            {
                "text": "We now focus our attention on the throughput and memory behavior of SystemT, and draw a comparison with GATE. For this purpose, we have configured both ANNIE and T-NE to identify only the same eight types of entities listed for NER task. Throughput. Fig. 9(a) plots the throughput of the two systems on multiple Enron x datasets with average document sizes of between 0.5KB and 100KB. For this experiment, both systems ran with a maximum Java heap size of 1GB. As shown in Fig. 9(a) , even though the throughput of ANNIE-Optimized (using the optimized transducer) increases two-fold compared to ANNIE under default configuration, T-NE is between 8 and 24 times faster compared to ANNIE-Optimized. For both systems, throughput varied with document size. For T-NE, the relatively low throughput on very small document sizes (less than 1KB) is due to fixed overhead in setting up operators to process a document. As document size increases, the overhead becomes less noticeable.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 250,
                        "end": 259,
                        "text": "Fig. 9(a)",
                        "ref_id": "FIGREF9"
                    },
                    {
                        "start": 473,
                        "end": 482,
                        "text": "Fig. 9(a)",
                        "ref_id": "FIGREF9"
                    }
                ],
                "eq_spans": [],
                "section": "Performance Evaluation",
                "sec_num": "5.2"
            },
            {
                "text": "We have observed similar trends on the rest of the test collections. Table 3 shows that T-NE is at least an order of magnitude faster than ANNIE-Optimized across all datasets. In particular, on Finance L T-NE's throughput remains high, whereas the performance of both ANNIE and ANNIE-Optimized degraded significantly.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 69,
                        "end": 76,
                        "text": "Table 3",
                        "ref_id": "TABREF3"
                    }
                ],
                "eq_spans": [],
                "section": "Performance Evaluation",
                "sec_num": "5.2"
            },
            {
                "text": "To ascertain whether the difference in performance in the two systems is due to low-level components such as dictionary evaluation, we performed detailed profiling of the systems. The profiling revealed that 8.2%, 16.2% and respectively 14.2% of the execution time was spent on average on low-level components in the case of ANNIE, ANNIE-Optimized and T-NE, respectively, thus leading us to conclude that the observed differences are due to SystemT's efficient use of resources at a macroscopic level. Memory utilization. In theory, grammar based systems can stream tuples through each stage for minimal memory consumption, whereas Sys-temT operator graphs may need to materialize intermediate results for the full document at certain points to evaluate the constraints in the original AQL. The goal of this study is to evaluate whether this potential problem does occur in practice.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Performance Evaluation",
                "sec_num": "5.2"
            },
            {
                "text": "In this experiment we ran both systems with a maximum heap size of 2GB, and used the Java garbage collector's built-in telemetry to measure the total quantity of live objects in the heap over time while annotating the different test corpora. Fig. 9(b) plots the minimum, maximum, and mean heap sizes with the Enron x datasets. On small doc-uments of size up to 15KB, memory consumption is dominated by the fixed size of the data structures used (e.g., dictionaries, FST/operator graph), and is comparable for both systems. As documents get larger, memory consumption increases for both systems. However, the increase is much smaller for T-NE compared to that for both AN-NIE and ANNIE-Optimized. A similar trend can be observed on the other datasets as shown in Table 3. In particular, for Finance L , both ANNIE and ANNIE-Optimized required 8GB of Java heap size to achieve reasonable throughput 7 , in contrast to T-NE which utilized at most 300MB out of the 2GB of maximum Java heap size allocation.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 242,
                        "end": 251,
                        "text": "Fig. 9(b)",
                        "ref_id": "FIGREF9"
                    }
                ],
                "eq_spans": [],
                "section": "Performance Evaluation",
                "sec_num": "5.2"
            },
            {
                "text": "SystemT requires much less memory than GATE in general due to its runtime, which monitors data dependencies between operators and clears out low-level results when they are no longer needed. Although a streaming CPSL implementation is theoretically possible, in practice mechanisms that allow an escape to custom code make it difficult to decide when an intermediate result will no longer be used, hence GATE keeps most intermediate data in memory until it is done analyzing the current document. The BandReview Task. We conclude by briefly discussing our experience with the BandReview task from Fig. 8 . We built two versions of this annotator, one in AQL, and the other using expanded CPSL grammar. The grammar implementation processed a 4.5GB collection of 1.05 million blogs in 5.6 hours and output 280 reviews. In contrast, the SystemT version (85 AQL statements) extracted 323 reviews in only 10 minutes!",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 597,
                        "end": 603,
                        "text": "Fig. 8",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Performance Evaluation",
                "sec_num": "5.2"
            },
            {
                "text": "In this paper, we described SystemT, a declarative IE system based on an algebraic framework. We presented both formal and empirical arguments for the benefits of our approach to IE. Our extensive experimental results show that highquality annotators can be built using SystemT, with an order of magnitude throughput improvement compared to state-of-the-art grammar-based systems. Going forward, SystemT opens up several new areas of research, including implementing better optimization strategies and augmenting the algebra with additional operators to support advanced features such as coreference resolution.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": "6"
            },
            {
                "text": "To the best of our knowledge, ANNIE(Cunningham et al., 2002) is the only publicly available NER library implemented in a grammar-based system (JAPE in GATE).4 http://www.cs.cmu.edu/ enron/ 5 Only entities of type NAM have been considered.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            },
            {
                "text": "GATE ran out of memory when using less than 5GB of Java heap size, and thrashed when run with 5GB to 7GB",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "",
                "sec_num": null
            }
        ],
        "back_matter": [],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "The common pattern specification language",
                "authors": [
                    {
                        "first": "Douglas",
                        "middle": [
                            "E"
                        ],
                        "last": "Appelt",
                        "suffix": ""
                    },
                    {
                        "first": "Boyan",
                        "middle": [],
                        "last": "Onyshkevych",
                        "suffix": ""
                    }
                ],
                "year": 1998,
                "venue": "TIP-STER workshop",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Douglas E. Appelt and Boyan Onyshkevych. 1998. The common pattern specification language. In TIP- STER workshop.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Annotation-based finite state processing in a large-scale nlp arhitecture",
                "authors": [
                    {
                        "first": "Branimir",
                        "middle": [],
                        "last": "Boguraev",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "RANLP",
                "volume": "",
                "issue": "",
                "pages": "61--80",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Branimir Boguraev. 2003. Annotation-based finite state processing in a large-scale nlp arhitecture. In RANLP, pages 61-80.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "A history of System R and SQL/data system",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "D"
                        ],
                        "last": "Chamberlin",
                        "suffix": ""
                    },
                    {
                        "first": "A",
                        "middle": [
                            "M"
                        ],
                        "last": "Gilbert",
                        "suffix": ""
                    },
                    {
                        "first": "Robert",
                        "middle": [
                            "A"
                        ],
                        "last": "Yost",
                        "suffix": ""
                    }
                ],
                "year": 1981,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "D. D. Chamberlin, A. M. Gilbert, and Robert A. Yost. 1981. A history of System R and SQL/data system. In vldb.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "Efficient batch top-k search for dictionarybased entity recognition",
                "authors": [
                    {
                        "first": "Amit",
                        "middle": [],
                        "last": "Chandel",
                        "suffix": ""
                    },
                    {
                        "first": "P",
                        "middle": [
                            "C"
                        ],
                        "last": "Nagesh",
                        "suffix": ""
                    },
                    {
                        "first": "Sunita",
                        "middle": [],
                        "last": "Sarawagi",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "ICDE",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Amit Chandel, P. C. Nagesh, and Sunita Sarawagi. 2006. Efficient batch top-k search for dictionary- based entity recognition. In ICDE.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "The relational model for database management: version 2",
                "authors": [
                    {
                        "first": "E",
                        "middle": [
                            "F"
                        ],
                        "last": "Codd",
                        "suffix": ""
                    }
                ],
                "year": 1990,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "E. F. Codd. 1990. The relational model for database management: version 2. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "JAPE: a Java Annotation Patterns Engine (Second Edition)",
                "authors": [
                    {
                        "first": "H",
                        "middle": [],
                        "last": "Cunningham",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [],
                        "last": "Maynard",
                        "suffix": ""
                    },
                    {
                        "first": "V",
                        "middle": [],
                        "last": "Tablan",
                        "suffix": ""
                    }
                ],
                "year": 2000,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "H. Cunningham, D. Maynard, and V. Tablan. 2000. JAPE: a Java Annotation Patterns Engine (Sec- ond Edition). Research Memorandum CS-00-10, Department of Computer Science, University of Sheffield, November.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "GATE: A framework and graphical development environment for robust NLP tools and applications",
                "authors": [
                    {
                        "first": "H",
                        "middle": [],
                        "last": "Cunningham",
                        "suffix": ""
                    },
                    {
                        "first": "D",
                        "middle": [],
                        "last": "Maynard",
                        "suffix": ""
                    },
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Bontcheva",
                        "suffix": ""
                    },
                    {
                        "first": "V",
                        "middle": [],
                        "last": "Tablan",
                        "suffix": ""
                    }
                ],
                "year": 2002,
                "venue": "Proceedings of the 40th Anniversary Meeting of the Association for Computational Linguistics",
                "volume": "",
                "issue": "",
                "pages": "168--175",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "H. Cunningham, D. Maynard, K. Bontcheva, and V. Tablan. 2002. GATE: A framework and graphical development environment for robust NLP tools and applications. In Proceedings of the 40th Anniver- sary Meeting of the Association for Computational Linguistics, pages 168 -175.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Special issue on managing information extraction",
                "authors": [
                    {
                        "first": "Anhai",
                        "middle": [],
                        "last": "Doan",
                        "suffix": ""
                    },
                    {
                        "first": "Luis",
                        "middle": [],
                        "last": "Gravano",
                        "suffix": ""
                    },
                    {
                        "first": "Raghu",
                        "middle": [],
                        "last": "Ramakrishnan",
                        "suffix": ""
                    },
                    {
                        "first": "Shivakumar",
                        "middle": [],
                        "last": "Vaithyanathan",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "SIGMOD Record",
                "volume": "",
                "issue": "4",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "AnHai Doan, Luis Gravano, Raghu Ramakrishnan, and Shivakumar Vaithyanathan. 2008. Special issue on managing information extraction. SIGMOD Record, 37(4).",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "Shallow processing with unification and typed feature structures -foundations and applications",
                "authors": [
                    {
                        "first": "Witold",
                        "middle": [],
                        "last": "Drozdzynski",
                        "suffix": ""
                    },
                    {
                        "first": "Hans-Ulrich",
                        "middle": [],
                        "last": "Krieger",
                        "suffix": ""
                    },
                    {
                        "first": "Jakub",
                        "middle": [],
                        "last": "Piskorski",
                        "suffix": ""
                    },
                    {
                        "first": "Ulrich",
                        "middle": [],
                        "last": "Sch\u00e4fer",
                        "suffix": ""
                    },
                    {
                        "first": "Feiyu",
                        "middle": [],
                        "last": "Xu",
                        "suffix": ""
                    }
                ],
                "year": 2004,
                "venue": "K\u00fcnstliche Intelligenz",
                "volume": "1",
                "issue": "",
                "pages": "17--23",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Witold Drozdzynski, Hans-Ulrich Krieger, Jakub Piskorski, Ulrich Sch\u00e4fer, and Feiyu Xu. 2004. Shallow processing with unification and typed fea- ture structures -foundations and applications. K\u00fcnstliche Intelligenz, 1:17-23.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "Message understanding conference -6: A brief history",
                "authors": [
                    {
                        "first": "Ralph",
                        "middle": [],
                        "last": "Grishman",
                        "suffix": ""
                    },
                    {
                        "first": "Beth",
                        "middle": [],
                        "last": "Sundheim",
                        "suffix": ""
                    }
                ],
                "year": 1996,
                "venue": "COLING",
                "volume": "",
                "issue": "",
                "pages": "466--471",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ralph Grishman and Beth Sundheim. 1996. Message understanding conference -6: A brief history. In COLING, pages 466-471.",
                "links": null
            },
            "BIBREF12": {
                "ref_id": "b12",
                "title": "To search or to crawl?: towards a query optimizer for text-centric tasks",
                "authors": [
                    {
                        "first": "P",
                        "middle": [
                            "G"
                        ],
                        "last": "Ipeirotis",
                        "suffix": ""
                    },
                    {
                        "first": "E",
                        "middle": [],
                        "last": "Agichtein",
                        "suffix": ""
                    },
                    {
                        "first": "P",
                        "middle": [],
                        "last": "Jain",
                        "suffix": ""
                    },
                    {
                        "first": "L",
                        "middle": [],
                        "last": "Gravano",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "SIGMOD",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "P. G. Ipeirotis, E. Agichtein, P. Jain, and L. Gravano. 2006. To search or to crawl?: towards a query opti- mizer for text-centric tasks. In SIGMOD.",
                "links": null
            },
            "BIBREF13": {
                "ref_id": "b13",
                "title": "Join optimization of information extraction output: Quality matters! In ICDE",
                "authors": [
                    {
                        "first": "Alpa",
                        "middle": [],
                        "last": "Jain",
                        "suffix": ""
                    },
                    {
                        "first": "G",
                        "middle": [],
                        "last": "Panagiotis",
                        "suffix": ""
                    },
                    {
                        "first": "Anhai",
                        "middle": [],
                        "last": "Ipeirotis",
                        "suffix": ""
                    },
                    {
                        "first": "Luis",
                        "middle": [],
                        "last": "Doan",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Gravano",
                        "suffix": ""
                    }
                ],
                "year": 2009,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Alpa Jain, Panagiotis G. Ipeirotis, AnHai Doan, and Luis Gravano. 2009. Join optimization of informa- tion extraction output: Quality matters! In ICDE.",
                "links": null
            },
            "BIBREF14": {
                "ref_id": "b14",
                "title": "Towards a semantic extraction of named entities",
                "authors": [
                    {
                        "first": "Diana",
                        "middle": [],
                        "last": "Maynard",
                        "suffix": ""
                    },
                    {
                        "first": "Kalina",
                        "middle": [],
                        "last": "Bontcheva",
                        "suffix": ""
                    },
                    {
                        "first": "Hamish",
                        "middle": [],
                        "last": "Cunningham",
                        "suffix": ""
                    }
                ],
                "year": 2003,
                "venue": "Recent Advances in Natural Language Processing",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Diana Maynard, Kalina Bontcheva, and Hamish Cun- ningham. 2003. Towards a semantic extraction of named entities. In Recent Advances in Natural Lan- guage Processing.",
                "links": null
            },
            "BIBREF15": {
                "ref_id": "b15",
                "title": "Extracting personal names from emails: Applying named entity recognition to informal text",
                "authors": [
                    {
                        "first": "Einat",
                        "middle": [],
                        "last": "Minkov",
                        "suffix": ""
                    },
                    {
                        "first": "Richard",
                        "middle": [
                            "C"
                        ],
                        "last": "Wang",
                        "suffix": ""
                    },
                    {
                        "first": "William",
                        "middle": [
                            "W"
                        ],
                        "last": "Cohen",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Einat Minkov, Richard C. Wang, and William W. Co- hen. 2005. Extracting personal names from emails: Applying named entity recognition to informal text. In HLT/EMNLP.",
                "links": null
            },
            "BIBREF16": {
                "ref_id": "b16",
                "title": "The ACE evaluation plan",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Nist",
                        "suffix": ""
                    }
                ],
                "year": 2005,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "NIST. 2005. The ACE evaluation plan.",
                "links": null
            },
            "BIBREF17": {
                "ref_id": "b17",
                "title": "Entity annotation based on inverse index operations",
                "authors": [
                    {
                        "first": "Sreeram",
                        "middle": [],
                        "last": "Ganesh Ramakrishnan",
                        "suffix": ""
                    },
                    {
                        "first": "Sachindra",
                        "middle": [],
                        "last": "Balakrishnan",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 2006,
                "venue": "EMNLP",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ganesh Ramakrishnan, Sreeram Balakrishnan, and Sachindra Joshi. 2006. Entity annotation based on inverse index operations. In EMNLP.",
                "links": null
            },
            "BIBREF18": {
                "ref_id": "b18",
                "title": "Optimization issues in inverted index-based entity annotation",
                "authors": [
                    {
                        "first": "Sachindra",
                        "middle": [],
                        "last": "Ganesh Ramakrishnan",
                        "suffix": ""
                    },
                    {
                        "first": "Sanjeet",
                        "middle": [],
                        "last": "Joshi",
                        "suffix": ""
                    },
                    {
                        "first": "Sreeram",
                        "middle": [],
                        "last": "Khaitan",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Balakrishnan",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ganesh Ramakrishnan, Sachindra Joshi, Sanjeet Khai- tan, and Sreeram Balakrishnan. 2008. Optimization issues in inverted index-based entity annotation. In InfoScale.",
                "links": null
            },
            "BIBREF19": {
                "ref_id": "b19",
                "title": "An algebraic approach to rule-based information extraction",
                "authors": [
                    {
                        "first": "Frederick",
                        "middle": [],
                        "last": "Reiss",
                        "suffix": ""
                    },
                    {
                        "first": "Sriram",
                        "middle": [],
                        "last": "Raghavan",
                        "suffix": ""
                    },
                    {
                        "first": "Rajasekar",
                        "middle": [],
                        "last": "Krishnamurthy",
                        "suffix": ""
                    },
                    {
                        "first": "Huaiyu",
                        "middle": [],
                        "last": "Zhu",
                        "suffix": ""
                    },
                    {
                        "first": "Shivakumar",
                        "middle": [],
                        "last": "Vaithyanathan",
                        "suffix": ""
                    }
                ],
                "year": 2008,
                "venue": "ICDE",
                "volume": "",
                "issue": "",
                "pages": "933--942",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Frederick Reiss, Sriram Raghavan, Rajasekar Kr- ishnamurthy, Huaiyu Zhu, and Shivakumar Vaithyanathan. 2008. An algebraic approach to rule-based information extraction. In ICDE, pages 933-942.",
                "links": null
            },
            "BIBREF21": {
                "ref_id": "b21",
                "title": "Text Mining with SAS Text Miner",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Sas",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "SAS. 2010. Text Mining with SAS Text Miner.",
                "links": null
            },
            "BIBREF22": {
                "ref_id": "b22",
                "title": "Declarative information extraction using datalog with embedded extraction predicates",
                "authors": [
                    {
                        "first": "Warren",
                        "middle": [],
                        "last": "Shen",
                        "suffix": ""
                    },
                    {
                        "first": "Anhai",
                        "middle": [],
                        "last": "Doan",
                        "suffix": ""
                    },
                    {
                        "first": "Jeffrey",
                        "middle": [
                            "F"
                        ],
                        "last": "Naughton",
                        "suffix": ""
                    },
                    {
                        "first": "Raghu",
                        "middle": [],
                        "last": "Ramakrishnan",
                        "suffix": ""
                    }
                ],
                "year": 2007,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Warren Shen, AnHai Doan, Jeffrey F. Naughton, and Raghu Ramakrishnan. 2007. Declarative informa- tion extraction using datalog with embedded extrac- tion predicates. In vldb.",
                "links": null
            },
            "BIBREF23": {
                "ref_id": "b23",
                "title": "AQL Manual",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Systemt",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "SystemT. 2010. AQL Manual. http://www.alphaworks.ibm.com/tech/systemt.",
                "links": null
            },
            "BIBREF24": {
                "ref_id": "b24",
                "title": "Regular expression search algorithm",
                "authors": [
                    {
                        "first": "Ken",
                        "middle": [],
                        "last": "Thompson",
                        "suffix": ""
                    }
                ],
                "year": 1968,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "419--422",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Ken Thompson. 1968. Regular expression search al- gorithm. pages 419-422.",
                "links": null
            },
            "BIBREF25": {
                "ref_id": "b25",
                "title": "Unstructured Information Management Architecture",
                "authors": [
                    {
                        "first": "",
                        "middle": [],
                        "last": "Uima",
                        "suffix": ""
                    }
                ],
                "year": 2010,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "UIMA. 2010. Unstructured Information Management Architecture. http://uima.apache.org.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF1": {
                "text": "Cascading grammar for identifying Person names",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF3": {
                "text": "Regular Expression Extraction Operator words that are both capitalized and present in the FirstGaz gazetteer\" or \"Identify Person annotations that occur within an EmailAddress\".",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF4": {
                "text": "(b) illustrates how the above extensions help in identifying the correct matches 'Mark Scott'",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF5": {
                "text": "Person annotator as AQL query over sets of tuples, is well-documented and wellunderstood",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF6": {
                "text": "create view CapsLast as extract pattern <C.name> <L.name> from Caps C, Last L;",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF7": {
                "text": "The compilation process in SystemTFigure 6: Execution strategies for the CapsLast rule inFig. 4",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF8": {
                "text": "Supporting Complex Rule Interactions used in SystemT, we now compare the two in terms of expressivity and performance.",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "FIGREF9": {
                "text": "6 http://www.ontotext.com/gate/japec.html Throughput (a) and memory consumption (b) comparisons on Enron x datasets.",
                "uris": null,
                "num": null,
                "type_str": "figure"
            },
            "TABREF0": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "",
                "content": "<table><tr><td>Phase</td><td>Types</td><td>RuleId</td></tr><tr><td>P 1</td><td>Input Lookup</td><td>P 1 R 1</td></tr><tr><td/><td>Token</td><td>P 1 R 2</td></tr><tr><td/><td>Output First</td><td>P 1 R 3</td></tr><tr><td/><td>Last</td><td/></tr><tr><td/><td>Caps</td><td/></tr><tr><td>P 2</td><td>Last Input First</td><td>P 2 R 2</td></tr><tr><td/><td>Caps Token</td><td>P 2 R 3</td></tr><tr><td/><td>Output</td><td>P 2 R 4</td></tr><tr><td/><td>Person</td><td/></tr><tr><td/><td/><td>P 2 R 5</td></tr><tr><td>P 2 R 3</td><td/><td/></tr><tr><td/><td/><td>Bind match</td><td>Create Person</td></tr><tr><td/><td/><td>to variables</td><td>annotation</td></tr></table>"
            },
            "TABREF1": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "Datasets for performance evaluation.",
                "content": "<table><tr><td>Dataset</td><td>Description of the Content</td><td>Number of</td><td colspan=\"2\">Document size</td></tr><tr><td/><td/><td>documents</td><td>range</td><td>average</td></tr><tr><td>Enronx</td><td>Emails randomly sampled from the Enron corpus of average size xKB (0.5 &lt; x &lt; 100) 2</td><td>1000</td><td>xKB +/ \u2212 10%</td><td>xKB</td></tr><tr><td>WebCrawl</td><td>Small to medium size web pages representing company news, with HTML tags removed</td><td>1931</td><td>68b -388.6KB</td><td>8.8KB</td></tr><tr><td>FinanceM</td><td>Medium size financial regulatory filings</td><td>100</td><td>240KB -0.9MB</td><td>401KB</td></tr><tr><td>FinanceL</td><td>Large size financial regulatory filings</td><td>30</td><td>1MB -3.4MB</td><td>1.54MB</td></tr></table>"
            },
            "TABREF2": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "Quality of Person on test datasets.",
                "content": "<table><tr><td/><td>Precision (%)</td><td>Recall (%)</td><td>F1 measure (%)</td></tr><tr><td/><td>(Exact/Partial)</td><td>(Exact/Partial)</td><td>(Exact/Partial)</td></tr><tr><td/><td colspan=\"2\">EnronMeetings</td><td/></tr><tr><td>ANNIE</td><td>57.05/76.84</td><td>48.59/65.46</td><td>52.48/70.69</td></tr><tr><td>T-NE</td><td>88.41/92.99</td><td>82.39/86.65</td><td>85.29/89.71</td></tr><tr><td>Minkov</td><td>81.1/NA</td><td>74.9/NA</td><td>77.9/NA</td></tr><tr><td/><td/><td>ACE</td><td/></tr><tr><td>ANNIE</td><td>39.41/78.15</td><td>30.39/60.27</td><td>34.32/68.06</td></tr><tr><td>T-NE</td><td>93.90/95.82</td><td>90.90/92.76</td><td>92.38/94.27</td></tr></table>"
            },
            "TABREF3": {
                "html": null,
                "type_str": "table",
                "num": null,
                "text": "Throughput and mean heap size.",
                "content": "<table><tr><td/><td colspan=\"2\">ANNIE</td><td colspan=\"2\">ANNIE-Optimized</td><td>T-NE</td><td/></tr><tr><td colspan=\"7\">Dataset ThroughputMemoryThroughput Memory ThroughputMemory</td></tr><tr><td/><td>(KB/s)</td><td>(MB)</td><td>(KB/s)</td><td>(MB)</td><td>(KB/s)</td><td>(MB)</td></tr><tr><td>WebCrawl</td><td>23.9</td><td>212.6</td><td>42.8</td><td>201.8</td><td>498.9</td><td>77.2</td></tr><tr><td colspan=\"2\">FinanceM 18.82</td><td>715.1</td><td>26.3</td><td>601.8</td><td>703.5</td><td>143.7</td></tr><tr><td>FinanceL</td><td>19.2</td><td>2586.2</td><td>21.1</td><td>2683.5</td><td>954.5</td><td>189.6</td></tr></table>"
            }
        }
    }
}