Upload 16 files

evaluation_data/carb/oie_readers/allennlpReader.py

@@ -0,0 +1,86 @@
+from .oieReader import OieReader
+from .extraction import Extraction
+import math
+import os
+import ipdb
+
+class AllennlpReader(OieReader):
+    
+    def __init__(self, threshold=None):
+        self.name = 'Allennlp'
+        self.threshold = threshold
+    
+    def read(self, fn):
+        d = {}
+        # with open(fn) as fin:
+        if os.path.exists(fn):
+            # print("reading from file")
+            fin = open(fn)
+        else:
+            # print("reading from string")
+            fin = fn.strip().split('\n')
+        
+        for line in fin:
+            '''
+            data = line.strip().split('\t')
+            confidence = data[0]
+            if not all(data[2:5]):
+                continue
+            arg1, rel = [s[s.index('(') + 1:s.index(',List(')] for s in data[2:4]]
+            #args = data[4].strip().split(');')
+            #print arg2s
+            args = [s[s.index('(') + 1:s.index(',List(')] for s in data[4].strip().split(');')]
+            # if arg1 == "the younger La Flesche":
+            #    print len(args)
+            text = data[5]
+            if data[1]:
+                #print arg1, rel
+                s = data[1]
+                if not (arg1 + ' ' + rel).startswith(s[s.index('(') + 1:s.index(',List(')]):
+                    #print "##########Not adding context" 
+                    arg1 = s[s.index('(') + 1:s.index(',List(')] + ' ' + arg1
+                    #print arg1 + rel, ",,,,, ", s[s.index('(') + 1:s.index(',List(')] 
+            '''
+            # print(line)
+            line = line.strip().split('\t')
+            # print(line)
+            text = line[0]
+            try:
+                confidence = line[2]
+            except:
+                confidence = 0
+                # raise Exception('Unable to find confidence in line: ',line)
+            line = line[1]
+            try:
+                arg1 = line[line.index('<arg1>') + 6:line.index('</arg1>')]
+            except:
+                arg1 = ""
+            try:
+                rel = line[line.index('<rel>') + 5:line.index('</rel>')]
+            except:
+                rel = ""
+            try:
+                arg2 = line[line.index('<arg2>') + 6:line.index('</arg2>')]
+            except:
+                arg2 = ""
+
+            if(type(self.threshold) != type(None) and float(confidence) < self.threshold):
+                continue
+
+            if not ( arg1 or arg2 or rel):
+                continue
+            #confidence = 1
+            #print(arg1, rel, arg2, confidence)
+            # curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = -1/float(confidence))
+            # curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = math.exp(float(confidence)))
+            curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = float(confidence))
+            curExtraction.addArg(arg1)
+            curExtraction.addArg(arg2)
+            #for arg in args:
+            #    curExtraction.addArg(arg)
+            d[text] = d.get(text, []) + [curExtraction]
+        
+        if os.path.exists(fn):
+            fin.close()
+        # print(d)
+        self.oie = d

evaluation_data/carb/oie_readers/argument.py

@@ -0,0 +1,21 @@
+import nltk
+from operator import itemgetter
+
+class Argument:
+    def __init__(self, arg):
+        self.words = [x for x in arg[0].strip().split(' ') if x]
+        self.posTags = map(itemgetter(1), nltk.pos_tag(self.words))
+        self.indices = arg[1]
+        self.feats = {}
+
+    def __str__(self):
+        return "({})".format('\t'.join(map(str,
+                                           [escape_special_chars(' '.join(self.words)),
+                                            str(self.indices)])))
+
+COREF = 'coref'
+
+## Helper functions
+def escape_special_chars(s):
+    return s.replace('\t', '\\t')
+

evaluation_data/carb/oie_readers/benchmarkGoldReader.py

