A Survey on Open Information Extraction

In plain words

Information extraction turns sentences into structured facts, such as "Person, relation, Place". Traditional tools look for a fixed list of relations that someone chose in advance. Open Information Extraction (Open IE) drops that list and tries to pull out whatever relations a sentence states, so it can run over large, mixed text such as the web.

This paper is a guided tour of the systems built for that goal. It groups them by how they work: some learn patterns from data they label automatically, some apply hand-written rules, some first rewrite a long sentence into shorter ones, and some try to keep track of which facts are only claimed or hypothetical. It also looks at how these systems have been tested and why the results are hard to compare, and it ends with open problems such as other languages, merging duplicate names and checking the results across systems.

TL;DR

A survey, not a method. Open IE aims to extract all relations from text without a predefined list. The paper sorts systems into four families, and it argues that evaluation is the weak point: there is no agreed large gold standard, most studies use few hundred hand-checked sentences, and recall is rarely measured directly. The paper reports no results of its own.

Problem

Traditional IE needs a target relation and hand-crafted or hand-labelled patterns for each one, so moving to a new domain means more manual work §1. Open IE was defined to remove that need. Its task is to extract relations of any type from heterogeneous text, with three stated requirements: automation (unsupervised, one pass over the corpus), corpus heterogeneity (no tools that only work in one genre, such as named entity recognisers tied to fixed types), and efficiency (shallow features preferred over deep parse features) §1. The paper notes that later systems often break these requirements, for example by relying on a dependency parser §1.

Method

The survey classifies systems rather than proposing one. Each entry below states the system, its approach and the claim the paper makes for it.

Learning-based systems §2.1

• TextRunner §2.1: self-supervised. A dependency parser labels extractions from a small set of Penn Treebank sentences as positive or negative. A Naive Bayes classifier over unlexicalised POS and noun-phrase chunk features then decides which candidate tuples to keep. A redundancy-based assessor scores each tuple by how many sentences support it. The paper says shallow features make it efficient §2.1.
• WOE §2.1: bootstraps from Wikipedia infobox attribute-value pairs matched to sentences. Two variants: WOE-pos uses a linear-chain CRF over shallow features; WOE-parse classifies the shortest dependency path between two noun phrases. The paper reports that dependency features raise precision and recall but cost extraction speed §2.1.
• OLLIE §2.1 fig. 2: bootstraps from high-precision seed tuples of ReVerb and learns open pattern templates over dependency parses. It adds a context step for attribution and clausal modifiers §2.4, and it covers relations mediated by nouns and adjectives as well as verbs §2.1.
• ReNoun §2.1: targets noun-mediated relations. It starts from manually written seed patterns for noun phrases, learns dependency patterns by distant supervision, and scores candidates by pattern frequency and coherence §2.1.

Rule-based systems §2.2

• ReVerb §2.2 fig. 3: a shallow extractor with a part-of-speech regular expression that the paper says covers about 85% of verb-based relational phrases. A lexical constraint requires a relation phrase to take many distinct arguments across a large corpus. It finds relation phrases first, then arguments.
• KrakeN §2.2: built for n-ary facts. It gathers all arguments of each relational phrase from typed dependency parses using hand-written rules.
• Exemplar §2.2: n-ary extraction from dependency patterns that find a trigger and attached arguments, labelled with semantic roles (subject, direct object, prepositional object and similar) §2.2.
• PropS §2.2: converts a dependency tree into a directed graph shaped like the sentence's propositions, using a rule-based converter §2.2.
• PredPatt §2.2: non-lexicalised rules over Universal Dependencies. The paper notes it is one of the few systems that work across languages in principle, though it was evaluated only on English §2.2 §4.

Clause-based systems §2.3

• ClausIE §2.3 tab. 1: maps dependency relations to clause constituents using English grammar knowledge and verb lexica. It assigns each clause one of seven basic types and generates propositions from each type tab. 1.
• Schmid et al. (2014) §2.3: splits a sentence into chunks, classifies the dependency between chunk pairs as connected, disconnected or dependent (by rules or by a Naive Bayes model), then merges chunks before extraction.
• Stanford Open IE §2.3 fig. 4: a classifier decides at each dependency edge whether it yields an independent clause. Each clause is shortened with natural logic inference, then 14 hand-written patterns turn each utterance into a predicate-argument triple §2.3.

Systems capturing inter-proposition relationships §2.4

