# Patent

## Title
Open information extraction from the Web

## Abstract

To implement open information extraction, a new extraction paradigm has been developed in which a system makes a single data-driven pass over a corpus of text, extracting a large set of relational tuples without requiring any human input. Using training data, a Self-Supervised Learner employs a parser and heuristics to determine criteria that will be used by an extraction classifier (or other ranking model) for evaluating the trustworthiness of candidate tuples that have been extracted from the corpus of text, by applying heuristics to the corpus of text. The classifier retains tuples with a sufficiently high probability of being trustworthy. A redundancy-based assessor assigns a probability to each retained tuple to indicate a likelihood that the retained tuple is an actual instance of a relationship between a plurality of objects comprising the retained tuple. The retained tuples comprise an extraction graph that can be queried for information.

## Background
GOVERNMENT RIGHTS
This invention was made with government support under grants IIS-0312988 and IIS-0535284 awarded by the National Science Foundation (NSF), grant N00014-05-1-0185 awarded by the Office of Naval Research (ONR), and contract NBCHD03001 awarded by the Defense Advanced Research Projects Agency (DARPA). The government has certain rights in the invention.


BACKGROUND
Traditionally, Information Extraction (IE) has focused on satisfying precise, narrow, pre-specified requests from small homogeneous corpora (e.g., extract the location and time of seminars from a set of announcements). Shifting to a new domain requires the user to name the target relations and to manually create new extraction rules or hand-tag new training examples. This manual labor scales linearly with the number of target relations. Thus, IE has traditionally relied on extensive human involvement in the form of hand-crafted extraction rules or hand-tagged training examples. Moreover, the user is required to explicitly pre-specify each relation of interest. While IE has become increasingly automated over time, enumerating all potential relations of interest for extraction by an IE system is highly problematic for corpora as large and varied as the Web. To make it possible for users to issue diverse queries over heterogeneous corpora, IE systems must move away from architectures that require relations to be specified prior to query time in favor of those that aim to discover all possible relations in the text.
In the past, IE has been used on small, homogeneous corpora such as newswire stories or seminar announcements. As a result, traditional IE systems are able to rely on “heavy” linguistic technologies tuned to the domain of interest, such as dependency parsers and Named-Entity Recognizers (NERs). These systems were not designed to scale relative to the size of the corpus or the number of relations extracted, as both parameters were fixed and small.
The problem of extracting information from the Web violates all of these assumptions. Corpora are massive and heterogeneous, the relations of interest are unanticipated, and their number can be large. These challenges are discussed below in greater detail.
The first step in automating IE was moving from knowledge-based IE systems to trainable systems that took as input hand-tagged instances or document segments and automatically learned domain-specific extraction patterns. Certain prior approaches, including Web-based question answering systems, have further reduced the manual labor needed for relation-specific text extraction by requiring only a small set of tagged seed instances or a few hand-crafted extraction patterns, per relation, to launch the training process. Still, the creation of suitable training data required substantial expertise as well as non-trivial manual effort for every relation extracted, and the relations have to be specified in advance.
Previous approaches to relation extraction have employed kernel-based methods, maximum-entropy models, graphical models, and co-occurrence statistics over small, domain-specific corpora and limited sets of relations. The use of NERs, as well as syntactic or dependency parsers, is a common thread that unifies most previous work. But this rather “heavy” linguistic technology runs into problems when applied to the heterogeneous text found on the Web. While the parsers of the prior approaches work well when trained and applied to a particular genre of text, such as financial news data in the Penn Treebank, they make many more parsing errors when confronted with the diversity of Web text. Moreover, the number and complexity of entity types on the Web means that existing NER systems are inapplicable.
Recent efforts by others who are seeking to undertake large-scale extraction indicate a growing interest in the problem. This year, a paradigm was proposed by other researchers, for “on-demand information extraction,” which aims to eliminate customization involved with adapting IE systems to new topics. Using unsupervised learning methods, this earlier system automatically creates patterns and performs extraction based on a topic that has been specified by a user.
In addition, another research group described an approach to “unrestricted relation discovery,” that was tested on a collection of 28,000 newswire articles. This early work contains the important idea of avoiding relation-specificity, but does not scale to the magnitude of the problem of extracting information from the entire Web, as explained below. Given a collection of documents, the prior system first performs clustering of the entire set of newswire articles, partitioning the corpus into sets of articles believed to discuss similar topics. Within each cluster, named-entity recognition, co-reference resolution, and deep linguistic parse structures are computed and are then used to automatically identify relations between sets of entities. This use of “heavy” linguistic machinery would be problematic if applied to the Web, since the time requirement for extracting information would be too great.
This earlier approach uses pair wise vector-space clustering and initially requires an O (D2) effort where D is the number of documents. Each document assigned to a cluster is then subject to linguistic processing, potentially resulting in another pass through the entire set of input documents. This approach is far more expensive for large document collections than would be desirable and would likely not be practical for extracting information from a corpus of text the size of the Web.
KNOWITALL is a previously developed Web extraction system that addresses the automation challenge by learning to label its own training examples using a small set of domain-independent extraction patterns. KNOWITALL also addresses corpus heterogeneity by relying on a part-of-speech tagger instead of a parser, and by not requiring an NER. However, KNOWITALL requires large numbers of search engine queries and Web page downloads to extract the desired information from a corpus such as the Web. As a result, experiments using KNOWITALL can take weeks to complete. Finally, KNOWITALL takes relation names as input. Thus, the extraction process has to be run, and re-run, each time a relation of interest is identified. Instead, it would thus be desirable to employ a novel paradigm that retains KNOWITALL's benefits, while substantially avoiding its inefficiencies.
SUMMARY
An exemplary method has been created for extracting relational information from a corpus of text without supervision or the use of predefined templates. Details of this method are described below. The method includes the step of automatically creating a classifier or other form of ranking model for classifying a quality of tuples that will be extracted from the corpus of text. Each tuple includes a plurality of objects and at least one relationship that connects the plurality of objects. Heuristics are automatically applied for extracting the tuples from the corpus of text, without human supervision or direction. Next, the classifier or ranking function that was created is employed to assess the quality of each of the tuples that were automatically extracted. The method then automatically determines which of the tuples will be retained, based upon the quality of each tuple that is returned by the classifier or ranking function.
When automatically applying heuristics to extract the tuples, the method identifies nouns and verbs in sentence-like text included in the corpus of text. Nouns that are identified prospectively comprise the objects included in tuples, and the verbs prospectively comprise relationships between the objects for tuples. The classifier can be applied by using a probability model to determine a probability that the relationship between objects in each tuple that has been extracted is trustworthy or not trustworthy. To determine which of the tuples will be retained, one approach provides for only retaining the tuples for which the relationship between the objects of the tuple has been determined to be trustworthy, so that the probability thus comprises an indication of the quality of the tuple.
In at least one embodiment, the classifier is created by using a parser to automatically identify objects and relationships of each tuple in training data. Each tuple in the training data is labeled as either trustworthy or not trustworthy in regard to a relationship between the plurality of objects comprising the tuple. The classifier learns how to classify tuples extracted from the corpus of text, in regard to their quality, in an unsupervised manner from the tuples that have been labeled as a training example. The classifier thus comprises an independent feature model classifier that is automatically trained without human interaction.
Another aspect of the novel approach that is discussed herein is directed to an exemplary system for automatically extracting relational information from a corpus of text without specifying criteria or patterns for controlling extraction of the relational information. The system includes a memory in which a plurality of machine instructions are stored, and a storage in which a corpus of text are stored. An interface is provided for coupling to the storage. A processor is coupled to the memory, and also to the storage through the interface. The processor executes the machine instructions stored in the memory to carry out a plurality of functions that are generally consistent with the steps of the method discussed above. Yet another aspect is directed to a memory medium on which machine executable instructions are stored. When executed by a processor, these machine executable instructions cause the processor to carry out functions that are also generally consistent with the steps of the method discussed above.
This Summary has been provided to introduce a few concepts in a simplified form that are further described in detail below in the Description. However, this Summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.