@@ -0,0 +1,55 @@
+""" Usage:
+    benchmarkGoldReader --in=INPUT_FILE
+
+Read a tab-formatted file.
+Each line consists of:
+sent, prob, pred, arg1, arg2, ...
+
+"""
+
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+from docopt import docopt
+import logging
+
+logging.basicConfig(level = logging.DEBUG)
+
+class BenchmarkGoldReader(OieReader):
+
+    def __init__(self):
+        self.name = 'BenchmarkGoldReader'
+
+    def read(self, fn):
+        """
+        Read a tabbed format line
+        Each line consists of:
+        sent, prob, pred, arg1, arg2, ...
+        """
+        d = {}
+        ex_index = 0
+        with open(fn) as fin:
+            for line in fin:
+                if not line.strip():
+                    continue
+                data = line.strip().split('\t')
+                text, rel = data[:2]
+                curExtraction = Extraction(pred = rel.strip(),
+                                           head_pred_index = None,
+                                           sent = text.strip(),
+                                           confidence = 1.0,
+                                           question_dist = "./question_distributions/dist_wh_sbj_obj1.json",
+                                           index = ex_index)
+                ex_index += 1
+
+                for arg in data[2:]:
+                    curExtraction.addArg(arg.strip())
+
+                d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d
+
+
+if __name__ == "__main__":
+    args = docopt(__doc__)
+    input_fn = args["--in"]
+    tr = BenchmarkGoldReader()
+    tr.read(input_fn)

evaluation_data/carb/oie_readers/clausieReader.py

@@ -0,0 +1,90 @@
+""" Usage:
+    <file-name> --in=INPUT_FILE --out=OUTPUT_FILE [--debug]
+
+Convert to tabbed format
+"""
+# External imports
+import logging
+from pprint import pprint
+from pprint import pformat
+from docopt import docopt
+
+# Local imports
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+import ipdb
+#=-----
+
+class ClausieReader(OieReader):
+    
+    def __init__(self):
+        self.name = 'ClausIE'
+    
+    def read(self, fn):
+        d = {}
+        with open(fn, encoding="utf-8") as fin:
+            for line in fin:
+                data = line.strip().split('\t')
+                if len(data) == 1:
+                    text = data[0]
+                elif len(data) == 5:
+                    arg1, rel, arg2 = [s[1:-1] for s in data[1:4]]
+                    confidence = data[4]
+                    
+                    curExtraction = Extraction(pred = rel,
+                                               head_pred_index = -1,
+                                               sent = text,
+                                               confidence = float(confidence))
+
+                    curExtraction.addArg(arg1)
+                    curExtraction.addArg(arg2)
+                    d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d
+        # self.normalizeConfidence()
+
+        # # remove exxtractions below the confidence threshold
+        # if type(self.threshold) != type(None):
+        #     new_d = {}
+        #     for sent in self.oie:
+        #         for extraction in self.oie[sent]:
+        #             if extraction.confidence < self.threshold:
+        #                 continue
+        #             else:
+        #                 new_d[sent] = new_d.get(sent, []) + [extraction]
+        #     self.oie = new_d
+
+    
+    
+    def normalizeConfidence(self):
+        ''' Normalize confidence to resemble probabilities '''        
+        EPSILON = 1e-3
+        
+        confidences = [extraction.confidence for sent in self.oie for extraction in self.oie[sent]]
+        maxConfidence = max(confidences)
+        minConfidence = min(confidences)
+        
+        denom = maxConfidence - minConfidence + (2*EPSILON)
+        
+        for sent, extractions in self.oie.items():
+            for extraction in extractions:
+                extraction.confidence = ( (extraction.confidence - minConfidence) + EPSILON) / denom
+
+
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    args = docopt(__doc__)
+    inp_fn = args["--in"]
+    out_fn = args["--out"]
+    debug = args["--debug"]
+    if debug:
+        logging.basicConfig(level = logging.DEBUG)
+    else:
+        logging.basicConfig(level = logging.INFO)
+
+
+    oie = ClausieReader()
+    oie.read(inp_fn)
+    oie.output_tabbed(out_fn)
+
+    logging.info("DONE")

evaluation_data/carb/oie_readers/extraction.py