• OLLIE's context step §2.4: adds an attribution field (who asserts the proposition) and a clausal-modifier field (for example a condition). Attribution is found through a list of communication and cognition verbs from VerbNet. Clausal modifiers are found through adverbial-clause edges filtered by cue words §2.4.
• OpenIE4 §2.4: combines SRL-based extraction (SrlIE) with noun-mediated extraction (RelNoun). It labels temporal and spatial arguments with T or S §2.4.
• OpenIE 5.0 §2.4: integrates BONIE (tuples with a number or quantity-unit argument) and an extractor for conjunctive sentences §2.4.
• CSD-IE §2.4: splits a sentence into contexts with hand-written rules over a constituency parse, and links them by identifiers that a later step can substitute §2.4.
• NestIE §2.4: learns binary and nested tuples, where one tuple's argument is another tuple, from a textual entailment dataset with manual rules for links §2.4.
• MinIE §2.4: built on ClausIE. It removes overly specific parts of relation and argument phrases in one of four minimisation modes, and it stores polarity, modality, attribution and quantity as annotations rather than in the tuple itself §2.4.
• Graphene §2.4 fig. 5: applies hand-written simplification rules to turn a sentence into core facts and their contexts, then labels the links between them with rhetorical relations based on syntactic and lexical patterns §2.4.

The paper has no numbered algorithm. The pseudocode below restates the relation-first order that the paper gives for ReVerb §2.2, and the generic pattern-based scheme that the paper says most systems follow §2.

# Relation-first extraction, as described for ReVerb  [§2.2]
# Input:  tagged sentences (POS tags, noun-phrase chunks)
# Output: list of (arg1, relation, arg2) tuples

def extract(sentences, corpus_stats):
    # 1. Find relation phrases that match the POS regular expression [§2.2]
    #    (covers about 85% of verb-based relational phrases, per the paper)
    candidates = match_pos_pattern(sentences)

    # 2. Keep phrases that take many distinct arguments in the corpus [§2.2]
    relations = [r for r in candidates
                 if distinct_argument_count(r, corpus_stats) >= min_args]

    tuples = []
    for relation in relations:
        # 3. Find a noun-phrase pair for each kept relation [§2.2]
        #    (how the pair is chosen is not stated in this survey)
        arg1, arg2 = find_argument_pair(relation, sentences)
        tuples.append((arg1, relation, arg2))
    return tuples

Most pattern-based systems share one step: they match a set of hand-crafted or learned patterns against a sentence to produce relational tuples §2. The paper does not give numeric values for min_args; the threshold is not stated.

Hyperparameters

Not applicable. The paper describes systems but reports no training or extraction settings of its own. Where it quotes a number, it is a property of the cited system, for example the 85% coverage of ReVerb's pattern §2.2 or the 14 patterns of Stanford Open IE §2.3.

Results

Not applicable. The paper runs no experiments and reports no scores of its own. It describes evaluation designs, which the table below summarises from tab. 2 and §3:

Paper vs code

No official code. The paper links an OpenIE 5.0 repository (dair-iitd/OpenIE-standalone) and OpenIEListExtractor (swarnaHub) §2.4. Both belong to other groups and are not the authors' code, so they are not used here. A GitHub repository search for "open information extraction survey" returned two unrelated repositories. The paper has no experiments whose code could be compared.

Pitfalls

• Scope and date. The paper covers systems up to 2017 §2. Its most recent systems are MinIE (2017) and Graphene, cited as Cetto et al. (2018) §2.4. Systems after that date are not covered.
• Taxonomy is the author's. The four families are the paper's own grouping. Several systems sit on the border; for example, OLLIE both bootstraps patterns and adds a context step §2.1 §2.4.
• Claims are reported as the paper states them. Figures such as the 85% coverage of ReVerb's pattern §2.2, and the claim that OLLIE is the first to cover noun- and adjective-mediated relations §2.1, come from the cited works, not from this survey's own tests.
• Evaluation is the paper's main critique. It notes that no formal definition of a valid tuple exists, that no large, widely used gold corpus existed when it was written, and that recall is often replaced by yield or coverage §3. Read the results of any single system in that light.
• Language coverage. Most systems target English. The paper names a few exceptions, including a German port of PropS and a multilingual system for English, Spanish, Portuguese and Galician §4.
• Open problems stated by the paper §4: standard evaluation adoption (the paper says neither benchmark suite was adopted yet, apart from Graphene's use of one), relational phrase and argument canonicalisation, and coreference resolution.

Lineage

• Origin: TextRunner (Banko et al., 2007) introduced the Open IE task and its three requirements §1.
• Builds on: ReVerb (rule-based relational phrases) and dependency parsing, which OLLIE and WOE-parse use §2.1 §2.2.
• Compared against: the paper's evaluation tables compare systems pairwise, such as OLLIE against ReVerb and ClausIE against TextRunner, as summarised in tab. 2.
• Superseded by: not stated in this paper.