def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
infstep.indbs = [db.copy() for db in dbs]
infstep.outdbs = [db.copy() for db in dbs]
logger.debug('Running {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Generating CRAM Plan(s)'))
if not hasattr(self.prac.actioncores[node.frame.actioncore], 'plan'):
raise ActionKnowledgeError('I don\'t know how to %s' %
node.frame.sentence)
yield
ac = self.prac.actioncores[node.frame.actioncore]
# fill dictionary with all inferred roles...
acdict = dict([(k, v.type)
for k, v in list(node.frame.actionroles.items())])
# ..and their properties
acdict.update(
dict([('{}_props'.format(k), ' '.join([
'({} {})'.format(pkey, pval)
for pkey, pval in list(v.props.tojson().items())
])) for k, v in list(node.frame.actionroles.items())]))
# update dictionary with missing roles and roles properties
for role in ac.roles:
if acdict.get(role) is None:
acdict[role] = 'Unknown'
acdict['{}_props'.format(role)] = ''
node.plan = ac.parameterize_plan(**acdict)
if self.prac.verbose:
print()
print(prac_heading('PLAN GENERATION RESULTS'))
print(colorize('actioncore:', (None, 'white', True), True),
colorize(ac.name, (None, 'cyan', True), True))
print(colorize('assignments:', (None, 'white', True), True))
for x in acdict:
print('\t{}: {}'.format(
colorize(x, (None, 'white', True), True),
colorize(acdict[x], (None, 'cyan', True), True)))
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
if not isinstance(node, NLInstruction):
raise ValueError('Argument must be NLInstruction, got %s' %
type(node).__name__)
if self.prac.verbose > 0:
print prac_heading('Parsing %s' % node)
infstep = PRACInferenceStep(node, self)
# ======================================================================
# Preprocessing
# ======================================================================
instr = self.compounds(node.instr)
# ======================================================================
# Parsing Instructions
# ======================================================================
if self.prac.verbose > 0:
print colorize('Parsing instruction: "%s"',
(None, 'white', True), True) % instr
dbs = self.parse([instr])
#-----------------------------------------------------------------------
# here come some dirty hacks to catch some very frequent and
# annoying parsing errors:
# 1. "season" is consequently tagged as a noun. We retag it as a verb
for db in dbs:
for q in db.query('has_pos(?w,NN)'):
if q['?w'].lower().startswith('season'):
db['has_pos(%s,NN)' % q['?w']] = 0
db['has_pos(%s,VB)' % q['?w']] = 1
pngs = {}
for i, db in enumerate(dbs):
infstep.outdbs.append(db)
if self.prac.verbose > 1:
print
print colorize('Syntactic evidence:', (None, 'white', True),
True)
db.write(sys.stdout, True)
print
pngs['NL Parsing - ' + str(i)] = get_cond_prob_png(
','.join([x.name for x in self.mln.predicates[:10]]) + ',...',
str(node.instr),
filename=self.name)
infstep.png = pngs
yield node
def train(self, praclearning):
print prac_heading('Training knowledgebase')
mlnName = praclearning.otherParams.get('mln', None)
mlnLogic = praclearning.otherParams.get('logic', None)
objName = praclearning.otherParams.get('concept', None)
onTheFly = praclearning.otherParams.get('onthefly', False)
mln = MLN(mlnfile=os.path.abspath(mlnName), logic=mlnLogic,
grammar='PRACGrammar')
pracTrainingDBS = praclearning.training_dbs
trainingDBS = []
if len(pracTrainingDBS) >= 1 and type(
pracTrainingDBS[0]) is str: # db from file
logger.info('Learning from db files...')
inputdbs = Database.load(mln, dbfile=pracTrainingDBS,
ignore_unknown_preds=True)
trainingDBS += inputdbs
elif len(pracTrainingDBS) > 1:
logger.info('Learning from db files (xfold)...')
trainingDBS = pracTrainingDBS
else: # db from inference result
logger.info('Learning from inference result...')
inputdbs = pracTrainingDBS
for db in inputdbs:
db << 'object(cluster, {})'.format(objName)
trainingDBS.append(db)
outputfile = '{}_trained.mln'.format(mlnName.split('.')[0])
# learning mln
trainedMLN = mln.learnWeights(trainingDBS, LearningMethods.DCLL,
evidencePreds=possibleProps, partSize=1,
gaussianPriorSigma=10, useMultiCPU=0,
optimizer='cg', learningRate=0.9)
print prac_heading('Learnt Formulas')
trainedMLN.printFormulas()
trainedMLN.write(file(outputfile, "w"))
return trainedMLN
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Role COMPLETION: %s' % node.frame.actioncore))
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
infstep.executable_plans = []
pngs = {}
for i, db in enumerate(dbs):
# ==================================================================
# Mongo Lookup
# ==================================================================
infstep.indbs.append(db.copy())
db_, missingroles = self.determine_missing_roles(node, db)
if self.prac.verbose > 1:
print()
print(prac_heading('ROLE COMPLETION RESULTS'))
for m in missingroles:
r = node.frame.actionroles.get(m)
if r: print(m, r.type)
# ==================================================================
# Postprocessing
# ==================================================================
infstep.outdbs.append(db_)
for word, actioncore in db.actioncores():
pngs['LookUp - ' + str(i)] = get_query_png(list(missingroles),
dbs,
filename=self.name,
skolemword=word)
infstep.png = pngs
infstep.applied_settings = {
'module': 'missing_roles',
'method': 'DB lookup'
}
return [node]
def __call__(self, pracinference, **params):
print(prac_heading('Word Sense Disambiguation'))
if params.get('kb', None) is None:
# load the default arguments
dbs = pracinference.inference_steps[-1].output_dbs
kb = self.load_prac_kb('default')
kb.dbs = dbs
else:
kb = params['kb']
if not hasattr(kb, 'dbs'):
kb.dbs = pracinference.inference_steps[-1].output_dbs
mln = kb.query_mln
mln.write()
logic = kb.query_params['logic']
fol = False
if (logic == 'FirstOrderLogic'):
fol = True
known_concepts = mln.domains.get('concept', [])
inf_step = PRACInferenceStep(pracinference, self)
wordnet_module = self.prac.module('wn_senses')
for db in kb.dbs:
db = wordnet_module.get_senses_and_similarities(db, known_concepts)
result_db = list(kb.infer(db))
inf_step.output_dbs.extend(result_db)
print()
for r_db in result_db:
print(prac_heading('Inferred most probable word senses'))
for q in r_db.query('has_sense(?w, ?s)'):
if q['?s'] == 'null': continue
print('{}:'.format(q['?w']))
wordnet_module.printWordSenses(
wordnet_module.get_possible_meanings_of_word(
r_db, q['?w']), q['?s'])
print()
return inf_step
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print prac_heading('Processing complex Action Core refinement')
frame = node.frame
pngs = {}
howto = self.closest_howto(node.frame)
if howto is None: return
print howto.shortstr()
subst = {}
for role, obj in frame.actionroles.iteritems():
obj_ = howto.actionroles.get(role)
if obj_ is not None and obj_.type != obj.type:
subst[obj_.type] = obj
for step in howto.steps:
for role, obj in step.actionroles.iteritems():
if obj.type in subst:
step.actionroles[role] = subst[obj.type]
pred = None
for step in howto.steps:
newnode = FrameNode(node.pracinfer,
step,
node,
pred,
indbs=[
PRACDatabase(
self.prac,
evidence={a: 1
for a in step.todb()})
])
newnode.previous_module = 'coref_resolution'
pred = step
yield newnode
return
def __call__(self, pracinference, **params):
logger.info('Running {}'.format(self.name))
print prac_heading('Recognizing Objects')
# load default project
projectpath = os.path.join(pracloc.pracmodules, self.name, self.defproject)
project = MLNProject.open(projectpath)
inf_step = PRACInferenceStep(pracinference, self)
dbs = pracinference.inference_steps[-1].output_dbs
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FuzzyLogic'),
grammar=project.queryconf.get('grammar',
'PRACGrammar'))
wordnet_module = self.prac.module('wn_senses')
# adding evidence properties to new query db
for db in dbs:
# find properties and add word similarities
logger.error(db.domains)
logger.error(mln.domains)
output_db = wordnet_module.add_similarities(db, mln)
output_db.write()
# infer and update output dbs
infer = self.mlnquery(config=project.queryconf,
db=output_db, mln=mln)
result_db = infer.resultdb
inf_step.outdbs.append(result_db)
return inf_step
def __call__(self, pracinference, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Recognizing Control Structures'))
if params.get('project', None) is None:
# load default project
projectpath = os.path.join(pracloc.pracmodules, self.name,
self.defproject)
ac_project = MLNProject.open(projectpath)
else:
logger.info(
colorize('Loading Project from params', (None, 'cyan', True),
True))
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
ac_project = params.get('project')
dbs = pracinference.inference_steps[-1].output_dbs
mlntext = ac_project.mlns.get(ac_project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=ac_project.queryconf.get('logic',
'FirstOrderLogic'),
grammar=ac_project.queryconf.get(
'grammar', 'PRACGrammar'))
inf_step = PRACInferenceStep(pracinference, self)
pngs = {}
for i, db in enumerate(dbs):
db_ = db.copy()
# ======================================================================
# Inference
# ======================================================================
infer = self.mlnquery(config=ac_project.queryconf, db=db, mln=mln)
result_db = infer.resultdb
if self.prac.verbose == 2:
print()
print(prac_heading('INFERENCE RESULTS'))
infer.write()
# ==========================================================
# Postprocessing
# ==========================================================
for q in result_db.query('event(?w,?ac)'):
db_ << 'event({},{})'.format(q['?w'], q['?ac'])
for q in result_db.query('condition(?w)'):
db_ << 'condition({})'.format(q['?w'])
inf_step.output_dbs.append(db_)
pngs['CS' + str(i)] = get_cond_prob_png(ac_project.queryconf.get(
'queries', ''),
dbs,
filename=self.name)
inf_step.png = pngs
inf_step.applied_settings = ac_project.queryconf.config
return inf_step
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print prac_heading('Resolving Coreferences')
preds = list(
node.rdfs(
goaltest=lambda n: isinstance(n, FrameNode) and not n.children,
all=True))[:2]
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
projectpath = os.path.join(pracloc.pracmodules, self.name)
ac = None
pngs = {}
# if not preds: return []
# ======================================================================
# Preprocessing
# ======================================================================
# merge output dbs from senses_and_roles step, containing
# roles inferred from multiple sentences.
if not preds:
# no coreferencing required - forward dbs and settings
# from previous module
infstep.indbs = [db.copy() for db in dbs]
infstep.outdbs = [db.copy() for db in infstep.indbs]
logger.debug(
'%s has no predecessors. Nothing to do here. Passing db...' %
node)
return [node]
# retrieve all words from the dbs to calculate distances.
# Do not use pracinference.instructions as they are not
# annotated by the Stanford parser.
sentences = [db.words() for pred in preds for db in pred.indbs]
infstep.indbs = [db.copy() for db in dbs]
# infstep.outdbs = [db.copy() for db in infstep.indbs]
# query action core to load corresponding project
actioncore = node.frame.actioncore
# clear corefdb and unify current db with the two preceding ones
corefdb = PRACDatabase(self.prac)
corefdb = corefdb.union(dbs, self.prac.mln)
# for s in range(max(0, i - 2), i+1):
# corefdb = corefdb.union(dbs[s], self.prac.mln)
for pred in preds:
logger.debug('unifying with %s' % pred)
for db in pred.indbs:
corefdb = corefdb.union(db, self.prac.mln)
# remove all senses from the databases' domain that are not
# assigned to any word.
for q in corefdb.query('!(EXIST ?w (has_sense(?w,?sense)))'):
corefdb.rmval('sense', q['?sense'])
try:
# preprocessing: adding distance information for each
# word in the instructions
# s = words[max(0, i - 2):i+1]
# snts = list(enumerate(s))
# idx = len(snts) - 1 # idx of current sentence
# for s in snts[:-1]:
# idx2 = s[0]
# for w in s[1]:
# corefdb << 'distance({},DIST{})'.format(w, idx - idx2)
for sidx, s in enumerate(sentences):
for w in s:
cont = True
for q in corefdb.query('distance({}, ?w)'.format(w)):
cont = False
break
if not cont: continue
corefdb << 'distance({},DIST{})'.format(w, sidx)
# print 'distance({},DIST{})'.format(w, sidx)
logger.debug('loading Project: {}'.format(
colorize(actioncore, (None, 'cyan', True), True)))
project = MLNProject.open(
os.path.join(projectpath, '{}.pracmln'.format(actioncore)))
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FuzzyLogic'),
grammar=project.queryconf.get(
'grammar', 'PRACGrammar'))
except MLNParsingError:
logger.warning(
'Could not use MLN in project {} for coreference resolution'.
format(colorize(actioncore, (None, 'cyan', True), True)))
infstep.outdbs = [db.copy(self.prac.mln) for db in dbs]
infstep.png = node.parent.laststep.png
infstep.applied_settings = node.parent.laststep.applied_settings
return [node]
except Exception:
infstep.outdbs = [db.copy(self.prac.mln) for db in dbs]
infstep.png = node.parent.laststep.png
infstep.applied_settings = node.parent.laststep.applied_settings
logger.warning(
'Could not load project "{}". Passing dbs to next module...'.
format(ac))
return [node]
# adding similarities
wnmod = self.prac.module('wn_senses')
newdatabase = wnmod.add_sims(corefdb, mln)
# update queries depending on missing roles
acroles = filter(lambda role: role != 'action_verb',
self.prac.actioncores[actioncore].roles)
missingroles = [
ar for ar in acroles
if len(list(newdatabase.query('{}(?w,{})'.format(ar, actioncore))))
== 0
]
conf = project.queryconf
conf.update({'queries': ','.join(missingroles)})
print colorize('querying for missing roles {}'.format(conf['queries']),
(None, 'green', True), True)
# asserting impossible role-ac combinations, leaving previously
# inferred roles untouched
fulldom = mergedom(mln.domains, newdatabase.domains)
ac_domains = [dom for dom in fulldom if '_ac' in dom]
acs = list(set([v for a in ac_domains for v in fulldom[a]]))
acs = filter(lambda ac_: ac_ != actioncore, acs)
for ac1 in acs:
for r in missingroles:
for w in newdatabase.domains['word']:
# words with no sense are asserted false
if list(
corefdb.query(
'!(EXIST ?sense (has_sense({},?sense)))'.
format(w))):
newdatabase << '!{}({},{})'.format(r, w, actioncore)
# leave previously inferred information roles
# untouched
if list(newdatabase.query('{}({},{})'.format(r, w, ac1))):
continue
else:
newdatabase << '!{}({},{})'.format(r, w, ac1)
try:
# ==========================================================
# Inference
# ==========================================================
infer = self.mlnquery(config=conf,
verbose=self.prac.verbose > 2,
db=newdatabase,
mln=mln)
if self.prac.verbose == 2:
print
print prac_heading('INFERENCE RESULTS')
infer.write()
# ==========================================================
# Postprocessing
# ==========================================================
# merge initial db with results
for db in infstep.indbs:
resultdb = db.copy()
for res in infer.results.keys():
if infer.results[res] != 1.0:
continue
resultdb << str(res)
_, _, args = self.prac.mln.logic.parse_literal(res)
w = args[0]
for q in newdatabase.query(
'has_sense({0},?s) ^ has_pos({0},?pos)'.format(w)):
resultdb << 'has_sense({},{})'.format(w, q['?s'])
resultdb << 'is_a({0},{0})'.format(q['?s'])
resultdb << 'has_pos({},{})'.format(w, q['?pos'])
resultdb = wnmod.add_sims(resultdb, mln)
# enhance the frame data
for mrole in missingroles:
for q in resultdb.query(
'{role}(?w, {actioncore}) ^ has_sense(?w, ?s)'.
format(role=mrole, actioncore=actioncore)):
for p in preds:
if p.frame.object(q['?w']) is not None:
node.frame.actionroles[mrole] = p.frame.object(
q['?w'])
break
infstep.outdbs.append(resultdb)
pprint(node.frame.tojson())
except NoConstraintsError:
logger.debug('No coreferences found. Passing db...')
infstep.outdbs.append(db)
except Exception:
logger.error('Something went wrong')
traceback.print_exc()
pngs['Coref - ' + str(node)] = get_cond_prob_png(project.queryconf.get(
'queries', ''),
dbs,
filename=self.name)
infstep.png = pngs
infstep.applied_settings = project.queryconf.config
return [node]
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Recognizing Action Cores'))
if params.get('project', None) is None:
# load default project
projectpath = os.path.join(pracloc.pracmodules, self.name,
self.defproject)
ac_project = MLNProject.open(projectpath)
else:
logger.info(
colorize('Loading Project from params', (None, 'cyan', True),
True))
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
ac_project = params.get('project')
dbs = node.outdbs
mlntext = ac_project.mlns.get(ac_project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=ac_project.queryconf.get('logic',
'FirstOrderLogic'),
grammar=ac_project.queryconf.get(
'grammar', 'PRACGrammar'))
known_concepts = mln.domains.get('concept', [])
infstep = PRACInferenceStep(node, self)
wnmod = self.prac.module('wn_senses')
pngs = {}
nlinstr = node.nlinstr()
sidx = nlinstr.idx()
sentence = nlinstr.instr
for db_ in dbs:
# ==================================================================
# Preprocessing
# ==================================================================
db = wnmod.get_senses_and_similarities(db_, known_concepts)
tmp_union_db = db.union(db_, mln=self.prac.mln)
infstep.indbs.append(tmp_union_db)
# ==================================================================
# Inference
# ==================================================================
infer = self.mlnquery(config=ac_project.queryconf,
verbose=self.prac.verbose > 2,
db=tmp_union_db,
mln=mln)
resultdb = infer.resultdb
if self.prac.verbose == 2:
print()
print(prac_heading('INFERENCE RESULTS'))
infer.write()
# ==================================================================
# Postprocessing
# ==================================================================
unified_db = resultdb.union(tmp_union_db, mln=self.prac.mln)
# infstep.outdbs
infstep.outdbs.extend(
self.extract_multiple_action_cores(self.prac, unified_db,
wnmod, known_concepts))
pngs[unified_db.domains.get('actioncore',
[None])[0]] = get_cond_prob_png(
ac_project.queryconf.get(
'queries', ''),
dbs,
filename=self.name)
infstep.png = pngs
infstep.applied_settings = ac_project.queryconf.config
pred = None
for outdb in infstep.outdbs:
# out('in ac rec:')
# for w, ac in outdb.actioncores():
# out(w, ac)
for frame in node.pracinfer.buildframes(outdb, sidx, sentence):
node_ = FrameNode(node.pracinfer,
frame,
node,
pred,
indbs=[outdb],
prevmod=self.name)
pred = node_
yield node_
break
else:
logger.error('no actioncore recognized in %s' % node)
raise Exception('no actioncore recognized in %s' % node)
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Refining Actioncores'))
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
# if node.previous_module == 'achieved_by':
# raise ActionKnowledgeError('I don\'t know how to %s' % node.frame.sentence)
# ======================================================================
# Preprocessing
# ======================================================================
for olddb in dbs:
infstep.indbs.append(olddb.copy())
#To handle multiple acs in one task, we have to check if the single
# dbs contain achieved_bys which representing already plans
pngs = {}
actioncore = node.frame.actioncore
mod = self.prac.module('complex_achieved_by')
newnodes = list(mod(node))
n = None
parentframes = [
p.frame for p in node.parentspath()
if isinstance(p, FrameNode)
]
if any(n.frame in parentframes for n in newnodes):
logger.error(
'aborting reasoning because of infinite loop. (%s)' %
node.frame)
node.children = []
else:
for n in newnodes:
yield n
if n is not None: return
if n is None:
# This list is used to avoid an infinite loop during the
# achieved by inference.
# To avoid this infinite loop, the list contains the pracmlns
# which were inferenced during the process.
# Every pracmln should be used only once during the process
# because the evidence for the inference will always remain
# the same.
# So if the pracmln hadnt inferenced a plan in the first time,
# it will never do it.
# Need to remove possible achieved_by predicates from
# previous achieved_by inferences
db_ = PRACDatabase(self.prac)
for atom, truth in sorted(olddb.evidence.items()):
if 'achieved_by' in atom: continue
db_ << (atom, truth)
if params.get('project', None) is None:
logger.debug('Loading Project: {}.pracmln'.format(
colorize(actioncore, (None, 'cyan', True), True)))
projectpath = os.path.join(pracloc.pracmodules, self.name,
'{}.pracmln'.format(actioncore))
if os.path.exists(projectpath):
project = MLNProject.open(projectpath)
else:
infstep.outdbs.append(olddb)
logger.error(actioncore + ".pracmln does not exist.")
return
else:
logger.debug(
colorize('Loading Project from params',
(None, 'cyan', True), True))
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
project = params.get('project')
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(
mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FirstOrderLogic'),
grammar=project.queryconf.get('grammar', 'PRACGrammar'))
known_concepts = mln.domains.get('concept', [])
wnmod = self.prac.module('wn_senses')
#Merge domains of db and given mln to avoid errors due to role inference and the resulting missing fuzzy perdicates
known_concepts = list(
set(known_concepts).union(
set(db_.domains.get('concept', []))))
db = wnmod.get_senses_and_similarities(db_, known_concepts)
unified_db = db_.union(db)
dbnew = wnmod.add_sims(unified_db, unified_db)
# Inference achieved_by predicate
db_ = self.extendDBWithAchievedByEvidence(
dbnew, mln, actioncore)
# ==============================================================
# Inference
# ==============================================================
# db_.write()
try:
infer = self.mlnquery(config=project.queryconf,
verbose=self.prac.verbose > 2,
db=db_,
mln=mln)
except NoConstraintsError:
logger.error(
'achieved_by inference failed due to NoConstraintsError: %s'
% node.frame)
return
result_db = infer.resultdb
if self.prac.verbose == 2:
print()
print(prac_heading('INFERENCE RESULTS'))
infer.write()
# ==============================================================
# Postprocessing
# ==============================================================
# unified_db = result_db.union(kb.query_mln, db_)
# only add inferred achieved_by atoms, leave out
# 0-evidence atoms
for qa in result_db.query('achieved_by(?ac1,?ac2)'):
if qa['?ac2'] == 'Complex': continue
unified_db << 'achieved_by({},{})'.format(
qa['?ac1'], qa['?ac2'])
pngs[qa['?ac2']] = get_cond_prob_png(project.queryconf.get(
'queries', ''),
dbs,
filename=self.name)
newframe = Frame(self.prac,
node.frame.sidx,
'',
words=[],
syntax=[],
actioncore=qa['?ac2'],
actionroles={})
# out('->', newframe)
infstep.outdbs.append(unified_db)
yield FrameNode(node.pracinfer,
newframe,
node,
pred=None,
indbs=[unified_db],
prevmod=self.name)
return
infstep.outdbs.append(unified_db)
# raise ActionKnowledgeError('I don\'t know how to %s' % node.frame.sentence)
def main():
headline("Running main...")
usage = 'PRAC Object Recognition tool'
parser = argparse.ArgumentParser(description=usage)
parser.add_argument(
"-i",
"--interactive",
dest="interactive",
default=False,
action='store_true',
help="Starts PRAC object recognition with an interactive "
"GUI tool.")
parser.add_argument(
"-t",
"--train",
dest="trainMLN",
nargs=1,
default=None,
help=
"Train given MLN with inference results from argument. Example: pracobjrec -t orange.n.01 'It is a yellow "
"or orange fruit.'")
parser.add_argument(
"-r",
"--regular",
dest="regular",
default=False,
action='store_true',
help="Runs regular inference pipeline. Arguments: mlnName")
parser.add_argument("-f",
"--onthefly",
dest="onthefly",
default=False,
action='store_true',
help="Generate MLN on the fly")
parser.add_argument(
"-m",
"--mln",
nargs=2,
dest='mln',
default=None,
help="Runs regular inference pipeline. Arguments: mlnName")
args = parser.parse_args()
opts_ = vars(args)
interactive = args.interactive
regular = args.regular
sentences = args
prac = PRAC()
prac.wordnet = WordNet(concepts=None)
infer = PRACInference(prac, sentences)
# in case we have natural-language parameters, parse them
if len(infer.instructions) > 0:
parser = prac.module('nl_parsing')
prac.run(infer, parser)
if interactive: # use the GUI
logger.info('Entering interactive mode')
gui = PRACQueryGUI(infer)
gui.open()
elif args.trainMLN: # training with property inference output
logger.info(
'Training MLN {} with result from property inference'.format(
args.trainMLN))
# property inference from parsed input
propExtract = prac.module('prop_extraction')
prac.run(infer, propExtract)
objRecog = prac.module('obj_recognition')
praclearn = PRACLearning(prac)
praclearn.otherParams['mln'] = args.mln[0]
praclearn.otherParams['logic'] = args.mln[1]
praclearn.otherParams['concept'] = args.trainMLN
praclearn.otherParams['onthefly'] = args.onthefly
praclearn.training_dbs = infer.inference_steps[-1].output_dbs
objRecog.train(praclearn)
sys.exit(0)
else: # regular PRAC pipeline
logger.info('Entering regular inference pipeline')
# property inference from parsed input
propExtract = prac.module('prop_extraction')
prac.run(infer, propExtract)
objRecog = prac.module('obj_recognition')
# object inference based on inferred properties
prac.run(infer, objRecog)
step = infer.inference_steps[-1]
print()
print(prac_heading('PRAC INFERENCE RESULTS'))
print()
print('Object description: {}'.format(
colorize(''.join(sentences), (None, 'white', True), True)))
print()
for db in step.output_dbs:
print('Inferred properties:')
for ek in sorted(db.evidence):
e = db.evidence[ek]
if e == 1.0 and any(
ek.startswith(p) for p in [
'color', 'size', 'shape', 'hypernym', 'hasa',
'dimension', 'consistency', 'material'
]):
print('{}({}, {}'.format(
colorize(ek.split('(')[0], (None, 'white', True), True),
colorize(
ek.split('(')[1].split(',')[0],
(None, 'magenta', True), True),
colorize(
ek.split('(')[1].split(',')[1], (None, 'green', True),
True)))
for db in step.output_dbs:
print()
print('Inferred possible concepts:')
for ek in sorted(db.evidence, key=db.evidence.get, reverse=True):
e = db.evidence[ek]
if e > 0.001 and ek.startswith('object'):
print('{} {}({}, {})'.format(
colorize('{:.4f}'.format(e), (None, 'cyan', True), True),
colorize('object', (None, 'white', True), True),
colorize(
ek.split(',')[0].split('(')[1],
(None, 'magenta', True), True),
colorize(
ek.split(',')[1].split(')')[0], (None, 'yellow', True),
True)))
def main():
logger.level = logs.DEBUG
usage = 'PRAC Query Tool'
parser = argparse.ArgumentParser(description=usage)
parser.add_argument("instruction", help="The instruction.")
parser.add_argument(
"-i",
"--interactive",
dest="interactive",
default=False,
action='store_true',
help="Starts PRAC inference with an interactive GUI tool.")
parser.add_argument("-v",
"--verbose",
dest="verbose",
default=1,
type=int,
action="store",
help="Set verbosity level {0..3}. Default is 1.")
args = parser.parse_args()
opts_ = vars(args)
sentences = args.instruction
prac = PRAC()
prac.verbose = args.verbose
conf = PRACMLNConfig(DEFAULT_CONFIG)
if args.interactive: # use the GUI
from tkinter import Tk
root = Tk()
# in case we have natural-language parameters, parse them
infer = PRACInference(prac, sentences)
if len(sentences) > 0:
# module = prac.module('nl_parsing')
# prac.run(infer, module)
n = infer.runstep()
# print parsing result
for odb in n.outdbs:
odb.write()
# print input sentence
print(n.nlinstr())
#Started control structure handling
'''
cs_recognition = prac.module('cs_recognition')
prac.run(inference, cs_recognition)
dbs = inference.inference_steps[-1].output_dbs
dbs_ = []
for db in dbs:
dbs_.extend(parser.extract_multiple_action_cores(db))
inference.inference_steps[-1].output_dbs = dbs_
'''
app = PRACQueryGUI(root,
infer.prac,
n,
conf,
directory=args[0] if args else None)
root.mainloop()
exit(0)
# regular PRAC pipeline
infer = PRACInference(prac, sentences)
infer.run()
print(headline('inference results'))
print('instructions:')
for i in infer.root:
print(i)
frames = []
for step in infer.steps():
print(step.frame)
print(prac_heading('cram plans', color='blue'))
for step in infer.steps():
if hasattr(step, 'plan'):
print(step.plan)
# infer.write()
exit(0)
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print prac_heading('Update roles based on Action Core Refinement')
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
# planlist = self.getPlanList()
# out(node.parent.frame, '->', node.frame)
pngs = {}
for i, db_ in enumerate(dbs):
# db = db_.copy()
# db = PRACDatabase(self.prac)
# ==================================================================
# Preprocessing
# ==================================================================
actioncore = node.frame.actioncore
logger.debug('Action core: {}'.format(actioncore))
if params.get('project', None) is None:
logger.debug('Loading Project: {}.pracmln'.format(
colorize(actioncore, (None, 'cyan', True), True)))
projectpath = os.path.join(
pracloc.pracmodules, self.name,
'{}Transformation.pracmln'.format(actioncore))
project = MLNProject.open(projectpath)
else:
logger.debug(
colorize('Loading Project from params',
(None, 'cyan', True), True))
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
project = params.get('project')
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(
mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FirstOrderLogic'),
grammar=project.queryconf.get('grammar', 'PRACGrammar'))
result_db = None
for pdb in node.parent.outdbs:
db = pdb.copy()
db = db.union(db_)
objs = {o.id for o in node.parent.frame.actionroles.values()}
for w in set(db.domains['word']):
if w not in objs:
db.rmval('word', w)
infstep.indbs.append(db)
ac = node.parent.frame.actioncore
db << 'achieved_by(%s, %s)' % (ac, actioncore)
for role, object_ in node.parent.frame.actionroles.iteritems():
db << '%s(%s, %s)' % (role, object_.id, ac)
try:
# ==========================================================
# Inference
# ==========================================================
infer = self.mlnquery(config=project.queryconf,
db=db,
verbose=self.prac.verbose > 2,
mln=mln)
result_db = infer.resultdb
if self.prac.verbose == 2:
print
print prac_heading('INFERENCE RESULTS')
print
infer.write()
except NoConstraintsError:
logger.error(
'no constraints in role transformation: %s -> %s' %
(node.parent.frame, node.frame))
result_db = db
# ==============================================================
# Postprocessing
# ==============================================================
r_db = PRACDatabase(self.prac)
roles = self.prac.actioncores[actioncore].roles
for atom, truth in sorted(result_db.evidence.iteritems()):
if any(r in atom for r in roles):
_, predname, args = self.prac.mln.logic.parse_literal(atom)
word, ac = args
if ac == actioncore:
r_db << (atom, truth)
if truth:
sense = pdb.sense(word)
props = pdb.properties(word)
obj = Object(self.prac,
id_=word,
type_=sense,
props=props,
syntax=node.pracinfer.buildword(
pdb, word))
node.frame.actionroles[predname] = obj
# out('->', node.frame)
unified_db = db.union(r_db, mln=self.prac.mln)
r_db_ = PRACDatabase(self.prac)
# It will be assumed that there is only one true action_
# c1ore predicate per database
# for actionverb, actioncore in unified_db.actioncores(): break
for atom, truth in sorted(unified_db.evidence.iteritems()):
if 'action_core' in atom: continue
r_db_ << (atom, truth)
infstep.outdbs.append(r_db_)
pngs['RolesTransformation - ' + str(i)] = get_cond_prob_png(
project.queryconf.get('queries', ''), dbs, filename=self.name)
infstep.png = pngs
infstep.applied_settings = project.queryconf.config
return [node]
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print(prac_heading('Property Extraction'))
if params.get('project', None) is None:
# load default project
projectpath = os.path.join(pracloc.pracmodules, self.name,
self.defproject)
project = MLNProject.open(projectpath)
else:
# load project from params
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
project = params.get('project')
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FuzzyLogic'),
grammar=project.queryconf.get('grammar',
'PRACGrammar'))
wnmod = self.prac.module('wn_senses')
pngs = {}
for i, db in enumerate(dbs):
# ==================================================================
# Preprocessing
# ==================================================================
db_ = wnmod.add_sims(db, mln)
infstep.indbs.append(db_)
try:
# ==============================================================
# Inference
# ==============================================================
infer = self.mlnquery(config=project.queryconf,
verbose=self.prac.verbose > 2,
db=db_,
mln=mln)
result_db = infer.resultdb
if self.prac.verbose == 2:
print()
print(prac_heading('INFERENCE RESULTS'))
print()
infer.write()
# ==============================================================
# Postprocessing
# ==============================================================
unified_db = db.copy(self.prac.mln)
props = [
p for p in project.queryconf.get('queries', '').split(',')
if p != 'has_sense'
]
for p in props:
for q in result_db.query(
'{}(?w1,?w2) ^ has_sense(?w2,?s2)'.format(p)):
unified_db << '{}({},{})'.format(p, q['?w1'], q['?w2'])
unified_db << 'has_sense({},{})'.format(
q['?w2'], q['?s2'])
infstep.outdbs.append(unified_db)
except NoConstraintsError:
logger.debug('No properties found. Passing db...')
infstep.outdbs.append(db.copy())
except Exception:
logger.error('Something went wrong')
traceback.print_exc()
pngs['PropExtraction - ' + str(i)] = get_cond_prob_png(
project.queryconf.get('queries', ''),
infstep.indbs,
filename=self.name)
infstep.png = pngs
infstep.applied_settings = project.queryconf.config
return [node]
def main():
#===========================================================================
# Parse command line arguments
#===========================================================================
usage = 'PRAC Tell'
parser = argparse.ArgumentParser(description=usage)
parser.add_argument('--howto', '-H', type=str, help='Title of the howto, e.g. "Make pancakes"')
parser.add_argument('--steps', '-s', nargs='+', type=str, dest='steps', help='A list of instruction steps in natural language. If set, his option must be the last in the list of options followed by the list of instructions.')
parser.add_argument('--batch', '-b', dest='batch', default=False, action='store_true', help='Import a list of howtos in batch processing whose filenames are given the respective howto title, e.g. "Make a pancake." The file content must then be given by the single instruction steps, one by line.')
parser.add_argument('--recursive', '-r', dest='recursive', default=False, help='Apply the import of instructions recursively to subdirectories.')
parser.add_argument("--verbose", "-v", dest="verbose", default=1, type=int, action="store", help="Set verbosity level {0..3}. Default is 1.")
parser.add_argument('--quiet', '-q', dest='quiet', action='store_true', default=False, help='Do not print any status messages.')
parser.add_argument('--multicore', '-m', dest='multicore', action='store_true', default=False, help='Perform information extraction in multicore modus')
parser.add_argument('--save', action='store_true', default=False, help='Store the howto in the PRAC database permanently.')
args = parser.parse_args()
if args.quiet: args.verbose = 0
if args.verbose:
print(prac_heading('Telling PRAC, how to {}'.format(args.howto)))
# ===========================================================================
# If the 'steps' flag is set, take all arguments as the list of instructions
# ===========================================================================
howtos = []
if args.steps:
howtos = [{args.howto: args.steps}]
elif args.batch:
for path in args:
if args.recursive:
for loc, dirs, files in os.walk(path):
for filename in files:
with open(os.path.join(loc, filename)) as f:
howtos.append({' '.join(filename.split('-')): [_f for _f in (line.strip() for line in f) if _f]})
else:
for filename in os.listdir(path):
if os.path.isdir(filename): continue
with open(os.path.join(path, filename)) as f:
howtos.append({' '.join(filename.split('-')): [_f for _f in (line.strip() for line in f) if _f]})
else:
for filename in args:
with open(filename) as f:
howtos.append({' '.join(filename.split('-')): [_f for _f in (line.strip() for line in f) if _f]})
# ===========================================================================
# start the import
# ===========================================================================
try:
cpu_count = multiprocessing.cpu_count() if args.multicore else 1
pool = multicore.NonDaemonicPool(cpu_count)
pool.map(multicore.with_tracing(import_howto), list(zip(howtos, itertools.repeat(args.verbose), itertools.repeat(args.save))))
except KeyboardInterrupt:
traceback.print_exc()
pool.terminate()
else:
# =======================================================================
# finished
# =======================================================================
if args.verbose:
print('Done. Imported %d howtos' % len(howtos))
finally:
pool.close()
pool.join()
def role_distributions(self, step):
'''
TODO
:param step:
:return:
'''
distrs = {}
for db_ in step.output_dbs:
for word in db_.domains['word']:
for q in db_.query('action_core(?w,?ac)'):
# ==========================================================
# Initializaton
# ==========================================================
actioncore = q['?ac']
projectpath = os.path.join(self.module_path,
'{}.pracmln'.format(actioncore))
project = MLNProject.open(projectpath)
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(
mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic',
'FirstOrderLogic'),
grammar=project.queryconf.get('grammar',
'PRACGrammar'))
# ==========================================================
# Preprocessing
# ==========================================================
# add inferred concepts to known_concepts to display
# them in the graph. Ignore verbs and adjectives,
# as they do not have hypernym relations to nouns
concepts = self.prac.config.getlist('wordnet', 'concepts')
for con in db_.query('has_sense(?w,?s)'):
if con['?s'].split('.')[1] in ['a', 's', 'v']:
continue
concepts.append(con['?s'])
wn = WordNet(concepts=concepts)
db = db_.copy(mln=mln)
for qs in db_.query('!(EXIST ?w (has_sense(?w,?s)))'):
db.rmval('sense', qs['?s'])
for concept in db_.domains['concept']:
if concept not in mln.domains['concept']:
db.rmval('concept', concept)
for res in db_.query('has_sense({}, ?s)'.format(word)):
sense = res['?s']
if sense == 'null': continue
roles = self.prac.actioncores[actioncore].roles
role = None
for r in roles:
vars = [
'?v{}'.format(i) for i in range(
len(db_.mln.predicate(r).argdoms) - 1)
]
br = False
for qr in db_.query('{}({},{})'.format(
r, ','.join(vars), actioncore)):
for v in vars:
if qr[v] == word:
role = r
br = True
break
if br: break
if br: break
if role is None: continue
db.retract('has_sense({},{})'.format(word, sense))
add_all_wordnet_similarities(db, wn)
# ======================================================
# Inference
# ======================================================
infer = self.mlnquery(method='EnumerationAsk',
mln=mln,
db=db,
queries='has_sense',
cw=True,
multicore=True,
verbose=self.prac.verbose > 2)
result = infer.resultdb
if self.prac.verbose == 2:
print
print prac_heading('INFERENCE RESULTS')
print
infer.write()
# ======================================================
# Graph generation
# ======================================================
g = wn.to_dot()
maxprob = 0.
for atom, truth in result.gndatoms():
_, predname, args = db.mln.logic.parse_literal(
atom)
concept = args[1]
if predname == 'has_sense' and args[
0] == word and concept != 'null':
maxprob = max(maxprob, truth)
for atom, truth in result.gndatoms():
_, predname, args = db.mln.logic.parse_literal(
atom)
concept = args[1]
if predname == 'has_sense' and args[
0] == word and concept != 'null':
if concept in concepts:
g.node(concept,
fillcolor=get_prob_color(truth /
maxprob))
distrs[role] = render_gv(g)
return distrs
def __call__(self, node, **params):
# ======================================================================
# Initialization
# ======================================================================
logger.debug('inference on {}'.format(self.name))
if self.prac.verbose > 0:
print prac_heading('Recognizing {} Roles'.format({
True: 'MISSING',
False: 'GIVEN'
}[params.get('missing', False)]))
dbs = node.outdbs
infstep = PRACInferenceStep(node, self)
queries = ''
wnmod = self.prac.module('wn_senses')
actionroles = defaultdict(list)
pngs = {}
for n, olddb in enumerate(dbs):
db_copy = olddb.copy(mln=self.prac.mln)
actioncore = node.frame.actioncore
logger.debug(actioncore)
if params.get('project', None) is None:
logger.debug('Loading Project: {}.pracmln'.format(
colorize(actioncore, (None, 'cyan', True), True)))
projectpath = os.path.join(pracloc.pracmodules, self.name,
'{}.pracmln'.format(actioncore))
project = MLNProject.open(projectpath)
else:
logger.debug(
colorize('Loading Project from params',
(None, 'cyan', True), True))
projectpath = os.path.join(
params.get('projectpath', None)
or os.path.join(pracloc.pracmodules, self.name),
params.get('project').name)
project = params.get('project')
queries = project.queryconf.get('queries', '')
mlntext = project.mlns.get(project.queryconf['mln'], None)
mln = parse_mln(mlntext,
searchpaths=[self.module_path],
projectpath=projectpath,
logic=project.queryconf.get('logic', 'FuzzyLogic'),
grammar=project.queryconf.get(
'grammar', 'PRACGrammar'))
known_concepts = mln.domains.get('concept', [])
# ==============================================================
# Preprocessing
# ==============================================================
# adding senses and similarities. might be obsolete as it has
# already been performed in ac recognition
logger.debug('adding senses. concepts={}'.format(known_concepts))
db = wnmod.get_senses_and_similarities(db_copy, known_concepts)
# we need senses and similarities as well as original evidence
tmp_union_db = db.union(db_copy, mln=self.prac.mln)
# ignore roles of false ac's
new_tmp_union_db = tmp_union_db.copy(mln=self.prac.mln)
roles = self.prac.actioncores[actioncore].roles
for ac in tmp_union_db.domains['actioncore']:
if ac == actioncore: continue
for r in roles:
for w in new_tmp_union_db.words():
new_tmp_union_db << ('{}({},{})'.format(r, w, ac), 0)
infstep.indbs.append(new_tmp_union_db)
# ==============================================================
# Inference
# ==============================================================
infer = self.mlnquery(config=project.queryconf,
verbose=self.prac.verbose > 2,
db=new_tmp_union_db,
mln=mln)
resultdb = infer.resultdb
if self.prac.verbose == 2:
print
print prac_heading('INFERENCE RESULTS')
infer.write()
# ==============================================================
# Postprocessing
# ==============================================================
# get query roles for given actioncore and add inference results
# for them to final output db. ignore 0-truth results.
unified_db = new_tmp_union_db.union(resultdb, mln=self.prac.mln)
# node.frame.actionroles = defaultdict(list)
for role, word in unified_db.rolesw(actioncore):
sense = unified_db.sense(word)
props = dict(unified_db.properties(word))
obj = Object(self.prac,
id_=word,
type_=sense,
props=props,
syntax=node.pracinfer.buildword(unified_db, word))
actionroles[role].append(obj)
# argdoms = kb.query_mln.predicate(role).argdoms
roles = self.prac.actioncores[actioncore].roles
new_result = PRACDatabase(self.prac)
for atom, truth in unified_db.evidence.iteritems():
if any(r in atom for r in roles):
(_, predname,
args) = self.prac.mln.logic.parse_literal(atom)
if not args[-1] == actioncore:
continue
new_result << (atom, truth)
for q in unified_db.query('has_sense(?w, ?s)'):
# TODO Add additional formulas to avoid the using of null values
if self.prac.verbose > 1:
print colorize(' WORD:', (None, 'white', True),
True), q['?w']
print colorize(' SENSE:', (None, 'white', True),
True), q['?s']
wnmod.printWordSenses(
wnmod.get_possible_meanings_of_word(
unified_db, q['?w']), q['?s'])
print
infstep.outdbs.append(new_result)
pngs['Recognizing {} roles - {}'.format(
'given', str(n))] = get_cond_prob_png(queries,
infstep.indbs,
filename=self.name)
infstep.png = pngs
if 'project' not in locals():
raise Exception('no actioncore in database: %s' % olddb)
infstep.applied_settings = project.queryconf.config
# pprint(actionroles)
newframes = splitd(actionroles)
pred = None
for newframe in newframes:
# pprint(newframe)
f = Frame(self.prac,
node.frame.sidx,
node.frame.sentence,
syntax=list(olddb.syntax()),
words=node.frame.words,
actioncore=node.frame.actioncore,
actionroles=newframe)
logger.debug('created new frame %s' % f)
# for db in infstep.outdbs:
# out(db.syntax())
pred = FrameNode(node.pracinfer,
f,
node,
pred,
indbs=infstep.outdbs,
prevmod=self.name)
yield pred