@@ -0,0 +1,443 @@
+from oie_readers.argument import Argument
+from operator import itemgetter
+from collections import defaultdict
+import nltk
+import itertools
+import logging
+import numpy as np
+
+
+class Extraction:
+    """
+    Stores sentence, single predicate and corresponding arguments.
+    """
+    def __init__(self, pred, head_pred_index, sent, confidence, question_dist = '', index = -1):
+        self.pred = pred
+        self.head_pred_index = head_pred_index
+        self.sent = sent
+        self.args = []
+        self.confidence = confidence
+        self.matched = []
+        self.questions = {}
+        self.indsForQuestions = defaultdict(lambda: set())
+        self.is_mwp = False
+        self.question_dist = question_dist
+        self.index = index
+
+    def distArgFromPred(self, arg):
+        assert(len(self.pred) == 2)
+        dists = []
+        for x in self.pred[1]:
+            for y in arg.indices:
+                dists.append(abs(x - y))
+
+        return min(dists)
+
+    def argsByDistFromPred(self, question):
+        return sorted(self.questions[question], key = lambda arg: self.distArgFromPred(arg))
+
+    def addArg(self, arg, question = None):
+        self.args.append(arg)
+        if question:
+            self.questions[question] = self.questions.get(question,[]) + [Argument(arg)]
+
+    def noPronounArgs(self):
+        """
+        Returns True iff all of this extraction's arguments are not pronouns.
+        """
+        for (a, _) in self.args:
+            tokenized_arg = nltk.word_tokenize(a)
+            if len(tokenized_arg) == 1:
+                _, pos_tag = nltk.pos_tag(tokenized_arg)[0]
+                if ('PRP' in pos_tag):
+                    return False
+        return True
+
+    def isContiguous(self):
+        return all([indices for (_, indices) in self.args])
+
+    def toBinary(self):
+        ''' Try to represent this extraction's arguments as binary
+        If fails, this function will return an empty list.  '''
+
+        ret = [self.elementToStr(self.pred)]
+
+        if len(self.args) == 2:
+            # we're in luck
+            return ret + [self.elementToStr(arg) for arg in self.args]
+
+        return []
+
+        if not self.isContiguous():
+            # give up on non contiguous arguments (as we need indexes)
+            return []
+
+        # otherwise, try to merge based on indices
+        # TODO: you can explore other methods for doing this
+        binarized = self.binarizeByIndex()
+
+        if binarized:
+            return ret + binarized
+
+        return []
+
+
+    def elementToStr(self, elem, print_indices = True):
+        ''' formats an extraction element (pred or arg) as a raw string
+        removes indices and trailing spaces '''
+        if print_indices:
+            return str(elem)
+        if isinstance(elem, str):
+            return elem
+        if isinstance(elem, tuple):
+            ret = elem[0].rstrip().lstrip()
+        else:
+            ret = ' '.join(elem.words)
+        assert ret, "empty element? {0}".format(elem)
+        return ret
+
+    def binarizeByIndex(self):
+        extraction = [self.pred] + self.args
+        markPred = [(w, ind, i == 0) for i, (w, ind) in enumerate(extraction)]
+        sortedExtraction = sorted(markPred, key = lambda ws, indices, f : indices[0])
+        s =  ' '.join(['{1} {0} {1}'.format(self.elementToStr(elem), SEP) if elem[2] else self.elementToStr(elem) for elem in sortedExtraction])
+        binArgs = [a for a in s.split(SEP) if a.rstrip().lstrip()]
+
+        if len(binArgs) == 2:
+            return binArgs
+
+        # failure
+        return []
+
+    def bow(self):
+        return ' '.join([self.elementToStr(elem) for elem in [self.pred] + self.args])
+
+    def getSortedArgs(self):
+        """
+        Sort the list of arguments.
+        If a question distribution is provided - use it,
+        otherwise, default to the order of appearance in the sentence.
+        """
+        if self.question_dist:
+            # There's a question distribtuion - use it
+            return self.sort_args_by_distribution()
+        ls = []
+        for q, args in self.questions.iteritems():
+            if (len(args) != 1):
+                logging.debug("Not one argument: {}".format(args))
+                continue
+            arg = args[0]
+            indices = list(self.indsForQuestions[q].union(arg.indices))
+            if not indices:
+                logging.debug("Empty indexes for arg {} -- backing to zero".format(arg))
+                indices = [0]
+            ls.append(((arg, q), indices))
+        return [a for a, _ in sorted(ls,
+                                     key = lambda _, indices: min(indices))]
+
+    def question_prob_for_loc(self, question, loc):
+        """
+        Returns the probability of the given question leading to argument
+        appearing in the given location in the output slot.
+        """
+        gen_question = generalize_question(question)
+        q_dist = self.question_dist[gen_question]
+        logging.debug("distribution of {}: {}".format(gen_question,
+                                                      q_dist))
+
+        return float(q_dist.get(loc, 0)) /  \
+            sum(q_dist.values())
+
+    def sort_args_by_distribution(self):
+        """
+        Use this instance's question distribution (this func assumes it exists)
+        in determining the positioning of the arguments.
+        Greedy algorithm:
+        0. Decide on which argument will serve as the ``subject'' (first slot) of this extraction
+        0.1 Based on the most probable one for this spot
+        (special care is given to select the highly-influential subject position)
+        1. For all other arguments, sort arguments by the prevalance of their questions
+        2. For each argument:
+        2.1 Assign to it the most probable slot still available
+        2.2 If non such exist (fallback) - default to put it in the last location
+        """
+        INF_LOC = 100 # Used as an impractical last argument
+
+        # Store arguments by slot
+        ret = {INF_LOC: []}
+        logging.debug("sorting: {}".format(self.questions))
+
+        # Find the most suitable arguemnt for the subject location
+        logging.debug("probs for subject: {}".format([(q, self.question_prob_for_loc(q, 0))
+                                                      for (q, _) in self.questions.iteritems()]))
+
+        subj_question, subj_args = max(self.questions.iteritems(),
+                                       key = lambda q, _: self.question_prob_for_loc(q, 0))
+
+        ret[0] = [(subj_args[0], subj_question)]
+
+        # Find the rest
+        for (question, args) in sorted([(q, a)
+                                        for (q, a) in self.questions.iteritems() if (q not in [subj_question])],
+                                       key = lambda q, _: \
+                                       sum(self.question_dist[generalize_question(q)].values()),
+                                       reverse = True):
+            gen_question = generalize_question(question)
+            arg = args[0]
+            assigned_flag = False
+            for (loc, count) in sorted(self.question_dist[gen_question].iteritems(),
+                                       key = lambda _ , c: c,
+                                       reverse = True):
+                if loc not in ret:
+                    # Found an empty slot for this item
+                    # Place it there and break out
+                    ret[loc] = [(arg, question)]
+                    assigned_flag = True
+                    break
+
+            if not assigned_flag:
+                # Add this argument to the non-assigned (hopefully doesn't happen much)
+                logging.debug("Couldn't find an open assignment for {}".format((arg, gen_question)))
+                ret[INF_LOC].append((arg, question))
+
+        logging.debug("Linearizing arg list: {}".format(ret))
+
+        # Finished iterating - consolidate and return a list of arguments
+        return [arg
+                for (_, arg_ls) in sorted(ret.iteritems(),
+                                          key = lambda k, v: int(k))
+                for arg in arg_ls]
+
+
+    def __str__(self):
+        pred_str = self.elementToStr(self.pred)
+        return '{}\t{}\t{}'.format(self.get_base_verb(pred_str),
+                                   self.compute_global_pred(pred_str,
+                                                            self.questions.keys()),
+                                   '\t'.join([escape_special_chars(self.augment_arg_with_question(self.elementToStr(arg),
+                                                                                                  question))
+                                              for arg, question in self.getSortedArgs()]))
+
+    def get_base_verb(self, surface_pred):
+        """
+        Given the surface pred, return the original annotated verb
+        """
+        # Assumes that at this point the verb is always the last word
+        # in the surface predicate
+        return surface_pred.split(' ')[-1]
+
+
+    def compute_global_pred(self, surface_pred, questions):
+        """
+        Given the surface pred and all instansiations of questions,
+        make global coherence decisions regarding the final form of the predicate
+        This should hopefully take care of multi word predicates and correct inflections
+        """
+        from operator import itemgetter
+        split_surface = surface_pred.split(' ')
+
+        if len(split_surface) > 1:
+            # This predicate has a modal preceding the base verb
+            verb = split_surface[-1]
+            ret = split_surface[:-1] # get all of the elements in the modal
+        else:
+            verb = split_surface[0]
+            ret = []
+
+        split_questions = map(lambda question: question.split(' '),
+                            questions)
+
+        preds = map(normalize_element,
+                    map(itemgetter(QUESTION_TRG_INDEX),
+                        split_questions))
+        if len(set(preds)) > 1:
+            # This predicate is appears in multiple ways, let's stick to the base form
+            ret.append(verb)
+
+        if len(set(preds)) == 1:
+            # Change the predciate to the inflected form
+            # if there's exactly one way in which the predicate is conveyed
+            ret.append(preds[0])
+
+            pps = map(normalize_element,
+                      map(itemgetter(QUESTION_PP_INDEX),
+                          split_questions))
+
+            obj2s = map(normalize_element,
+                        map(itemgetter(QUESTION_OBJ2_INDEX),
+                            split_questions))
+
+            if (len(set(pps)) == 1):
+                # If all questions for the predicate include the same pp attachemnt -
+                # assume it's a multiword predicate
+                self.is_mwp = True # Signal to arguments that they shouldn't take the preposition
+                ret.append(pps[0])
+
+        # Concat all elements in the predicate and return
+        return " ".join(ret).strip()
+
+
+    def augment_arg_with_question(self, arg, question):
+        """
+        Decide what elements from the question to incorporate in the given
+        corresponding argument
+        """
+        # Parse question
+        wh, aux, sbj, trg, obj1, pp, obj2 = map(normalize_element,
+                                                question.split(' ')[:-1]) # Last split is the question mark
+
+        # Place preposition in argument
+        # This is safer when dealing with n-ary arguments, as it's directly attaches to the
+        # appropriate argument
+        if (not self.is_mwp) and pp and (not obj2):
+            if not(arg.startswith("{} ".format(pp))):
+                # Avoid repeating the preporition in cases where both question and answer contain it
+                return " ".join([pp,
+                                 arg])
+
+        # Normal cases
+        return arg
+
+    def clusterScore(self, cluster):
+        """
+        Calculate cluster density score as the mean distance of the maximum distance of each slot.
+        Lower score represents a denser cluster.
+        """
+        logging.debug("*-*-*- Cluster: {}".format(cluster))
+
+        # Find global centroid
+        arr = np.array([x for ls in cluster for x in ls])
+        centroid = np.sum(arr)/arr.shape[0]
+        logging.debug("Centroid: {}".format(centroid))
+
+        # Calculate mean over all maxmimum points
+        return np.average([max([abs(x - centroid) for x in ls]) for ls in cluster])
+
+    def resolveAmbiguity(self):
+        """
+        Heursitic to map the elments (argument and predicates) of this extraction
+        back to the indices of the sentence.
+        """
+        ## TODO: This removes arguments for which there was no consecutive span found
+        ## Part of these are non-consecutive arguments,
+        ## but other could be a bug in recognizing some punctuation marks
+
+        elements = [self.pred] \
+                   + [(s, indices)
+                      for (s, indices)
+                      in self.args
+                      if indices]
+        logging.debug("Resolving ambiguity in: {}".format(elements))
+
+        # Collect all possible combinations of arguments and predicate indices
+        # (hopefully it's not too much)
+        all_combinations = list(itertools.product(*map(itemgetter(1), elements)))
+        logging.debug("Number of combinations: {}".format(len(all_combinations)))
+
+        # Choose the ones with best clustering and unfold them
+        resolved_elements = zip(map(itemgetter(0), elements),
+                                min(all_combinations,
+                                    key = lambda cluster: self.clusterScore(cluster)))
+        logging.debug("Resolved elements = {}".format(resolved_elements))
+
+        self.pred = resolved_elements[0]
+        self.args = resolved_elements[1:]
+
+    def conll(self, external_feats = {}):
+        """
+        Return a CoNLL string representation of this extraction
+        """
+        return '\n'.join(["\t".join(map(str,
+                                        [i, w] + \
+                                        list(self.pred) + \
+                                        [self.head_pred_index] + \
+                                        external_feats + \
+                                        [self.get_label(i)]))
+                          for (i, w)
+                          in enumerate(self.sent.split(" "))]) + '\n'
+
+    def get_label(self, index):
+        """
+        Given an index of a word in the sentence -- returns the appropriate BIO conll label
+        Assumes that ambiguation was already resolved.
+        """
+        # Get the element(s) in which this index appears
+        ent = [(elem_ind, elem)
+               for (elem_ind, elem)
+               in enumerate(map(itemgetter(1),
+                                [self.pred] + self.args))
+               if index in elem]
+
+        if not ent:
+            # index doesnt appear in any element
+            return "O"
+
+        if len(ent) > 1:
+            # The same word appears in two different answers
+            # In this case we choose the first one as label
+            logging.warn("Index {} appears in one than more element: {}".\
+                         format(index,
+                                "\t".join(map(str,
+                                              [ent,
+                                               self.sent,
+                                               self.pred,
+                                               self.args]))))
+
+        ## Some indices appear in more than one argument (ones where the above message appears)
+        ## From empricial observation, these seem to mostly consist of different levels of granularity:
+        ##     what	had	_	been taken	_	_	_	?	loan commitments topping $ 3 billion
+        ##     how much	had	_	been taken	_	_	_	?	topping $ 3 billion
+        ## In these cases we heuristically choose the shorter answer span, hopefully creating minimal spans
+        ## E.g., in this example two arguemnts are created: (loan commitments, topping $ 3 billion)
+
+        elem_ind, elem = min(ent, key = lambda _, ls: len(ls))
+
+        # Distinguish between predicate and arguments
+        prefix = "P" if elem_ind == 0 else "A{}".format(elem_ind - 1)
+
+        # Distinguish between Beginning and Inside labels
+        suffix = "B" if index == elem[0] else "I"
+
+        return "{}-{}".format(prefix, suffix)
+
+    def __str__(self):
+        return '{0}\t{1}'.format(self.elementToStr(self.pred,
+                                                   print_indices = True),
+                                 '\t'.join([self.elementToStr(arg)
+                                            for arg
+                                            in self.args]))
+
+# Flatten a list of lists
+flatten = lambda l: [item for sublist in l for item in sublist]
+
+
+def normalize_element(elem):
+    """
+    Return a surface form of the given question element.
+    the output should be properly able to precede a predicate (or blank otherwise)
+    """
+    return elem.replace("_", " ") \
+        if (elem != "_")\
+           else ""
+
+## Helper functions
+def escape_special_chars(s):
+    return s.replace('\t', '\\t')
+
+
+def generalize_question(question):
+    """
+    Given a question in the context of the sentence and the predicate index within
+    the question - return a generalized version which extracts only order-imposing features
+    """
+    import nltk   # Using nltk since couldn't get spaCy to agree on the tokenization
+    wh, aux, sbj, trg, obj1, pp, obj2 = question.split(' ')[:-1] # Last split is the question mark
+    return ' '.join([wh, sbj, obj1])
+
+
+
+## CONSTANTS
+SEP = ';;;'
+QUESTION_TRG_INDEX =  3 # index of the predicate within the question
+QUESTION_PP_INDEX = 5
+QUESTION_OBJ2_INDEX = 6