DRAWINGS
Various aspects and attendant advantages of one or more exemplary embodiments and modifications thereto will become more readily appreciated as the same becomes better understood by reference to the following detailed description, when taken in conjunction with the accompanying drawings, wherein:
FIG. 1 is a block diagram illustrating the functional components of an exemplary embodiment of a system (referred to herein as “TEXTRUNNERTM”) for carrying out unsupervised extraction of relationships from a corpus of text;
FIG. 2A illustrates an exemplary portion of an extraction graph (not all edges for these nodes are shown); an edge points from the first node or object in a tuple, toward a second node or object;
FIG. 2B graphically illustrates the use of an inverted index formed from an extraction graph for query processing, where the inverted index over the extraction graph text enables a spreading activation algorithm to instantly find all tuples that contain the search terms included in a query;
FIG. 3 is a graph providing an overview of the tuples extracted from a 9 million Web page corpus;
FIG. 4 is a chart comparing various characteristics of traditional (prior art) information extraction with the open information extraction provided by the present novel approach;
FIG. 5 is a chart illustrating the unsupervised learning technique that employs training data to develop an extraction classifier that can classify extracted information relationships as either trustworthy or untrustworthy;
FIG. 6 is functional diagram that illustrates how the extraction classifier is used for assessing the trustworthiness of two exemplary extracted tuples;
FIG. 7 is an exemplary flowchart illustrating the logical steps that are carried out in creating an extraction graph for a corpus of text (such as the Web);
FIG. 8 is an exemplary flowchart illustrating further details for the logical steps employed for creating an extraction classifier by unsupervised learning applied to training data, using shallow linguistic analysis, parsing, and heuristics; and
FIG. 9 is a schematic block diagram of an exemplary generally conventional computing device that is suitable for use in the unsupervised extraction of information from a corpus of text, i.e., for carrying out the novel approach disclosed herein.



DESCRIPTION
Figures and Disclosed Embodiments Are Not Limiting
Exemplary embodiments are illustrated in referenced Figures of the drawings. It is intended that the embodiments and Figures disclosed herein are to be considered illustrative rather than restrictive. No limitation on the scope of the technology and of the claims that follow is to be imputed to the examples shown in the drawings and discussed herein.
Exemplary Embodiment
TEXTRUNNERTM
TEXTRUNNER is an exemplary fully implemented system that extracts relational tuples from text included in a corpus of text (such as the Web), in accord with the present approach. The tuples are assigned a probability and indexed to support efficient extraction and exploration via user queries.
The following discussion:

    
    
        Introduce Open Information Extraction (OIE)—a new extraction paradigm that obviates relation specificity by automatically discovering possible relations of interest while making only a single pass over its corpus.
        Introduce TEXTRUNNER, a fully implemented OIE system, and highlight the key elements of its novel architecture. The following discussion compares TEXTRUNNER experimentally with the Web IE system, KNOWITALL, and show that TEXTRUNNER achieves a 33% relative error reduction for a comparable number of extractions.
        Report on statistics over TEXTRUNNER's 11,000,000 highest probability extractions, which demonstrates its scalability, helps to assess the quality of its extractions, and suggests directions for future work.

Open IE in TEXTRUNNER

    
    


The following describes TEXTRUNNER's architecture focusing on its novel components, which are shown in FIG. 1, and then considers how TEXTRUNNER addresses each of the challenges outlined above. Other than training data 13 that are used by a self-supervised learner 15, TEXTRUNNER's sole input is a corpus of text 11, and its output is a set of extractions, comprising an extraction graph 23 that are efficiently indexed, for example, to support exploration via user queries.
TEXTRUNNER includes three key modules:

    
    
        1. Self-Supervised Learner (15): Given a small corpus sample as input, the Self-Supervised Learner produces a classifier 17 that is capable of labeling candidate tuples or extractions as “trustworthy” or not. The Self-Supervised Learner does not require hand-tagged data or predefined criteria to carry out this function. Other approaches besides a classifier can be used for ranking the tuples or relationships.
        2. A Single-Pass Extractor (19): The Single-Pass Extractor makes a single pass over the entire corpus of text to extract candidate tuples for all possible relations. The Single-Pass Extractor does not utilize a parser. The Single-Pass Extractor generates one or more candidate tuples from each sentence in the corpus of text, sends each candidate tuple to classifier 17, and retains the tuples that are labeled as trustworthy.
        3. A Redundancy-Based Assessor (21): Redundancy-Based Assessor 21 assigns a probability to each retained (trustworthy) tuple based on a probabilistic model of redundancy in the text (which is an approach previously used by others). Its output is extraction graph 23, which includes the retained tuples that were extracted, along with a probability value that was determined by the Redundancy-Based Assessor.
    
    


