def main():
filename = sys.argv[1]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
# Uncomment to see output of parser
print "\nentities", par.entity_arguments
print "\npredicates", par.predicate_entities, par.predicate_arguments
print "\nfiles", par.files
print "\ngroupby", par.groupby
print "\nfeat_file:", par.femodule
print "\nfeat_class:", par.feclass
print "\ndb_file:", par.dbmodule
print "\ndb_class:", par.dbclass
print "\nsc_file:", par.scmodule
for i, ruleset in enumerate(par.rulesets):
print "\nRuleset # {0}\n".format(i)
if 'rule' in ruleset:
print "Rules"
for rule in ruleset['rule']:
print rule
print "\tfilters:", rule.filters
print "\tfeat_functions:", rule.feat_functions
print "\tdb_func:", rule.dbfunc
print "\tsc_func:", rule.scoring_function
print "\tlambda:", rule.lambda_
print "\ttarget:", rule.target
print "\tsplit_on:", rule.split_on
print "\tsplit_on_type:", rule.split_on_ttype
else:
print "No rules parsed"
if 'constr' in ruleset:
print "\nConstraints"
for rule in ruleset['constr']:
print rule
print "\tfilters:", rule.filters
else:
print "No constraints parsed"
def main():
if len(sys.argv) < 4:
sys.exit(
"Usage:" + " python " + sys.argv[0] +
" [rule file] [data path] [filter_file] [-arg1 arg, -arg2 arg, ...]"
)
filename = sys.argv[1]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
filter_ids = []
with open(sys.argv[3]) as f:
for line in f:
filter_ids.append(line.strip())
kwargs = {}
for i in range(4, len(sys.argv), 2):
kwargs[sys.argv[i][1:]] = sys.argv[i + 1]
db = Database()
path = sys.argv[2]
db.load_predicates(par.predicate_arguments, path, par.files)
db.load_labels(par.label_types.keys(), path, par.files)
for ruleset, group_by in zip(par.rulesets, par.groupby):
for i, rule_template in enumerate(ruleset):
X = []
Y = []
if rule_template.isconstr:
continue
mod = __import__(rule_template.feat_file,
fromlist=[rule_template.feat_class])
fe_class = getattr(mod, rule_template.feat_class)
if rule_template.head.isobs:
# multiclass
train_groundings = db.unfold_train_groundings(
rule_template, filter_by=(group_by, filter_ids))
else:
# binary
neg_train_groundings = db.unfold_train_groundings(
rule_template,
filter_by=(group_by, filter_ids),
neg_head=True)
pos_train_groundigs = db.unfold_train_groundings(
rule_template,
filter_by=(group_by, filter_ids),
neg_gead=False)
train_groundings = neg_train_groundings + pos_train_groundigs
fe = fe_class(train_groundings, **kwargs)
fe.build()
grd_x = fe.extract(train_groundings[0],
rule_template.feat_functions)
rule_template.feat_vector_sz = len(grd_x)
for instance_grd in train_groundings:
grd_x = fe.extract(instance_grd, rule_template.feat_functions)
X.append(grd_x)
# when multiclass I need a label for the output
if rule_template.head.isobs:
grd_y = fe.extract_multiclass_head(instance_grd)
Y.append(grd_y)
X = np.asarray(X)
Y = np.asarray(Y)
print X.shape, Y.shape
def main():
if len(sys.argv) < 3:
sys.exit("Usage:" + " python " + sys.argv[0] +
" [rule file] [data path] [dbmodulepath (optional)]")
#fout = open("testresult.txt", 'w')
filename = sys.argv[1]
path = sys.argv[2]
if len(sys.argv) > 3:
dbmodule_path = sys.argv[3]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
# Uncomment to see output of parser
print "predicates", par.predicate_arguments
print "labels", par.label_types.keys()
print "files", par.files
print "rulesets", par.rulesets
print "groupby", par.groupby
ruleset = par.rulesets[0]
group_by = par.groupby[0]
if par.dbmodule is None:
db = Database()
db.load_predicates(par.predicate_arguments, path, par.files)
db.load_predicates(par.entity_arguments, path, par.files)
db.load_labels(par.label_types.keys(), path, par.files)
db.predicate_entities = par.predicate_entities
print db.table_index
else:
module_path = os.path.join(dbmodule_path, "{0}.py".format(dbmodule))
mod = imp.load_source(par.dbmodule, module_path)
db_class = getattr(mod, par.dbclass)
db = db_class()
db.load_data(dataset_path)
# this will return the ids that can then be used to query the database
# to group ILP problems
instances = db.get_ruleset_instances(ruleset['rule'], group_by, [], False)
for i in instances:
instance_groundings = []
constraint_groundings = []
if i != 17:
continue
#fout.write("\ninstance: " + str(i))
print "\ninstance " + str(i)
gold_heads = db.get_gold_predicates(ruleset['rule'], [], group_by, i)
gold_heads_set = set(
[RuleGrounding.pred_str(head) for head in gold_heads])
#print gold_heads_set
for ruleidx, rule_template in enumerate(ruleset['rule']):
print "Rule", rule_template
class_split = None
if par.dbmodule is None:
rule_groundings = db.unfold_rule_groundings(rule_template,
ruleidx,
group_by,
i,
class_split,
gold_heads_set,
filter_by=[])
else:
rule_groundings = \
getattr(db, rule_template.dbfunc)(
istrain=False,
isneg=False,
filters=[],
split_class=class_split,
instance_id=i)
#fout.write(str(rule_groundings) + "\n")
instance_groundings += rule_groundings
for rule_template in ruleset['constr']:
print "Constraint", rule_template
class_split = None
if par.dbmodule is None:
rule_groundings = db.unfold_rule_groundings(rule_template,
ruleidx,
group_by,
i,
class_split,
gold_heads_set,
filter_by=[])
else:
rule_groundings = \
getattr(db, rule_template.dbfunc)(
istrain=False,
isneg=False,
filters=[],
split_class=class_split,
instance_id=i)
#fout.write(str(rule_groundings) + "\n")
constraint_groundings += rule_groundings
print "Instance groundings"
for gr in instance_groundings:
print gr
print "Constraint groundings"
for gr in constraint_groundings:
print gr
break
def main():
if os.path.isfile(":memory"):
os.system("rm :memory")
if len(sys.argv) != 3:
sys.exit("Usage: python {0} [rule_file] [data_path]".format(
sys.argv[0]))
filename = sys.argv[1]
path = sys.argv[2]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
# Uncomment to see output of parser
print "predicates", par.predicate_arguments
print "labels", par.label_types.keys()
print "files", par.files
print "rulesets", par.rulesets
print "groupby", par.groupby
db = Database()
db.load_predicates(par.predicate_arguments, path, par.files)
db.load_labels(par.label_types.keys(), path, par.files)
print db.table_index
for ruleset, group_by in zip(par.rulesets, par.groupby):
instances = db.get_ruleset_instances(ruleset, group_by)
for i in instances:
instance_groundings = []
print "\ninstance " + str(i)
for rule_template in ruleset:
if not rule_template.head.isobs:
'''if the predicate is not observed we have a binary pred problem'''
# this will be positive examples
rule_groundings = db.unfold_train_groundings(
rule_template, group_by=group_by, instance_id=i)
# this will be negative examples
neg_rule_groundings = db.unfold_train_groundings(
rule_template,
neg_head=True,
group_by=group_by,
instance_id=i)
n_pos = len(rule_groundings)
n_neg = len(neg_rule_groundings)
print "Pos examples", n_pos / (n_pos + 1.0 * n_neg) * 100
print "Neg examples", n_neg / (n_pos + 1.0 * n_neg) * 100
elif rule_template.head.label_type() is not None:
'''if the predicate is observed, then we must have an unobserved variable'''
rule_groundings = db.unfold_train_groundings(
rule_template, group_by=group_by, instance_id=i)
else:
'''if the predicate is observed and the variables are observed
we don't have anything to predict'''
print "This rule has nothing to predict"
continue
for i in range(0, min(100, len(rule_groundings))):
print rule_groundings[i]
os.system("rm :memory")
def main():
if len(sys.argv) < 3:
sys.exit("Usage:" + " python " + sys.argv[0] +
" [rule file] [data path] [filter_file1, filter_file2, ...]")
#fout = open("testresult.txt", 'w')
filename = sys.argv[1]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
filter_instances = []
for i in range(3, len(sys.argv)):
with open(sys.argv[i]) as f:
for line in f:
filter_instances.append(line.strip())
# Uncomment to see output of parser
print "predicates", par.predicate_arguments
print "labels", par.label_types.keys()
print "files", par.files
print "rulesets", par.rulesets
print "groupby", par.groupby
db = Database()
# Use your own path
path = sys.argv[2]
db.load_predicates(par.predicate_arguments, path, par.files)
db.load_labels(par.label_types.keys(), path, par.files)
print db.table_index
ruleset = par.rulesets[0]
groupby = par.groupby[0]
for i, rule_template in enumerate(ruleset['predict']):
#fout.write("\nrule_template: " + str(i))
# this will return the ids that can then be used to query the database
# to group ILP problems
print "\ntemplate", rule_template
'''
if the predicate is not observed we have a binary predicate problem
'''
if rule_template.head.isobs == False:
# this will be positive examples
rule_groundings = db.unfold_train_groundings(
rule_template, filter_by=(groupby, filter_instances))
# this will be negative examples
neg_rule_groundings = db.unfold_train_groundings(
rule_template,
filter_by=(groupby, filter_instances),
neg_head=True)
n_pos = len(rule_groundings)
n_neg = len(neg_rule_groundings)
print "Pos examples", n_pos / (n_pos + 1.0 * n_neg) * 100
print "Neg examples", n_neg / (n_pos + 1.0 * n_neg) * 100
elif rule_template.head.label_type() is not None:
'''
if the predicate is observed, then we must have an unobserved variable
'''
rule_groundings = db.unfold_train_groundings(
rule_template, filter_by=(groupby, filter_instances))
else:
'''
if the predicate is observed and the variables are observed
we don't have anything to predict
'''
print "This rule has nothing to predict"
continue
if rule_template.head.isobs == False:
print "NEG"
for i in range(0, 100):
print neg_rule_groundings[i]
print "\nPOS"
for i in range(0, min(len(rule_groundings), 100)):
print rule_groundings[i]
def main():
print "main"
if os.path.isfile(":memory"):
os.system("rm :memory")
if len(sys.argv) != 2:
sys.exit("Usage:" + " python " + sys.argv[0] + " [rule file]")
#'''
# fout = open("testresult.txt", 'w')
filename = sys.argv[1]
text = open(filename).read()
par = parser.Parser()
par.build()
par.parse(filename)
# Uncomment to see output of parser
print "predicates", par.predicate_arguments
print "files", par.files
print "rulesets", par.rulesets
print "groupby", par.groupby
db = Database()
# Use your own path
path = "examples/EntityRelation/all"
db.load(par.predicate_arguments, path, par.files)
print db.table_index
for ruleset, group_by in zip(par.rulesets, par.groupby):
# this will return the ids that can then be used to query the database
# to group ILP problems
instances = db.get_ruleset_instances(ruleset, group_by)
#print instances
# fout.write(str(instances) + "\n")
for sent_id in instances:
instance_groundings = []
for rule_template in ruleset:
rule_groundings = db.unfold_rule_groundings(
rule_template, group_by, sent_id)
# fout.write(str(rule_groundings) + "\n")
for g in rule_groundings:
print g
instance_groundings += rule_groundings
# instantiate an ILPinferencer
ruleWeights = OrderedDict()
for ruleGrg in instance_groundings:
ruleWeights[ruleGrg] = 0.5
inferencer = ILPInferencer(ruleWeights, 'LP')
inferencer.createModel("testModel {}".format(sent_id))
inferencer.addVariables()
inferencer.addConstraints()
print(str(inferencer.model))
inferencer.optimize()
predVal = inferencer.getAttriValues()
break
# fout.write("\n")
# fout.close()
#'''
os.system("rm :memory")