evaluation_data/carb/oie_readers/goldReader.py

@@ -0,0 +1,44 @@
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+from _collections import defaultdict
+import ipdb
+
+class GoldReader(OieReader):
+    
+    # Path relative to repo root folder
+    default_filename = './oie_corpus/all.oie' 
+    
+    def __init__(self):
+        self.name = 'Gold'
+    
+    def read(self, fn):
+        d = defaultdict(lambda: [])
+        with open(fn) as fin:
+            for line_ind, line in enumerate(fin):
+#                print line
+                data = line.strip().split('\t')
+                text, rel = data[:2]
+                args = data[2:]
+                confidence = 1
+                
+                curExtraction = Extraction(pred = rel.strip(),
+                                           head_pred_index = None,
+                                           sent = text.strip(),
+                                           confidence = float(confidence),
+                                           index = line_ind)
+                for arg in args:
+                    if "C: " in arg:
+                        continue
+                    curExtraction.addArg(arg.strip())
+                    
+                d[text.strip()].append(curExtraction)
+        self.oie = d
+        
+
+if __name__ == '__main__' :
+    g = GoldReader()
+    g.read('../oie_corpus/all.oie', includeNominal = False)
+    d = g.oie
+    e = d.items()[0]
+    print(e[1][0].bow())
+    print(g.count())