Each of these key modules is described below in greater detail. Also discussed is TEXTRUNNER's ability to efficiently process queries over its extraction set, and analyze the system's time complexity and speed.
Self-Supervised Learner
Self-Supervised Learner 15 operates in two steps. First, it automatically labels its own training data 13 as positive or negative, producing labeled data. Second, in this exemplary embodiment, it uses this labeled data to train a Naive Bayes classifier (i.e., to create classifier 17), which is then used by Single-Pass Extractor module 17. Other approaches can be used for ranking the data, to produce labeled data, and to learn how to rank the data.
While deploying a deep linguistic parser to extract relationships between objects is not practical at Web scale, it is hypothesized that a parser can help to train a classifier. Thus, as has been suggested by others, prior to full-scale relation extraction, the Learner uses a parser to automatically identify and label a set of trustworthy (and untrustworthy) extractions. These extractions are used as positive (or negative) training examples to a Naive Bayes classifier. (Since this Learner labels its own training data, it is referred to as “self supervised.”) Use of a noise-tolerant learning algorithm helps the system recover from the errors made by the parser when applied to heterogeneous Web text.
Extractions take the form of a tuple t=(ei, i,j, ej), where ei and ej are strings meant to denote entities or objects, and i,j is a string meant to denote a relationship between the entities or objects.
The trainer of Self-Supervised Learner 15 parses several thousand sentences in training data 13 to obtain their dependency graph representations. For each parsed sentence, the system finds all base noun phrase constituents ei. (In this exemplary embodiment, base noun phrases do not contain nested noun phrases, or optional phrase modifiers, such as prepositional phrases.) For each pair of noun phrases (ei, ej), i<j, the Self-Supervised Learner traverses the parse structure connecting them to locate a sequence of words that becomes a potential relation i,j in the tuple t. The Self-Supervised Learner labels t as a positive example if certain constraints on the syntactic structure shared by ei and ej are met. These constraints seek to extract relationships that are likely to be correct even when the parse tree contains some local errors; if any constraint fails, t is labeled as a negative instance. Some of the heuristics used by this exemplary embodiment are as follows:

    
    
        There exists a dependency chain between ei and ej that is no longer than a certain length. For example, restricting the length of the dependency chain to no more than 4 was found to work well.
        The path from ei to ej along the syntax tree does not cross a sentence-like boundary (e.g., relative clauses).
        Neither ei nor ej consists solely of a pronoun.
    
    


Once the Self-Supervised Learner has found and labeled a set of tuples of the form t=(ei, i,j, ej), it maps each such tuple to a feature vector representation. All features are domain independent, and can be evaluated at extraction time without the use of a parser. Examples of features include the presence of part-of-speech tag sequences in the relation i,j, the number of tokens in ri, j, the number of stop words in i,j, whether an object e is found to be a proper noun, the part-of-speech tag to the left of ei, and the part-of-speech tag to the right of ej. Following feature extraction, the Self-Supervised Learner uses this set of automatically labeled feature vectors as input to a Naive Bayes classifier. As noted above, it is also contemplated that other approaches for carrying out the function of ranking data and for employing the training data to create such a ranking function or model.
Classifier 17, which is output by Self-Supervised Learner 15, is language-specific but contains no relation-specific or lexical features. Thus, it can be used in a domain-independent manner.
FIG. 5 graphically illustrates further details of a more specific example 60 that illustrates how Self-Supervised Learner 15 produces the classifier that will be used in processing a corpus of text. In this example, a few sentences are input to an analysis block 62, which parses the sentences to identify subject, verbs, prepositions, and objects, using a simple parser, as discussed above. As indicated, the parser extracts the relationship: “Oppenheimer taught at Berkeley and CalTech.” Next, simple heuristics (indicated by reference number 64) are applied to label two training instances, as indicated in a block 66, specifically producing tuples t1 and t2, as follows: (t1) Oppenheimer, taught at, Berkeley; and (t2) Oppenheimer, taught at, CalTech. Feature extraction is then applied in a block 68 to identify specific characteristics of each of these tuples. Naive Bayes training (indicated by a reference number 70) is then used to produce an extraction classifier 72 that is relation independent, uses low-level linguistic features (no parsing is used), and is language specific.
FIG. 6 illustrates a simple example to show how extraction classifier 72 is used in connection with part of a sentence 84 that is included in a corpus of text 80. From this sentence, two possible relationships are extracted. A first relationship 86 is the tuple: Einstein, presented, The Theory of Relativity. The classifier determines that this tuple is trustworthy, since it indicates a relationship with a probability of about 0.95. A second relationship 88 is: The Theory of Relativity, in, a paper. The classifier correctly determines that this is an untrustworthy relationship, having a probability of only 0.3. So only the first relationship is included in retained extractions 82, as a result of processing by the extraction classifier 72. It must be emphasized that extraction classifier 72 is but one approach that is used in this exemplary embodiment for ranking the relationships that are identified, in terms of trustworthiness. This ranking or classifying function can be implemented in a myriad of different ways (e.g., by applying a probabilistic approach, a frequency-based approach, a heuristic approach, etc.). Thus, it is not intended that the ranking or classifying step discussed herein in anyway be limited to an extraction classifier.
Prior to using a learning approach like that disclosed above, several weeks were invested in manually constructing a relation-independent extraction classifier. A first attempt at relation extraction took the entire string between two entities detected to be of interest. Not surprisingly, this permissive approach captured an excess of extraneous and incoherent information. At the other extreme, a strict approach that simply looks for verbs in relation to a pair of nouns resulted in a loss of other links of importance, such as those that specify noun or attribute-centric properties, for example, (Oppenheimer, professor of, theoretical physics) and (trade schools, similar to, colleges). A purely verb-centric method was prone to extracting incomplete relationships, for example, (Berkeley, located, Bay Area) instead of (Berkeley, located in, Bay Area). The heuristic-based approaches that were attempted exposed the difficulties involved in anticipating the form of a relation and its arguments in a general manner. At best, a final hand-built classifier, which is a natural baseline for the learned one (i.e., for classifier 17), achieved a mere one third of the accuracy of classifier 17, which was produced by the Self-Supervised Learner.
Single-Pass Extractor
Single-Pass Extractor 19 makes a single pass over corpus of text 11, automatically tagging each word in each sentence with its most probable part-of-speech. Using these tags, entities or objects are found by identifying noun phrases using a lightweight noun-phrase chunker. Relations are found by examining the text between the noun phrases and heuristically eliminating non-essential phrases, such as prepositional phrases that over specify an entity (e.g. “Scientists from many universities are studying . . . ” is analyzed as “Scientists are studying . . . ”), or individual tokens, such as adverbs (e.g., “definitely developed” is reduced to “developed”).
For each noun phrase it finds, the chunker also provides the probability with which each word is believed to be part of the entity. These probabilities are subsequently used to discard tuples containing entities found with low levels of confidence. Finally, each candidate tuple t is presented to the classifier. If the classifier labels t as trustworthy, it is extracted and stored by TEXTRUNNER, for input to Redundancy-Based Assessor 21.
Redundancy-Based Assessor
During the extraction process, TEXTRUNNER creates a normalized form of the relation that omits non-essential modifiers to verbs and nouns, e.g. “was developed by” as a normalized form of “was originally developed by.” After extraction has been performed over the entire corpus of text 11, TEXTRUNNER automatically merges tuples, in which both entities (or objects) and the normalized relation between the entities are identical and counts the number of distinct sentences (or sentence-like text) from which each extraction was found.
Following extraction, Redundancy-Based Assessor 21 uses these counts of distinct sentences to assign a probability to each tuple using a probabilistic model. Without hand-tagged data, the model efficiently estimates the probability that a tuple t=(ei, i,j, ej) is a correct instance of the relation i,j between ei and ej given that it was extracted from k different sentences (or sentence-like text). The model was shown to estimate far more accurate probabilities for IE than noisy-or and point-wise mutual information-based methods.
FIG. 2A illustrates several exemplary tuples 10 corresponding to a portion of an extraction graph produced by the present approach. In a first tuple, an entity 12 (Heisenberg) is coupled with an entity 14 (Oppenheimer) by a relationship 16 (spoke with). Entity 14 is also coupled to an entity 18 (American Scientist) by a relationship 20 (is a), with an entity 22 (Berkeley) by a relationship 24 (hired), and to an entity 26 (Physicist) by a relationship 28 (worked as).
Exemplary Logical Steps for Implementing Unsupervised Extraction of Relationships
FIG. 7 is a flowchart 100 that illustrates exemplary logical steps for carrying out the process discussed above. The process starts by using training data 104, which may comprise a few thousand sentences of text and which may optionally be simply a subset of a much larger corpus of text 102. The corpus of text can be many millions of sentences or phrases of text (terabytes of data), and is contemplated, for example, to comprise all of the text included on the entire World Wide Web. Using the training data, a Self-Supervised Learner 106 creates an extraction classifier 108. Details of exemplary logical steps employed for creating the extraction classifier are explained below and are shown in FIG. 8.
Corpus of text 102 is accessed by a single-pass extractor 110, which determines extraction candidates 112, as discussed above. Each extraction candidate will include at least two entities or objects that are coupled by at least one relationship. The extraction candidates found in the corpus of text are then input to extraction classifier 108. The extraction classifier determines whether each extraction candidate or tuple is trustworthy or not, based upon a probability that the tuple correctly indicates a relationship between the one or more objects or entities comprising the tuple. A decision step 114 determines if each extraction is trustworthy and should be retained and included in retained extractions 118, or is untrustworthy and should be discarded as indicated in a step 116. This decision is based upon whether the probability, P, assigned to the candidate extraction or tuple is greater than some predefined limit, t. An assessor 120 (e.g., a Redundancy-Based Assessor) then assesses whether each tuple included in the retained extraction 118 should be included in an extraction graph 122, based upon the count of distinct sentences or phrases in which each retained extracted tuple was found. This assessment assigns a probability to each tuple using a probabilistic model, to estimate the probability that a tuple is a correct instance of the relationship indicated in the tuple, as a function of the number of distinct sentences (or sentence-like text) from which the tuple was extracted.
Query Processing
TEXTRUNNER is capable of responding to queries over millions of tuples at interactive speeds due to an inverted index distributed over a pool of machines. Each relation found during tuple extraction is assigned to a single machine in the pool. Every machine then computes an inverted index over the text of the locally-stored tuples, ensuring that each machine is guaranteed to store all of the tuples containing a reference to any relation assigned to that machine.
FIG. 2B illustrates a simple example that shows how an inverted index over tuple text 30 enables a spreading activation algorithm to efficiently find all tuples (or triples in this example) that include specified search terms. In this example, the objects or entities are listed in a column 32, next to the tuples in which those terms are included. An exemplary query includes the terms, “American,” “Berkeley,” and “Physicist,” all of which have entries in the inverted index (as shown by the tuples illustrated to the left of the inverted index, which correspond to those in FIG. 2A). Retrieving graph regions that contain search terms enables spreading activation to quickly reach other nodes within the regions. In the illustrated example, the node “Oppenheimer” (i.e., entity 14) will score very highly since it receives activation from all three query terms, which correspond respectively to entities 18, 22, and 26 and respectively comprise tuples t90, t55, and t812.
The efficient indexing of tuples in TEXTRUNNER means that when a user (or application) wants to access a subset of tuples by naming one or more of its elements, the relevant subset can be retrieved in a manner of seconds, and irrelevant extractions remain unrevealed to the user. Since the relation names in TEXTRUNNER are drawn directly from the text, the intuitions that they implicitly use in formulating a search query are effective. Querying relational triples will be easier once TEXTRUNNER is able to know which relations are synonymous with others. However, asking the user to “guess the right word” to use in a query is a problem that is shared by most search engines, which suggests that it is manageable for naive users.
Finally, TEXTRUNNER's relation-centric index enables complex relational queries that are not currently possible using a standard inverted index used by today's search engines. These include relationship queries, unnamed-item queries, and multiple-attribute queries, each of which is well known to those of ordinary skill in the art.
Analysis
Tuple extraction in TEXTRUNNER happens in O(D) time, where D is the number of documents in the corpus. It subsequently takes O(T log T) time to sort, count, and assess the set of T tuples found by the system. In contrast, each time a traditional IE system is asked to find instances of a new set of relations R, it may be forced to examine a substantial fraction of the documents in the corpus, making system run-time equal to O(R·D). Thus, when D and R are large, as is typically the case on the Web, TEXTRUNNER's ability to extract information for all relations at once, without having them named explicitly in its input, results in a significant scalability advantage over previous IE systems (including KNOWITALL).
TEXTRUNNER extracts facts at an average speed of 0.036 CPU seconds per sentence. Compared to dependency parsers, which take an average of 3 seconds to process a single sentence, TEXTRUNNER runs more than 80 times faster on the corpus of text used when testing it. On average, a Web page in this corpus of text contains 18 sentences, making TEXTRUNNER's average processing speed per document equal to about 0.65 CPU seconds and the total CPU time to extract tuples from the 9 million Web page corpus of text less than 68 CPU hours. Because the corpus of text used in this test is easily divided into separate chunks, the total time for the process on a 20 machine cluster was less than 4 hours. It takes an additional 5 hours for TEXTRUNNER to merge and sort the extracted tuples. The performance of TEXTRUNNER relative to the prior art Web IE system, KNOWITNOW, is compared in FIG. 3.
The key to TEXTRUNNER's scalability is processing time that is linear in D (and constant in R). But, as the above measurements show, TEXTRUNNER is not only scalable in theory, but is also fast in practice.
Exemplary System for Implementing OIE of the Web
FIG. 9 illustrates an exemplary computing system 200 that is suitable for use as a computing device employed for implementing the novel approach described above, i.e., for carrying out the unsupervised extraction of information from at least a part of the corpus of text stored on the Web. It will be appreciated that a plurality of computing systems 200 will likely be employed for creating and maintaining an extraction graph for the Web, since a single such system (with the processing power/speed currently available), is too slow to achieve the desired speed and efficiency to carry out this task. Instead, it is likely that hundreds of such computing systems will share in this task, enabling the extraction process to be carried out and updated in an acceptable time.
Computing system 200 includes a processor 212 that is coupled in communication with a generally conventional data bus 214. Also coupled to the data bus is a memory 216 that includes both random access memory (RAM) and read only memory (ROM). Machine instructions are loaded into memory 216 from storage on a hard drive 218 or from other suitable non-volatile memory, such as an optical disk or other optical or magnetic media. These machine instructions, when executed by processor 212 can carry out a plurality of different functions employed to implement the approach as described herein, as well as other functions.
An input/output (I/O) interface 220 that includes a plurality of different types of ports, such as serial, parallel, universal serial bus, PS/2, and Firewire ports, is coupled to data bus 214 and is in turn connected to one or more input devices 224, such as a keyboard, mouse, or other pointing device, enabling a user to interact with the computing system and to provide input and control the operation of the computing system. A display interface 222 couples a display device 226 to the data bus, enabling a browser program window and other graphic and text information to be displayed for viewing by a user, if computing system 200 comprises a client computing device. The computing system is coupled to a network and/or to the Internet 230 (or other wide area network) via a network interface 228, which couples to data bus 214. Through the network interface, the computing system is able to access at least a portion of the corpus of text that is stored on distributed storage at remote storage sites 232a-232n, wherein the subscript “n” on “remote storage site 232n” can be a very large number, e.g., indicating that there are more than 100's of thousands of remote storage sites being accessed to extract information from the corpus of text stored at least in part at those sites.
Experimental Results
Recall and error rate of TEXTRUNNER were compared with that of a closed IE system on a set of relations, as listed below. The more fascinating challenge of characterizing the far broader set of facts and relations extracted by TEXTRUNNER is also discussed below.
Comparison with a Traditional IE System
One means of evaluating Open IE is to compare its performance with an existing state-of-the-art Web IE system. For this comparison, KNOWITALL, which is an unsupervised IE system capable of performing large-scale extraction from the Web, was used. To control the experiments, both TEXTRUNNER and KNOWITALL were tested on the task of extracting facts from a 9 million Web page corpus of text.
Since KNOWITALL is a closed IE system, it was necessary to select a set of relations in advance. (The term “closed IE system” refers to the requirement to specify the set of relations found by an IE system up front.) The following 10 relations that could be found in at least 1,000 sentences in the corpus of text used were randomly selected, while manually filtering out relations that were overly vague (e.g., relations with words such as “includes”):