evaluation_data/carb/oie_readers/oieReader.py

@@ -0,0 +1,45 @@
+class OieReader:
+
+    def read(self, fn, includeNominal):
+        ''' should set oie as a class member
+        as a dictionary of extractions by sentence'''
+        raise Exception("Don't run me")
+
+    def count(self):
+        ''' number of extractions '''
+        return sum([len(extractions) for _, extractions in self.oie.items()])
+
+    def split_to_corpus(self, corpus_fn, out_fn):
+        """
+        Given a corpus file name, containing a list of sentences
+        print only the extractions pertaining to it to out_fn in a tab separated format:
+        sent, prob, pred, arg1, arg2, ...
+        """
+        raw_sents = [line.strip() for line in open(corpus_fn)]
+        with open(out_fn, 'w') as fout:
+            for line in self.get_tabbed().split('\n'):
+                data = line.split('\t')
+                sent = data[0]
+                if sent in raw_sents:
+                    fout.write(line + '\n')
+
+    def output_tabbed(self, out_fn):
+        """
+        Write a tabbed represenation of this corpus.
+        """
+        with open(out_fn, 'w') as fout:
+            fout.write(self.get_tabbed())
+
+    def get_tabbed(self):
+        """
+        Get a tabbed format representation of this corpus (assumes that input was
+        already read).
+        """
+        return "\n".join(['\t'.join(map(str,
+                                        [ex.sent,
+                                         ex.confidence,
+                                         ex.pred,
+                                         '\t'.join(ex.args)]))
+                          for (sent, exs) in self.oie.iteritems()
+                          for ex in exs])
+