(<proper   noun>,   acquired,   <proper   noun>)



(<proper  noun>,  graduated  from,  <proper  noun>)



(<proper  noun>,  is  author  of,  <proper  noun>)



(<proper  noun>,  is  based  in,  <proper  noun>)



(<proper    noun>,   studied,   <noun   phrase>)



(<proper   noun>,   studied  at,   <proper   noun>)



(<proper  noun>,  was  developed  by,  <proper  noun>)



(<proper   noun>,   was   formed   in,   <year>)



(<proper  noun>,  was  founded  by,  <proper  noun>)



(<proper noun>, worked with, <proper noun>)










Table 1, which is included below, shows the average error rate over the ten relations and the total number of correct extractions for each of the two systems. TEXTRUNNER's average error rate is 33% lower than KNOWITALL's, but it finds an almost identical number of correct extractions. TEXTRUNNER's improvement over KNOWITALL can be largely attributed to its ability to better identify appropriate arguments to relations.










TABLE 1







Average Error Rate
Correct Extractions




















TEXTRUNNER
12%
11,476



KNOWITALL
18%
11,631










Still, a large proportion of the errors of both systems were from noun phrase analysis, where arguments were truncated or stray words added. It is difficult to find extraction boundaries accurately when the intended type of arguments such as company names, person names, or book titles are not specified to the system. This concern was particularly true for the “author of relation,” where many arguments reflecting book titles were truncated and the error rate was 32% for TEXTRUNNER and 47% for KNOWITALL. With this outlier excluded, the average error rate is 10% for TEXTRUNNER and 16% for KNOWITALL.
Even when extracting information for only ten relations, TEXTRUNNER's efficiency advantage is apparent. Although they were run over the same 9 million page corpus, TEXTRUNNER's distributed extraction process took a total of 85 CPU hours to perform extraction for all relations in the corpus at once, whereas KNOWITALL, which analyzed all sentences in the corpus that potentially matched its rules, took an average of 6.3 CPU hours per relation. In the amount of time that KNOWITALL can extract data for 14 pre-specified relations, TEXTRUNNER discovers orders of magnitude more relations that are not pre-specified, from the same corpus.
Beyond the ten relations sampled, there is a fundamental difference between the two systems. Standard IE systems can only operate on relations given to them a priori by the user and are only practical for a relatively small number of relations. In contrast, Open IE operates without knowing the relations a priori and extracts information from all relations at once.
Global Statistics on Facts Learned
Given a corpus of 9 million Web pages, containing 133 million sentences, TEXTRUNNER automatically extracted a set of 60.5 million tuples at an extraction rate of 2.2 tuples per sentence.
When analyzing the output of open IE systems such as TEXTRUNNER, several questions naturally arise. How many of the tuples found represent actual relationships with plausible arguments? What subset of these tuples is correct? How many of these tuples are distinct, as opposed to identical or synonymous? Answering these questions is challenging due to both the size and diversity of the tuple set. As explained below, a series of estimates and approximations were made in order to address such questions.
As a first step, the analysis was restricted to the subset of tuples that TEXTRUNNER extracted with high probability. Specifically, the tuples that were evaluated met the following criteria: (1) TEXTRUNNER assigned a probability of at least 0.8 to the tuple; (2) the tuple's relation is supported by at least 10 distinct sentences in the corpus; (3) the tuple's relation is not found to be in the top 0.1% of relations by number of supporting sentences. (These relations were so general as to be nearly vacuous, such as (NP1, has, NP2).) This filtered set includes 11.3 million tuples containing 278,085 distinct relation strings and is the filtered set used in all the measurements described herein.
Estimating the Correctness of Facts
Four hundred tuples were randomly selected from the filtered set as a sample. The measurements below are extrapolated, based on hand tagging the sample. The tuples were then manually inspected in order to characterize the data extracted by TEXTRUNNER. Each evaluator first judged whether the relation was well-formed. A relation r is considered to be well-formed if there is some pair of entities X and Y such that (X, r, Y) is a relation between X and Y. For example, (FCI, specializes in, software development) contains a well-formed relation, but (demands, of securing, border) does not. If a tuple was found to possess a well-formed relation, it was then judged to see if the arguments were reasonable for the relation. X and Y are well-formed arguments for the relation r if X and Y are of a “type” of entity that can form a relation (X, r, Y). An example of a tuple whose arguments are not well-formed is (29, dropped, instruments).
The tuples that met these criteria were then further classified as either concrete or abstract. Concrete means that the truth of the tuple is grounded in particular entities, for example, (Tesla, invented, coil transformer). Abstract tuples are underspecified, such as (Einstein, derived, theory), or refer to entities specified elsewhere, but imply properties of general classes, such as (executive, hired by, company).
Finally, each concrete or abstract tuple was judged as true or false, based on whether it was consistent with the truth value of the sentence from which it was extracted. FIG. 3 summarizes this analysis of the extracted tuples. As indicated therein, about 11.3 million tuples were extracted from a limited corpus of text that included 9 million exemplary Web pages. Of these, about 9.3 tuples were found to have a well-formed relationship between the entities in the tuples, and about 7.8 million facts were found having both a well-formed relation and arguments (or entities) and a probability at least 0.8. Of those facts or tuples, 80.4% were deemed to be correct, according to human reviewers. Within a given relation, an average of 14% of the tuples (i.e., about 1 million) were deemed to be concrete facts, of which 88.1% are correct, and about 79.2% (or about 6.8 million tuples) were deemed to be abstract facts, of which about 77.2% were determined to be correct. Concrete facts are potentially useful for information extraction or question answering, while abstract assertions are useful for ontology learning and other applications. Of course, only a small subset of the universe of tuples would be of interest in any particular application (e.g., the tuples corresponding to the relations in the experiment described above).
Estimating the Number of Distinct Facts
Of the millions of tuples extracted by TEXTRUNNER, how many reflect distinct statements as opposed to reformulations of existing extractions? In order to answer this question, it is necessary to be able to detect when one relation is synonymous with another, as well as when an entity is referred to by multiple names. Both problems are very difficult in an unsupervised, domain-independent context, with a very large number of relations and entities of widely varying types. In these evaluative measurements, it was only possible to address relation synonymy, which means that the measurements reported below should be viewed as rough approximations.
In order to assess the number of distinct relations found by TEXTRUNNER, relations differing only in leading or trailing punctuation, auxiliary verbs, or in leading stopwords such as that, who, and which were further merged. For example, “are consistent with” is merged with, “which is consistent with.” Also merged were relations differing only by their use of active and passive voice (e.g., invented is merged with was invented by). This procedure reduced the number of distinct relations to 91% of the number before merging.
Even after implementing the above-described merge, the question remains: how many of the relation strings are synonymous? This question is exceedingly difficult to answer because many of the relations that TEXTRUNNER finds have multiple senses. The relation developed, for example, may be a relation between a person and an invention but also between a person and a disease. It is rare to find two distinct relations that are truly synonymous in all senses of each phrase, unless domain-specific type checking is performed on one or both arguments. If the first argument is the name of a scientist, then developed is very likely to be synonymous with invented and created, and is closely related to patented. Without such argument type checking, these relations will pick out overlapping, but quite distinct sets of tuples. (Several preliminary experiments were carried out using a data-driven approach to synonym discovery based on a known approach for discovering inference rules from text that confirmed this hypothesis.)
It is, however, easier for a human to assess similarity at the tuple level, where context in the form of entities grounding the relationship is available. In order to estimate the number of similar facts extracted by TEXTRUNNER, the process began with the filtered set of 11.3 million tuples. For each tuple, clusters were found of concrete tuples, of the form:

(e1,r,e2),(e1,q,e2) where r=6q

that is, tuples where the entities match, but the relation strings are distinct. It was found that only one third of the tuples belonged to such “synonymy clusters.”

Next, 100 synonymy clusters were randomly sampled and a manual process was carried out to determine how many distinct facts existed within each cluster. For example, the cluster of four tuples below describes two distinct relations R1 and R2 between Bletchley Park and Station X, as follows:
R1 (Bletchley Park, was location of, Station X)
R2 (Bletchley Park, being called, Station X)
R2 (Bletchley Park, known as, Station X)
R2 (Bletchley Park, codenamed, Station X)
Overall, it was found that roughly one quarter of the tuples in the sample were reformulations of other tuples contained somewhere in the filtered set of 11.3 million tuples. Given the previous measurement that two thirds of the concrete fact tuples do not belong to synonymy clusters, it can be computed that roughly 92% of the tuples found by TEXTRUNNER express distinct assertions. As pointed out earlier, this is an overestimate of the number of unique facts because the impact of multiple entity names is not factored into the result.
CONCLUSIONS
The preceding discussion discloses an exemplary approach to implement Open IE from the Web, using an unsupervised extraction paradigm that eschews relation-specific extraction in favor of a single extraction pass over the corpus of text, during which relations of interest are automatically discovered and efficiently stored. Unlike traditional IE systems that repeatedly incur the cost of analysis of the corpus of text with the naming of each new relation, the approach for implementing Open IE with a one-time relation discovery procedure enables a user to name and explore relationships at interactive speeds.
The preceding discussion also introduces TEXTRUNNER, an exemplary fully implemented Open IE system, and demonstrates its ability to extract massive amounts of high-quality information from a nine million Web page corpus of text. It has been shown that TEXTRUNNER is able to match the recall of the KNOWITALL state-of-the-art Web IE system, while achieving higher precision.
Although the concepts disclosed herein have been described in connection with the preferred form of practicing them and modifications thereto, those of ordinary skill in the art will understand that many other modifications can be made thereto within the scope of the claims that follow. Accordingly, it is not intended that the scope of these concepts in any way be limited by the above description, but instead be determined entirely by reference to the claims that follow.