evaluation_data/carb/oie_readers/ollieReader.py

@@ -0,0 +1,22 @@
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+
+class OllieReader(OieReader):
+    
+    def __init__(self):
+        self.name = 'OLLIE'
+    
+    def read(self, fn):
+        d = {}
+        with open(fn) as fin:
+            fin.readline() #remove header
+            for line in fin:
+                data = line.strip().split('\t')
+                confidence, arg1, rel, arg2, enabler, attribution, text  = data[:7]
+                curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = float(confidence))
+                curExtraction.addArg(arg1)
+                curExtraction.addArg(arg2)
+                d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d
+    
+

evaluation_data/carb/oie_readers/openieFiveReader.py

@@ -0,0 +1,38 @@
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+
+class OpenieFiveReader(OieReader):
+
+    def __init__(self):
+        self.name = 'OpenIE-5'
+    
+    def read(self, fn):
+        d = {}
+        with open(fn) as fin:
+            for line in fin:
+                data = line.strip().split('\t')
+                confidence = data[0]
+
+                if not all(data[2:5]):
+                    continue
+                arg1, rel = [s[s.index('(') + 1:s.index(',List(')] for s in data[2:4]]
+                #args = data[4].strip().split(');')
+                #print arg2s
+                args = [s[s.index('(') + 1:s.index(',List(')] for s in data[4].strip().split(');')]
+#                if arg1 == "the younger La Flesche":
+#                    print len(args)
+                text = data[5]
+                if data[1]:
+                    #print arg1, rel
+                    s = data[1]
+                    if not (arg1 + ' ' + rel).startswith(s[s.index('(') + 1:s.index(',List(')]):
+                        #print "##########Not adding context" 
+                        arg1 = s[s.index('(') + 1:s.index(',List(')] + ' ' + arg1
+                        #print arg1 + rel, ",,,,, ", s[s.index('(') + 1:s.index(',List(')] 
+                #curExtraction = Extraction(pred = rel, sent = text, confidence = float(confidence))
+                curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = float(confidence))
+                curExtraction.addArg(arg1)
+                for arg in args:
+                    curExtraction.addArg(arg)
+                d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d