## Claims

1. A method for unsupervised determination of relational information from a corpus of text, comprising the steps of:
(a) employing a first module that develops a heuristic model configured for extracting relationships from text, each relationship comprising a tuple;
(b) employing a second module that uses an extractor and the heuristic model to automatically discover and extract a plurality of tuples from the corpus of text, wherein the extractor provides the plurality of tuples by tagging at least a portion of words within the corpus of text with each tagged word's most probable part of speech, without parsing the corpus of text and without generating a parse tree; and
(c) providing one or more of the unparsed tuples in response to a query.

2. The method of claim 1, further comprising the step of automatically creating means for ranking a quality of the plurality of tuples extracted from the corpus of text, each tuple including a plurality of objects and at least one relationship that connects the plurality of objects.

3. The method of claim 2, further comprising the step of automatically applying the means for ranking to assess the quality of each of the tuples that is automatically extracted from the corpus of text.

4. The method of claim 3, further comprising the step of automatically determining which of the tuples will be retained, based upon the quality of each tuple that is assessed by the means for ranking.

5. The method of claim 1, wherein the step of using the heuristic model to automatically discover and extract the plurality of tuples comprises the step of automatically identifying nouns and verbs in sentence-like text found in the corpus of text, the nouns that are identified prospectively comprising objects, and the verbs prospectively comprising relationships between the objects.

6. The method of claim 4, wherein the step of automatically applying the means for ranking comprises the step of using a probability model to determine a probability that the relationship between objects in each tuple that has been extracted is trustworthy or not trustworthy.

7. The method of claim 6, wherein the step of automatically determining which of the tuples will be retained comprises the step of only retaining tuples for which the relationship has been determined to be trustworthy, the probability thus comprising an indication of the quality of the tuple.

8. The method of claim 2, wherein the step of automatically creating the means for ranking comprises the steps of:
(a) for training data, using a parser to automatically identify objects and relationships of each tuple in the training data and to label each tuple in the training data as either trustworthy or not trustworthy in regard to a relationship between the plurality of objects comprising the tuple; and
(b) using the tuples that have thus been labeled as a training example for the means for ranking that will be employed to determine the quality of the tuples extracted from the corpus of text, so that the means for ranking learns in an unsupervised manner from the training example how to classify tuples extracted from the corpus of text, in regard to their quality.

9. The method of claim 8, wherein the means for ranking comprises an independent feature model classifier that is automatically trained without human interaction.

10. A memory medium on which computer executable machine instructions are stored, for carrying out the steps of claim 1.

11. A method for automatically extracting relational information from a corpus of text with a computing device without specifying criteria or patterns for controlling extraction of the relational information by the computing device, comprising the steps of:
(a) employing a first module that determines a set of linguistic features that are domain independent and which can be used to extract relationships between objects from text; and
(b) employing a second module that uses an extractor and the linguistic features to automatically extract a plurality of tuples from the corpus of text, each tuple including a plurality of objects connected by at least one relationship, wherein the extractor provides the plurality of tuples by tagging at least a portion of words within the corpus of text with each tagged word's most probable part of speech, without parsing the corpus of text and without generating a parse tree.

12. The method of claim 11, wherein the step of determining the set of linguistic features is automatically carried out by the computing device without using manually input tagged examples, and without manual intervention.

13. The method of claim 11, further comprising the step of automatically learning to identify extracted relationships between objects as being either trustworthy or not trustworthy, by labeling relationships extracted from a relatively small set of training data as trustworthy or not.

14. The method of claim 13, based upon an ability to rank relationships that was learned with the small set of training data, further comprising the step of automatically producing a ranking model that can characterize each relationship extracted from the corpus of text in regard to a quality of the relationship.

15. The method of claim 14, further comprising the step of applying the ranking model to automatically learn to assess the tuples that are extracted in regard to the quality of the relationships of the tuples, to determine which tuples are to be retained.

16. The method of claim 15, further comprising the step of assessing a probability for each tuple that is to be retained as extracted relational information for the corpus of text, based upon a probabilistic model that indicates a level of confidence for the tuple.

17. The method of claim 15, wherein the step of automatically learning to assess comprises the steps of:
(a) automatically labeling each relationship extracted from the training data as either positive or negative, producing labeled data; and
(b) training an independent feature model using the labeled data, so that the independent feature model is used to determine the quality of the relationships indicated by the tuples, in regard to whether each of the relationships of the tuples extracted from the corpus of text is trustworthy or not trustworthy.

18. The method of claim 17, wherein the independent feature model comprises a Naive Bayes classifier that operates without manual supervision and is thus self-supervised.

19. The method of claim 11, further comprising the step of mapping each tuple extracted from the corpus of text to a feature vector representation, wherein all features are domain independent.

20. The method of claim 16, wherein the step of automatically extracting tuples from the corpus of text comprises the step of carrying out a single pass through the corpus of text in which words are automatically tagged in regards to a most probable part-of-speech, and wherein nouns are identified as being possible objects in a tuple.

21. The method of claim 20, wherein the step of automatically extracting tuples comprises the step of employing a noun chunker to automatically identify objects that comprise each of the tuples extracted from the corpus of text.

22. The method of claim 21, further comprising the step of employing the noun chunker for automatically determining a probability that each word identified in a possible noun phrase, is a noun that actually represents an object in a tuple.

23. The method of claim 22, further comprising the step of using the probability that was automatically determined, to discard tuples that include objects having an unacceptably low level of confidence, because the probability determined for one or more nouns comprising the objects of the tuple is below a predefined value.

24. The method of claim 21, wherein the step of automatically extracting further comprises the steps of:
(a) creating a normalized form of relationships in each tuple that is extracted, by omitting non-essential modifiers of verbs and nouns in the tuple;
(b) merging tuples in which objects and their normalized relationships are substantially identical; and
(c) counting a number of distinct sentences included in the corpus of text from which each retained tuple was extracted.

25. The method of claim 24, wherein the step of assessing a probability for each tuple that is to be retained with the probabilistic model comprises the step of using a count of the number of distinct sentences that was determined to assess the quality of the tuple.

26. The method of claim 15, further comprising the step of computing an inverted index over the tuples that have been retained to facilitate responding to queries, for accessing the information provided within an extraction graph comprising the retained tuples.

27. A memory medium on which computer executable machine instructions are stored, for carrying out the steps of claim 11.

28. A system for automatically extracting relational information from a corpus of text without specifying criteria or patterns for controlling extraction of the relational information, comprising:
(a) a memory in which a plurality of machine instructions are stored;
(b) a storage in which a corpus of text is stored;
(c) an interface for coupling to the storage; and
(d) a processor that is coupled to the memory and also coupled to the storage through the interface, the processor executing the machine instructions stored in the memory to carry out a plurality of functions, including:
(i) employing a first module that determines a set of linguistic features that are domain independent and which can be used to extract relationships between objects from text; and
(ii) employing a second module that uses an extractor and the linguistic features to automatically extract a plurality of tuples from the corpus of text, each tuple including a plurality of objects connected by at least one relationship, wherein the extractor provides the plurality of tuples by tagging at least a portion of words within the corpus of text with each tagged word's most probable part of speech, without parsing the corpus of text and without generating a parse tree.

29. The system of claim 28, wherein the machine instructions further cause the processor to determine the linguistic features automatically without using manually input tagged examples, and without manual intervention.

30. The system of claim 28, wherein the machine instructions further cause the processor to automatically learn to rank extracted relationships between objects, by identifying relationships extracted from training data, as being either trustworthy or not trustworthy.

31. The system of claim 30, wherein based upon ranking results learned from the training data, the machine instructions further cause the processor to automatically implement a ranking function that can characterize each relationship extracted from the corpus of text in regard to a quality of the relationship connecting the objects.

32. The system of claim 31, wherein the machine instructions further cause the processor to apply the ranking function to automatically rank the tuples that are extracted in regard to the quality of the relationships indicated for the tuples, the quality assigned by the ranking function to a tuple being used to determine if the tuple will be retained.

33. The system of claim 32, wherein the machine instructions further cause the processor to assess a probability for each tuple that is to be retained, based upon a probabilistic model that depends on the quality of the relationships for the retained tuples and upon a number of distinct instances from which each tuple was extracted, wherein the probability indicates a likelihood that the retained tuple indicates a correct instance of the relationship between the objects included in the retained tuple.

34. The system of claim 31, wherein the machine instructions further cause the processor to:
(a) automatically label each relationship extracted from the training data as either positive or negative, producing labeled data; and
(b) train an independent feature model function using the labeled data, so that the independent feature model function is used for implementing the ranking function to determine the quality of the relationships indicated by the tuples, in regard to whether each of the relationships of the tuples extracted from the corpus of text is trustworthy or not, and thus, whether each tuple extracted will be retained.

35. The system of claim 34, wherein the independent feature model function comprises a Naive Bayes classifier that operates without manual supervision and is thus self-supervised.

36. The system of claim 28, wherein the machine instructions further cause the processor to map each tuple extracted from the corpus of text to a feature vector representation, wherein all features are domain independent.

37. The system of claim 28, wherein the machine instructions cause the processor to make a single pass through the corpus of text, while automatically tagging words included therein in regards to a most probable part-of-speech, and wherein nouns are identified as being possible objects included in a tuple.

38. The system of claim 37, wherein the machine instructions cause the processor to employ a noun chunker to automatically identify objects comprising each of the tuples that are extracted from the corpus of text.

39. The system of claim 38, wherein the machine instructions cause the processor to employ the noun chunker to automatically determine a probability with which each word identified as possibly comprising a noun phrase is a noun that actually represents an object in a tuple.

40. The system of claim 39, wherein the machine instructions cause the processor to use the probability to discard tuples that include objects having a low level of confidence, because the probability determined for one or more nouns respectively comprising one or more of the objects of the tuple, is below a predefined value.

41. The system of claim 28, wherein the machine instructions cause the processor to:
(a) create a normalized form of relationships in each tuple that is extracted, by omitting non-essential modifiers of verbs and nouns in the tuple;
(b) merge tuples for which objects and their normalized relationships are substantially identical; and
(c) count a number of distinct sentences included in the corpus of text from which each retained tuple was extracted.

42. The system of claim 41, wherein the machine instructions further cause the processor to use the number of distinct sentences that were counted to assess a quality of each tuple, to determine whether the tuple will be retained.

43. The system of claim 32, wherein the machine instructions further cause the processor to compute an inverted index over the tuples that have been retained, to facilitate responding to queries by accessing the information provided by the tuples.

44. The system of claim 28, wherein the interface couples the processor to a network over which the storage of the corpus of text is distributed.

45. The system of claim 44, wherein the storage for the corpus of text is distributed over a plurality of servers that are accessed via the Internet.

46. The system of claim 28, wherein the machine language instructions further cause the processor to process queries to return information related to one or more of the objects in the tuples extracted from the corpus of text.

47. A system that executes software to automatically extract relational information from a corpus of text, without operator supervision and without regard to a domain of the information, comprising:
(a) in a first module, a self-supervising learning function that learns from training data how to classify information that will be extracted from the corpus of text as being trustworthy or not trustworthy, the self-supervising learning function producing a classifier;
(b) in a second module, an extractor that makes a pass through the corpus of text and extracts candidate tuples, each candidate tuple including a plurality of objects coupled by at least one possible relationship, wherein the extractor provides the candidate tuples by tagging at least a portion of words within the corpus of text with each tagged word's most probable part of speech, without parsing the corpus of text and without generating a parse tree, the classifier processing each candidate tuple to determine if the candidate tuple is trustworthy, producing a set of retained tuples comprising all of the candidate tuples that have been determined by the classifier to be trustworthy; and
(c) in a third module, a redundancy-based assessor that assigns a probability to each retained tuple, the probability being indicative of a likelihood that the retained tuple is an actual instance of a relationship between the plurality of objects comprising the retained tuple.

48. The system of claim 47, wherein the self-supervised learning function uses a parser and heuristics to extract objects and relationships between the objects included in the training data and then labels the relationships between the objects that were extracted as being either trustworthy or not, to teach the classifier to determine if the candidate tuples extracted from the corpus of text are trustworthy or not.

49. The system of claim 47, wherein the extractor processes the corpus of text to tag words included therein as a most probable part-of-speech and then employs a noun chunker to identify noun phrases from which the candidate tuples are extracted.

50. The system of claim 49, wherein the noun chunker heuristically eliminates non-essential phrases when extracting the candidate tuples during the pass through the corpus of text.

51. The system of claim 47, wherein the redundancy-based assessor counts a number of distinct instances of each retained tuple extracted from the corpus of text, and based at least in part upon the number of distinct instances counted, the redundancy-based assessor determines the probability that the relationship between the plurality of objects comprising the retained tuple has been correctly identified.