evaluation_data/carb/oie_readers/openieFourReader.py

@@ -0,0 +1,59 @@
+""" Usage:
+    <file-name> --in=INPUT_FILE --out=OUTPUT_FILE [--debug]
+
+Convert to tabbed format
+"""
+# External imports
+import logging
+from pprint import pprint
+from pprint import pformat
+from docopt import docopt
+
+# Local imports
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+import ipdb
+
+#=-----
+
+class OpenieFourReader(OieReader):
+
+    def __init__(self):
+        self.name = 'OpenIE-4'
+
+    def read(self, fn):
+        d = {}
+        with open(fn) as fin:
+            for line in fin:
+                data = line.strip().split('\t')
+                confidence = data[0]
+                if not all(data[2:5]):
+                    logging.debug("Skipped line: {}".format(line))
+                    continue
+                arg1, rel, arg2 = [s[s.index('(') + 1:s.index(',List(')] for s in data[2:5]]
+                text = data[5]
+                curExtraction = Extraction(pred = rel, head_pred_index = -1, sent = text, confidence = float(confidence))
+                curExtraction.addArg(arg1)
+                curExtraction.addArg(arg2)
+                d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d
+
+
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    args = docopt(__doc__)
+    inp_fn = args["--in"]
+    out_fn = args["--out"]
+    debug = args["--debug"]
+    if debug:
+        logging.basicConfig(level = logging.DEBUG)
+    else:
+        logging.basicConfig(level = logging.INFO)
+
+
+    oie = OpenieFourReader()
+    oie.read(inp_fn)
+    oie.output_tabbed(out_fn)
+
+    logging.info("DONE")

evaluation_data/carb/oie_readers/propsReader.py

@@ -0,0 +1,44 @@
+from oie_readers.oieReader import OieReader
+from oie_readers.extraction import Extraction
+
+
+class PropSReader(OieReader):
+    
+    def __init__(self):
+        self.name = 'PropS'
+    
+    def read(self, fn):
+        d = {}
+        with open(fn) as fin:
+            for line in fin:
+                if not line.strip():
+                    continue
+                data = line.strip().split('\t')
+                confidence, text, rel = data[:3]
+                curExtraction = Extraction(pred = rel, sent = text, confidence = float(confidence), head_pred_index=-1)
+                
+                for arg in data[4::2]:
+                    curExtraction.addArg(arg)
+                    
+                d[text] = d.get(text, []) + [curExtraction]
+        self.oie = d
+        # self.normalizeConfidence()
+    
+    
+    def normalizeConfidence(self):
+        ''' Normalize confidence to resemble probabilities '''        
+        EPSILON = 1e-3
+        
+        self.confidences = [extraction.confidence for sent in self.oie for extraction in self.oie[sent]]
+        maxConfidence = max(self.confidences)
+        minConfidence = min(self.confidences)
+        
+        denom = maxConfidence - minConfidence + (2*EPSILON)
+        
+        for sent, extractions in self.oie.items():
+            for extraction in extractions:
+                extraction.confidence = ( (extraction.confidence - minConfidence) + EPSILON) / denom
+
+    
+    
+    

evaluation_data/carb/oie_readers/reVerbReader.py

@@ -24,4 +24,6 @@ class ReVerbReader(OieReader):
         
     # ReVerb requires a different files from which to get the input sentences
     # Relative to repo root folder
-    RAW_SENTS_FILE = './raw_sentences/all.txt'    
+    RAW_SENTS_FILE = './raw_sentences/all.txt'    
+
+

evaluation_data/carb/oie_readers/split_corpus.py

@@ -34,4 +34,4 @@ if __name__ == "__main__":
     reader = available_readers[args["--reader"]]()
     reader.read(inp)
     reader.split_to_corpus(corpus,
-                           out)
+                           out)

evaluation_data/carb/oie_readers/stanfordReader.py

@@ -19,4 +19,4 @@ class StanfordReader(OieReader):
                 curExtraction.addArg(arg1)
                 curExtraction.addArg(arg2)
                 d[text] = d.get(text, []) + [curExtraction]
-        self.oie = d
+        self.oie = d

evaluation_data/carb/oie_readers/tabReader.py

@@ -53,4 +53,4 @@ if __name__ == "__main__":
     args = docopt(__doc__)
     input_fn = args["--in"]
     tr = TabReader()
-    tr.read(input_fn)
+    tr.read(input_fn)